GameModeBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "Templates/SubclassOf.h"
#include "GameFramework/Actor.h"
#include "GameFramework/Pawn.h"
#include "GameFramework/Info.h"
#include "Engine/ServerStatReplicator.h"
#include "Online/CoreOnline.h"
#include "Net/Core/Connection/NetEnums.h"
#include "GameFramework/PlayerController.h"
#include "GameModeBase.generated.h"
 
class AGameSession;
class AGameStateBase;
class AHUD;
class APlayerState;
class ASpectatorPawn;
class UNetConnection;
class UPlayer;
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogGameMode, Log, All);
 
DECLARE_DELEGATE_RetVal(bool, FCanUnpause);
 
UCLASS(config = Game, notplaceable, BlueprintType, Blueprintable, Transient, hideCategories = (Info, Rendering, MovementReplication, Replication, Actor), meta = (ShortTooltip = "Game Mode Base defines the game being played, its rules, scoring, and other facets of the game type."), MinimalAPI)
class AGameModeBase : public AInfo
{
    GENERATED_UCLASS_BODY()
 
public:
 
    //~=============================================================================
    // Initializing the game
 
    ENGINE_API virtual void InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage);
 
    ENGINE_API virtual void InitGameState();
 
    UPROPERTY(BlueprintReadOnly, Category=GameMode)
    FString OptionsString;
 
 
    //~=============================================================================
    // Accessors for classes spawned by game
 
    ENGINE_API virtual TSubclassOf<AGameSession> GetGameSessionClass() const;
 
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category=Classes)
    ENGINE_API UClass* GetDefaultPawnClassForController(AController* InController);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Classes)
    TSubclassOf<AGameSession> GameSessionClass;
 
    UPROPERTY(EditAnywhere, NoClear, BlueprintReadOnly, Category=Classes)
    TSubclassOf<AGameStateBase> GameStateClass;
 
    UPROPERTY(EditAnywhere, NoClear, BlueprintReadOnly, Category=Classes)
    TSubclassOf<APlayerController> PlayerControllerClass;
 
    UPROPERTY(EditAnywhere, NoClear, BlueprintReadOnly, Category=Classes)
    TSubclassOf<APlayerState> PlayerStateClass;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Classes, meta = (DisplayName = "HUD Class"))
    TSubclassOf<AHUD> HUDClass;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Classes)
    TSubclassOf<APawn> DefaultPawnClass;
 
    UPROPERTY(EditAnywhere, NoClear, BlueprintReadOnly, Category=Classes)
    TSubclassOf<ASpectatorPawn> SpectatorClass;
 
    UPROPERTY(EditAnywhere, NoClear, BlueprintReadOnly, Category=Classes)
    TSubclassOf<APlayerController> ReplaySpectatorPlayerControllerClass;
 
    UPROPERTY(EditAnywhere, NoClear, BlueprintReadOnly, Category = Classes)
    TSubclassOf<AServerStatReplicator> ServerStatReplicatorClass;
 
    EReplicationSystem GetGameNetDriverReplicationSystem() const { return GameNetDriverReplicationSystem; }
 
    //~=============================================================================
    // Accessors for current state
 
    UPROPERTY(Transient)
    TObjectPtr<AGameSession> GameSession;
 
    UPROPERTY(Transient)
    TObjectPtr<AGameStateBase> GameState;
 
    template< class T >
    T* GetGameState() const
    {
        return Cast<T>(GameState);
    }
 
    UPROPERTY(Transient)
    TObjectPtr<AServerStatReplicator> ServerStatReplicator;
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual int32 GetNumPlayers();
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual int32 GetNumSpectators();
 
 
    //~=============================================================================
    // Starting/pausing/resetting the game
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void StartPlay();
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual bool HasMatchStarted() const;
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual bool HasMatchEnded() const;
 
    ENGINE_API virtual bool SetPause(APlayerController* PC, FCanUnpause CanUnpauseDelegate = FCanUnpause());
 
    ENGINE_API virtual bool ClearPause();
 
    ENGINE_API void ForceClearUnpauseDelegates(AActor* PauseActor);
 
    ENGINE_API virtual bool AllowPausing(APlayerController* PC = nullptr);
 
    ENGINE_API virtual bool IsPaused() const;
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API bool ShouldReset(AActor* ActorToReset);
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void ResetLevel();
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void ReturnToMainMenuHost();
 
    ENGINE_API virtual bool CanServerTravel(const FString& URL, bool bAbsolute);
 
    ENGINE_API virtual void ProcessServerTravel(const FString& URL, bool bAbsolute = false);
 
    ENGINE_API virtual void GetSeamlessTravelActorList(bool bToTransition, TArray<AActor*>& ActorList);
 
    ENGINE_API virtual void SwapPlayerControllers(APlayerController* OldPC, APlayerController* NewPC);
 
    ENGINE_API virtual TSubclassOf<APlayerController> GetPlayerControllerClassToSpawnForSeamlessTravel(APlayerController* PreviousPlayerController);
 
    ENGINE_API virtual void HandleSeamlessTravelPlayer(AController*& C);
 
    ENGINE_API virtual void PostSeamlessTravel();
 
    ENGINE_API virtual void StartToLeaveMap();
 
 
    //~=============================================================================
    // Player joining and leaving
 
    ENGINE_API virtual void GameWelcomePlayer(UNetConnection* Connection, FString& RedirectURL);
 
    ENGINE_API virtual void PreLogin(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage);
 
    DECLARE_DELEGATE_OneParam(FOnPreLoginCompleteDelegate, const FString& /*ErrorMsg*/);
 
    ENGINE_API virtual void PreLoginAsync(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId, const FOnPreLoginCompleteDelegate& OnComplete);
 
    ENGINE_API virtual APlayerController* Login(UPlayer* NewPlayer, ENetRole InRemoteRole, const FString& Portal, const FString& Options, const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage);
 
    ENGINE_API virtual void PostLogin(APlayerController* NewPlayer);
 
    UE_DEPRECATED(5.6, "This functionality has been moved into OnPostLogin. You cannot call that function directly, it is executed at the end of PostLogin.")
    ENGINE_API void DispatchPostLogin(AController* NewPlayer);
 
