ProjectXGameState.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Debug.h"
#include "ProjectX.h"
#include "GameFramework/GameState.h"
#include "Net/UnrealNetwork.h"
#include "Components/ActorComponent.h"
#include "ProjectXDamageType.h"
#include "GenericOctree.h"
#include "Gameplay/HealthInterface.h"
#include "WeakInterfacePtr.h"
#include "Team/SpawnTargetInterface.h"
#include "ProjectXGameState.generated.h"
 
#define INVALID_TEAM 255
 
 
class APlayerState;
class AProjectXGameMode;
class AProjectXCharacter;
class UProjectXPlayerState;
class APostGameScreen;
class APickup;
class APickupReviveBeacon;
 
UENUM(BlueprintType)
enum class EMatchResult : uint8
{
    Win = 0,
    Loss = 1,
    Tie = 2,
    None = 255,
};
 
UENUM(BlueprintType)
enum class EGameType : uint8
{
    NONE = 0,
    BaseControl = 1,
    Assault = 2,
    CaptureTheFlag = 3,
    TeamDeathmatch = 4,
    KingOfTheHill = 5,
    VIP = 6,
    Horde = 7,
    CUSTOM = 255,
};
 
UENUM(BlueprintType)
enum class EDifficultyLevel : uint8
{
    NONE = 0,
    Bronze = 1,
    Silver = 2,
    Gold = 3,
    Any = 254,
    CUSTOM = 255,
};
 
USTRUCT(Blueprintable)
struct FGenericTimerInfo
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY()
    float EndTime = INDEX_NONE;
    UPROPERTY()
    uint8 Type = 0;
};
 
USTRUCT(Blueprintable)
struct FTeamTicketInfo
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY()
    int16 Tickets = INDEX_NONE;
};
 
USTRUCT(Blueprintable)
struct FTeamScoreInfo
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY(BlueprintReadWrite, EditInstanceOnly, Category = "Score Info")
    uint8 Team;
    UPROPERTY(BlueprintReadWrite, EditInstanceOnly, Category = "Score Info")
    float Score;
};
 
struct FTargetableOctreeElement
{
public:
    TWeakObjectPtr<AActor> Targetable = nullptr;
    FBoxSphereBounds BoxSphereBounds;
 
    FTargetableOctreeElement()
    {
        BoxSphereBounds = FBoxSphereBounds(FVector(0.0f, 0.0f, 0.0f), FVector(1.0f, 1.0f, 1.0f), 1.0f);
    }
};
 
struct FTargetOctreeElementInfo
{
    FTargetOctreeElementInfo();
    FTargetOctreeElementInfo(FOctreeElementId InId, const FVector& Location) : Id(InId), CachedLocation(Location) {}
 
public:
    FOctreeElementId Id;
    FVector CachedLocation = FVector::ZeroVector;
};
 
USTRUCT()
struct FWorldPickupInfo
{
    GENERATED_BODY()
 
public:
    UPROPERTY()
    FVector_NetQuantize ExpectedTargetLocation = FVector::ZeroVector;
    UPROPERTY()
    FVector_NetQuantize SpawnLocation = FVector::ZeroVector;
    UPROPERTY()
    TSubclassOf<APickup> PickupClass;
    UPROPERTY()
    int32 PickupID = 0;
    TWeakObjectPtr<APickup> Pickup;
};
 
