CheatManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
//=============================================================================
// CheatManager
// Object within playercontroller that manages development "cheat"
// commands only spawned in single player mode
// No cheat manager is created in shipping builds.
//=============================================================================
 
#pragma once
 
#include "CheatManagerDefines.h"
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "UObject/ScriptMacros.h"
#include "UObject/Interface.h"
 
#include "CheatManager.generated.h"
 
struct FDebugTraceInfo
{
    // Line Trace Start
    FVector LineTraceStart;
 
    // Line Trace End
    FVector LineTraceEnd;
 
    // Hit Normal Start
    FVector HitNormalStart;
 
    // Hit Normal End
    FVector HitNormalEnd;
 
    // Hit ImpactNormal End
    FVector HitImpactNormalEnd;
 
    // Hit Location
    FVector HitLocation;
 
    // Half collision capsule height
    float CapsuleHalfHeight;
 
    // Half collision capsule radius
    float CapsuleRadius;
 
    // this is when blocked and penetrating
    uint32 bInsideOfObject:1;
 
    FDebugTraceInfo()
        : LineTraceStart(ForceInit)
        , LineTraceEnd(ForceInit)
        , HitNormalStart(ForceInit)
        , HitNormalEnd(ForceInit)
        , HitLocation(ForceInit)
        , CapsuleHalfHeight(0)
        , CapsuleRadius(0)
        , bInsideOfObject(false)
    {
    }
};
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnCheatManagerCreated, UCheatManager*);
 
 
UCLASS(Blueprintable, Within=CheatManager, MinimalAPI)
class UCheatManagerExtension : public UObject
{
    GENERATED_BODY()
 
public:
    ENGINE_API virtual UWorld* GetWorld() const override;
 
    UFUNCTION(BlueprintPure, Category = "Cheat Manager")
    ENGINE_API APlayerController* GetPlayerController() const;
 
    UFUNCTION(BlueprintNativeEvent, meta=(DisplayName = "Added To Cheat Manager", Keywords="Begin Play"))
    ENGINE_API void AddedToCheatManager();
    ENGINE_API virtual void AddedToCheatManager_Implementation();
 
    UFUNCTION(BlueprintNativeEvent, meta = (DisplayName = "Removed From Cheat Manager", Keywords = "End Play"))
    ENGINE_API void RemovedFromCheatManager();
    ENGINE_API virtual void RemovedFromCheatManager_Implementation();
 
    ENGINE_API virtual void DoExtensionSpecificBugItLog(FOutputDevice& OutputFile);
};
 
UCLASS(Blueprintable, Within=PlayerController, MinimalAPI)
class UCheatManager : public UObject
{
    GENERATED_UCLASS_BODY()
 
    //~UObject interface
    ENGINE_API virtual bool ProcessConsoleExec(const TCHAR* Cmd, FOutputDevice& Ar, UObject* Executor) override;
    //~End of UObject interface
 
    UPROPERTY()
    TObjectPtr<class ADebugCameraController> DebugCameraControllerRef;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Debug Camera")
    TSubclassOf<class ADebugCameraController>  DebugCameraControllerClass;
 
    // Trace/Sweep debug start
    uint32 bDebugCapsuleSweep:1;
 
    uint32 bDebugCapsuleTraceComplex:1;
 
    uint32 bToggleAILogging : 1;
 
    static ENGINE_API bool bDebugCapsuleSweepPawn;
 
    static inline bool IsDebugCapsuleSweepPawnEnabled() { return bDebugCapsuleSweepPawn; }
 
    float DebugTraceDistance;
 
    float DebugCapsuleHalfHeight;
 
    float DebugCapsuleRadius;
 
    float DebugTraceDrawNormalLength;
 
    TEnumAsByte<enum ECollisionChannel> DebugTraceChannel;
 
    TArray<struct FDebugTraceInfo> DebugTraceInfoList;
 
    TArray<struct FDebugTraceInfo> DebugTracePawnInfoList;
 