protected:
    ENGINE_API virtual void OnPostLogin(AController* NewPlayer);
 
public:
    UFUNCTION(BlueprintImplementableEvent, Category=Game, meta = (DisplayName = "OnPostLogin", ScriptName = "OnPostLogin"))
    ENGINE_API void K2_PostLogin(APlayerController* NewPlayer);
 
    ENGINE_API virtual void Logout(AController* Exiting);
 
    UFUNCTION(BlueprintImplementableEvent, Category=Game, meta = (DisplayName = "OnLogout", ScriptName = "OnLogout"))
    ENGINE_API void K2_OnLogout(AController* ExitingController);
 
    ENGINE_API virtual APlayerController* SpawnPlayerController(ENetRole InRemoteRole, const FString& Options);
 
    UE_DEPRECATED(4.20, "SpawnPlayerController with Location and Rotation is deprecated, call or override the version that takes an Option string instead")
    ENGINE_API virtual APlayerController* SpawnPlayerController(ENetRole InRemoteRole, FVector const& SpawnLocation, FRotator const& SpawnRotation);
    UE_DEPRECATED(4.20, "SpawnReplayPlayerController is deprecated, replay controller spawning is handled inside the new version of the SpawnPlayerController function")
    ENGINE_API virtual APlayerController* SpawnReplayPlayerController(ENetRole InRemoteRole, FVector const& SpawnLocation, FRotator const& SpawnRotation);
 
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API void HandleStartingNewPlayer(APlayerController* NewPlayer);
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API bool MustSpectate(APlayerController* NewPlayerController) const;
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API bool CanSpectate(APlayerController* Viewer, APlayerState* ViewTarget);
 
    UPROPERTY(EditAnywhere, Category=Game)
    FText DefaultPlayerName;
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void ChangeName(AController* Controller, const FString& NewName, bool bNameChange);
 
    UFUNCTION(BlueprintImplementableEvent,Category=Game,meta=(DisplayName="OnChangeName", ScriptName="OnChangeName"))
    ENGINE_API void K2_OnChangeName(AController* Other, const FString& NewName, bool bNameChange);
 
 
    //~=============================================================================
    // Spawning the player's pawn
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API AActor* ChoosePlayerStart(AController* Player);
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API AActor* FindPlayerStart(AController* Player, const FString& IncomingName = TEXT(""));
 
    UFUNCTION(BlueprintPure, Category=Game, meta = (DisplayName = "FindPlayerStart"))
    ENGINE_API AActor* K2_FindPlayerStart(AController* Player, const FString& IncomingName = TEXT(""));
 
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category=Game)
    ENGINE_API bool PlayerCanRestart(APlayerController* Player);
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void RestartPlayer(AController* NewPlayer);
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void RestartPlayerAtPlayerStart(AController* NewPlayer, AActor* StartSpot);
 
    UFUNCTION(BlueprintCallable, Category=Game)
    ENGINE_API virtual void RestartPlayerAtTransform(AController* NewPlayer, const FTransform& SpawnTransform);
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API APawn* SpawnDefaultPawnFor(AController* NewPlayer, AActor* StartSpot);
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API APawn* SpawnDefaultPawnAtTransform(AController* NewPlayer, const FTransform& SpawnTransform);
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API void InitStartSpot(AActor* StartSpot, AController* NewPlayer);
 
    UFUNCTION(BlueprintImplementableEvent, Category=Game, meta = (DisplayName = "OnRestartPlayer", ScriptName = "OnRestartPlayer"))
    ENGINE_API void K2_OnRestartPlayer(AController* NewPlayer);
 
    ENGINE_API virtual void SetPlayerDefaults(APawn* PlayerPawn);
 
 
    //~=============================================================================
    // Engine hooks
 
    ENGINE_API virtual bool AllowCheats(APlayerController* P);
 
    ENGINE_API virtual bool IsHandlingReplays();
 
    ENGINE_API virtual bool SpawnPlayerFromSimulate(const FVector& NewLocation, const FRotator& NewRotation);
 
    //~ Begin AActor Interface
    ENGINE_API virtual void PreInitializeComponents() override;
    ENGINE_API virtual void Reset() override;
    //~ End AActor Interface
 