typedef TOctree<struct FTargetableOctreeElement, struct FTargetableOctreeSemantics> FTargetableOctree;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FKilledAlertSignature, AController*, Controller);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FServerBroadcastMessageSignature, FText, Message);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTrackableActorAddedSignature, const AActor*, Actor);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FServerBroadcastMarkedLocationSignature, AActor*, MarkedActor, TSubclassOf<UActorComponent>, MarkerToPlace);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FMatchStartSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerUltimatingSignature, AProjectXPlayerState*, Player);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnBotSpawnSignature, AProjectXCharacter*, SpawnedCharacter);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnBotKilledSignature, AProjectXCharacter*, KilledCharacter, FVector, SpawnLocation);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerStateAddedSignature, APlayerState*, AddedPlayerState);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerStateRemovedSignature, APlayerState*, RemovedPlayerState);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FMatchStateChangedSignature, FName, NewMatchState, FName, PreviousMatchState);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FiveParams(FKillFeedSignature, class AProjectXPlayerState*, Killer, class AProjectXPlayerState*, Killed, int32, Data, TSubclassOf<class UProjectXDamageType>, DamageType, bool, bWasHeadshot);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWinningTeamSignature, int32, WinningTeam);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTeamScoreChangedSignature, const TArray<FTeamScoreInfo>&, Scores);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTeamTicketChangedSignature, const TArray<FTeamTicketInfo>&, Tickets); 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWelcomeMessageChangedSignature, const FString&, WelcomeMessage);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FTimerStartSignature, const float, EndTime, const FText&, TimerDescription);
 
UCLASS(config = Game)
class PROJECTX_API AProjectXGameState : public AGameState
{
    GENERATED_UCLASS_BODY()
 
public:
    static FTargetableOctree* Octree;
    static TMap<uint32, FTargetOctreeElementInfo> TargetableOctreeElements;
    static void RegisterTargetableActor(AActor* const Targetable);
    static void DeRegisterTargetableActor(AActor* const Targetable);
    TArray<TWeakInterfacePtr<ISpawnTargetInterface>> GetSpawnTargetsRegisteredForScoring() const {return SpawnTargetsRegisteredForScoring; }
 
    template <class T> 
    TArray<T*> GetTargetableActorsInRadius(const FVector& Location, const float Radius, bool bMustBeAlive = false);
 
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE class UVehicleRespawnManager* GetVehicleRespawnManager() const { return VehicleRespawnManager; }
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE int32 GetWinningTeam() const { return WinningTeam; }
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE USquadComponent* GetSquadComponent() const { return SquadComponent; }
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE float GetMatchStartTime() const { return MatchStartTime; }
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE float GetTimeUntilMatchStart() const { return FMath::Clamp(MatchStartTime - GetServerWorldTimeSeconds(), 0.0f, BIG_NUMBER); }
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE float GetMatchElapsedTime() const { return GetServerWorldTimeSeconds() - MatchStartTime; }
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE float GetMatchTimeRemaining() const { return GetMatchLength() - GetMatchElapsedTime(); };
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE float GetMaxPlayers() const { return MaxPlayers; };
    UFUNCTION(BlueprintPure, Category = GameState)
    FORCEINLINE TSubclassOf<APickupReviveBeacon> GetReviveBeaconGlobalOverride() const { return GlobalReviveBeaconOverride; }
 
    UFUNCTION(BlueprintPure, Category = GameState)
    float GetMatchLength() const;
    /* Returns the predicted time length of the match based on the time it takes for a match to complete + time it takes it to start */
    UFUNCTION(BlueprintPure, Category = GameState)
    float GetMatchEndTime() const;
    /* Returns the timestamp of the real end of the match, not the predicted one like GetMatchEndTime does, careful, this is a REPLICATED variable, make sure its value is not -1 before using it */
    UFUNCTION(BlueprintPure, Category = GameState)
    float GetMatchEndTimestamp() const {return MatchEndTimestamp; }
    UFUNCTION(BlueprintPure, Category = GameState)
    float GetPostGameLength() const;
    UFUNCTION(BlueprintPure, Category = GameState)
    virtual EMatchResult GetPlayerResult(AProjectXPlayerState* PlayerState);
    UFUNCTION(BlueprintPure, Category = GameState)
    bool IsInWarmUp() const;
    UFUNCTION(BlueprintPure,Category = GameState)
    FORCEINLINE bool CanShowDeployScreen() const { return bShowDeployScreen;}
    UFUNCTION(BlueprintPure, Category = "Game Mode")
    virtual int32 GetTicketCount(uint8 Team) const;
    UFUNCTION(BlueprintPure, Category = "Game Mode")
    virtual int32 GetStartingTicketCount(uint8 Team) const;
    const TArray<FTeamTicketInfo>& GetTeamTicketList() const { return TeamTicketList; }
    virtual void InitializeGameState(AProjectXGameMode* GameMode);
    UFUNCTION(BlueprintPure, Category = "GameMode")
    virtual float GetRedeployRespawnDelay() const;
    UFUNCTION(BlueprintPure, Category = "GameMode")
    virtual float GetReviveDuration() const;
    void RegisterSpawnTargetForScoring(AActor* const Target);
    void DeRegisterSpawnTargetForScoring(AActor* const Target);
 
