GameInstance.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Online/CoreOnlineFwd.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
#include "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineBaseTypes.h"
#include "Engine/NetworkDelegates.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "Subsystems/SubsystemCollection.h"
#include "GameFramework/OnlineReplStructs.h"
#include "ReplayTypes.h"
 
#include "GameInstance.generated.h"
 
class AGameModeBase;
class APlayerController;
class FOnlineSessionSearchResult;
class FTimerManager;
class UGameViewportClient;
class ULocalPlayer;
class UOnlineSession;
enum EPlayNetMode : int;
struct FLatentActionManager;
struct FNetDriverReplicationSystemConfig;
class ULevelEditorPlaySettings;
class IAnalyticsProvider;
namespace ERHIFeatureLevel { enum Type : int; }
 
// 
//  EWelcomeScreen,     //initial screen.  Used for platforms where we may not have a signed in user yet.
//  EMessageScreen,     //message screen.  Used to display a message - EG unable to connect to game.
//  EMainMenu,      //Main frontend state of the game.  No gameplay, just user/session management and UI.   
//  EPlaying,       //Game should be playable, or loading into a playable state.
//  EShutdown,      //Game is shutting down.
//  EUnknown,       //unknown state. mostly for some initializing game-logic objects.
 
namespace GameInstanceState
{
    extern ENGINE_API const FName Playing;          // We are playing the game
}
 
class FOnlineSessionSearchResult;
 
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnPreClientTravel, const FString& /*PendingURL*/, ETravelType /*TravelType*/, bool /*bIsSeamlessTravel*/);
typedef FOnPreClientTravel::FDelegate FOnPreClientTravelDelegate;
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnPawnControllerChanged, APawn*, Pawn, AController*, Controller);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnUserInputDeviceConnectionChange, EInputDeviceConnectionState, NewConnectionState, FPlatformUserId, PlatformUserId, FInputDeviceId, InputDeviceId);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnUserInputDevicePairingChange, FInputDeviceId, InputDeviceId, FPlatformUserId, NewUserPlatformId, FPlatformUserId, OldUserPlatformId);
 
 
#if WITH_EDITOR
 
// The result of a UGameInstance PIE operation
struct FGameInstancePIEResult
{
public:
    // If not, what was the failure reason
    FText FailureReason;
 
    // Did the PIE operation succeed?
    bool bSuccess;
 
public:
    static FGameInstancePIEResult Success()
    {
        return FGameInstancePIEResult(true, FText::GetEmpty());
    }
 
    static FGameInstancePIEResult Failure(const FText& InReason)
    {
        return FGameInstancePIEResult(false, InReason);
    }
 
    bool IsSuccess() const
    {
        return bSuccess;
    }
private:
    FGameInstancePIEResult(bool bWasSuccess, const FText& InReason)
        : FailureReason(InReason)
        , bSuccess(bWasSuccess)
    {
    }
};
 
// Parameters used to initialize / start a PIE game instance
//@TODO: Some of these are really mutually exclusive and should be refactored (put into a struct to make this easier in the future)
struct FGameInstancePIEParameters
{
    ENGINE_API FGameInstancePIEParameters();
 
    // Are we doing SIE instead of PIE?
    bool bSimulateInEditor;
 
    // Were there any BP compile errors?
    bool bAnyBlueprintErrors;
 
    // Should we start in spectator mode?
    bool bStartInSpectatorMode;
 
    // Is this a dedicated server instance for PIE?
    bool bRunAsDedicated;
 
    // Is this the primary PIE client?
    bool bIsPrimaryPIEClient;
 
    // What time did we start PIE in the editor?
    double PIEStartTime = 0;
 
    // The feature level that PIE world should use
    ERHIFeatureLevel::Type WorldFeatureLevel;
 
    // Kept alive externally.
    ULevelEditorPlaySettings* EditorPlaySettings;
 
    // Which net mode should this PIE instance start in? Affects which maps are loaded.
    EPlayNetMode NetMode;
 
    // The map we should force the game to load instead of the one currently running in the editor. Blank for no override
    FString OverrideMapURL;
};
 
#endif
 
enum class EInputDeviceConnectionState : uint8;
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnLocalPlayerEvent, ULocalPlayer*);
 
UCLASS(config=Game, transient, BlueprintType, Blueprintable, MinimalAPI)
class UGameInstance : public UObject, public FExec
{
    GENERATED_UCLASS_BODY()
 
protected:
    struct FWorldContext* WorldContext;
 
    // @todo jcf list of logged-in players?
 