protected:
    ENGINE_API virtual bool UpdatePlayerStartSpot(AController* Player, const FString& Portal, FString& OutErrorMessage);
 
    ENGINE_API virtual bool ShouldStartInCinematicMode(APlayerController* Player, bool& OutHidePlayer, bool& OutHideHud, bool& OutDisableMovement, bool& OutDisableTurning);
 
    ENGINE_API virtual void UpdateGameplayMuteList(APlayerController* aPlayer);
 
    ENGINE_API virtual FString InitNewPlayer(APlayerController* NewPlayerController, const FUniqueNetIdRepl& UniqueId, const FString& Options, const FString& Portal = TEXT(""));
 
    UFUNCTION(BlueprintNativeEvent, Category=Game)
    ENGINE_API void InitializeHUDForPlayer(APlayerController* NewPlayer);
 
    ENGINE_API virtual void GenericPlayerInitialization(AController* C);
 
    ENGINE_API virtual void ReplicateStreamingStatus(APlayerController* PC);
 
    ENGINE_API virtual bool ShouldSpawnAtStartSpot(AController* Player);
 
    ENGINE_API virtual void FinishRestartPlayer(AController* NewPlayer, const FRotator& StartRotation);
 
    ENGINE_API virtual void FailedToRestartPlayer(AController* NewPlayer);
 
    ENGINE_API virtual APlayerController* ProcessClientTravel(FString& URL, bool bSeamless, bool bAbsolute);
 
    ENGINE_API virtual void InitSeamlessTravelPlayer(AController* NewController);
 
    UFUNCTION(BlueprintImplementableEvent, Category=Game, meta=(DisplayName="OnSwapPlayerControllers", ScriptName="OnSwapPlayerControllers"))
    ENGINE_API void K2_OnSwapPlayerControllers(APlayerController* OldPC, APlayerController* NewPC);
 
    ENGINE_API virtual APlayerController* SpawnPlayerControllerCommon(ENetRole InRemoteRole, FVector const& SpawnLocation, FRotator const& SpawnRotation, TSubclassOf<APlayerController> InPlayerControllerClass);
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=GameMode)
    uint32 bUseSeamlessTravel : 1;
protected:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=GameMode)
    uint32 bStartPlayersAsSpectators : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=GameMode)
    uint32 bPauseable : 1;
 
    UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = GameMode)
    EReplicationSystem GameNetDriverReplicationSystem = EReplicationSystem::Default;
 
    TArray<FCanUnpause> Pausers;
 
private:
    // Hidden functions that don't make sense to use on this class.
    HIDE_ACTOR_TRANSFORM_FUNCTIONS();
};
 
class FGameModeEvents
{
public:
 
    DECLARE_EVENT_OneParam(AGameModeBase, FGameModeInitializedEvent, AGameModeBase* /*GameMode*/);
 
    DECLARE_EVENT_ThreeParams(AGameModeBase, FGameModePreLoginEvent, AGameModeBase* /*GameMode*/, const FUniqueNetIdRepl& /*NewPlayer*/, FString& /*ErrorMessage*/);
 
    DECLARE_EVENT_TwoParams(AGameModeBase, FGameModePostLoginEvent, AGameModeBase* /*GameMode*/, APlayerController* /*NewPlayer*/);
 
    DECLARE_EVENT_TwoParams(AGameModeBase, FGameModeLogoutEvent, AGameModeBase* /*GameMode*/, AController* /*Exiting*/);
 
    DECLARE_EVENT_OneParam(AGameModeBase, FGameModeMatchStateSetEvent, FName /*MatchState*/);
 
public: 
    
    static FGameModeInitializedEvent& OnGameModeInitializedEvent() { return GameModeInitializedEvent; } 
    static FGameModePreLoginEvent& OnGameModePreLoginEvent() { return GameModePreLoginEvent; }
    static FGameModePostLoginEvent& OnGameModePostLoginEvent() { return GameModePostLoginEvent; }
    static FGameModeLogoutEvent& OnGameModeLogoutEvent() { return GameModeLogoutEvent; }
    static FGameModeMatchStateSetEvent& OnGameModeMatchStateSetEvent() { return GameModeMatchStateSetEvent; }
 
    static ENGINE_API FGameModeInitializedEvent GameModeInitializedEvent;
    static ENGINE_API FGameModePreLoginEvent GameModePreLoginEvent;
    static ENGINE_API FGameModePostLoginEvent GameModePostLoginEvent;
    static ENGINE_API FGameModeLogoutEvent GameModeLogoutEvent;
    static ENGINE_API FGameModeMatchStateSetEvent GameModeMatchStateSetEvent;
};