GameMode.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 "Templates/SubclassOf.h"
#include "GameFramework/GameModeBase.h"
#include "GameMode.generated.h"
 
class APlayerState;
class ULocalMessage;
class UNetDriver;
 
namespace MatchState
{
    extern ENGINE_API const FName EnteringMap;          // We are entering this map, actors are not yet ticking
    extern ENGINE_API const FName WaitingToStart;       // Actors are ticking, but the match has not yet started
    extern ENGINE_API const FName InProgress;           // Normal gameplay is occurring. Specific games will have their own state machine inside this state
    extern ENGINE_API const FName WaitingPostMatch;     // Match has ended so we aren't accepting new players, but actors are still ticking
    extern ENGINE_API const FName LeavingMap;           // We are transitioning out of the map to another location
    extern ENGINE_API const FName Aborted;              // Match has failed due to network issues or other problems, cannot continue
 
    // If a game needs to add additional states, you may need to override HasMatchStarted and HasMatchEnded to deal with the new states
    // Do not add any states before WaitingToStart or after WaitingPostMatch
}
 
UCLASS(MinimalAPI)
class AGameMode : public AGameModeBase
{
    GENERATED_UCLASS_BODY()
 
    // Code to deal with the match state machine
 
    
    UFUNCTION(BlueprintCallable, Category="Game")
    FName GetMatchState() const { return MatchState; }
 
    UFUNCTION(BlueprintCallable, Category="Game")
    ENGINE_API virtual bool IsMatchInProgress() const;
 
    UFUNCTION(BlueprintCallable, Category="Game")
    ENGINE_API virtual void StartMatch();
 
    UFUNCTION(BlueprintCallable, Category="Game")
    ENGINE_API virtual void EndMatch();
 
    UFUNCTION(BlueprintCallable, Category="Game")
    ENGINE_API virtual void RestartGame();
 
    UFUNCTION(BlueprintCallable, Category="Game")
    ENGINE_API virtual void AbortMatch();
 
protected:
 
    UPROPERTY(Transient)
    FName MatchState;
 
    ENGINE_API virtual void SetMatchState(FName NewState);
 
    ENGINE_API virtual void OnMatchStateSet();
 
    UFUNCTION(BlueprintImplementableEvent, Category="Game", meta=(DisplayName="OnSetMatchState", ScriptName="OnSetMatchState"))
    ENGINE_API void K2_OnSetMatchState(FName NewState);
 
    // Games should override these functions to deal with their game specific logic
 
    ENGINE_API virtual void HandleMatchIsWaitingToStart();
 
    UFUNCTION(BlueprintNativeEvent, Category="Game")
    ENGINE_API bool ReadyToStartMatch();
 
    ENGINE_API virtual void HandleMatchHasStarted();
 
    UFUNCTION(BlueprintNativeEvent, Category="Game")
    ENGINE_API bool ReadyToEndMatch();
 
    ENGINE_API virtual void HandleMatchHasEnded();
 
    ENGINE_API virtual void HandleLeavingMap();
 
    ENGINE_API virtual void HandleMatchAborted();
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="GameMode")
    uint32 bDelayedStart : 1;
 
    UPROPERTY(BlueprintReadOnly, Category=GameMode)
    int32 NumSpectators;    
 
    UPROPERTY(BlueprintReadOnly, Category=GameMode)
    int32 NumPlayers;    
 
    UPROPERTY(BlueprintReadOnly, Category=GameMode)
    int32 NumBots;    
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=GameMode, meta=(DisplayName="Minimum Respawn Delay"))
    float MinRespawnDelay;
 
    UPROPERTY(BlueprintReadOnly, Category=GameMode)
    int32 NumTravellingPlayers;
 
    UPROPERTY()
    TSubclassOf<class ULocalMessage> EngineMessageClass;
 
    UPROPERTY()
    TArray<TObjectPtr<class APlayerState>> InactivePlayerArray;    
 
protected:
 
    UPROPERTY(EditAnywhere, Category=GameMode)
    float InactivePlayerStateLifeSpan;
 
    UPROPERTY(EditAnywhere, Category = GameMode)
    int32 MaxInactivePlayers;
 
    UPROPERTY(config)
    bool bHandleDedicatedServerReplays;
 
public:
 
    ENGINE_API virtual FString GetNetworkNumber();
    
    ENGINE_API void PlayerSwitchedToSpectatorOnly(APlayerController* PC);
 
    ENGINE_API void RemovePlayerControllerFromPlayerCount(APlayerController* PC);
 
    ENGINE_API virtual bool GetTravelType();
 
    UFUNCTION(Exec, BlueprintCallable, Category = AI)
    ENGINE_API virtual void Say(const FString& Msg);
 
    ENGINE_API virtual void Broadcast( AActor* Sender, const FString& Msg, FName Type = NAME_None );
 
    ENGINE_API virtual void BroadcastLocalized( AActor* Sender, TSubclassOf<ULocalMessage> Message, int32 Switch = 0, APlayerState* RelatedPlayerState_1 = NULL, APlayerState* RelatedPlayerState_2 = NULL, UObject* OptionalObject = NULL );
 
    ENGINE_API virtual void AddInactivePlayer(APlayerState* PlayerState, APlayerController* PC);
 
    ENGINE_API virtual bool FindInactivePlayer(APlayerController* PC);
 
    ENGINE_API virtual void OverridePlayerState(APlayerController* PC, APlayerState* OldPlayerState);
 
    ENGINE_API virtual void SetSeamlessTravelViewTarget(APlayerController* PC);
 
    ENGINE_API virtual void PreCommitMapChange(const FString& PreviousMapName, const FString& NextMapName);
 
    ENGINE_API virtual void PostCommitMapChange();
 
    ENGINE_API virtual void NotifyPendingConnectionLost(const FUniqueNetIdRepl& ConnectionUniqueId);
 
    ENGINE_API virtual void HandleDisconnect(UWorld* InWorld, UNetDriver* NetDriver);
 
    //~ Begin AActor Interface
    ENGINE_API virtual void Tick(float DeltaSeconds) override;
    //~ End AActor Interface
 
    //~ Begin AGameModeBase Interface
    ENGINE_API virtual void InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage) override;
    ENGINE_API virtual void StartPlay() override;
    ENGINE_API virtual bool HasMatchStarted() const override;
    ENGINE_API virtual bool HasMatchEnded() const override;
    ENGINE_API virtual void PostLogin(APlayerController* NewPlayer) override;
    ENGINE_API virtual void Logout(AController* Exiting) override;
    ENGINE_API virtual int32 GetNumPlayers() override;
    ENGINE_API virtual int32 GetNumSpectators() override;
    ENGINE_API virtual bool IsHandlingReplays() override;
    ENGINE_API virtual void HandleStartingNewPlayer_Implementation(APlayerController* NewPlayer) override;
    ENGINE_API virtual bool PlayerCanRestart_Implementation(APlayerController* Player) override;
    ENGINE_API virtual void PostSeamlessTravel() override;
    ENGINE_API virtual void HandleSeamlessTravelPlayer(AController*& C) override;
    ENGINE_API virtual void InitSeamlessTravelPlayer(AController* NewController) override;
    ENGINE_API virtual bool CanServerTravel(const FString& URL, bool bAbsolute) override;
    ENGINE_API virtual void StartToLeaveMap() override;
    ENGINE_API virtual bool SpawnPlayerFromSimulate(const FVector& NewLocation, const FRotator& NewRotation) override;
    //~ End AGameModeBase Interface
};