bool UPlayer::Exec( UWorld* InWorld, const TCHAR* Cmd,FOutputDevice& Ar)
{
if(PlayerController)
{
// Since UGameViewportClient calls Exec on UWorld, we only need to explicitly
// call UWorld::Exec if we either have a null GEngine or a null ViewportClient
UWorld* World = PlayerController->GetWorld();
check(World);
check(InWorld == NULL || InWorld == World);
const bool bWorldNeedsExec = GEngine == NULL || Cast<ULocalPlayer>(this) == NULL || static_cast<ULocalPlayer*>(this)->ViewportClient == NULL;
APawn* PCPawn = PlayerController->GetPawnOrSpectator();
if( bWorldNeedsExec && World->Exec(World, Cmd,Ar) )
{
return true;
}
else if( PlayerController->PlayerInput && PlayerController->PlayerInput->ProcessConsoleExec(Cmd,Ar,PCPawn) )
{
return true;
}
else if( PlayerController->ProcessConsoleExec(Cmd,Ar,PCPawn) )
{
return true;
}
else if( PCPawn && PCPawn->ProcessConsoleExec(Cmd,Ar,PCPawn) )
{
return true;
}
else if( PlayerController->MyHUD && PlayerController->MyHUD->ProcessConsoleExec(Cmd,Ar,PCPawn) )
{
return true;
}
else if( World->GetGameInstance() && World->GetGameInstance()->ProcessConsoleExec(Cmd, Ar, PCPawn) )
{
return true;
}
else if( World->GetAuthGameMode() && World->GetAuthGameMode()->ProcessConsoleExec(Cmd,Ar,PCPawn) )
{
return true;
}
else if( PlayerController->CheatManager && PlayerController->CheatManager->ProcessConsoleExec(Cmd,Ar,PCPawn) )
{
return true;
}
else if (World->GameState && World->GameState->ProcessConsoleExec(Cmd, Ar, PCPawn))
{
return true;
}
else if (PlayerController->PlayerCameraManager && PlayerController->PlayerCameraManager->ProcessConsoleExec(Cmd, Ar, PCPawn))
{
return true;
}
}
return false;
}
APGGameMode::APGGameMode() :
PowerToWinFactor{ 2.f },
DecayRate{ 0.05f },
CurrentGameState{ EPGPlayState::EUnknown }
{
UWorld* World = GetWorld();
UGameInstance* GameInstance = (World != nullptr) ? World->GetGameInstance() : nullptr;
UPGGameInstance* PGGameInstance = Cast<UPGGameInstance>(GameInstance);
if (PGGameInstance && PGGameInstance->PlayerCharacterClass)
{
DefaultPawnClass = PGGameInstance->PlayerCharacterClass;
}
else
{
DefaultPawnClass = ARobotCharacter::StaticClass();
}
check(DefaultPawnClass);
PlayerControllerClass = APGPlayerController::StaticClass();
static auto HUDBlueprintClassName = TEXT("WidgetBlueprint'/Game/Blueprints/BatteryHUD.BatteryHUD_C'");
static auto HUDFinder = ConstructorHelpers::FClassFinder<UUserWidget>(HUDBlueprintClassName);
if (HUDFinder.Succeeded())
{
HUDWidgetClass = HUDFinder.Class;
}
}
void AGameplayDebuggingReplicator::TickActor(float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction)
{
Super::TickActor(DeltaTime, TickType, ThisTickFunction);
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
UWorld* World = GetWorld();
if (!IsGlobalInWorld() || !World || GetNetMode() == ENetMode::NM_Client || !IGameplayDebugger::IsAvailable())
{
// global level replicator don't have any local player and it's prepared to work only on servers
return;
}
UGameInstance* GameInstance = World->GetGameInstance();
if (!GameInstance || !World->IsGameWorld())
{
return;
}
PlayerControllersUpdateDelay -= DeltaTime;
if (PlayerControllersUpdateDelay <= 0)
{
for (FConstPlayerControllerIterator Iterator = World->GetPlayerControllerIterator(); Iterator; Iterator++)
{
APlayerController* PC = *Iterator;
if (PC)
{
IGameplayDebugger& Debugger = IGameplayDebugger::Get();
Debugger.CreateGameplayDebuggerForPlayerController(PC);
}
}
PlayerControllersUpdateDelay = 5;
}
#endif
}
void UBrainPauseMenuWidget::RestartLevel()
{
UWorld* world = GetWorld();
if (world)
{
UBrainGameInstance* gameInstance = Cast<UBrainGameInstance>(world->GetGameInstance());
if (gameInstance)
{
gameInstance->GetSaveManager()->FlushCachedSaveData();
UGameplayStatics::OpenLevel(world,FName(*world->GetName()));
}
}
}
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 AGameplayDebuggerReplicator::TickActor(float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction)
{
Super::TickActor(DeltaTime, TickType, ThisTickFunction);
#if ENABLED_GAMEPLAY_DEBUGGER
UWorld* World = GetWorld();
const ENetMode NetMode = GetNetMode();
if (!World)
{
// return without world
return;
}
UGameInstance* GameInstance = World->GetGameInstance();
if (!GameInstance || !World->IsGameWorld())
{
return;
}
if (NetMode != NM_DedicatedServer)
{
if (bActivationKeyPressed)
{
ActivationKeyTime += DeltaTime;
if (ActivationKeyTime >= GameplayDebuggerHelpers::ActivationKeyTimePch)
{
GEngine->bEnableOnScreenDebugMessages = false;
if (AHUD* const GameHUD = LocalPlayerOwner ? LocalPlayerOwner->GetHUD() : nullptr)
{
GameHUD->bShowHUD = false;
}
BindKeyboardInput(InputComponent);
ServerActivateGameplayDebugger(true);
ClientActivateGameplayDebugger(true);
bActivationKeyPressed = false;
}
}
if (bEnabledTargetSelection)
{
if (GetLocalPlayerOwner())
{
SelectTargetToDebug();
}
}
bool bMarkComponentsAsRenderStateDirty = false;
for (UGameplayDebuggerBaseObject* Obj : ReplicatedObjects)
{
if (Obj && Obj->IsRenderStateDirty())
{
if (!bMarkComponentsAsRenderStateDirty)
{
MarkComponentsRenderStateDirty();
}
bMarkComponentsAsRenderStateDirty = true;
Obj->CleanRenderStateDirtyFlag();
}
}
}
if (NetMode < NM_Client && LocalPlayerOwner)
{
TMap<FString, TArray<UGameplayDebuggerBaseObject*> > CategoryToClasses;
for (UGameplayDebuggerBaseObject* Obj : ReplicatedObjects)
{
if (Obj)
{
FString Category = Obj->GetCategoryName();
if (IsCategoryEnabled(Category))
{
CategoryToClasses.FindOrAdd(Category).Add(Obj);
}
}
}
for (auto It(CategoryToClasses.CreateIterator()); It; ++It)
{
TArray<UGameplayDebuggerBaseObject*>& CurrentObjects = It.Value();
for (UGameplayDebuggerBaseObject* Obj : CurrentObjects)
{
Obj->CollectDataToReplicateOnServer(LocalPlayerOwner, LastSelectedActorToDebug);
}
}
}
#endif
}