    ENGINE_API virtual bool HandleOpenCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
    ENGINE_API virtual bool HandleDisconnectCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
    ENGINE_API virtual bool HandleReconnectCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
    ENGINE_API virtual bool HandleTravelCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
 
    ENGINE_API void OnPlayTogetherEventReceived(int32 UserIndex, const TArray<const FUniqueNetId&>& UserList);
 
    ENGINE_API void OnConsoleInput(const FString& Command);
 
    UPROPERTY()
    TArray<TObjectPtr<ULocalPlayer>> LocalPlayers;
    
    UPROPERTY()
    TObjectPtr<class UOnlineSession> OnlineSession;
 
    UPROPERTY()
    TArray<TObjectPtr<UObject>> ReferencedObjects;
 
    FOnPreClientTravel NotifyPreClientTravelDelegates;
 
    UPROPERTY(BlueprintAssignable, DisplayName=OnPawnControllerChanged)
    FOnPawnControllerChanged OnPawnControllerChangedDelegates;
 
    FDelegateHandle OnPlayTogetherEventReceivedDelegateHandle;
 
public:
 
    FString PIEMapName;
#if WITH_EDITOR
    double PIEStartTime = 0;
    bool bReportedPIEStartupTime = false;
#endif
 
    //~ Begin FExec Interface
#if UE_ALLOW_EXEC_COMMANDS
    ENGINE_API virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out = *GLog) override;
#endif
    //~ End FExec Interface
 
    //~ Begin UObject Interface
    ENGINE_API virtual class UWorld* GetWorld() const final;
    ENGINE_API virtual void FinishDestroy() override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    //~ End UObject Interface
 
    ENGINE_API virtual void Init();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Init"))
    ENGINE_API void ReceiveInit();
 
    ENGINE_API virtual void Shutdown();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Shutdown"))
    ENGINE_API void ReceiveShutdown();
 
    ENGINE_API virtual void HandleInputDeviceConnectionChange(EInputDeviceConnectionState NewConnectionState, FPlatformUserId PlatformUserId, FInputDeviceId InputDeviceId);
 
    UPROPERTY(BlueprintAssignable, DisplayName=OnInputDeviceConnectionChange)
    FOnUserInputDeviceConnectionChange OnInputDeviceConnectionChange;
    
    ENGINE_API virtual void HandleInputDevicePairingChange(FInputDeviceId InputDeviceId, FPlatformUserId NewUserPlatformId, FPlatformUserId OldUserPlatformId);
 
    UPROPERTY(BlueprintAssignable, DisplayName=OnUserInputDevicePairingChange)
    FOnUserInputDevicePairingChange OnUserInputDevicePairingChange;
    
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "NetworkError"))
    ENGINE_API void HandleNetworkError(ENetworkFailure::Type FailureType, bool bIsServer);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "TravelError"))
    ENGINE_API void HandleTravelError(ETravelFailure::Type FailureType);
 
    /* Called to initialize the game instance for standalone instances of the game */
    ENGINE_API void InitializeStandalone(const FName InWorldName = NAME_None, UPackage* InWorldPackage = nullptr);
 
    /* Called to initialize the game instance with a minimal world suitable for basic network RPC */
    ENGINE_API void InitializeForMinimalNetRPC(const FName InPackageName);
 
    static ENGINE_API void CreateMinimalNetRPCWorld(const FName InPackageName, UPackage*& OutWorldPackage, UWorld*& OutWorld);
 
#if WITH_EDITOR
    /* Called to initialize the game instance for PIE instances of the game */
    ENGINE_API virtual FGameInstancePIEResult InitializeForPlayInEditor(int32 PIEInstanceIndex, const FGameInstancePIEParameters& Params);
 
    /* Called to actually start the game when doing Play/Simulate In Editor */
    ENGINE_API virtual FGameInstancePIEResult StartPlayInEditorGameInstance(ULocalPlayer* LocalPlayer, const FGameInstancePIEParameters& Params);
 
    ENGINE_API virtual FGameInstancePIEResult PostCreateGameModeForPIE(const FGameInstancePIEParameters& Params, AGameModeBase* GameMode);
 
    ENGINE_API virtual void ReportPIEStartupTime();
