void ANUTActor::NetMulticastPing_Implementation()
{
UWorld* CurWorld = GetWorld();
if (CurWorld->GetNetMode() == NM_Client && !NUTNet::IsUnitTestWorld(CurWorld))
{
UE_LOG(LogUnitTest, Log, TEXT("Unit Test Client Ping."));
}
}
void UWorldComposition::UpdateStreamingState()
{
UWorld* PlayWorld = GetWorld();
check(PlayWorld);
// Commandlets and Dedicated server does not use distance based streaming and just loads everything
if (IsRunningCommandlet() || PlayWorld->GetNetMode() == NM_DedicatedServer)
{
UpdateStreamingState(FVector::ZeroVector);
return;
}
int32 NumPlayers = GEngine->GetNumGamePlayers(PlayWorld);
if (NumPlayers == 0)
{
return;
}
// calculate centroid location using local players views
bool bCinematic = false;
FVector CentroidLocation = FVector::ZeroVector;
TArray<FVector, TInlineAllocator<16>> Locations;
for (int32 PlayerIndex = 0; PlayerIndex < NumPlayers; ++PlayerIndex)
{
ULocalPlayer* Player = GEngine->GetGamePlayer(PlayWorld, PlayerIndex);
if (Player && Player->PlayerController)
{
FVector ViewLocation;
FRotator ViewRotation;
Player->PlayerController->GetPlayerViewPoint(ViewLocation, ViewRotation);
Locations.Add(ViewLocation);
CentroidLocation+= ViewLocation;
bCinematic|= Player->PlayerController->bCinematicMode;
}
}
// In case there is no valid views don't bother updating level streaming state
if (Locations.Num())
{
CentroidLocation/= Locations.Num();
if (PlayWorld->GetWorldSettings()->bEnableWorldOriginRebasing)
{
EvaluateWorldOriginLocation(CentroidLocation);
}
if (bCinematic)
{
UpdateStreamingStateCinematic(Locations.GetData(), Locations.Num());
}
else
{
UpdateStreamingState(Locations.GetData(), Locations.Num());
}
}
}
//----------------------------------------------------------------------//
// rendering
//----------------------------------------------------------------------//
FPrimitiveSceneProxy* UGameplayDebuggingComponent::CreateSceneProxy()
{
FDebugRenderSceneCompositeProxy* CompositeProxy = NULL;
AGameplayDebuggingReplicator* Replicator = Cast<AGameplayDebuggingReplicator>(GetOwner());
if (!World || World->GetNetMode() == NM_DedicatedServer)
{
return NULL;
}
if (!Replicator || !Replicator->IsDrawEnabled())
{
return NULL;
}
#if WITH_RECAST
if (ShouldReplicateData(EAIDebugDrawDataView::NavMesh))
{
FNavMeshSceneProxyData NewNavmeshRenderData;
NewNavmeshRenderData.Reset();
NewNavmeshRenderData.bNeedsNewData = false;
NewNavmeshRenderData.bEnableDrawing = false;
PrepareNavMeshData(&NewNavmeshRenderData);
NavMeshBounds = NewNavmeshRenderData.Bounds;
CompositeProxy = CompositeProxy ? CompositeProxy : (new FDebugRenderSceneCompositeProxy(this));
CompositeProxy->AddChild(new FRecastRenderingSceneProxy(this, &NewNavmeshRenderData, true));
}
#endif
#if USE_EQS_DEBUGGER
if (ShouldReplicateData(EAIDebugDrawDataView::EQS) && IsClientEQSSceneProxyEnabled())
{
const int32 EQSIndex = EQSLocalData.Num() > 0 ? FMath::Clamp(CurrentEQSIndex, 0, EQSLocalData.Num() - 1) : INDEX_NONE;
if (EQSLocalData.IsValidIndex(EQSIndex))
{
CompositeProxy = CompositeProxy ? CompositeProxy : (new FDebugRenderSceneCompositeProxy(this));
auto& CurrentLocalData = EQSLocalData[EQSIndex];
FString ViewFlagName = TEXT("Game");
#if WITH_EDITOR
UEditorEngine* EEngine = Cast<UEditorEngine>(GEngine);
if (EEngine && EEngine->bIsSimulatingInEditor)
{
ViewFlagName = TEXT("DebugAI");
}
#endif
CompositeProxy->AddChild(new FEQSSceneProxy(this, ViewFlagName, false, CurrentLocalData.SolidSpheres, CurrentLocalData.Texts));
}
}
#endif // USE_EQS_DEBUGGER
return CompositeProxy;
}
void UCheatManager::ToggleAILogging()
{
#if ENABLE_VISUAL_LOG
APlayerController* PC = GetOuterAPlayerController();
if (!PC)
{
return;
}
UWorld *World = GetWorld();
if (World && World->GetNetMode() == NM_Client)
{
PC->ServerToggleAILogging();
}
else
{
ServerToggleAILogging();
}
#endif
}
void AGameplayDebuggerPlayerManager::BeginPlay()
{
Super::BeginPlay();
UWorld* World = GetWorld();
const ENetMode NetMode = World->GetNetMode();
bHasAuthority = (NetMode != NM_Client);
bIsLocal = (NetMode != NM_DedicatedServer);
bInitialized = true;
if (bHasAuthority)
{
UpdateAuthReplicators();
SetActorTickEnabled(true);
}
for (int32 Idx = 0; Idx < PendingRegistrations.Num(); Idx++)
{
RegisterReplicator(*PendingRegistrations[Idx]);
}
PendingRegistrations.Empty();
}
void UWorldComposition::UpdateStreamingState(const FVector* InLocations, int32 Num)
{
UWorld* OwningWorld = GetWorld();
// Get the list of visible and hidden levels from current view point
TArray<FDistanceVisibleLevel> DistanceVisibleLevels;
TArray<FDistanceVisibleLevel> DistanceHiddenLevels;
GetDistanceVisibleLevels(InLocations, Num, DistanceVisibleLevels, DistanceHiddenLevels);
// Dedicated server always blocks on load
bool bShouldBlock = (OwningWorld->GetNetMode() == NM_DedicatedServer);
// Set distance hidden levels to unload
for (const auto& Level : DistanceHiddenLevels)
{
CommitTileStreamingState(OwningWorld, Level.TileIdx, false, false, bShouldBlock, Level.LODIndex);
}
// Set distance visible levels to load
for (const auto& Level : DistanceVisibleLevels)
{
CommitTileStreamingState(OwningWorld, Level.TileIdx, true, true, bShouldBlock, Level.LODIndex);
}
}
bool FGameplayDebugger::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
bool bHandled = false;
if (FParse::Command(&Cmd, TEXT("RunEQS")) && InWorld)
{
APlayerController* MyPC = InWorld->GetGameInstance() ? InWorld->GetGameInstance()->GetFirstLocalPlayerController() : nullptr;
UAISystem* AISys = UAISystem::GetCurrent(*InWorld);
UEnvQueryManager* EQS = AISys ? AISys->GetEnvironmentQueryManager() : NULL;
if (MyPC && EQS)
{
AGameplayDebuggingReplicator* DebuggingReplicator = NULL;
for (TActorIterator<AGameplayDebuggingReplicator> It(InWorld); It; ++It)
{
AGameplayDebuggingReplicator* A = *It;
if (!A->IsPendingKill())
{
DebuggingReplicator = A;
if (!DebuggingReplicator->IsGlobalInWorld() && DebuggingReplicator->GetLocalPlayerOwner() == MyPC)
{
break;
}
}
}
UObject* Target = DebuggingReplicator != NULL ? DebuggingReplicator->GetSelectedActorToDebug() : NULL;
FString QueryName = FParse::Token(Cmd, 0);
if (Target)
{
AISys->RunEQS(QueryName, Target);
}
else
{
MyPC->ClientMessage(TEXT("No debugging target to run EQS"));
}
}
return true;
}
if (FParse::Command(&Cmd, TEXT("EnableGDT")) == false)
{
return false;
}
FString UniquePlayerId = FParse::Token(Cmd, 0);
APlayerController* LocalPC = NULL;
UWorld* MyWorld = InWorld;
if (MyWorld == nullptr)
{
if (UniquePlayerId.Len() > 0)
{
// let's find correct world based on Player Id
const TIndirectArray<FWorldContext> WorldContexts = GEngine->GetWorldContexts();
for (auto& Context : WorldContexts)
{
if (Context.WorldType != EWorldType::Game && Context.WorldType != EWorldType::PIE)
{
continue;
}
UWorld *CurrentWorld = Context.World();
for (FConstPlayerControllerIterator Iterator = CurrentWorld->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PC = *Iterator;
if (PC && PC->PlayerState->UniqueId.ToString() == UniquePlayerId)
{
LocalPC = PC;
MyWorld = PC->GetWorld();
break;
}
}
if (LocalPC && MyWorld)
{
break;
}
}
}
}
if (MyWorld == nullptr)
{
return false;
}
if (LocalPC == nullptr)
{
if (UniquePlayerId.Len() > 0)
{
for (FConstPlayerControllerIterator Iterator = MyWorld->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = *Iterator;
UE_LOG(LogGameplayDebugger, Log, TEXT("- Client: %s"), *PlayerController->PlayerState->UniqueId.ToString());
if (PlayerController && PlayerController->PlayerState->UniqueId.ToString() == UniquePlayerId)
{
LocalPC = PlayerController;
break;
}
}
}
if (!LocalPC && MyWorld->GetNetMode() != NM_DedicatedServer)
{
LocalPC = MyWorld->GetGameInstance() ? MyWorld->GetGameInstance()->GetFirstLocalPlayerController() : nullptr;
}
}
if (LocalPC == nullptr)
{
return false;
}
if (MyWorld->GetNetMode() == NM_Client)
{
AGameplayDebuggingReplicator* Replicator = NULL;
for (TActorIterator<AGameplayDebuggingReplicator> It(MyWorld); It; ++It)
{
Replicator = *It;
if (Replicator && !Replicator->IsPendingKill())
{
APlayerController* PCOwner = Replicator->GetLocalPlayerOwner();
if (LocalPC == PCOwner)
{
break;
}
}
Replicator = NULL;
}
if (!Replicator)
{
LocalPC->ClientMessage(TEXT("Enabling GameplayDebugger on server, please wait for replicated data..."));
if (LocalPC->PlayerState)
{
const FString ServerCheatString = FString::Printf(TEXT("cheat EnableGDT %s"), *LocalPC->PlayerState->UniqueId.ToString());
UE_LOG(LogGameplayDebugger, Warning, TEXT("Sending to Server: %s"), *ServerCheatString);
LocalPC->ConsoleCommand(*ServerCheatString);
bHandled = true;
}
}
else
{
if (Replicator->IsToolCreated() == false)
{
Replicator->CreateTool();
}
Replicator->EnableTool();
bHandled = true;
}
}
else
{
UE_LOG(LogGameplayDebugger, Warning, TEXT("Got from client: EnableGDT %s"), *UniquePlayerId);
{
AGameplayDebuggingReplicator* Replicator = NULL;
for (TActorIterator<AGameplayDebuggingReplicator> It(MyWorld); It; ++It)
{
Replicator = *It;
if (Replicator && !Replicator->IsPendingKill())
{
APlayerController* PCOwner = Replicator->GetLocalPlayerOwner();
if (LocalPC == PCOwner)
{
break;
}
}
Replicator = NULL;
}
if (!Replicator)
{
CreateGameplayDebuggerForPlayerController(LocalPC);
for (TActorIterator<AGameplayDebuggingReplicator> It(MyWorld); It; ++It)
{
Replicator = *It;
if (Replicator && !Replicator->IsPendingKill())
{
APlayerController* PCOwner = Replicator->GetLocalPlayerOwner();
if (LocalPC == PCOwner)
{
break;
}
}
Replicator = NULL;
}
}
if (MyWorld->GetNetMode() != NM_DedicatedServer)
{
if (Replicator && !Replicator->IsToolCreated())
{
Replicator->CreateTool();
Replicator->EnableTool();
bHandled = true;
}
}
else
{
if (Replicator)
{
Replicator->ClientAutoActivate();
bHandled = true;
}
}
}
}
return bHandled;
#else
return false;
#endif //!(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
void SBlueprintEditorSelectedDebugObjectWidget::GenerateDebugWorldNames(bool bRestoreSelection)
{
TSharedPtr<FString> OldSelection;
// Store off the old selection
if (bRestoreSelection && DebugWorldsComboBox.IsValid())
{
OldSelection = DebugWorldsComboBox->GetSelectedItem();
}
DebugWorldNames.Empty();
DebugWorlds.Empty();
DebugWorlds.Add(NULL);
DebugWorldNames.Add(MakeShareable(new FString(GetDebugAllWorldsString())));
UWorld* PreviewWorld = NULL;
TSharedPtr<SSCSEditorViewport> PreviewViewportPtr = BlueprintEditor.Pin()->GetSCSViewport();
if (PreviewViewportPtr.IsValid())
{
PreviewWorld = PreviewViewportPtr->GetPreviewScene().GetWorld();
}
for (TObjectIterator<UWorld> It; It; ++It)
{
UWorld *TestWorld = *It;
if (!TestWorld || TestWorld->WorldType != EWorldType::PIE)
{
continue;
}
DebugWorlds.Add(TestWorld);
ENetMode NetMode = TestWorld->GetNetMode();
FString WorldName;
switch (NetMode)
{
case NM_Standalone:
WorldName = NSLOCTEXT("BlueprintEditor", "DebugWorldStandalone", "Standalone").ToString();
break;
case NM_ListenServer:
WorldName = NSLOCTEXT("BlueprintEditor", "DebugWorldListenServer", "Listen Server").ToString();
break;
case NM_DedicatedServer:
WorldName = NSLOCTEXT("BlueprintEditor", "DebugWorldDedicatedServer", "Dedicated Server").ToString();
break;
case NM_Client:
FWorldContext &PieContext = GEngine->WorldContextFromWorld(TestWorld);
WorldName = FString::Printf(TEXT("%s %d"), *NSLOCTEXT("BlueprintEditor", "DebugWorldClient", "Client").ToString(), PieContext.PIEInstance - 1);
break;
};
DebugWorldNames.Add(MakeShareable(new FString(WorldName)));
}
// Attempt to restore the old selection
if (bRestoreSelection && DebugWorldsComboBox.IsValid())
{
bool bMatchFound = false;
for (int32 WorldIdx = 0; WorldIdx < DebugWorldNames.Num(); ++WorldIdx)
{
if (*DebugWorldNames[WorldIdx] == *OldSelection)
{
DebugWorldsComboBox->SetSelectedItem(DebugWorldNames[WorldIdx]);
bMatchFound = true;
break;
}
}
// No match found, use the default option
if (!bMatchFound)
{
DebugWorldsComboBox->SetSelectedItem(DebugWorldNames[0]);
}
}
// Finally ensure we have a valid selection
if (DebugWorldsComboBox.IsValid())
{
TSharedPtr<FString> CurrentSelection = DebugWorldsComboBox->GetSelectedItem();
if (DebugWorldNames.Find(CurrentSelection) == INDEX_NONE)
{
if (DebugWorldNames.Num() > 0)
{
DebugWorldsComboBox->SetSelectedItem(DebugWorldNames[0]);
}
else
{
DebugWorldsComboBox->ClearSelection();
}
}
}
}
void UGameplayDebuggingComponent::ServerCollectNavmeshData_Implementation(FVector_NetQuantize10 TargetLocation)
{
#if WITH_RECAST
UNavigationSystem* NavSys = UNavigationSystem::GetCurrent(GetWorld());
ARecastNavMesh* NavData = GetNavData();
if (NavData == NULL)
{
NavmeshRepData.Empty();
return;
}
const double Timer1 = FPlatformTime::Seconds();
TArray<int32> Indices;
int32 TileX = 0;
int32 TileY = 0;
const int32 DeltaX[] = { 0, 1, 1, 0, -1, -1, -1, 0, 1 };
const int32 DeltaY[] = { 0, 0, 1, 1, 1, 0, -1, -1, -1 };
NavData->BeginBatchQuery();
// add 3x3 neighborhood of target
int32 TargetTileX = 0;
int32 TargetTileY = 0;
NavData->GetNavMeshTileXY(TargetLocation, TargetTileX, TargetTileY);
for (int32 i = 0; i < ARRAY_COUNT(DeltaX); i++)
{
const int32 NeiX = TargetTileX + DeltaX[i];
const int32 NeiY = TargetTileY + DeltaY[i];
if (FMath::Abs(NeiX - TileX) > 1 || FMath::Abs(NeiY - TileY) > 1)
{
NavData->GetNavMeshTilesAt(NeiX, NeiY, Indices);
}
}
const FNavDataConfig& NavConfig = NavData->GetConfig();
FColor NavMeshColors[RECAST_MAX_AREAS];
NavMeshColors[RECAST_DEFAULT_AREA] = NavConfig.Color.DWColor() > 0 ? NavConfig.Color : NavMeshRenderColor_RecastMesh;
for (uint8 i = 0; i < RECAST_DEFAULT_AREA; ++i)
{
NavMeshColors[i] = NavData->GetAreaIDColor(i);
}
TArray<uint8> UncompressedBuffer;
FMemoryWriter ArWriter(UncompressedBuffer);
int32 NumIndices = Indices.Num();
ArWriter << NumIndices;
for (int32 i = 0; i < NumIndices; i++)
{
FRecastDebugGeometry NavMeshGeometry;
NavMeshGeometry.bGatherPolyEdges = false;
NavMeshGeometry.bGatherNavMeshEdges = false;
NavData->GetDebugGeometry(NavMeshGeometry, Indices[i]);
NavMeshDebug::FTileData TileData;
const FBox TileBoundingBox = NavData->GetNavMeshTileBounds(Indices[i]);
TileData.Location = TileBoundingBox.GetCenter();
for (int32 VertIndex = 0; VertIndex < NavMeshGeometry.MeshVerts.Num(); ++VertIndex)
{
const NavMeshDebug::FShortVector SV = NavMeshGeometry.MeshVerts[VertIndex] - TileData.Location;
TileData.Verts.Add(SV);
}
for (int32 iArea = 0; iArea < RECAST_MAX_AREAS; iArea++)
{
const int32 NumTris = NavMeshGeometry.AreaIndices[iArea].Num();
if (NumTris)
{
NavMeshDebug::FAreaPolys AreaPolys;
for (int32 AreaIndicesIndex = 0; AreaIndicesIndex < NavMeshGeometry.AreaIndices[iArea].Num(); ++AreaIndicesIndex)
{
AreaPolys.Indices.Add(NavMeshGeometry.AreaIndices[iArea][AreaIndicesIndex]);
}
AreaPolys.Color = NavMeshColors[iArea];
TileData.Areas.Add(AreaPolys);
}
}
TileData.Links.Reserve(NavMeshGeometry.OffMeshLinks.Num());
for (int32 iLink = 0; iLink < NavMeshGeometry.OffMeshLinks.Num(); iLink++)
{
const FRecastDebugGeometry::FOffMeshLink& SrcLink = NavMeshGeometry.OffMeshLinks[iLink];
NavMeshDebug::FOffMeshLink Link;
Link.Left = SrcLink.Left - TileData.Location;
Link.Right = SrcLink.Right - TileData.Location;
Link.Color = ((SrcLink.Direction && SrcLink.ValidEnds) || (SrcLink.ValidEnds & FRecastDebugGeometry::OMLE_Left)) ? DarkenColor(NavMeshColors[SrcLink.AreaID]) : NavMeshRenderColor_OffMeshConnectionInvalid;
Link.PackedFlags.Radius = (int8)SrcLink.Radius;
Link.PackedFlags.Direction = SrcLink.Direction;
Link.PackedFlags.ValidEnds = SrcLink.ValidEnds;
TileData.Links.Add(Link);
}
ArWriter << TileData;
}
NavData->FinishBatchQuery();
const double Timer2 = FPlatformTime::Seconds();
const int32 HeaderSize = sizeof(int32);
NavmeshRepData.Init(0, HeaderSize + FMath::TruncToInt(1.1f * UncompressedBuffer.Num()));
const int32 UncompressedSize = UncompressedBuffer.Num();
int32 CompressedSize = NavmeshRepData.Num() - HeaderSize;
uint8* DestBuffer = NavmeshRepData.GetData();
FMemory::Memcpy(DestBuffer, &UncompressedSize, HeaderSize);
DestBuffer += HeaderSize;
FCompression::CompressMemory((ECompressionFlags)(COMPRESS_ZLIB | COMPRESS_BiasMemory),
(void*)DestBuffer, CompressedSize, (void*)UncompressedBuffer.GetData(), UncompressedSize);
NavmeshRepData.SetNum(CompressedSize + HeaderSize, false);
const double Timer3 = FPlatformTime::Seconds();
UE_LOG(LogGDT, Log, TEXT("Preparing navmesh data: %.1fkB took %.3fms (collect: %.3fms + compress %d%%: %.3fms)"),
NavmeshRepData.Num() / 1024.0f, 1000.0f * (Timer3 - Timer1),
1000.0f * (Timer2 - Timer1),
FMath::TruncToInt(100.0f * NavmeshRepData.Num() / UncompressedBuffer.Num()), 1000.0f * (Timer3 - Timer2));
#endif
if (World && World->GetNetMode() != NM_DedicatedServer)
{
OnRep_UpdateNavmesh();
}
}
void UGameplayDebuggingComponent::CollectEQSData()
{
#if USE_EQS_DEBUGGER
if (!ShouldReplicateData(EAIDebugDrawDataView::EQS))
{
return;
}
UWorld* World = GetWorld();
UEnvQueryManager* QueryManager = World ? UEnvQueryManager::GetCurrent(World) : NULL;
const AActor* Owner = GetSelectedActor();
AGameplayDebuggingReplicator* Replicator = Cast<AGameplayDebuggingReplicator>(GetOwner());
if (QueryManager == NULL || Owner == NULL)
{
return;
}
auto AllQueries = QueryManager->GetDebugger().GetAllQueriesForOwner(Owner);
const class APawn* OwnerAsPawn = Cast<class APawn>(Owner);
if (OwnerAsPawn != NULL && OwnerAsPawn->GetController())
{
const auto& AllControllerQueries = QueryManager->GetDebugger().GetAllQueriesForOwner(OwnerAsPawn->GetController());
AllQueries.Append(AllControllerQueries);
}
struct FEnvQueryInfoSort
{
FORCEINLINE bool operator()(const FEQSDebugger::FEnvQueryInfo& A, const FEQSDebugger::FEnvQueryInfo& B) const
{
return (A.Timestamp < B.Timestamp);
}
};
TArray<FEQSDebugger::FEnvQueryInfo> QueriesToSort = AllQueries;
QueriesToSort.Sort(FEnvQueryInfoSort()); //sort queries by timestamp
QueriesToSort.SetNum(FMath::Min<int32>(Replicator->MaxEQSQueries, AllQueries.Num()));
for (int32 Index = AllQueries.Num() - 1; Index >= 0; --Index)
{
auto &CurrentQuery = AllQueries[Index];
if (QueriesToSort.Find(CurrentQuery) == INDEX_NONE)
{
AllQueries.RemoveAt(Index);
}
}
EQSLocalData.Reset();
for (int32 Index = 0; Index < FMath::Min<int32>(Replicator->MaxEQSQueries, AllQueries.Num()); ++Index)
{
EQSDebug::FQueryData* CurrentLocalData = NULL;
CachedQueryInstance = AllQueries[Index].Instance;
const float CachedTimestamp = AllQueries[Index].Timestamp;
if (!CurrentLocalData)
{
EQSLocalData.AddZeroed();
CurrentLocalData = &EQSLocalData[EQSLocalData.Num()-1];
}
UEnvQueryDebugHelpers::QueryToDebugData(CachedQueryInstance.Get(), *CurrentLocalData);
CurrentLocalData->Timestamp = AllQueries[Index].Timestamp;
}
TArray<uint8> UncompressedBuffer;
FMemoryWriter ArWriter(UncompressedBuffer);
ArWriter << EQSLocalData;
const int32 UncompressedSize = UncompressedBuffer.Num();
const int32 HeaderSize = sizeof(int32);
EQSRepData.Init(0, HeaderSize + FMath::TruncToInt(1.1f * UncompressedSize));
int32 CompressedSize = EQSRepData.Num() - HeaderSize;
uint8* DestBuffer = EQSRepData.GetData();
FMemory::Memcpy(DestBuffer, &UncompressedSize, HeaderSize);
DestBuffer += HeaderSize;
FCompression::CompressMemory((ECompressionFlags)(COMPRESS_ZLIB | COMPRESS_BiasMemory), (void*)DestBuffer, CompressedSize, (void*)UncompressedBuffer.GetData(), UncompressedSize);
EQSRepData.SetNum(CompressedSize + HeaderSize, false);
if (World && World->GetNetMode() != NM_DedicatedServer)
{
OnRep_UpdateEQS();
}
#endif
}