    UFUNCTION(BlueprintCallable, Category = "GameMode")
    bool CanSpawnInPV() const { return bCanSpawnInPV; }
 
    virtual float ModifyDamage(AActor* Target, float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser);
 
    APostGameScreen* GetPostGameLineup();
    void UpdateTeamTickets(uint8 Team, int32 Amount = 1, bool bOverride = false);
    int32 GetTeamTickets(uint8 Team);
 
    virtual void OnRep_MatchState() override;
    virtual void HandleMatchWarmupEnded();
    virtual void HandleMatchHasEnded() override;
    virtual TSubclassOf<AActor> CheckForActorReplacement(TSubclassOf<AActor> Actor);
    
    UFUNCTION(BlueprintCallable, Category = "GameState")
    virtual bool IsMatchInProgress() const override;
    virtual float GetPlayerRespawnDelay(class AController* Controller) const override;
    bool GetShouldOpenMapOnPlayerStart() const { return bShouldOpenMapOnPlayerStart; }
    bool UsesLandingScreen() const { return bUseLandingScreen; }
 
    UFUNCTION(BlueprintCallable, Category = GameState)
    const TArray<TSubclassOf<AProjectXCharacter>>& GetPlayerClassList() const;
 
    virtual int32 GetTeam(const AActor* Target) const;
    virtual bool IsSquadMate(const AActor* Target, const AActor* EventInstigator) const;
    virtual bool IsAlly(const AActor* Target, const AActor* EventInstigator) const;
    virtual bool IsEnemy(const AActor* Target, const AActor* EventInstigator) const;
    virtual bool IsNeutral(const AActor* Target) const;
 
    virtual void AddPlayerState(APlayerState* PlayerState) override;
    virtual void RemovePlayerState(APlayerState* PlayerState) override;
    /* todo: Winning team should be predictively determined per gamestate based team score */
    void SetWinningTeam(int32 Team);
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void Tick(float DeltaSeconds) override;
    virtual void BeginPlay() override;
    virtual void BroadcastTimer(const float TimerDuration, const uint8 Type);
    virtual void StopTimer();
    UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"))
    static void BroadcastTimerStatic(const UObject* const WorldContextObject, const float TimerDuration, const uint8 Type);
    UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"))
    static void StopBroadcastedTimerStatic(const UObject* const WorldContextObject);
 
    /* Compares Target to EventInstigator and if both are on the same team returns AllyColour, returning EnemyColour otherwise*/
    virtual void GetActorColour(const AActor* Target, const FName& ColourName, const AActor* EventInstigator, FLinearColor& LinearColor) const;
    virtual FText GetTeamName(const AActor* Target) const;
    virtual FText GetTeamNameByTeam(const int32 Team) const;
 
    UFUNCTION(BlueprintImplementableEvent)
    void OnPlayerPawnSpawned(AProjectXCharacter* Character);
    UFUNCTION(BlueprintNativeEvent, Category = GameState)
    FText GetRevivePromptOverride(const AProjectXPlayerState* Target, const AProjectXPlayerState* ReviveInstigator) const;
 
