ProjectXGameMode.h

Go to the documentation of this file.

// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/GameMode.h"
#include "ProjectXGameMode.generated.h"
 
class AProjectXPlayerController;
class AProjectXPlayerState;
class APlayerStart;
class UExperienceConfiguration;
class AProjectXVehicle;
class UVehicleSeatComponent;
class ULevelInfo;
 
namespace MatchState
{
    extern PROJECTX_API const FName WarmUp;
}
 
class AProjectXPlayerStateTeam;
 
USTRUCT(Blueprintable)
struct FTeamInfo
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
    int32 StartingTicketCount = INDEX_NONE;
 
    TArray<class APlayerStart*> PlayerStarts;
};
 
UENUM(BlueprintType)
enum class ETeamJoinResponse : uint8
{
    Success = 0,
    AlreadyOnTeam = 1,
    TeamFull = 2,
    TeamUnbalance = 3,
    InvalidTeam = 4,
    Failure = 5,
    None = 255
};
 
/* Events that will be broadcasted to client/clients relevant to team games. */
UENUM(BlueprintType)
enum class ETeamGameEvent : uint8
{
    TeamKillWarning = 0,
 
    None = 255
};
 
UENUM()
enum class EEndGameEvent : uint8
{
    EndGameGeneric = 0,
    EndGameTeam = 1,
    EndGameTeamPoints = 2,
    EndGameTeamTime = 3,
    EndGameTeamCaptures = 4,
};
 
USTRUCT()
struct FEndGameEvent
{
    GENERATED_USTRUCT_BODY()
 
    FEndGameEvent() { }
    FEndGameEvent(const int32 InWinningTeam) : WinningTeam(InWinningTeam) {}
    int32 WinningTeam = INDEX_NONE;
};
 
USTRUCT(Blueprintable)
struct FActorSpawnInfo
{
    GENERATED_USTRUCT_BODY()
 
    /* Which actor to spawn */
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite)
    TSubclassOf<class AActor> SpawnableActor = nullptr;
    /* The chance of this actor spawning is SpawnWeight / AllSpawnWeights. If you have 3 actors with 100 weight, your chance to spawn would be 100/300 or 1 in 3. */
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, meta = (ClampMin = "-1.0", ClampMax = "1000.0", UIMin = "-1.0", UIMax = "1000.0"))
    float SpawnWeight = 100.0f;
    /* Spawn this actor indefinitely so long as the system is running.*/
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite)
    bool bSpawnIndefinitely = true;
    /* Check this box if this only needs to spawn on the server. (For example, AI) */
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite)
    bool bAuthorityOnly = false;
    /* What is the minimum and maximum number of actors of this type that should be spawned?*/
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, meta = (EditCondition = "!bSpawnIndefinitely"))
    FVector2D SpawnMinMax = FVector2D(1.0f, 2.0f);
 
    FORCEINLINE const float GetMaxSpawn() const { return SpawnMinMax.Y; }
    FORCEINLINE const float GetMinSpawn() const { return SpawnMinMax.X; }
 
    bool operator!=(const FActorSpawnInfo& rhs) const
    {
        return SpawnableActor != rhs.SpawnableActor || SpawnWeight != rhs.SpawnWeight || bSpawnIndefinitely != rhs.bSpawnIndefinitely || SpawnedCount != rhs.SpawnedCount;
    }
    bool operator==(const FActorSpawnInfo& rhs) const
    {
        return SpawnableActor == rhs.SpawnableActor && SpawnWeight == rhs.SpawnWeight && bSpawnIndefinitely == rhs.bSpawnIndefinitely && SpawnedCount == rhs.SpawnedCount;
    }
 
    uint32 SpawnedCount = 0;
};
 
UCLASS(config = Game)
class AProjectXGameMode : public AGameMode
{
    GENERATED_UCLASS_BODY()
 
public:
    FORCEINLINE TSubclassOf<AHUD> GetHUDClass() const { return HUDClass; }
    FORCEINLINE TSubclassOf<AHUD> GetSpectatorHUDClass() const { return SpectatorHUDClass; }
    FORCEINLINE TSubclassOf<class ULocalMessage> GetExperienceEventMessageClass() const { return ExperienceEventMessageClass; }
    int32 GetMaxPlayers() const;
    FORCEINLINE int32 GetAverageFramerate() const { return AverageFrameRate; }
    FORCEINLINE int32 GetHighestAverageFramerate() const { return HighestFrameRate; }
    FORCEINLINE int32 GetLowestAverageFramerate() const { return LowestFrameRate; }
    FORCEINLINE int32 GetShortestFrame() const { return ShortestFrame; }
    FORCEINLINE int32 GetLongestFrame() const { return LongestFrame; }
    UExperienceConfiguration* GetExperienceConfiguration() const;
 
    /* gets the default gamemode object for clients to get config properties. */
    UFUNCTION(BlueprintPure, Category = GameMode, meta = (WorldContext = "WorldContextObject"))
    static AProjectXGameMode* GetGameModeDefaultObject(const UObject* WorldContextObject);
    
