258 lines
6.9 KiB
C++
258 lines
6.9 KiB
C++
// Fill out your copyright notice in the Description page of Project Settings.
|
|
|
|
|
|
#include "cppGI.h"
|
|
#include "Kismet/GameplayStatics.h"
|
|
#include "Misc/paths.h"
|
|
#include "Engine/levelstreamingdynamic.h"
|
|
|
|
CSocket* soc;
|
|
char ipc[100];
|
|
|
|
|
|
/*for working tarray::Contains*/
|
|
bool operator==(const Fcppcoords& c1, const Fcppcoords& c2) {
|
|
return c1.flat == c2.flat &&
|
|
c1.floor == c2.floor &&
|
|
c1.house == c2.house &&
|
|
c1.section == c2.section &&
|
|
c1.type == c2.type &&
|
|
c1.zone == c2.zone;
|
|
}
|
|
|
|
void UcppGI::cppLvlManage(UObject* WorldContextObject, Fcppcoords currentCoords, uint8 currentState, TArray<ULevelStreaming*>& Levelss)
|
|
{
|
|
bool loadthis = false;
|
|
auto is3DTour = currentState == 11;
|
|
|
|
int32 temp1[5] = { currentCoords.flat,currentCoords.zone,currentCoords.house,currentCoords.section,currentCoords.floor };
|
|
//cpplvlsForLoading.Add(Fcppcoords(1, -2, -2, 1, -1));
|
|
|
|
/*complete lvls for loading*/
|
|
/*for (auto& lvl : cpplvlsForLoading) {
|
|
int32* temp[5] = { &lvl.flat,&lvl.zone,&lvl.house,&lvl.section,&lvl.floor };
|
|
int8 n = 0;
|
|
for (auto i : temp) {
|
|
if (*i == -2) *i = temp1[n];
|
|
n++;
|
|
}
|
|
}*/
|
|
|
|
if (is3DTour && currentCoords.house < 1) cpplvlsForLoading.AddUnique(Fcppcoords(1, -2, -2, 1, -1));
|
|
|
|
|
|
cpplvlsForLoading.AddUnique(currentCoords);
|
|
for (const FcppLevelStruct& lvl : cpplevelLIst) {
|
|
FString tt = lvl.path;
|
|
if (false); //currentCoords.floor == 100);
|
|
else {
|
|
loadthis = false;
|
|
bool ceq[7];
|
|
for (const auto& crd : cpplvlsForLoading) // here is filter code
|
|
{
|
|
cppCoordsEq(crd, lvl.coords, true, false, ceq[0], ceq[1], ceq[2], ceq[3], ceq[4], ceq[5], ceq[6]);
|
|
|
|
if (
|
|
(
|
|
((ceq[0] || !is3DTour || lvl.coords.flat == -1) && ceq[5])
|
|
|| (is3DTour ? lvl.anotherLvl >= 1 && lvl.anotherLvl == crd.flat : lvl.anotherLvl >= 1 && (crd.flat >= 0 ? lvl.anotherLvl == crd.flat : currentCoords.floor < 90/*or 2-floor flat will be loaded anyway*/) && lvl.coords.floor < crd.floor)
|
|
)
|
|
&& ceq[3] && ceq[4]
|
|
) loadthis = true; //load all on floor and under 2-floor flat, and full 2-floor flat in 3d tour
|
|
|
|
|
|
//if (ceq[6]) loadthis = true; //classic load with parallax
|
|
}
|
|
}
|
|
TArray<FString> blya;
|
|
blya.Add(FString::FromInt(lvl.coords.flat));
|
|
blya.Add(FString::FromInt(lvl.coords.zone));
|
|
blya.Add(FString::FromInt(lvl.coords.house));
|
|
blya.Add(FString::FromInt(lvl.coords.section));
|
|
blya.Add(FString::FromInt(lvl.coords.floor));
|
|
blya.Add(FString::FromInt(lvl.Z));
|
|
|
|
FString instanceStr = FString::Join(blya, L"_");
|
|
instanceStr.Append(L"_").Append(FPaths::GetCleanFilename(lvl.path));
|
|
FName instanceName = FName(instanceStr);
|
|
|
|
if (loadthis) {
|
|
if (cppdynamicLvls.Contains(instanceName)) {
|
|
ULevelStreaming* lvl1 = UGameplayStatics::GetStreamingLevel(WorldContextObject, instanceName);
|
|
lvl1->bShouldBlockOnLoad = (currentState != 11) && lvl.dontUnload;
|
|
lvl1->SetShouldBeLoaded(true);
|
|
lvl1->SetShouldBeVisible(true);
|
|
Levelss.Add(lvl1);
|
|
}
|
|
else {
|
|
bool b;
|
|
if (ULevelStreamingDynamic* newlvl = ULevelStreamingDynamic::LoadLevelInstance(WorldContextObject, lvl.path, FVector(0, 0, lvl.Z), FRotator(0), b, instanceStr)) {
|
|
newlvl->SetPriority(lvl.coords.flat == -1 ? 1 : 0);
|
|
newlvl->bShouldBlockOnLoad = lvl.dontUnload;
|
|
cppdynamicLvls.Add(instanceName);
|
|
Levelss.Add(newlvl);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (cppdynamicLvls.Contains(instanceName)) UGameplayStatics::GetStreamingLevel(WorldContextObject, instanceName)->SetShouldBeLoaded(false);
|
|
}
|
|
}
|
|
|
|
cpplvlsForLoading.Empty();
|
|
return;
|
|
}
|
|
|
|
|
|
void UcppGI::cppCoordsEq(Fcppcoords coords, Fcppcoords coords1, bool relevantMinus2, bool fastEq, bool& flat_, bool& type_, bool& zone_, bool& house_, bool& section_, bool& floor_, bool& fullEq)
|
|
{
|
|
bool* outLvl[6] = { &flat_, &type_, &zone_, &house_, §ion_, &floor_ };
|
|
int32 c1[6] = { coords.flat,coords.type, coords.zone, coords.house, coords.section, coords.floor };
|
|
int32 c2[6] = { coords1.flat,coords1.type, coords1.zone, coords1.house, coords1.section, coords1.floor };
|
|
int32 mins[6] = { 0,0,1,1,1,0 };
|
|
if (fastEq) {
|
|
for (int32 i = 0; i < 6; i++)
|
|
{
|
|
*outLvl[i] = (c1[i] == c2[i]);
|
|
}
|
|
}
|
|
else {
|
|
for (int32 i = 0; i < 6; i++) {
|
|
*outLvl[i] = ((c1[i] < mins[i]) && (c2[i] < mins[i])) || (c1[i] == c2[i]) || (c1[i] == -2) || ((c2[i] == -2) && relevantMinus2);
|
|
}
|
|
}
|
|
fullEq = true;
|
|
for (const auto var : outLvl)
|
|
{
|
|
if (!*var)fullEq = false;
|
|
}
|
|
|
|
}
|
|
|
|
void UcppGI::avoidAutoState()
|
|
{
|
|
if (!soc)return;
|
|
|
|
DECLARE_CMD(CMD_NOP, cmd);
|
|
sendCommand(*soc, cmd);
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
}
|
|
|
|
void UcppGI::makeSocket(FString ip, int port)
|
|
{
|
|
//static char ipc[100];
|
|
wcstombs(&ipc[0], *ip, ip.Len() + 1);
|
|
//size_t sz;
|
|
//wcstombs_s(&sz, ipc, ip.Len(),*ip,ip.Len());
|
|
if(!soc) soc = new CSocket(&ipc[0], port);
|
|
connectSoc();
|
|
|
|
}
|
|
|
|
void UcppGI::connectSoc(const TCommand& command) {
|
|
if (!soc)return;
|
|
const TCommand _cmd = command;
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [ command]()
|
|
{
|
|
soc->connect_();
|
|
// sendCommand(*soc, command); not working(
|
|
|
|
});
|
|
}
|
|
|
|
void UcppGI::connectSoc() {
|
|
if (!soc)return;
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, []()
|
|
{
|
|
soc->connect_();
|
|
});
|
|
}
|
|
|
|
|
|
void UcppGI::setColor(uint8 code, FColor color)
|
|
{
|
|
if (!soc)return;
|
|
DECLARE_CMD(CMD_SET_COLOR, cmd);
|
|
cmd.code = code;
|
|
cmd.r = color.R, cmd.g = color.G, cmd.b = color.B;
|
|
if (!sendCommand(*soc, cmd)) {
|
|
connectSoc(cmd);
|
|
};
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
|
|
}
|
|
|
|
void UcppGI::setLight(int house, int floor, int strip, uint8 state)
|
|
{
|
|
if (!soc)return;
|
|
|
|
if (strip < 0) {
|
|
if (floor < 0) {
|
|
if (house < 0) {
|
|
DECLARE_CMD(CMD_SET_ALL_STATE, cmd);
|
|
cmd.state = state;
|
|
if (!sendCommand(*soc, cmd)) connectSoc(cmd);
|
|
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
return;
|
|
}
|
|
DECLARE_CMD(CMD_SET_BUILDING_STATE, cmd);
|
|
cmd.state = state;
|
|
cmd.building = house;
|
|
if (!sendCommand(*soc, cmd)) connectSoc( cmd);
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
return;
|
|
}
|
|
DECLARE_CMD(CMD_SET_FLOOR_STATE, cmd);
|
|
cmd.state = state;
|
|
cmd.building = house;
|
|
cmd.floor = floor;
|
|
if (!sendCommand(*soc, cmd)) connectSoc(cmd);
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
return;
|
|
}
|
|
DECLARE_CMD(CMD_SET_ROOM_STATE, cmd);
|
|
cmd.state = state;
|
|
cmd.building = house;
|
|
cmd.floor = floor;
|
|
cmd.strip = strip;
|
|
if (!sendCommand(*soc, cmd)) connectSoc(cmd);
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
|
|
}
|
|
|
|
void UcppGI::setPartState(uint8 part, uint8 state)
|
|
{
|
|
if (!soc)return;
|
|
DECLARE_CMD(CMD_SET_PART_MODE, cmd);
|
|
cmd.mode = state;
|
|
cmd.part = part;
|
|
if (!sendCommand(*soc, cmd)) connectSoc(cmd);
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [cmd]()
|
|
{});
|
|
|
|
|
|
}
|
|
|
|
void UcppGI::sendBytes(TArray<uint8> bytes)
|
|
{/*
|
|
if (!soc)return;
|
|
char ass=1;
|
|
//UIntToChar(bytes[0], &ass);
|
|
soc->write(reinterpret_cast<const char*>(&ass), sizeof(ass));*/
|
|
}
|
|
|
|
void UcppGI::Shutdown()
|
|
{
|
|
delete soc;
|
|
soc = nullptr;
|
|
Super::Shutdown();
|
|
return;
|
|
}
|