    UFUNCTION(BlueprintCallable)
    const FLinearColor& GetAllyColour(const FName& ColourName = NAME_None) const;
    UFUNCTION(BlueprintCallable)
    const FLinearColor& GetEnemyColour(const FName& ColourName = NAME_None) const;
    const FLinearColor& GetNeutralColour() const;
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject"))
    static const FText& GetGameTypeTextStatic(UObject* const WorldContextObject, EGameType InGameType);
    UFUNCTION(BlueprintCallable, Category= GameState)
    EGameType GetGameType() const;
 
    virtual void GetPlayersOnTeam(const uint8 Team, TArray<APlayerState*>& Players) const;
    virtual uint8 GetNumPlayersOnTeam(const uint8 Team) const;
    UFUNCTION(BlueprintCallable, Category = GameState)
    virtual void GetTeamScores(TArray<FTeamScoreInfo>& OutTeamScores) const;
    UFUNCTION(BlueprintCallable)
    int32 GetNumberOfTeams() const { return TeamTicketList.Num(); }
    virtual void OnTeamScoreChanged();
 
    void AddPickupToWorldList(FWorldPickupInfo& WorldPickupInfo);
    void RemovePickupFromWorldList(int32 InID);
    bool GetWorldPickupByID(int32 InID, FWorldPickupInfo& OutWorldPickup);
 
    const int32 GetNewPickupID();
 
    virtual const FText GetTimerText();
 
    TArray<FLevelActorState> StateChangedActors;
 
    UFUNCTION()
    void OnRep_WelcomeMessage();
    UFUNCTION()
    void OnRep_TeamTicketList();
    UFUNCTION()
    void OnRep_GenericTimer();
public:
    UPROPERTY(BlueprintAssignable)
    FWinningTeamSignature OnWinningTeamSetEvent;
    UPROPERTY(BlueprintAssignable)
    FServerBroadcastMarkedLocationSignature OnServerBroadcastMarkedLocationRecieved;
    UPROPERTY(BlueprintAssignable)
    FServerBroadcastMarkedLocationSignature OnServerBroadcastMarkedLocationRemoved;
    UPROPERTY(BlueprintAssignable, Category = GameState)
    FKilledAlertSignature OnKilled;
    UPROPERTY(BlueprintAssignable, Category = GameState)
    FMatchStartSignature OnMatchStarted;
    UPROPERTY(BlueprintAssignable, Category = GameState)
    FPlayerStateAddedSignature OnPlayerStateAdded;
    UPROPERTY(BlueprintAssignable, Category = GameState)
    FPlayerStateRemovedSignature OnPlayerStateRemoved;
    UPROPERTY(BlueprintAssignable, Category = GameState)
    FMatchStateChangedSignature OnMatchStateChanged;
    UPROPERTY(BlueprintAssignable, Category = GameState)
    FKillFeedSignature OnKillFeedUpdate;
    UPROPERTY(BlueprintAssignable)
    FTeamScoreChangedSignature OnTeamScoresChanged;
    UPROPERTY(BlueprintAssignable)
    FTeamTicketChangedSignature OnTeamTicketsChanged;
    UPROPERTY(BlueprintAssignable)
    FPlayerUltimatingSignature OnUltimateEvent;
    UPROPERTY(BlueprintAssignable)
    FTrackableActorAddedSignature OnTrackableActorAdded;
    UPROPERTY(BlueprintAssignable)
    FWelcomeMessageChangedSignature OnWelcomeMessageChanged;
    UPROPERTY(BlueprintAssignable)
    FOnBotSpawnSignature OnBotSpawned;
    UPROPERTY(BlueprintAssignable)
    FOnBotKilledSignature OnBotKilled;
    UPROPERTY(BlueprintAssignable)
    FTimerStartSignature OnTimerStart;
 