    UFUNCTION(BlueprintPure)
    bool AreLoadoutsEnabled() const {return bLoadoutsEnabled;}
 
    const TMap<uint8, FTeamInfo>& GetTeamConfig() const { return TeamStartingConfig; }
    virtual APawn* SpawnDefaultPawnAtTransform_Implementation(AController* NewPlayer, const FTransform& SpawnTransform) override;
    float GetRedeployRespawnTime() const { return RedeployRespawnTime; }
    float GetReviveDuration() const {return ReviveDuration;}
    bool GetPreventsIdleKickWhileDead() const { return bPreventIdleKickWhileDead; }
 
public:
    /* When victory is called, how long does the server wait to reload the map? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    float RestartMatchTime = 5.0f;
 
    virtual void InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage) override;
    virtual void Tick(float DeltaSeconds) override;
    virtual void InitGameState() override;
    virtual void UpdateNetDriver();
    virtual void StartPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void OnDeath(AController* Killed, AController* Killer, TSubclassOf<class UProjectXDamageType> DamageType, bool bWasHeadshot);
    virtual void OnTeamKill(APlayerController* Killer, APlayerController* Killed);
    virtual void StartMatch() override;
    virtual void EndWarmUp();
    virtual void RequestServerRestart();
    virtual bool IsMatchInProgress() const override;
    virtual void OnMatchStateSet() override;
    virtual void EndMatch();
    virtual void SetNextMapOverrideByName(const FName& NextMapName);
    virtual void FinishMatch(FEndGameEvent const& EndGameEvent);
    virtual void MatchStartRequest();
    virtual bool CanRestart() const;
 
    virtual bool IsMatchInWarmUp() const;
    /* Called RestartMatchTime after EndMatch() is called, decides if we're restarting the map or if we're travelling to a new one. */
    UFUNCTION()
    virtual void EndMatchTimer();
 
    UFUNCTION(BlueprintCallable, Category = GameMode)
    virtual bool RequestServerTravel(const FString& URL);
 
    virtual void RestartPlayer(AController* NewPlayer) override;
    virtual void FinishRestartPlayer(AController* NewPlayer, const FRotator& StartRotation);
 
    virtual void PreLogin(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage) override;
    virtual APlayerController* Login(UPlayer* NewPlayer, ENetRole InRemoteRole, const FString& Portal, const FString& Options, const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage) override;
    virtual void PostLogin(APlayerController* NewPlayer) override;
    virtual void Logout(AController* Exiting) override;
 
    virtual AActor* ChoosePlayerStart_Implementation(AController* Player) override;
    virtual UClass* GetDefaultPawnClassForController_Implementation(AController* Player) override;
    virtual UClass* GetDefaultHUDClassForController(APlayerController* Player) const;
    
    virtual void InitializeHUDForPlayer_Implementation(APlayerController* NewPlayer) override;
 
    void RegisterPostGameLineup(AActor* PostGamePodium);
 
    float GetPassiveUltChargeAmount();
 
    void UpdateGameModeWinStat(AProjectXPlayerState* const PXPlayerState);
 
    FORCEINLINE int32 GetPlayerMaxDeployables() const { return MaxPlayerDeployables; }
 
    UFUNCTION(BlueprintCallable)
    virtual bool ConsumeTicket(int32 Team, int32 Amount = 1);
    virtual ETeamJoinResponse JoinTeam(APlayerController* PlayerController, uint8 Team);
    virtual ETeamJoinResponse CanJoinTeam(APlayerController* PlayerController, uint8 Team) const;
 
    TArray<FActorSpawnInfo> GetWorldDropsOverrideArray() const { return WorldDropsOverride; }
 
