ProjectXPlayerState.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2017. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine.h"
#include "GameFramework/GameState.h"
#include "GameFramework/PlayerState.h"
#include "ProjectX.h"
#include "OwnedInterface.h"
#include "ReactsToMatchEvents.h"
#include "PlayerStats.h"
#include "PlayerStructs.h"
#include "ProjectXSaveGame.h"
#include "CosmeticsManager.h"
#include "SpawnTargetInterface.h"
#include "TeamInterface.h"
#include "StatsTrackingManager.h"
 
#include "ProjectXPlayerState.generated.h"
 
class UWeaponInstance;
class UPlayerClass;
class UGlobalAmmoComponent;
class UPlayerProgressionManager;
class UBroadcastMessageExperienceEvent;
class ISpawnTargetInterface;
class UMaterial;
class UCosmeticExplosionAsset;
class AProjectXCharacter;
class ADeployable;
class UTelekenesisComponent;
class APickup;
class APickupReviveBeacon;
class UAfflictionComponent;
 
USTRUCT()
struct FAuthWeaponTicket
{
    GENERATED_USTRUCT_BODY()
 
public:
    FAuthWeaponTicket()
    {
        Weapon = NULL;
        ProjectileClass = NULL;
        Origin = FVector_NetQuantize(0, 0, 0);
        NumUses = 1;
        DamageModifier = 1.0f;
    }
 
    FAuthWeaponTicket(TSubclassOf<class UWeaponInstanceRanged> InWeapon, TSubclassOf<class AActor> InProjectileClass, const FVector_NetQuantize InOrigin, int8 InNumUses, float InDamageModifier)
    {
        Weapon = InWeapon;
        ProjectileClass = InProjectileClass;
        Origin = InOrigin;
        NumUses = InNumUses;
        DamageModifier = InDamageModifier;
    }
 
public:
    UPROPERTY()
    TSubclassOf<class UWeaponInstanceRanged> Weapon = NULL;
    //Projectile that was spawned from this ticket.
    UPROPERTY()
    TSubclassOf<class AProjectile> ProjectileClass = NULL;
    //The origin of the projectile spawned by this ticket.
    UPROPERTY()
    FVector_NetQuantize Origin = FVector_NetQuantize(0, 0, 0);
    //How many times can this ticket be used before its expired.
    UPROPERTY()
    int8 NumUses = 1;
    UPROPERTY()
    float DamageModifier = 1.0f;
};
 
USTRUCT(Blueprintable)
struct FPlayerClassUsage
{
    GENERATED_USTRUCT_BODY()
 
public:
    FPlayerClassUsage()
    {
        PlayerClass = NULL;
        TimeUsed = 0.f;
        Spawned = 0;
    }
 
    FPlayerClassUsage(TSubclassOf<AProjectXCharacter> InPlayerClass)
    {
        PlayerClass = InPlayerClass;
        TimeUsed = 0.f;
        Spawned = 0;
    }
 
public:
    UPROPERTY()
    TSubclassOf<AProjectXCharacter> PlayerClass = NULL;
    //Amount of time this player was alive as this class.
    UPROPERTY()
    float TimeUsed = 0.f;
    //How many times a player has spawned as this class.
    UPROPERTY()
    uint16 Spawned = 0;
 
    bool operator<(const FPlayerClassUsage& Other) const
    {
        return TimeUsed > Other.TimeUsed;
    }
 
public:
    static FPlayerClassUsage InvalidEntry;
};
 
UENUM(BlueprintType)
enum class EMessageType : uint8
{
    Admin = 0,
    Server = 1,
    Global = 2,
    Team = 3,
    Squad = 4,
    Whisper = 5,
    SquadAttackOrder = 6,
    SquadDefendOrder = 7,
    TeamHeal = 8,
    TeamRepair = 9,
    SquadPing = 10,
    None = 255
};
 
USTRUCT(Blueprintable)
struct FGeneralEquips
{
    GENERATED_USTRUCT_BODY()
    FGeneralEquips()
    {
        GraffitiMaterial = NULL;
        Border = NULL;
        Banner = NULL;
    }
public:
    UPROPERTY(BlueprintReadOnly)
    UMaterialInstance* GraffitiMaterial = NULL;
    UPROPERTY(BlueprintReadOnly)
    UMaterialInstance* Border = NULL;
    UPROPERTY(BlueprintReadOnly)
    UMaterialInstance* Banner= NULL;
};
 
USTRUCT(Blueprintable)
struct FQuickChatInfo
{
    GENERATED_USTRUCT_BODY()
    
public:
 
    UPROPERTY(BlueprintReadOnly, Category = "Message")
    AProjectXPlayerState* SendingPlayerState = nullptr;
        
    UPROPERTY(BlueprintReadOnly, Category = "Message")
    EMessageType MessageType = EMessageType::None;
 