    //Overrides PlayerClassList with custom list
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    TArray<TSubclassOf<AProjectXCharacter>> PlayerClassListOverride;
    //Overrides the duration of respawn delays
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float RespawnDelayOverride = -1.f;
    /* Overrides how long the player must wait when redeploying */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float RedeployRespawnDelayOverride = -1.f;
    /* Allows or prevents the deploy screen from opening when the player enters the map */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    bool bShouldOpenMapOnPlayerStart = true;
    /* Allows explosive damage to affect self */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    bool bAllowExplosiveDamageOnSelf = true;
    /* If we should automatically change to the spectator cam on death */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    bool bUseSpectatorCamOnDeath = false;
    /* How much friendly fire should be allowed? 1.0 is 100% */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float FriendlyFirePercent = 0.f;
    /* Multiplies the damage of ultimates */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    bool bDisableBulletMagnetism = false;
    /* Multiplies the damage of ultimates */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float UltimateDamageMultiplier = 1.0f;
    /* Multiplies the damage of explosives */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float ExplosiveDamageMultiplier = 1.0f;
    /* Multiplies the damage of headshots */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float HeadshotDamageMultiplier = 1.0f;
    /* Multiplies the damage of ultimates */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float WeaponDamageMultiplier = 1.0f;
    /* Multiplies the cooldown of abilities */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float AbilityCooldownMultiplier = 1.0f;
    /* Multiplies the distance of the hookshot */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float HookshotDistanceMultiplier = 1.0f;
    /* Multiplies the speed of the hookshot */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float HookshotSpeedMultiplier = 1.0f;
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    /* Multiplies the speed of ultimate charge */
    float UltimateChargeRateMultiplier = 1.0f;
    /* Modifies the number of grenades a player can carry */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float GrenadeCountModifier = 0.0f;
    /* Modifies the number of dash charges */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    int32 DashChargeModifier = 0;
    /* Overrides the unlimited ammo flag on weapons, rendering their ammo limited */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    bool bIsAmmoLimited = false;
    /* Altititude Limit Multiplier */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float AltitudeLimitMultiplier = 1.0f;
    /* Multiplies the amount of spread weapons have */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float WeaponSpreadMultiplier = 1.0f;
    /* Multiplier for the amount of gravity affecting players */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float GravityMultiplier = 1.0f;
    /* Multiplier for ground speed */
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    float GroundSpeedMultiplier = 1.0f;
    //Overrides the duration of respawn delays
    UPROPERTY(Replicated, GlobalConfig, EditDefaultsOnly)
    bool bCanSpawnInCombat = false;
 
    /* should show the deploy screen*/
    UPROPERTY(EditDefaultsOnly)
    bool bShowDeployScreen = true;
    /*does this mode use a landing screen*/
    UPROPERTY(EditDefaultsOnly)
    bool bUseLandingScreen = false;
    UPROPERTY(EditDefaultsOnly)
    bool bCanSpawnInPV = true;
    /* An override for the revive beacon to be used for all characters */
    UPROPERTY(GlobalConfig, EditDefaultsOnly)
    TSubclassOf<APickupReviveBeacon> GlobalReviveBeaconOverride = nullptr;
 
    UPROPERTY()
    float ExpMultiplier = 1.0f;
 
protected:
    UPROPERTY()
    class UVehicleRespawnManager* VehicleRespawnManager = NULL;
    UPROPERTY()
    class USquadComponent* SquadComponent = NULL;
    UFUNCTION()
    void OnRep_WinningTeam();
    UPROPERTY()
    TMap<int32, FWorldPickupInfo> WorldPickups;
        
    UPROPERTY()
    int32 WorldPickupID = 0;
 
    TArray<TWeakInterfacePtr<ISpawnTargetInterface>> SpawnTargetsRegisteredForScoring = {};
 
    /* Replicated team info (just contains tickets; Team ID == Index */
    UPROPERTY(ReplicatedUsing = OnRep_TeamTicketList)
    TArray<FTeamTicketInfo> TeamTicketList;
    UPROPERTY(ReplicatedUsing = OnRep_GenericTimer)
    FGenericTimerInfo GenericTimer;
 