#endif
 
    ENGINE_API class UEngine* GetEngine() const;
 
    struct FWorldContext* GetWorldContext() const { return WorldContext; };
    ENGINE_API class UGameViewportClient* GetGameViewportClient() const;
 
    ENGINE_API virtual void OnWorldChanged(UWorld* OldWorld, UWorld* NewWorld);
 
    ENGINE_API virtual void StartGameInstance();
    virtual bool JoinSession(ULocalPlayer* LocalPlayer, int32 SessionIndexInSearchResults) { return false; }
    virtual bool JoinSession(ULocalPlayer* LocalPlayer, const FOnlineSessionSearchResult& SearchResult) { return false; }
 
    virtual void LoadComplete(const float LoadTime, const FString& MapName) {}
 
    FOnLocalPlayerEvent OnLocalPlayerAddedEvent;
    FOnLocalPlayerEvent OnLocalPlayerRemovedEvent;
 
    UFUNCTION(exec)
    ENGINE_API virtual void         DebugCreatePlayer(int32 ControllerId);
 
    UFUNCTION(exec)
    ENGINE_API virtual void         DebugRemovePlayer(int32 ControllerId);
 
    ENGINE_API virtual ULocalPlayer*    CreateInitialPlayer(FString& OutError);
 
    ENGINE_API ULocalPlayer*            CreateLocalPlayer(int32 ControllerId, FString& OutError, bool bSpawnPlayerController);
 
    ENGINE_API ULocalPlayer* CreateLocalPlayer(FPlatformUserId UserId, FString& OutError, bool bSpawnPlayerController);
 
    ENGINE_API virtual int32 AddLocalPlayer(ULocalPlayer* NewPlayer, FPlatformUserId UserId);
 
    ENGINE_API virtual bool         RemoveLocalPlayer(ULocalPlayer * ExistingPlayer);
    
    ENGINE_API int32                    GetNumLocalPlayers() const;
 
    ENGINE_API ULocalPlayer*            GetLocalPlayerByIndex(const int32 Index) const;
 
    ENGINE_API ULocalPlayer*            GetFirstGamePlayer() const;
 
    ENGINE_API APlayerController*       GetFirstLocalPlayerController(const UWorld* World = nullptr) const;
 
    ENGINE_API ULocalPlayer*            FindLocalPlayerFromControllerId(const int32 ControllerId) const;
    
    ENGINE_API ULocalPlayer* FindLocalPlayerFromPlatformUserId(const FPlatformUserId UserId) const;
 
    ENGINE_API ULocalPlayer* FindLocalPlayerFromDeviceId(const FInputDeviceId DeviceID) const;
 
    ENGINE_API ULocalPlayer*            FindLocalPlayerFromUniqueNetId(FUniqueNetIdPtr UniqueNetId) const;
    ENGINE_API ULocalPlayer*            FindLocalPlayerFromUniqueNetId(const FUniqueNetId& UniqueNetId) const;
    ENGINE_API ULocalPlayer*            FindLocalPlayerFromUniqueNetId(const FUniqueNetIdRepl& UniqueNetId) const;
 
    ENGINE_API TArray<ULocalPlayer*>::TConstIterator    GetLocalPlayerIterator() const;
 
    ENGINE_API const TArray<ULocalPlayer*> &            GetLocalPlayers() const;
 
    ENGINE_API APlayerController* GetPrimaryPlayerController(bool bRequiresValidUniqueId = true) const;
 
    ENGINE_API FUniqueNetIdRepl GetPrimaryPlayerUniqueIdRepl() const;
 
    ENGINE_API void CleanupGameViewport();
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.1, "Now takes a EReplayResult instead.")
    virtual void HandleDemoPlaybackFailure(EDemoPlayFailure::Type FailureType, const FString& ErrorString = TEXT("")) { }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    virtual void HandleDemoPlaybackFailure(const UE::Net::TNetResult<EReplayResult>& Result) { }
 
    virtual void HandleDemoRecordFailure(const UE::Net::TNetResult<EReplayResult>& Result) { }
 
    virtual void OnSeamlessTravelDuringReplay() { }
 
    inline FTimerManager& GetTimerManager() const { return *TimerManager; }
 
    inline FLatentActionManager& GetLatentActionManager() const { return *LatentActionManager;  }
 
    UGameInstanceSubsystem* GetSubsystemBase(TSubclassOf<UGameInstanceSubsystem> SubsystemClass) const
    {
        return SubsystemCollection.GetSubsystem<UGameInstanceSubsystem>(SubsystemClass);
    }
 
    template <typename TSubsystemClass>
    TSubsystemClass* GetSubsystem() const
    {
        return SubsystemCollection.GetSubsystem<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    static inline TSubsystemClass* GetSubsystem(const UGameInstance* GameInstance)
    {
        if (GameInstance)
        {
            return GameInstance->GetSubsystem<TSubsystemClass>();
        }
        return nullptr;
    }
 
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetSubsystemArrayCopy() const
    {
        return SubsystemCollection.GetSubsystemArrayCopy<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    void ForEachSubsystem(TFunctionRef<void(TSubsystemClass*)> Operation) const
    {
        static_assert(TIsDerivedFrom<TSubsystemClass, UGameInstanceSubsystem>::IsDerived, "TSubsystemClass must be derived from UGameInstanceSubsystem");
        return SubsystemCollection.ForEachSubsystem([Operation=MoveTemp(Operation)](UGameInstanceSubsystem* Subsystem){
            Operation(CastChecked<TSubsystemClass>(Subsystem));
        }, TSubsystemClass::StaticClass());
    }
 
    ENGINE_API virtual void StartRecordingReplay(const FString& InName, const FString& FriendlyName, const TArray<FString>& AdditionalOptions = TArray<FString>(), TSharedPtr<IAnalyticsProvider> AnalyticsProvider = nullptr);
 
    ENGINE_API virtual void StopRecordingReplay();
 
    ENGINE_API virtual bool PlayReplay(const FString& InName, UWorld* WorldOverride = nullptr, const TArray<FString>& AdditionalOptions = TArray<FString>());
 
    ENGINE_API virtual bool IsReplayDeferred(const FString& ReplayName) const;
 
    ENGINE_API bool PlayReplayPlaylist(const struct FReplayPlaylistParams& PlaylistParams);
 
    ENGINE_API virtual void AddUserToReplay(const FString& UserString);
 
    ENGINE_API virtual bool EnableListenServer(bool bEnable, int32 PortOverride = 0);
 
    virtual void HandleGameNetControlMessage(class UNetConnection* Connection, uint8 MessageByte, const FString& MessageStr)
    {}
    
    ENGINE_API virtual void ReceivedNetworkEncryptionToken(const FString& EncryptionToken, const FOnEncryptionKeyResponse& Delegate);
 
    ENGINE_API virtual void ReceivedNetworkEncryptionAck(const FOnEncryptionKeyResponse& Delegate);
 
    ENGINE_API virtual EEncryptionFailureAction ReceivedNetworkEncryptionFailure(UNetConnection* Connection);
 
    ENGINE_API virtual void PreloadContentForURL(FURL InURL);
 
    ENGINE_API virtual class AGameModeBase* CreateGameModeForURL(FURL InURL, UWorld* InWorld);
 
    ENGINE_API virtual void SetPersistentTravelURL(FURL InURL);
 
    ENGINE_API virtual TSubclassOf<AGameModeBase> OverrideGameModeClass(TSubclassOf<AGameModeBase> GameModeClass, const FString& MapName, const FString& Options, const FString& Portal) const;
 
 
    virtual void ModifyClientTravelLevelURL(FString& LevelName)
    {
    }
 
    virtual bool DelayPendingNetGameTravel()
    {
        return false;
    }
 
    virtual bool DelayCompletionOfPendingNetGameTravel()
    {
        return false;
    }
 
    FTimerManager* TimerManager;
    FLatentActionManager* LatentActionManager;
 
    class UOnlineSession* GetOnlineSession() const { return OnlineSession; }
 
    ENGINE_API virtual TSubclassOf<UOnlineSession> GetOnlineSessionClass();
 
    ENGINE_API bool IsDedicatedServerInstance() const;
 
    ENGINE_API virtual FName GetOnlinePlatformName() const;
 
    ENGINE_API virtual bool ClientTravelToSession(int32 ControllerId, FName InSessionName);
 
    ENGINE_API void NotifyPreClientTravel(const FString& PendingURL, ETravelType TravelType, bool bIsSeamlessTravel);
    FOnPreClientTravel& OnNotifyPreClientTravel() { return NotifyPreClientTravelDelegates; }
 
    FOnPawnControllerChanged& GetOnPawnControllerChanged() { return OnPawnControllerChangedDelegates; }
 
    ENGINE_API virtual void ReturnToMainMenu();
 
    ENGINE_API virtual void RegisterReferencedObject(UObject* ObjectToReference);
 
    ENGINE_API virtual void UnregisterReferencedObject(UObject* ObjectToReference);
 
    ENGINE_API virtual EReplicationSystem GetDesiredReplicationSystem(FName InNetDriverDefinition) const;
 
    virtual void OverrideIrisReplicationSystemConfig(FNetDriverReplicationSystemConfig& OutConfig, bool bIsServer) const {}
 
protected:
    ENGINE_API void BroadcastOnStart();
 
    ENGINE_API virtual void OnStart();
 
    static ENGINE_API bool GetMapOverrideName(const TCHAR* CmdLine, FString& OverrideMapName);
 
private:
 
    FObjectSubsystemCollection<UGameInstanceSubsystem> SubsystemCollection;
};