    UPROPERTY(BlueprintReadOnly, Category = "Message")
    TWeakObjectPtr<AActor> SquadOrderActor = nullptr;
};
 
 
USTRUCT(Blueprintable)
struct FSquadOrder
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY(BlueprintReadOnly, Category = "Squad")
    TWeakObjectPtr<AActor> SquadOrderActor = nullptr;
 
    UPROPERTY(BlueprintReadOnly, Category = "Squad")
    EMessageType SquadOrder = EMessageType::None;
 
    void Reset()
    {
        SquadOrderActor = nullptr;
        SquadOrder = EMessageType::None;
    }
 
    bool IsValid()
    {
        if (SquadOrderActor.IsValid() || SquadOrder == EMessageType::None)
        {
            return false;
        }
 
        return true;
    }
};
 
USTRUCT()
struct FNemesisTrackingInfo
{
    GENERATED_USTRUCT_BODY()
 
public:
    uint16 NumTimesKilledByPlayer = 0;
    uint16 NumTimesKilledPlayer = 0;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FXPChangedSignature, float, XP, float, Delta);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FScoreChangedSignature, float, Score);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPlayerLevelChangedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPlayerStatsChangedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPlayerStateObjectChangedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPLayerStateReadyChangedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPlayerKillSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FUltimateTriggeredSignature, AProjectXPlayerState*, Player);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FUltimateUsedSignature, AProjectXPlayerState*, Player);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerCurrencyGainedSignature, float, Delta);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FExperienceEventSignature, const UExperienceEvent*,Event, const int, Value, const APlayerState*, B);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FClassEventSignature, TSubclassOf<AProjectXCharacter>, PlayerClass);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FPlayerChangedTeamSignature, AProjectXPlayerState*, PlayerState, uint8, Team);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSpawnTargetChangedSignature, TScriptInterface<ISpawnTargetInterface>, SpawnTarget);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTeamChangeCoolDownSignature, float, Duration);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FReviveTimerReceived, float, ReviveStartTime);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FAvatarUpdatedSignature, UTexture2D*, Avatar);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FCurrencyChangedSignature, int32, NewCurrency, int32, Delta);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FMessageReceivedSignature, const FString&, Message, AProjectXPlayerState*, Sender, const EMessageType, MessageType);
DECLARE_DELEGATE_OneParam(FDelegateMaterialInstanceSignature, UMaterialInstance*);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSquadLeaderChanged, AProjectXPlayerState*, NewSquadLeader);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FQuickChatMessageReceivedSignature, const FQuickChatInfo&, QuickChatData);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnCosmeticsUpdatedSignature, const FString&, PlayerID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnEquipsUpdatedSignature, ECosmeticType, Type, const FString&, ShortCode, const FString&, EquipCode);
 
 
UCLASS()
class PROJECTX_API AProjectXPlayerState : public APlayerState, public IOwnedInterface, public IReactsToMatchEvents, public ITeamInterface
{
    GENERATED_UCLASS_BODY()
 
public:
    bool operator>(const AProjectXPlayerState& Other) const
    {
        if (GetXP() != Other.GetXP())
        {
            return GetXP() > Other.GetXP();
        }
 
        if (GetEliminations() != Other.GetEliminations())
        {
            return GetKills() > Other.GetKills();
        }
 
        if (GetDeaths() != Other.GetDeaths())
        {
            return GetDeaths() < Other.GetDeaths();
        }
 
        if (GetUnpackedPing() != Other.GetUnpackedPing())
        {
            return GetUnpackedPing() > Other.GetUnpackedPing();
        }
 
        return true;
    }
 
//~ Begin AActor Interface
public:
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void BeginPlay() override;
//~ End AActor Interface
 
//~ Begin APlayerState Interface
protected:
    virtual void OverrideWith(APlayerState* PlayerState) override;
    virtual void CopyProperties(APlayerState* PlayerState) override;
//~ End APlayerState Interface
 
//~ Begin IReactsToMatchEvents Interface
public:
    virtual APlayerState* GetOwnedPlayerState() const override;
//~ End IReactsToMatchEvents Interface
 
//~ Begin IReactsToMatchEvents Interface
public:
    virtual void MatchEnded() override;
//~ End IReactsToMatchEvents Interface
 
public:
    void InitStat();
    std::string GetNakamaUserId() const;
    const FString& GetNakamaUserIdAsString() const { return NakamaUserId; }
    bool IsNakamaUserIdValid() const;
 