    TArray<FTeamTicketInfo> PreviousTeamTicketList;
 
    FString MatchStart = "VO_MatchStart";
    FString VictoryVO = "VO_Victory";
    FString DefeatVO = "VO_Failure";
    FString FiveMinutesLeft = "VO_5MinsLeft";
    FString OneMinutesLeft = "VO_1MinLeft";
    FString TenSecondsLeft = "VO_10SecondsLeft";
 
private:
    friend class AProjectXGameMode;
    UPROPERTY(Replicated)
    float MatchStartTime = 0.0f;
    UPROPERTY(Replicated)
    float MatchLength = 5.0f;
    UPROPERTY(Replicated)
    float MatchEndTimestamp = -1.f;
    UPROPERTY(Replicated)
    uint8 MaxPlayers;
    UPROPERTY(Replicated)
    TArray<int32> StartingTicketCount;
    UPROPERTY(ReplicatedUsing = OnRep_WinningTeam)
    int32 WinningTeam = -1;
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_WelcomeMessage, meta=(AllowPrivateAccess = "true"))
    FString WelcomeMessage = "";
 
    static TArray<TSubclassOf<AProjectXCharacter>> EmptyClassList;
 
    FTimerHandle TickTimeHandle;
 
    void WakeDelayedActors();
 
    APostGameScreen* Podium = NULL;
 