    int32 CurrentTraceIndex;
 
    int32 CurrentTracePawnIndex;
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void FreezeFrame(float Delay);
 
    /* Teleport to surface player is looking at. */
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void Teleport();
 
    /* Scale the player's size to be F * default size. */
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void ChangeSize(float F);
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void Fly();
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void Walk();
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void Ghost();
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void God();
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void Slomo(float NewTimeDilation);
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void DamageTarget(float DamageAmount);
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void DestroyTarget();
    
    UFUNCTION(exec)
    ENGINE_API virtual void DestroyAll(TSubclassOf<class AActor>  aClass);
 
    UFUNCTION(exec)
    ENGINE_API virtual void DestroyAllPawnsExceptTarget();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DestroyPawns(TSubclassOf<class APawn> aClass);
 
    UFUNCTION(exec)
    ENGINE_API virtual void Summon(const FString& ClassName);
 
    UFUNCTION(exec,BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void PlayersOnly();
 
    UFUNCTION(exec)
    ENGINE_API virtual void ViewSelf();
 
    UFUNCTION(exec)
    ENGINE_API virtual void ViewPlayer(const FString& S);
 
    UFUNCTION(exec)
    ENGINE_API virtual void ViewActor(FName ActorName);
 
    UFUNCTION(exec)
    ENGINE_API virtual void ViewClass(TSubclassOf<class AActor> DesiredClass);
 
    UFUNCTION(exec)
    ENGINE_API virtual void StreamLevelIn(FName PackageName);
 
    UFUNCTION(exec)
    ENGINE_API virtual void OnlyLoadLevel(FName PackageName);
 
    UFUNCTION(exec)
    ENGINE_API virtual void StreamLevelOut(FName PackageName);
 
    UFUNCTION(exec)
    ENGINE_API virtual void ToggleDebugCamera();
 
    ENGINE_API virtual bool IsDebugCameraActive() const;
 
    UFUNCTION(exec)
    ENGINE_API virtual void ToggleAILogging();
 
    UFUNCTION(reliable, server, WithValidation)
    ENGINE_API virtual void ServerToggleAILogging();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweep();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweepSize(float HalfHeight, float Radius);
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweepChannel(enum ECollisionChannel Channel);
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweepComplex(bool bTraceComplex);
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweepCapture();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweepPawn();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DebugCapsuleSweepClear();
 
    UFUNCTION(exec)
    ENGINE_API virtual void TestCollisionDistance();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DumpOnlineSessionState();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DumpPartyState();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DumpChatState();
 
    UFUNCTION(exec)
    ENGINE_API virtual void DumpVoiceMutingState();
 
    UFUNCTION(exec)
    ENGINE_API virtual void BugItGo(float X, float Y, float Z, float Pitch, float Yaw, float Roll);
 
    ENGINE_API virtual void BugItGoString(const FString& TheLocation, const FString& TheRotation);
 
    UFUNCTION(exec)
    ENGINE_API virtual void BugIt(const FString& ScreenShotDescription = TEXT(""));
 
    UFUNCTION(exec)
    ENGINE_API virtual void BugItStringCreator(FVector ViewLocation, FRotator ViewRotation, FString& GoString, FString& LocString);
 
    UFUNCTION(exec)
    ENGINE_API virtual void FlushLog();
 
    UFUNCTION(exec)
    ENGINE_API virtual void LogLoc();
 
    UFUNCTION(exec)
    ENGINE_API void SetWorldOrigin();
 
    UFUNCTION(exec)
    ENGINE_API virtual void SetMouseSensitivityToDefault();
 
    UFUNCTION(exec)
    ENGINE_API virtual void InvertMouse();
 
    UFUNCTION(exec)
    ENGINE_API void CheatScript(FString ScriptName);
 
    UFUNCTION(Exec)
    ENGINE_API void SpawnServerStatReplicator();
 
    UFUNCTION(Exec)
    ENGINE_API void DestroyServerStatReplicator();
 
    UFUNCTION(Exec)
    ENGINE_API void ToggleServerStatReplicatorClientOverwrite();
 
    UFUNCTION(Exec)
    ENGINE_API void ToggleServerStatReplicatorUpdateStatNet();
 
    UFUNCTION(exec)
    ENGINE_API void UpdateSafeArea();
 
    UFUNCTION()
    ENGINE_API void OnPlayerEndPlayed(AActor* Player, EEndPlayReason::Type EndPlayReason);
 
    ENGINE_API virtual void BugItWorker( FVector TheLocation, FRotator TheRotation );
 
    ENGINE_API virtual void LogOutBugItGoToLogFile( const FString& InScreenShotDesc, const FString& InScreenShotPath, const FString& InGoString, const FString& InLocString );
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API void TickCollisionDebug();
 
    ENGINE_API void AddCapsuleSweepDebugInfo(
        const FVector& LineTraceStart, 
        const FVector& LineTraceEnd, 
        const FVector& HitImpactLocation, 
        const FVector& HitNormal, 
        const FVector& HitImpactNormal, 
        const FVector& HitLocation, 
        float CapsuleHalfheight, 
        float CapsuleRadius, 
        bool bTracePawn, 
        bool bInsideOfObject ); 
 
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
    ENGINE_API virtual void SetLevelStreamingStatus(FName PackageName, bool bShouldBeLoaded, bool bShouldBeVisible);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Init Cheat Manager", Keywords="Begin Play"))
    ENGINE_API void ReceiveInitCheatManager();
 
    ENGINE_API virtual void InitCheatManager();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Shutdown", keywords="endplay"))
    ENGINE_API void ReceiveEndPlay();
    
    ENGINE_API virtual void BeginDestroy() override;
 
    ENGINE_API virtual UWorld* GetWorld() const override;
 
public:
    ENGINE_API void AddCheatManagerExtension(UCheatManagerExtension* CheatObject);
 
    ENGINE_API void RemoveCheatManagerExtension(UCheatManagerExtension* CheatObject);
    
    ENGINE_API UCheatManagerExtension* FindCheatManagerExtension(const UClass* InClass) const;
 
    template<typename T>
    T* FindCheatManagerExtension() const
    {
        return CastChecked<T>(FindCheatManagerExtension(T::StaticClass()), ECastCheckedType::NullAllowed);
    }
 
    ENGINE_API UCheatManagerExtension* FindCheatManagerExtensionInterface(const UClass* InClass) const;
 
    template<class T = UInterface>
    T* FindCheatManagerExtensionInterface() const
    {
        return CastChecked<T>(FindCheatManagerExtensionInterface(T::UClassType::StaticClass()), ECastCheckedType::NullAllowed);
    }
 
    static ENGINE_API FDelegateHandle RegisterForOnCheatManagerCreated(FOnCheatManagerCreated::FDelegate&& Delegate);
 
    static ENGINE_API void UnregisterFromOnCheatManagerCreated(FDelegateHandle DelegateHandle);
 
    ENGINE_API virtual bool DoGameSpecificBugItLog(FOutputDevice& OutputFile);
 
protected:
    UPROPERTY(Transient)
    TArray<TObjectPtr<UCheatManagerExtension>> CheatManagerExtensions;
 
    static ENGINE_API FOnCheatManagerCreated OnCheatManagerCreatedDelegate;
 
protected:
 
    UFUNCTION(BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void EnableDebugCamera();
    
    UFUNCTION(BlueprintCallable,Category="Cheat Manager")
    ENGINE_API virtual void DisableDebugCamera();
    
    ENGINE_API virtual AActor* GetTarget(APlayerController* PlayerController, struct FHitResult& OutHit);
 
public:
    UFUNCTION(BlueprintPure, Category = "Cheat Manager")
    ENGINE_API APlayerController* GetPlayerController() const;
};