    UFUNCTION()
    int32 SetTeam(int32 NewTeam) override;
    //Added assert to check for any potential getters checking this before we've assigned a team.
    FORCEINLINE virtual int32 GetTeam() const override { return Team; } 
 
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyLevel(int32 Delta);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyKills(AProjectXPlayerState* Killed, TSubclassOf<class UProjectXDamageType> DamageType);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyDeployablesDestructed(ADeployable* DeployableDestructed, TSubclassOf<class UProjectXDamageType> DamageType);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyDeaths(int32 Delta, AProjectXPlayerState* KillerState);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyAssists(int32 Delta, APlayerState* PlayerState, float MaxHealth, float Damage);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyTeamKills(int32 Delta);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyXP(EXPEventType Type, APlayerState* TargetState, UObject* Object,float Alpha = 1.0f, const TSubclassOf<UExperienceEvent> ExpereienceEventOverride = NULL);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = PlayerState)
    virtual void ModifyUltimateCharge(int32 Delta);
    /* Since the revive beacon is only tracked on the owning version of the PS, this gives the opportunity for external simulated proxies to broadcast the revive time to the PlayerState if they know it */
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual void BroadcastReviveTimeReceived(float ReviveStartTime);
    void ModifyCurrency(int32 Delta);
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual void SendQuickChat(AProjectXPlayerState* const To, const FString& Message, const EMessageType MessageType, AActor* const SquadOrderActor);
    UFUNCTION(BlueprintCallable)
    virtual bool GetIsSpawningOnReviveBeacon() const;
    UFUNCTION(Server, Reliable)
    virtual void Server_SendQuickChat(const FQuickChatInfo& QuickChatData);
    UFUNCTION(Client, Reliable)
    virtual void Client_SendQuickChat(const FQuickChatInfo& QuickChatData);
    UFUNCTION(Client, Reliable)
    virtual void Client_RequestSpawnTarget();
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual void SendMessage(const FString& Message, AProjectXPlayerState* const To, const EMessageType MessageType);
    UFUNCTION(Server, Reliable)
    virtual void Server_SendMessage(const FString& Message, AProjectXPlayerState* To, const EMessageType MessageType);
    UFUNCTION(BlueprintCallable, Client, Reliable)
    virtual void Client_SendMessage(const FString& Message, AProjectXPlayerState* To, const EMessageType MessageType);
    UFUNCTION(Client, Reliable)
    virtual void Client_Reliable_UpdateExperienceGains(const FPlayerProgressionUpdates& NewExperienceGains);
 
    virtual bool IsValidMessage(const FString& Message, const bool bDisplayErrors = false);
    virtual FString FormatMessage(const FString& Message);
    virtual FString FilterMatureLanaguage(const FString& SourceString);
    virtual void DecrementChatSpamMessageCount();
 
    UFUNCTION(Server, Reliable)
    virtual void Server_PickupItem(int32 PickUpID, AActor* OverlappedActor);
 
    void SpawnWorldPickup(TSubclassOf<APickup> PickupClass, const FVector SpawnLocation, const FVector ExpectedLandingPosition);
 
    UFUNCTION(NetMulticast, Reliable)
    void MultiCast_PickupSpawned(const FWorldPickupInfo& PickUpInfo);
 
    UFUNCTION(NetMulticast, Reliable)
    void MultiCast_DestroyPickup(int32 PickupID);
 
    UFUNCTION(NetMulticast, Reliable)
    void MultiCast_SpawnContextObject(const FVector_NetQuantize SpawnLocation, AProjectXPlayerState* SendingPlayerState);
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetUnpackedPing() const { return GetPing() * 4; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetPingString() const { return FString::FromInt(GetUnpackedPing()); }
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetLevel() const { return Level; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetLevelString() const { return FString::FromInt(GetLevel()); }
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetEliminations() const { return Kills + Assists; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetEliminationsString() const { return FString::FromInt(GetEliminations()); }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetKills() const { return Kills; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetKillsString() const { return FString::FromInt(GetKills()); }
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetDeaths() const { return Deaths; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetDeathsString() const { return FString::FromInt(GetDeaths()); }
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetAssists() const { return Assists; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetAssistsString() const { return FString::FromInt(GetAssists()); }
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int32 GetTeamKills() const { return TeamKills; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetTeamKillsString() const { return FString::FromInt(GetTeamKills()); }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE bool IsReady()const {return bReady;}
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE float GetXP() const { return GameXP; }
 
    /* Returns only the accumulated XP gains from contractor bonuses applied during the match*/
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE float GetGameXPFromMultiplier() const { return GameXPFromMultiplier; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetXPString() const { return FString::FromInt(int32(GetXP())); }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE bool IsMatchBonusAvailable() const {return bMatchBonusIsAvailable;}
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE bool IsTeamChangeOnCoolDown() const { return !bCanChangeTeam; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int GetUltimateCharge() const { return UltimateCharge; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE FString GetUltimateChargeString() const { return FString::FromInt(UltimateCharge); }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE bool IsUltimateCharged() const {return UltimateCharge >= MaxUltimateCharge;}
    UFUNCTION(BlueprintPure, Category = PlayerState)
    FORCEINLINE int GetMaxUltimateCharge() const {return MaxUltimateCharge;}
    UFUNCTION(BlueprintPure, Category = PlayerState)
    const FPlayerProgressionUpdates& GetPlayerProgression() const {return PlayerProgressionUpdates; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    const FEquips& GetPlayerEquips() const;
    const FGeneralEquips& GetGeneralEquips() const { return GeneralEquips; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    float GetExpMulitplier() const{return EXPMultiplier;}
    virtual void SetExpMultiplier(float NewMultiplier) { EXPMultiplier = NewMultiplier; }
    void SetMaxUltimateCharge(uint16 NewMaxUltimateCharage) { MaxUltimateCharge = NewMaxUltimateCharage; }
    FORCEINLINE TWeakObjectPtr<ADecalActor> GetGraffiti() const { return Graffiti; }
    void UpdateGraffiti(TWeakObjectPtr<ADecalActor> NewGraffiti) { Graffiti = NewGraffiti; }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    bool IsLocalPlayerState() const;
    UFUNCTION(BlueprintPure, Category = PlayerState)
    virtual FString GetPlayerID() const;
    UFUNCTION(BlueprintPure, Category = PlayerState)
    APickupReviveBeacon* GetReviveBeacon() const { return ReviveBeacon.Get(); }
    UFUNCTION(BlueprintPure, Category = PlayerState)
    UTexture2D* GetAvatarImage() const { return AvatarReference; } 
    UFUNCTION(BlueprintPure,Category = PlayerState)
    UAnimMontage* GetTaunt(uint8 TauntNumber) { return TauntMontages.Contains(TauntNumber) ? TauntMontages[TauntNumber] : NULL; }
    /* NOTE: this should never be directly called - call PlayerController::CanRestartPlayer instead! */
    UFUNCTION()
    virtual bool CanRestartPlayer();
    AProjectXCharacter* GetCharacter() const;
    UFUNCTION()
    void OnStatsLoaded();
    UFUNCTION(BlueprintCallable)
    void MutePlayerText(APlayerState* Player, bool bToggle);
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    TSubclassOf<AProjectXCharacter> GetPreferredPlayerClass() const { return PreferredPlayerClass; }
    UFUNCTION()
    void SetPreferredPlayerClass(TSubclassOf<AProjectXCharacter> NewPlayerClass);
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    float GetNextRespawnTime() const { return NextRespawnTime; }
    
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    float GetTimeUntilRespawn() const { return (GetWorld() && GetWorld()->GetGameState()) ? FMath::Max(0.f, NextRespawnTime - GetWorld()->GetGameState()->GetServerWorldTimeSeconds()) : MAX_FLT; }
 
    UFUNCTION()
    void SetNextRespawnTime(float NewRespawnTime);
 
    /* Called via AProjectXPlayerState::SetPawn, destroys all the deployables this player's new player class cannot make */
    UFUNCTION()
    virtual void DestroyInvalidDeployables(bool bForce = false);
 
    UFUNCTION()
    virtual void UpdatePlayerPerkUsage(APawn* InPawn);
 
    UFUNCTION()
    void OnEquipsLoaded(bool bSuccess);
    void LoadMatchBonusAvailable();
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual FPlayerClassUsage& GetClassUsageByClass(TSubclassOf<AProjectXCharacter> PlayerClass);
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual FPlayerClassUsage& GetMostUsedClass();
 
    const UPlayerProgressionManager* GetPlayerProgressionCDO() const;
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    FORCEINLINE UGlobalAmmoComponent* GetGlobalAmmoComponent() const { return GlobalAmmoComponent; }
    
    /* Adds authenticated ticket to this player's list. Returns true if a ticket was found. */
    virtual bool AddAuthenticatedTicket(const int32 TicketID, const FAuthWeaponTicket& Ticket);
    /* Consumes a use of an authenticated ticket. Returns true if successfully found a ticket. */
    virtual bool ConsumeAuthenticatedTicket(const int32 TicketID, TSubclassOf<class UWeaponInstanceRanged> Weapon, TSubclassOf<AProjectile>& ProjectileClass, float& DamageModifier);
    /* Invalidates a ticket. */
    virtual void OnTicketExpired(const int32 TicketID);
 
    UFUNCTION(Server, Reliable)
    void Server_ProcessProjectileHit(const uint8 ShotID, const int32& ProjectileID, const FHitResult& HitResult, TSubclassOf<class UWeaponInstanceRanged> Weapon, const TArray<FVector_NetQuantize>& FlightPath, UTelekenesisComponent* TelekenesisComponent = nullptr, const FRotator& CustomRotation = FRotator::ZeroRotator);
 
    UFUNCTION(Server, Reliable)
    void Server_ProcessExplosiveProjectileHit(const int32& ProjectileID, const FHitResult& HitResult, TSubclassOf<class UWeaponInstanceRanged> Weapon, const TArray<FVector_NetQuantize>& FlightPath, const TArray<AActor*>& RadialDamagedActors);
    static float ValidateFlightPath(UObject* const WorldContextObject, const TArray<FVector_NetQuantize>& FlightPath, AActor* HitActor = NULL);
    static float GetFlightPathDistance(const TArray<FVector_NetQuantize>& FlightPath);
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    static void SortPlayerStates(const TArray<AProjectXPlayerState*>& InPlayerStateList, TArray<AProjectXPlayerState*>& OutPlayerStateList);
 
    UFUNCTION(BlueprintPure, Category = PlayerState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static APlayerState* GetPlayerStateByName(const UObject* WorldContextObject, const FString& Name);
 
    UFUNCTION(BlueprintPure, Category = PlayerState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static AProjectXPlayerState* GetPlayerStateByID(const UObject* WorldContextObject, const FString& ID);
 
    //Not to be confused with AProjectXPlayerState::GetPlayerStateByID!
    UFUNCTION(BlueprintPure, Category = PlayerState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static AProjectXPlayerState* GetPlayerStateByPlayerID(const UObject* WorldContextObject, int32 ID);
    UFUNCTION(BlueprintPure, Category = PlayerState, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static AProjectXPlayerState* GetPlayerStateByNakamaPlayerID(const UObject* WorldContextObject, const FString& ID);
 
    UFUNCTION(BlueprintPure, Category = ClassUsage)
    static TSubclassOf<AProjectXCharacter> GetClassFromUsage(const FPlayerClassUsage& ClassUsage) { return ClassUsage.PlayerClass; }
    UFUNCTION(BlueprintPure, Category = ClassUsage)
    static float GetTimeFromUsage(const FPlayerClassUsage& ClassUsage) { return ClassUsage.TimeUsed; }
    UFUNCTION(BlueprintPure, Category = ClassUsage)
    static int32 GetSpawnCountFromUsage(const FPlayerClassUsage& ClassUsage) { return ClassUsage.Spawned; }
    UFUNCTION(BlueprintPure, Category = "Base Control")
    virtual TScriptInterface<ISpawnTargetInterface> GetSpawnTarget() const;
    UFUNCTION(BlueprintPure, Category = "Base Control")
    virtual bool HasSpawnTarget() const;
    UFUNCTION(BlueprintPure,Category = Loadouts)
    bool HasLoadedCosmetics() const {return bLoadedCosmetics;}
 
    UFUNCTION(BlueprintCallable,Category = "Player")
    bool GetKillExplosion(TSoftObjectPtr<UParticleSystem>& Particle, TSoftObjectPtr<USoundCue>& Sound);
    
    virtual void SetSpawnTarget(TScriptInterface<ISpawnTargetInterface> NewSpawnTarget);
 
    virtual void StartTeamChangeCoolDown();
 
    UFUNCTION(BlueprintPure)
    float GetTeamSwitchingCoolDownRemaining() const;
 
    void SetAvatar(UTexture2D* NewAvatar);
    UFUNCTION(BlueprintCallable)
    void PlayTaunt(uint8 TauntID);
    UFUNCTION()
    void OnItemEquipped(ECosmeticType Type, const FString& ShortCode, const FString& EquipCode);
    UFUNCTION(Server,Reliable,WithValidation)
    void Server_Reliable_UpdateSessionLockedCosmetics(uint16 CosmeticIDNumber);
 
    virtual void OnRep_UniqueId() override;
 
    UFUNCTION()
    void UpdatePassiveUltimateCharge();
 
    UFUNCTION()
    void UpdateKillExplosion(UCosmeticExplosionAsset* CosmeticAsset) { KillExplosionAsset = CosmeticAsset; }
 
    virtual void AddHealingDone(const float HealedAmount);
    virtual void AddRepairingDone(const float RepairedAmount, UClass* const TargetClassRepaired);
    virtual void ActivateHealBufferCheck();
    virtual void DeactivateHealBufferCheck();
    virtual void ActivateRepairBufferCheck();
    virtual void DeactivateRepairBufferCheck();
    virtual void ToggleReviveBeacon(bool bActivate);
    UFUNCTION()
    virtual void UltimateFinished();
    UFUNCTION()
    virtual void UltimateStarted(UWeaponInstance* Weapon);
    virtual void SetReadyStatus(bool bNewReadyStatus);
    void SetCanChangeTeams(bool bNewCanChangeTeams);
    void SpawnActorOnProjectileHit(const AProjectile* HitProjectile, const FHitResult& HitResult, const FRotator& CustomRotator = FRotator::ZeroRotator);
 
    void SetSquadLeader(bool const InSquadLeader);
 
    void SetCurrentSquadOrder(FSquadOrder const InSquadOrder);
    FVector GetReviveBeaconSpawnLocation() { return ReviveBeaconSpawnLocation; }
    UFUNCTION(BlueprintCallable, Category = "Squad")
    bool IsSquadLeader() { return bSquadLeader; }
 
    UFUNCTION(BlueprintCallable, Category = "Squad")
    FSquadOrder GetCurrentSquadOrder() { return CurrentSquadOrder; }
 
    /*Returns 1 if player is nemesis 2 if they killed their nemesis*/
    int32 IsPlayerStateNemesis(AProjectXPlayerState* const NemesisPlayerState);
 
    UFUNCTION(BlueprintCallable, Category = "Spawn")
    void PlayAnnouncerSpawnSound();
 
    void ModifyKillsByClass(AProjectXPlayerState* Killed);
 
    UFUNCTION(Client, Unreliable)
    void Client_PlayAnnouncer(const FString& VoiceToPlay);
 
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_UpdateStat(EStatNames StatToUpdate, int32 Value, UObject* InObject /* = nullptr */, const EStatUpdateBehaviour& StatUpdateBehaviour /* = EStatUpdateBehaviour::NONE */, int32 InDebugMapType /*= 0*/, const FString& InDebugMapName /*= ""*/);
 
    UFUNCTION(Client, Reliable)
    void Client_UnlockAchievement(const EAchievementData AchievementToUnlock);
 
    UFUNCTION(BlueprintCallable, Server, Reliable, WithValidation, Category = "PlayerState")
    void Server_KickPlayer(AProjectXPlayerState* PlayerToKick);
 
    UFUNCTION(Client, Reliable)
    void Client_QueryAchievements();
 
    float UltChargeMultiplier = 1.0f;
    static TArray<FString> MessageHistory;
public:
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerStatsChangedSignature OnPlayerStatsChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FXPChangedSignature OnXPChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerCurrencyGainedSignature OnUltimateChargeChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FXPChangedSignature OnTotalXPChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerCurrencyGainedSignature OnCurrencyGained;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FScoreChangedSignature OnPlayerScoreChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerLevelChangedSignature OnPlayerLevelChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FExperienceEventSignature OnExpGained;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FClassEventSignature OnPlayerClassChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FReviveTimerReceived OnReviveTimerReceived;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerStateObjectChangedSignature OnPlayerStateNextRespawnTimeChanged;
    UPROPERTY(BlueprintAssignable)
    FPlayerChangedTeamSignature OnPlayerChangedTeam;
    UPROPERTY(BlueprintAssignable)
    FSpawnTargetChangedSignature OnSpawnPointChanged;
    UPROPERTY(BlueprintAssignable)
    FTeamChangeCoolDownSignature OnTeamChangeCoolDownStart;
    UPROPERTY(BlueprintAssignable)
    FTeamChangeCoolDownSignature OnTeamChangeCoolDownFinish;
    UPROPERTY(BlueprintAssignable)
    FAvatarUpdatedSignature OnAvatarChangeDelegateEvent;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FCurrencyChangedSignature OnCurrencyUpdated;
    UPROPERTY(BlueprintAssignable)
    FMessageReceivedSignature OnMessageReceieved;
    UPROPERTY(BlueprintAssignable)
    FOnSquadLeaderChanged OnSquadLeaderChanged;
    UPROPERTY(BlueprintAssignable)
    FQuickChatMessageReceivedSignature OnQuickChatMessageReceived;
    UPROPERTY(BlueprintAssignable)
    FUltimateTriggeredSignature OnUltimateTriggered;
    UPROPERTY(BlueprintAssignable)
    FUltimateUsedSignature OnUltimateUsed;
    UPROPERTY(BlueprintAssignable)
    FOnCosmeticsUpdatedSignature OnCosmeticsUpdated;
    UPROPERTY(BlueprintAssignable)
    FPlayerKillSignature OnPlayerKillEvent;
    UPROPERTY(BlueprintAssignable)
    FOnEquipsUpdatedSignature OnEquipsUpdated;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerStatsChangedSignature OnGameXPFromMultiplierReceived;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPLayerStateReadyChangedSignature OnPlayerStateReadyEvent;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FPlayerStatsChangedSignature OnPlayerProgressionRewardedEvent;
 
protected:
    UFUNCTION()
    virtual void OnRep_Kills(uint16 LastKills);
    UFUNCTION()
    virtual void OnRep_Deaths(uint16 LastDeaths);
    UFUNCTION()
    virtual void OnRep_Assists(uint16 LastAssists);
    virtual void OnRep_Score() override;
    UFUNCTION()
    virtual void OnRep_GameXP(uint16 LastXP);
    UFUNCTION()
    virtual void OnRep_Level(uint16 PreviousLevel);
    UFUNCTION()
    virtual void OnRep_UltimateCharge();
    UFUNCTION()
    virtual void OnRep_PlayerClass();
    UFUNCTION()
    virtual void OnRep_Team();
    UFUNCTION()
    virtual void OnRep_CanSwitchTeams();
    UFUNCTION()
    virtual void OnRep_SquadLeader();
    UFUNCTION()
    virtual void OnRep_NextRespawnTime();
    UFUNCTION()
    virtual void OnRep_Ready();
    UFUNCTION()
    virtual void OnPlayerStateRemovedFromGameState(APlayerState* RemovedPlayerState);
    UFUNCTION()
    virtual void DoHealBonusXPBufferCheck();
    UFUNCTION()
    virtual void DoRepairBonusXPBufferCheck();
    UFUNCTION(BlueprintCallable)
    void LoadGeneralCosmetics(ECosmeticType Type, const FEquips& LoadingEquips,const FString& EquipCode);
    void LoadCosmeticMaterialAsset(TSoftObjectPtr<UMaterialInstance> AssetPointer, FDelegateMaterialInstanceSignature Callback);
    void LoadPlayerPerk();
    UFUNCTION(Server, Reliable)
    void Server_SendNakamaUserId(const FString& InNakamaUserId);
    UFUNCTION(Server, Reliable)
    void Server_Reliable_ToggleReviveBeacon(bool bActive);
    UFUNCTION(Server, Reliable)
    void Server_Reliable_PlayTaunt(uint8 TauntID);
    UFUNCTION(NetMulticast,UnReliable)
    void Multicast_Unreliable_PlayTaunt(uint8 TauntID);
    UFUNCTION(NetMulticast, Reliable)
    void Multicast_Reliable_EquipCosmeticItem(ECosmeticType Type, uint16 ShortCodeIndex, uint16 EquipCodeIndex);
    UFUNCTION(Server,Reliable)
    void Server_Reliable_EquipItem(ECosmeticType Type, uint16 ShortCodeIndex, uint16 EquipCodeIndex);
    UFUNCTION(Client, Reliable)
    void Client_Reliable_SendGameXPFromMultiplier(uint16 BonusEXP);
 
protected:
    UPROPERTY(ReplicatedUsing = OnRep_Kills)
    uint16 Kills = 0;
    UPROPERTY(ReplicatedUsing = OnRep_Deaths)
    uint16 Deaths = 0;
    UPROPERTY(ReplicatedUsing = OnRep_Assists)
    uint16 Assists = 0;
    UPROPERTY(ReplicatedUsing = OnRep_Level)
    uint16 Level = 0;
    UPROPERTY(ReplicatedUsing = OnRep_GameXP)
    uint16 GameXP = 0;
    UPROPERTY(ReplicatedUsing = OnRep_UltimateCharge)
    uint16 UltimateCharge = 0;
    UPROPERTY(ReplicatedUsing = OnRep_Team)
    uint8 Team = UINT8_MAX;
    UPROPERTY(ReplicatedUsing = OnRep_CanSwitchTeams)
    bool bCanChangeTeam = true;
    UPROPERTY(ReplicatedUsing = OnRep_PlayerClass)
    TSubclassOf<AProjectXCharacter> PreferredPlayerClass = NULL;
    UPROPERTY(ReplicatedUsing = OnRep_SquadLeader)
    bool bSquadLeader = false;
    UPROPERTY(Replicated)
    FSquadOrder CurrentSquadOrder;
    UPROPERTY(ReplicatedUsing = OnRep_NextRespawnTime)
    float NextRespawnTime = 0.f;
    UPROPERTY(ReplicatedUsing = OnRep_Ready)
    bool bReady = false;
    UPROPERTY(BlueprintReadOnly, Replicated, meta = (AllowPrivateAccess = true))
    bool bIsAdmin = false;
    UPROPERTY(Replicated)
    TWeakObjectPtr<APickupReviveBeacon> ReviveBeacon;
 
    UPROPERTY()
    TSubclassOf<AProjectXCharacter> PawnPlayerClass = NULL;
    UPROPERTY()
    TWeakObjectPtr<AActor> SpawnTarget = NULL;
    TWeakObjectPtr<ADecalActor> Graffiti;
 
    UPROPERTY()
    FGeneralEquips GeneralEquips;
    UPROPERTY()
    float SpawnWorldTime = -1.f;
 
    /* Next time this player is allowed to spawn at */
 
    UPROPERTY()
    TMap<int32, FAuthWeaponTicket> AuthenticatedTicketMap;
    UPROPERTY(EditDefaultsOnly)
    UCosmeticExplosionAsset* KillExplosionAsset = NULL;
    TMap<uint8,UAnimMontage*> TauntMontages;
    UPROPERTY(Transient)
    UTexture2D* AvatarReference = NULL;
    UPROPERTY()
    UGlobalAmmoComponent* GlobalAmmoComponent = NULL;
 
    /* How long between team switching do you have to wait*/
    UPROPERTY(EditDefaultsOnly, Category = Team)
    float TeamSwitchCoolDownDuration = 0.0f;
    /*Total Ultimate Charge*/
    UPROPERTY(EditDefaultsOnly, Category = Ultimate)
    int32 MaxUltimateCharge = 2;
    /* The time (in seconds) between checks on the accumulated healing done buffer to award healing bonus XP events */
    UPROPERTY(EditDefaultsOnly, Category = "Bonus XP Events")
    float HealBonusBufferCheckTime = 2.0f;
    /* The minimum amount of healing done needed to trigger the Ally Healed Bonus XP Event */
    UPROPERTY(EditDefaultsOnly, Category = "Bonus XP Events")
    float HealBonusThreshold = 2.0f;
    /* The time (in seconds) between checks on the accumulated repairing done buffer to award repair bonus XP events */
    UPROPERTY(EditDefaultsOnly, Category = "Bonus XP Events")
    float RepairBonusBufferCheckTime = 2.0f;
    /* The minimum amount of repairing done needed to trigger the repair Bonus XP Events */
    UPROPERTY(EditDefaultsOnly, Category = "Bonus XP Events")
    float RepairBonusThreshold = 300.f;
    int32 Currency = 0;
    bool bUsedUltimate = false;
 
    //The accumulated XP gained from contractor bonuses
    uint16 GameXPFromMultiplier = 0;
    float EXPMultiplier = 1.0f;
    bool bMatchBonusIsAvailable = false;
    TArray<FPlayerClassUsage> PlayerClassUsageList;
    FPlayerProgressionUpdates PlayerProgressionUpdates;
    uint16 TeamKills = 0;
    FTimerHandle TeamSwitchTimer;
    FTimerHandle ChatSpamTimer;
    uint8 ChatSpamMessageCount;
    /* A tracking of the interaction between players in terms of kills. (PlayerState's UniqueNetID -> How many times this player Killed us, How many times this player was Killed by us). Tracking info might reset based on Nemesis actions */
    TMap<uint32, FNemesisTrackingInfo> NemesisInfoMap = TMap<uint32, FNemesisTrackingInfo>();
    uint32 LastKillerID = 0;
    /* The accumulated healing done that's checked every HealBonusBufferCheckTime to award healing bonus xp events */
    float HealBonusXPBuffer = 0.f;
    FTimerHandle HealBonusXPCheckTimerHandle;
    /* The accumulated repair done that's checked every RepairBonusBufferCheckTime to award repair bonus xp events per class*/
    TMap<UClass*, float> RepairBonusXPBuffer = TMap<UClass*, float>();
    FTimerHandle RepairBonusXPCheckTimerHandle;
    
    FEquips Equips;
 
    FString EnemyDeployableDestroyed = "VO_EquipementDestroyed_Enemy";
 
    FString KilledLitEnemy = "VO_TheyWereLit";
 
    FString DoubleKill = "VO_DoubleKill";
    FString TripleKill = "VO_TripleKill";
    FString QuadKill = "VO_QuadKill";
    FString QuintKill = "VO_QuintKill"; 
 
    FString BecomeNemesis = "VO_Nemesis";
    FString AquiredNemesis = "VO_Nemesis_Recieve";
    FString NemesisKilled = "VO_NemesisPayback";
    FString PayBack = "VO_Payback";
    FString Avenger = "VO_Avenger";
    FString Saviour = "VO_Saviour";
    FString Death = "VO_Death";
 
    FString AssaultClassID = "Assault";
    FString EngineerClassID = "Engineer";
    FString ExplosiveClassID = "Explosive";
    FString HeavyClassID = "Heavy";
    FString SpecOpsClassID = "SpecOps";
    FString SniperClassID = "Sniper";
 
    FString Assault = "VO_SpawnAssault";
    FString Sniper = "VO_SpawnSniper";
    FString Heavy = "VO_SpawnHeavy";
    FString Engineer = "VO_SpawnEngineer";
    FString SpecOps = "VO_SpawnSpecops";
    FString Explosive = "VO_SpawnTech";
    FString NakamaUserId = "b297c970-8355-4768-9f41-6b03ccd8a938";
 
    bool bLoadedCosmetics = false;
    FVector ReviveBeaconSpawnLocation = FVector::ZeroVector;
};
 
//Helpers for APlayerState::OverrideWith() and APlayerState::CopyProperties()
#define COPY_PROPERTY(p, v)         \
{                                   \
    p->v = v;                       \
}