public:
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Has Match Started", ScriptName = "HasMatchStarted", WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool HasMatchStartedStatic(const UObject* WorldContextObject);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Get Match Length", ScriptName = "GetMatchLength", WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static float GetMatchLengthStatic(const UObject* WorldContextObject);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Get Match Elapsed Time", ScriptName = "GetMatchElapsedTime", WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static float GetMatchElapsedTimeStatic(const UObject* WorldContextObject);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Get Server World Time Seconds", ScriptName = "GetServerWorldTimeSeconds", WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static float GetServerWorldTimeSecondsStatic(const UObject* WorldContextObject);
    UFUNCTION(BlueprintCallable, meta=(DisplayName="Get Game State", ScriptName="GetGameState", WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static AGameStateBase* GetGameStateNoAutoWorldContext(const UObject* WorldContextObject);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool IsAlly(const UObject* WorldContextObject, const AActor* Target, const AActor* EventInstigator);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool IsSquadMate(const UObject* WorldContextObject, const AActor* Target, const AActor* EventInstigator);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool IsNeutral(const UObject* WorldContextObject, const AActor* Target);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool IsEnemy(const UObject* WorldContextObject, const AActor* Target, const AActor* EventInstigator);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool IsAllyByTeam(const UObject* WorldContextObject, const int32 Team, const AActor* EventInstigator);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static bool IsNeutralByTeam(const int32 Team);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (AutoCreateRefTerm = "ColourName"))
    /*Compares the Target actor with the EventInstigator and returns a Linear Color representing if they are Allies or Enemies (AllyColour or EnemyColour respectively) */
    static void GetTargetColour(const AActor* Target, const FName& ColourName, const AActor* EventInstigator, FLinearColor& LinearColor);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (AutoCreateRefTerm = "ColourName"))
    /*Compares a Team value with the EventInstigator's team and returns a Linear Color representing if those teams match as Allies or Enemies (AllyColour or EnemyColour respectively) */
    static void GetTargetColourByTeam(const int32 Team, const FName& ColourName, const AActor* EventInstigator, FLinearColor& LinearColor);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Get Team", ScriptName = "GetTeamStatic"))
    static int32 GetTeamStatic(const AActor* Target);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Get Team Name", ScriptName = "GetTeamNameStatic"))
    static FText GetTeamNameStatic(const AActor* Target);
    UFUNCTION(BlueprintPure, Category = GameState, meta = (DisplayName = "Get Team Name By Team", ScriptName = "GetTeamNameByTeam", WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static FText GetTeamNameByTeamStatic(const UObject* WorldContextObject, const int32 Team);
    UFUNCTION(BlueprintPure, Category = "Player Class", meta = (DisplayName = "Get Class List", ScriptName = "GetWeaponList"))
    static const TArray<TSubclassOf<AProjectXCharacter>>& GetPlayerClassListStatic(TSubclassOf<AProjectXGameState> GameStateClass);
    static FBoxSphereBounds GetActorBoxSphereBounds(const AActor* const Actor);
    UFUNCTION()
    void UpdateGameTimer();
    void SetWelcomeMessage(const FString& NewWelcomeMessage);
};
 
struct FTargetableOctreeSemantics
{
    enum { MaxElementsPerLeaf = 16 };
    enum { MinInclusiveElementsPerNode = 7 };
    enum { MaxNodeDepth = 12 };
 
    typedef TInlineAllocator<MaxElementsPerLeaf> ElementAllocator;
 
    FORCEINLINE static FBoxSphereBounds GetBoundingBox(const FTargetableOctreeElement& Element)
    {
        return Element.BoxSphereBounds;
    }
 
    FORCEINLINE static bool AreElementsEqual(const FTargetableOctreeElement& A, const FTargetableOctreeElement& B)
    {
        if (A.Targetable.Get() == B.Targetable.Get())
        {
            return true;
        }
 
        return false;
    }
 
    FORCEINLINE_DEBUGGABLE static void SetElementId(const FTargetableOctreeElement& Element, FOctreeElementId Id)
    {
        if (Element.Targetable.IsValid())
        {
            if (AProjectXGameState::TargetableOctreeElements.Contains(Element.Targetable->GetUniqueID()))
            {
                AProjectXGameState::TargetableOctreeElements[Element.Targetable->GetUniqueID()].Id = Id;
                AProjectXGameState::TargetableOctreeElements[Element.Targetable->GetUniqueID()].CachedLocation = Element.Targetable->GetActorLocation();
            }
            else
            {
                AProjectXGameState::TargetableOctreeElements.Add(Element.Targetable->GetUniqueID(), FTargetOctreeElementInfo(Id, Element.Targetable->GetActorLocation()));
            }
        }
    }
 
    FORCEINLINE static void ApplyOffset(FTargetableOctreeElement& Element, FVector Offset)
    {
        Element.BoxSphereBounds.Origin = Element.BoxSphereBounds.Origin + Offset;
    }
};
 
template <class T>
TArray<T*> AProjectXGameState::GetTargetableActorsInRadius(const FVector& Location, const float Radius, bool bMustBeAlive)
{
    if (!Octree)
    {
        return TArray<T*>();
    }
 
    const FBoxCenterAndExtent Query = FBoxCenterAndExtent(Location, FVector(Radius));
#if WITH_EDITOR
    //  DrawDebugBox(GetWorld(), Query.Center, Query.Extent, FColor().Red, false, 30.0f);
#endif
 
    TArray<T*> TargetableActors;
    for (FTargetableOctree::TConstElementBoxIterator<> OctreeIt(*Octree, Query); OctreeIt.HasPendingElements(); OctreeIt.Advance())
    {
        if (!OctreeIt.GetCurrentElement().Targetable.IsValid() || OctreeIt.GetCurrentElement().Targetable->GetWorld() != GetWorld())
        {
            continue;
        }
 
        if(bMustBeAlive)
        {
            IHealthInterface* const HealthInterface = Cast<IHealthInterface>(OctreeIt.GetCurrentElement().Targetable);
            if(HealthInterface && HealthInterface->IsDead())
            {
                continue;
            }
        }
 
        if (T* ClassFilteredActor = Cast<T>(OctreeIt.GetCurrentElement().Targetable.Get()))
        {
            TargetableActors.Emplace(ClassFilteredActor);
        }
    }
 
    return MoveTemp(TargetableActors);
}