    /* Default number of max players for this gamemode. Can be overridden by ini and commandline. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    int32 MaxPlayers = 16;
    /* Default number of max spectators for this gamemode. Can be overridden by ini and commandline. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Config, Category = GameMode)
    int32 MaxSpectators = 8;
    /* Largest allowed difference in team sizes for this gamemode. Can be overridden by ini and commandline. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Config, Category = GameMode)
    int32 MaxTeamImbalance = 1;
    /* When the first player joins, how long do we wait before starting the match? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    float MatchStartTime = 5.0f;
    /* Editor override for the setting 'MatchStartTime' */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    float MatchStartTimeEditor = 3.0f;
    /* The match will end if match length exceeds this value (seconds). -1 is no limit. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    float MatchLength = -1.0f;
    /*do players use loadouts*/
    UPROPERTY(EditDefaultsOnly, Config, BlueprintReadOnly, Category = GameMode)
    bool bLoadoutsEnabled = true;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameMode, meta = (DisplayName = "Minimum Redeploy Respawn Delay"))
    float RedeployRespawnTime = 10.0f;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameMode)
    bool bCanSwapTeams = true;
    /*This is a max number of deployables for each player per category IE (Turrets)*/
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameMode)
    int32 MaxPlayerDeployables = 1;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameMode)
    float ReviveDuration = 30.0f;
    /* If true, does not let the player be kicked when spectating */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameMode)
    bool bPreventIdleKickWhileDead = false;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Classes, meta = (DisplayName = "Spectator HUD Class"))
    TSubclassOf<AHUD> SpectatorHUDClass = NULL;
    UPROPERTY(EditDefaultsOnly, Config, Category = GameMode)
    TArray<FActorSpawnInfo> WorldDropsOverride;
    /* How long does this game mode keep waiting for players before asking for a restart? (seconds). Ignored if time is < 0 */
    UPROPERTY(EditDefaultsOnly, Config, BlueprintReadOnly, Category = GameMode)
    float ServerRestartTime = 0.f;
 
    UPROPERTY(EditDefaultsOnly, globalconfig, Category = Classes)
    TSubclassOf<class ULocalMessage> GameModeBroadcastMessage;
    UPROPERTY(EditDefaultsOnly, globalconfig, Category = Classes)
    TSubclassOf<class ULocalMessage> KillBroadcastMessage;
    UPROPERTY(EditDefaultsOnly, globalconfig, Category = Classes)
    TSubclassOf<class ULocalMessage> HeadshotKillBroadcastMessage;
    UPROPERTY(EditDefaultsOnly, globalconfig, Category = Classes)
    TSubclassOf<class ULocalMessage> MatchStartRequestMessage;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Classes, meta = (DisplayName = "Experience Event Class"))
    TSubclassOf<UExperienceConfiguration> ExperienceConfigurationClass = NULL;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Classes, meta = (DisplayName = "Experience Message Class"))
    TSubclassOf<ULocalMessage> ExperienceEventMessageClass = NULL;
 
    /* Team start information such as spawn points */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    TMap<uint8, FTeamInfo> TeamStartingConfig;
    int32 MaxTeamSize = 0;
 
    UPROPERTY(GlobalConfig)
    int32 TeamKillsToWarning = 2;
    UPROPERTY(GlobalConfig)
    int32 TeamKillsToKick = 5;
    UPROPERTY(GlobalConfig)
    int32 TeamKillsToSessionKick = 8;
    UPROPERTY(Config)
    float MatchLengthOverride = -1.0f;
    UPROPERTY(Config)
    float MaxPlayersOverride = -1.0f;
    UPROPERTY(Config)
    int32 MaxPlayerDeployablesOverride = -1;
    UPROPERTY(Config)
    TArray<int32> StartingTicketCountOverride;
 
    /* Rate at which the ultimate will charge passivly*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode)
    UCurveFloat* ChargeRateCurve;
 
    UPROPERTY(EditDefaultsOnly, Category = Classes)
    TSubclassOf<class ULocalMessage> TeamGameBroadcastMessage = NULL;
 
    FTimerHandle WarmUpTimer; //Timer for warmup
    FTimerHandle MatchTimer; //Timer for match
    FTimerHandle ServerResetTimer; //Timer for the server to call a restart since it's been sitting idle for too long
 
    TArray<APlayerStart*> LobbyPlayerStarts;
    TArray<APlayerStart*> MatchPlayerStarts;
 
    virtual TSubclassOf<AGameSession> GetGameSessionClass() const override;
    virtual void HandleMatchIsWaitingToStart() override;
    virtual void HandleMatchHasStarted() override;
    virtual void HandleMatchWarmupEnded();
 
 
    virtual void CalculateTicketWinCondition();
    virtual void CalculateTimeOutWinCondition();
    virtual int32 GetWinningTeamByTickets();
    //Called when a player initially joins the game. Attempts to assign the player to a preferred team and squad given their URL options or from their previous player state if applicable.
    virtual void AssignPlayerTeam(APlayerController* PlayerController, const FString& Options);
    virtual bool AssignPlayerTeamFromTarget(const FString& Target, APlayerController* PlayerController);
    virtual void AutoAssignPlayerTeam(APlayerController* PlayerController);
 
    virtual void CollectGamePlayObjects();
 
    void OnAntiCheatKickRequired(APlayerController* Player, const FString& KickReason);
    void OnAntiCheatMessageToClient(APlayerController* Recipient, TArrayView<const uint8> Message);
 
private:
    friend class AProjectXGameState;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode, meta = (AllowPrivateAccess = true))
    bool bUseMapRotation = true;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameMode, meta = (AllowPrivateAccess = true))
    TSubclassOf<AActor> PodiumClass;
    /* where in the world to spawn the podium*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = GameMode, meta = (AllowPrivateAccess = true))
    FVector PodiumSpawnLocation = FVector(0, 20000, 0);
    TMap<uint8, TArray<class APlayerStart*>> TeamStartLocations;
 
    TWeakObjectPtr<ULevelInfo> NextMapOverride = NULL;
    TArray<float> FrameRateList;
    int32 AverageFrameRate = 0;
    int32 LowestFrameRate = MAX_int32;
    int32 HighestFrameRate = 0;
    float ShortestFrame = MAX_FLT;
    float LongestFrame = 0.0f;
    bool bIsAntiCheatServerSessionActive = false;
};