ProjectXPlayerController.h

Go to the documentation of this file.

// Copyright Blue Isle Studios 2017. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "OwnedInterface.h"
#include "TeamInterface.h"
#include "ProjectX.h"
#include "CosmeticsManager.h"
#include "PlayerStructs.h"
#include "ProjectXGameViewportClient.h"
#include "ProjectXPlayerController.generated.h"
 
#define VIEW_TRACEDISTANCE 100000.0f
#define CONN_SERVER_NOT_RESPONDING_SECONDS 6.0f
#define CONN_BAD_PING 200
#define CONN_BAD_RESPONSE_SECONDS 2.0f
#define CONN_BAD_PACKET_LOSS 0.25f
#define CONN_ALERT_DELAY 5.0f
#define CONN_ALERT_RESTORE_DELAY 1.0f
#define NUM_ACTORSTATE_SEND_PER_CHUNK 50
 
class UDecalActor;
class AProjectXCharacter;
class UKillCameraComponent;
class AProjectXVehicle;
class UCurveFloat;
class APawn;
class UAdvancedUserWidget;
class UChatBoxWidget;
class AProjectXPlayerState;
class AProjectXRecordingPawn;
class UContextMenuWidget;
class APlayerState;
 
UENUM(BlueprintType)
enum class EPlayerError : uint8
{
    SpawnTargetDoesntExist,
    CantSpawnHere
};
 
UENUM(BlueprintType)
enum class ESpawnError : uint8
{
    InvalidPlayerController,
    InvalidPlayerState,
    InvalidSpawnTarget,
    InvalidSpawnLocation,
    NotReadyToRespawn,
    RedeployAborted,
    FailedToSpawnPawn
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnWarnPlayerIdle);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FNewHudCreatedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPlayerSpeakSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FVictorySignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnKeyBindingUpdatedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnInteractComplete);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FIdlePlayerSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnConnectionStatusChangedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnPlayerRestartEvent);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerErrorSignature, EPlayerError, Error);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnInteractSignature, float, ExitTime);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnRadarSizeUpdatedSignature, float, RadarSizeMultiplier);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FRestartFailureSignature, ESpawnError, SpawnError);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnCharacterTargetedSignature, AActor*, TargetedActor);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnTeamChangeResponseReceived, ETeamJoinResponse, ChangeResponse);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FGamePadStateChangeSignature, bool, bIsUsingGamepad);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FNewPawnSignature, APawn*, NewPawn);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPlayerKickedSignature, AProjectXPlayerState*, PlayerState);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPlayerFollowedSignature, AProjectXPlayerState*, PlayerState);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FKillParticipationSignature, AActor*, Victim, float, Damage, bool, bKiller);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FiveParams(FHitPredictionSignature, AActor*, Victim, TSubclassOf<UWeaponInstance>, Weapon, bool, bHeadshot, float, Damage, bool, bHealing);
 
//Set bUseDefaultProcess to false if we should skip regular rotation updates from inside ADriverCameraManager::ProcessViewRotation
DECLARE_EVENT_FourParams(AProjectXPlayerController, FViewRotationUpdateEvent, float /* DeltaTime */, FRotator& /* OutViewRotation */, FRotator& /* OutDeltaRot */, bool& /* bUseDefaultProcess */);
 
UCLASS(Config = Game)
class PROJECTX_API AProjectXPlayerController : public APlayerController, public IOwnedInterface, public ITeamInterface
{
    GENERATED_UCLASS_BODY()
 
public:
    virtual APlayerState* GetOwnedPlayerState() const override;
    virtual int32 GetTeam() const override;
    UFUNCTION(BlueprintCallable, Category = PlayerController)
    virtual UKillCameraComponent* GetKillCameraComponent() const { return KillCameraComponent; }
    UFUNCTION(BlueprintCallable, Category = PlayerController)
    FORCEINLINE class UMapRotationReceiverComponent* GetMapRotationReceiverComponent() const { return MapRotationReceiverComponent; }
 
    UFUNCTION(BlueprintCallable, Category = PlayerController, DisplayName = "Server Restart Player", meta = (ScriptName = "ServerRestartPlayer"))
    void K2_ServerRestartPlayer();
    UFUNCTION(BlueprintPure, Category = PlayerController, DisplayName = "Can Restart Player", meta = (ScriptName = "CanRestartPlayer"))
    bool K2_CanRestartPlayer() { return CanRestartPlayer(); }
 
    virtual void SetViewTargetWithBlend(class AActor* NewViewTarget, float BlendTime = 0, enum EViewTargetBlendFunction BlendFunc = VTBlend_Linear, float BlendExp = 0, bool bLockOutgoing = false);
    virtual void SetControlRotation(const FRotator& NewRotation);
    virtual void UpdateRotation(float DeltaTime);
    virtual void ServerRestartPlayer_Implementation() override;
    virtual void ServerFinalizeRestartPlayer();
    virtual bool CanRestartPlayer() override;
    virtual void ClientWasKicked_Implementation(const FText& KickReason) override;
    virtual void SetupInputComponent() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void BeginPlay() override;
    virtual void GetSeamlessTravelActorList(bool bToEntry, TArray<class AActor*>& ActorList) override;
    virtual void Tick(float DeltaSeconds) override;
    virtual void TickAimAssist(const FVector& PawnLocation, const FRotator& PawnRotation, float DeltaTime);
    virtual void TickCurrentViewHitResult(const FVector& PawnLocation, const FRotator& PawnRotation, float DeltaTime);
    virtual void TickConnectionQualityDetection(float DeltaTime);
    virtual void AddPitchInput(float Val) override;
    virtual void AddYawInput(float Val) override;
    virtual void AddRollInput(float Val) override;
    virtual void ModifyViewAcceleration(float Rate);
    virtual void InteractPressed();
    virtual void InteractReleased();
    virtual void RequestRevive();
    virtual void TriggerRevivePrompt(AProjectXPlayerState* Reviver);
    virtual void OnPossess(APawn* PawnToPossess) override;
    virtual void RespawnFromReviveBeacon();
    virtual void AcceptRevive();
    virtual void DeclineRevive();
    /* Kills the stored widget reference for the revive prompt */
    virtual void ClearWaitingOnReviveState();
    virtual void CloseRevivePrompt();
    virtual class APlayerState* GetNextViewablePlayer(int32 dir) override;
    virtual void ServerViewNextPlayer_Implementation() override;
    virtual void ServerViewPrevPlayer_Implementation() override;
    UFUNCTION(Client, Reliable, WithValidation)
    void Client_Reliable_ViewPlayer(AProjectXPlayerState* TargetPlayerState);
    UFUNCTION()
    virtual void SwitchToNextPlayer();
    UFUNCTION()
    virtual void SwitchToPreviousPlayer();
 
    UFUNCTION()
    virtual void MenuToggled(UAdvancedUserWidget* Widget, bool bToggle);
    virtual void PawnLeavingGame() override;
    void OnNewPawn(APawn* NewPawh);
    void InitializePlayerCosmeticRequestInfo();
    void RequestCosmeticFromPlayer();
 
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_RequestCosmeticFromPlayer(APlayerState* RequestedPlayerState);
 
    UFUNCTION(BlueprintPure, Category = Bindings)
    bool IsPlayerBindingNewButton() const {
        UProjectXGameViewportClient* Viewport = Cast<UProjectXGameViewportClient>(GetWorld()->GetGameViewport());
        return Viewport ? Viewport->IsPlayerBindingNewButton() : false;
    }
    UFUNCTION(BlueprintPure, Category = Bindings)
    bool IsPlayerHoldingControllerContextChangeButton() const { return bControllerContextChanged; }
    void ApplyInputSettings();
    UFUNCTION(BlueprintCallable)
    void KeysRebound() {OnKeybindUpdatedEvent.Broadcast(); }
    UFUNCTION(Client, Reliable)
    void Client_ConfirmHitActor(AActor* Victim, UClass* Weapon, bool bHeadshot, float Damage, bool bHealing);
    UFUNCTION(Client, Reliable)
    void Client_RequestRedeploy();
    UFUNCTION(Client, Reliable)
    void Client_PlayerEquipRequest(AProjectXPlayerState* PXPlayerState, const TArray<FEquipInfo>& Equips);
    UFUNCTION(Client, Reliable)
    void Client_ServerRestartPlayerFailed(ESpawnError ErrorType);
    UFUNCTION(BlueprintCallable)
    void UpdateRadarSizeMultiplier(float NewRadarSize);
    UFUNCTION(BlueprintCallable, Category = Spectating)
    void EnableSpectatorMode();
    UFUNCTION(BlueprintImplementableEvent, Category = "QuickChat")
    void SpawnContextPing(FVector SpawnVector);
    UFUNCTION(BlueprintCallable, Category = "Base Control")
    void SelectPlayerClass(TSubclassOf<AProjectXCharacter> PlayerClass);
    UFUNCTION(BlueprintCallable, Category = "Spawning")
    bool SelectSpawnTarget(AActor* SpawnTarget);
    UFUNCTION(BlueprintCallable, Category = "Spawning")
    bool SelectBestSpawnTarget(FVector TargetLocation, bool bUseTargetLocation = false);
    UFUNCTION(BlueprintCallable, Category = "Spawning")
    void ClearSpawnTarget();
    UFUNCTION(BlueprintCallable, Category = "Spawning")
    void UpdateReviveTimeMultiplier(float NewMultiplier) { ReviveTimeMultiplier = NewMultiplier; }
    UFUNCTION(BlueprintCallable, Category = "Spawning")
    FORCEINLINE float GetReviveTimeMultiplier() const { return ReviveTimeMultiplier; }
    FORCEINLINE bool GetHasDeployedAtLeastOnce() const { return bHasDeployedAtLeastOnce;}
    void SetHasDeployedAtLeastOnce(bool bHasDeployed) {bHasDeployedAtLeastOnce = bHasDeployed;}
    void StartPlayerTalking();
    void StopPlayerTalking();
 
    void ToggleFollowCam(bool bFollowEnabled);
    UFUNCTION(BlueprintCallable)
    AProjectXPlayerState* GetFollowPlayer() const;
 
    UFUNCTION(BlueprintCallable, Category = PlayerController)
    bool ChangeTeam(uint8 Team);
    UFUNCTION(BlueprintCallable, Category = PlayerController)
    bool ChangeSquad(int32 Squad) { Server_Reliable_SelectSquad(Squad); return true; }
    void RequestAutoAssignSquad() { Server_Reliable_AutoAssignSquad(); }
 
    UFUNCTION(BlueprintCallable, Category = PlayerController)
    virtual bool WaitingToPlayMatchStart();
 
    AProjectXPlayerState* FindPlayerByNameOrID(const FString& PlayerNameOrID) const;
 
    UFUNCTION(exec)
    void SetWelcomeMessage(const FString& NewWelcomeMessage);
    UFUNCTION(exec)
    void SessionKickPlayer(const FString& PlayerNameOrID, const FString& Reason);
    UFUNCTION(exec)
    void KickPlayer(const FString& PlayerNameOrID, const FString& Reason);
    UFUNCTION(exec)
    void BanPlayer(const FString& PlayerNameOrID, const FString& Reason);
    UFUNCTION(exec)
    void ReportPlayer(const FString& PlayerNameOrID, const FString& Reason);
    UFUNCTION(exec)
    void FlySpeed(const float NewFlySpeed = 1000.0f);
    UFUNCTION(exec)
    void GetMusicTrack();
    UFUNCTION(exec)
    void SmoothCam(const float NewSmoothCamSpeed = -1.0f);
    UFUNCTION(exec)
    void ToggleMeshes();
    UFUNCTION(exec)
    void SkipMap();
    UFUNCTION(exec)
    void SkipWave();
    UFUNCTION(exec)
    void DumpChat();
    UFUNCTION(exec)
    void StartMatch();
    UFUNCTION(exec)
    void PermanentInvisibility(); 
    UFUNCTION(exec)
    void IncrementPlayerStat(int8 EnumElement, int32 NumToAdd, int32 DebugMapType, FString MapName);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_SelectPlayerClass(TSubclassOf<AProjectXCharacter> PlayerClass);
    UFUNCTION(Server,Reliable,WithValidation)
    void Server_Reliable_RespawnFromReviveBeacon();
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_DeclineRevive();
 
    UFUNCTION(Server, Reliable, WithValidation)
    virtual void Server_Reliable_LeaveVehicle();
    // EOS Anti-Cheat: Helper for sending an anti-cheat message from client to server.
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_AntiCheatMessage(const TArray<uint8>& Message);
    // EOS Anti-Cheat: Helper for sending an anti-cheat message from server to client.
    UFUNCTION(Client, Reliable)
    void Client_AntiCheatMessage(const TArray<uint8>& Message);
    UFUNCTION(BlueprintCallable)
    void MatchStartRequest(){Server_Reliable_MatchStartRequest(); }
    UFUNCTION(BlueprintCallable)
    void ToggleReadyStatus(bool bReady);
    UFUNCTION(BlueprintCallable, Category = PlayerController)
    static void SendHitConfirm(AActor* Victim, float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser, bool bHealing);
 
    UFUNCTION()
    virtual void OnRep_KillCameraClass();
    virtual void OnRep_Pawn() override;
    virtual void OnRep_PlayerState() override;
    
    UFUNCTION()
    virtual void VoteYes();
    UFUNCTION()
    virtual void VoteNo();
    UFUNCTION()
    virtual void ToggleMap();
    UFUNCTION(BlueprintCallable, Category = "PlayerController")
    virtual void ResetIdleTimer();
    UFUNCTION()
    void WaitForInitialHud();
    UFUNCTION()
    void FocusReviveBeacon(float BlendTime);
    void OnInitialHudReady();
    TSubclassOf<UAdvancedUserWidget> GetChatBoxWidgetClass() { return ChatBoxWidgetClass; }
    virtual void CloseChat();
    template<bool bNewToggle>
    void ToggleControllerContextChange();
 
    //Returns the vehicle pawn this controller's pawn is currently possessing.
    UFUNCTION(BlueprintPure)
    virtual AProjectXVehicle* GetVehicle() const;
    //Returns the character pawn this controller is meant to control. Used when trying to get the "player" pawn when the owning controller is possessing a vehicle.
    UFUNCTION(BlueprintPure)
    virtual AProjectXCharacter* GetCharacter() const;
    virtual void LeaveVehicle();
 
    UFUNCTION(Server, WithValidation, Reliable)
    void Server_Reliable_PossessRecordingPawn(AProjectXCharacter* TargetedCharacter, AProjectXCharacter* OriginalCharacter);
 
    UFUNCTION(Server, WithValidation, Reliable)
    void Server_Reliable_PossessOriginalCharacter(AProjectXCharacter* OriginalCharacter);
public:
    /* If testing in editor, should game over result in a travel to the main menu? */
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = "Debug")
    bool bTravelIfGameOverInEditor = false;
 
    UPROPERTY(BlueprintAssignable, Category = "Push To Talk Events")
    FPlayerSpeakSignature OnPlayerStartedSpeaking;
    UPROPERTY(BlueprintAssignable, Category = "Push To Talk Events")
    FPlayerSpeakSignature OnPlayerStoppedSpeaking;
    UPROPERTY(BlueprintAssignable, Category = "Game Events")
    FVictorySignature OnPlayerVictory;
    UPROPERTY(BlueprintAssignable)
    FOnInteractSignature OnInteract;
    UPROPERTY(BlueprintAssignable)
    FOnInteractComplete OnInteractComplete;
    UPROPERTY(BlueprintAssignable, Category = "Game Events")
    FIdlePlayerSignature OnIdlePlayerWarning;
    UPROPERTY(BlueprintAssignable, Category = "Game Events")
    FOnTeamChangeResponseReceived OnTeamChangeResponseReceived;
    UPROPERTY(BlueprintAssignable, Category = "Game Events")
    FIdlePlayerSignature OnIdlePlayerStopWarning;
    UPROPERTY(BlueprintAssignable, Category = "Game Events")
    FGamePadStateChangeSignature OnGamepadStateChanged;
    UPROPERTY(BlueprintAssignable, Category = "Game Events")
    FNewPawnSignature OnPawnChanged;
    UPROPERTY(BlueprintAssignable, Category = "Network Events")
    FOnConnectionStatusChangedSignature OnBadConnectionDetected;
    UPROPERTY(BlueprintAssignable, Category = "Network Events")
    FOnConnectionStatusChangedSignature OnGoodConnectionDetected;
    UPROPERTY(BlueprintAssignable, Category = "Network Events")
    FOnConnectionStatusChangedSignature OnServerNotRespondingDetected;
    UPROPERTY(BlueprintAssignable, Category = "Network Events")
    FOnConnectionStatusChangedSignature OnServerRespondingDetected;
    UPROPERTY(BlueprintAssignable, Category = "Generic Events")
    FNewHudCreatedSignature OnNewHUDCreatedAndReady;
    UPROPERTY(BlueprintAssignable, Category = "Generic Events")
    FPlayerErrorSignature OnPlayerError;
    UPROPERTY(BlueprintAssignable, Category = "Player Restart Events")
    FRestartFailureSignature OnServerRestartPlayerFailure;
    UPROPERTY(BlueprintAssignable, Category = "Player Restart Events")
    FOnPlayerRestartEvent OnPlayerRestartRequested;
    UPROPERTY(BlueprintAssignable, Category = "Targeting Events")
    FOnCharacterTargetedSignature OnPlayerTargetedStartedEvent;
    UPROPERTY(BlueprintAssignable, Category = "Targeting Events")
    FOnCharacterTargetedSignature OnPlayerTargetedStoppedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnKeyBindingUpdatedSignature OnKeybindUpdatedEvent;
    FViewRotationUpdateEvent ViewRotationUpdateEvent;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FHitPredictionSignature OnClientHitPrediction;
    UPROPERTY(BlueprintAssignable, Category = "Radar")
    FOnRadarSizeUpdatedSignature OnRadarSizeMultiplierUpdated;
    UPROPERTY(BlueprintAssignable, Category = "GameEvents")
    FGenericDelegateSignature OnServerRequestedRedeploy;
    UPROPERTY(BlueprintAssignable, Category = "GameEvents")
    FOnPlayerKickedSignature OnPlayerKicked;
    UPROPERTY(BlueprintAssignable, Category = "GameEvents")
    FOnPlayerFollowedSignature OnFollowPlayerUpdatedEvent;
    UPROPERTY(BlueprintAssignable, Category = "GameEvents")
    FOnWarnPlayerIdle OnWarnPlayerIdle;
 
    UPROPERTY()
    bool bClientIdleWarned = false;
    bool ServerStatTracking = false;
 
    UPROPERTY(BlueprintReadOnly)
    float RadarSizeMultiplier = 1.0f;
 
    UPROPERTY()
    bool bDebug = false;
 
    float RedeployModifier = 0.0f;
    bool bSetRedeployTimer = false;
    bool bIsRedeploying = false;
 
    UFUNCTION(BlueprintCallable,BlueprintPure)
    FORCEINLINE UVivoxPlayerComponent* GetVivoxComponent() const { return VivoxPlayerComponent; }
 
    void SetAimAssistConfiguration(UCurveFloat* const FallOffCurve, FVector2D Angle);
    void SetLookSensitivityMultiplier(float Multiplier);
 
    void RegisterWithAntiCheat();
    void UnregisterWithAntiCheat();
 
    UFUNCTION(Client, Reliable)
    void Client_EndSession();
    UFUNCTION(Client, Reliable)
    void Client_BeginSession();
 
protected:
    UPROPERTY()
    class UMapRotationReceiverComponent* MapRotationReceiverComponent = NULL;
    
    UPROPERTY()
    class UKillCameraComponent* KillCameraComponent = NULL;
 
    UPROPERTY(ReplicatedUsing = OnRep_KillCameraClass, EditDefaultsOnly, Category = Kill)
    TSubclassOf<class UKillCameraComponent> KillCameraClass = NULL;
 
    UPROPERTY(EditDefaultsOnly, Category = DamageType)
    TSubclassOf<UDamageType> SuicideDamageType;
 
    UPROPERTY(GlobalConfig)
    TSubclassOf<class UKillCameraComponent> KillCameraClassOverride = NULL;
    UPROPERTY(GlobalConfig)
    int32 IdleTimeoutTime = 120;
    /* How long before opening the map on match start*/
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = "Menus")
    float MapOpenDelay = 2.f;
    UPROPERTY(EditDefaultsOnly)
    UVivoxPlayerComponent* VivoxPlayerComponent = NULL;
 
    UFUNCTION(Server, Reliable)
    void Server_RequestActorStateInfo();
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_SelectTeam(uint8 Team);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_SelectSquad(int32 Squad);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_AutoAssignSquad();
    UFUNCTION(Client, Reliable, WithValidation)
    virtual void Client_Reliable_TeamChangeResponse(ETeamJoinResponse ResponseMessage);
    UFUNCTION(Client, Reliable, WithValidation)
    virtual void Client_WarnIdlePlayerToggle(bool bWarn);
    UFUNCTION(Client, Reliable, WithValidation)
    virtual void Client_EarlyWarnIdlePlayer();
    virtual void ClientSetHUD_Implementation(TSubclassOf<AHUD> NewHUDClass) override;
 
    UFUNCTION(Server, Reliable, WithValidation)
    virtual void Server_ResetIdleTimer();
 
    UFUNCTION()
    virtual void WarnIdlePlayerToggle(bool bWarning);
    UFUNCTION()
    virtual void IdlePlayerTimeout();
    virtual void ResetIdleTimerIfNeeded();
    UFUNCTION(BlueprintCallable)
    virtual void ResetIdleTimerUI();
 
    virtual void ToggleTeamChat();
    virtual void ToggleChat();
    void SendContextPing();
    virtual void UpdatePlayerTargeting(const FVector& PawnLocation, const FRotator& PawnRotation, float DeltaSeconds);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_SelectSpawnTarget(AActor* SpawnTarget);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_ClearSpawnTarget();
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_ReadyStatusUpdated(bool bReady);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_Reliable_MatchStartRequest();
    UFUNCTION(BlueprintCallable, Server, Reliable, Category = PlayerController)
    void Server_RedeployCharacter();
 
    TArray<AActor*> GetIgnoredAimAssistActors();
 
    //Is this player waiting to play match start effects?
    UPROPERTY()
    bool bWaitingToPlayMatchStart = true;
 
    /* Amount to slow the reticle while it's over a target */
    UPROPERTY(EditDefaultsOnly)
    float AimAssistFriction = 0.6f;
    /* Strength of force that wants to snap the reticle to the target*/
    UPROPERTY(EditDefaultsOnly)
    float AimAssistAdhesion = 5.0f;
    /* How quickly to ramp up the player's turn speed while spinning. This value is a multiplier per second. */
    UPROPERTY(EditDefaultsOnly)
    float TurnRateAccelerationRate = 5.0f;
    /* How fast to ramp down the player's turn speed when no rotation is detected. This value is a multiplier per second. */
    UPROPERTY(EditDefaultsOnly)
    float TurnRateDeccelerationRate = 10.0f;
    /* This is the max value the multiplier is allowed to reach when TurnRateAccelerationRate is incrementing This value is a multiplier per second.*/
    UPROPERTY(EditDefaultsOnly)
    float TurnRateAccelerationMax = 5.0f;
    /* The amount of time you have to wait between requesting help*/
    UPROPERTY(EditDefaultsOnly)
    float RequestHelpDelay = 5.0f;
    UPROPERTY(EditDefaultsOnly)
    UCurveFloat* DefaultAutoAimFalloffCurve = nullptr;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "UI", meta = (AllowPrivateAccess = true))
    TSubclassOf<UAdvancedUserWidget> ChatBoxWidgetClass;
    UPROPERTY(EditDefaultsOnly)
    TSubclassOf<class UProjectXDamageType> ReviveDamageType;
    TWeakObjectPtr<UChatBoxWidget> ChatBoxInstance;
 
    TArray<TWeakObjectPtr<AActor>> PlayersToIgnore;
 
    TArray<TWeakObjectPtr<APlayerState>>PlayerToLoadCosmetics;
    TWeakObjectPtr<AProjectXPlayerState> FollowPlayer = NULL;
 
private:
    bool bIsBinding = false;
    bool bIsFollowingPlayer = false;
    bool bControllerContextChanged = false;
    UCurveFloat* AutoAimFalloffCurve = nullptr;
    FVector2D AimAssistAngle = FVector2D(15.0f, 30.0f);
    float ViewAccelerationCooldown = 0.0f;
    float ViewRotationMultiplier = 1.0f;
    float ViewAccelerationMultiplier = 1.0f;
    float LastKnownYaw = 0.f;
    float LastKnownPitch = 0.f;
    float ReviveTimeMultiplier = 1.0f;
    bool bIncludeAlliesInAimAssistHitResult = false;
    FHitResult AimAssistHitResult;
    FHitResult CurrentViewHitResult;
    FHitResult VisibilityHitResult;
    FHitResult TargetingHitResult;
    static FHitResult EmptyViewHitResult;
    static TArray<FHitResult> EmptyTargetingHitResult;
    static TArray<TWeakObjectPtr<AActor>> EmptyActorArray;
 
    TArray<TWeakObjectPtr<AActor>> TargetedActors;
    TWeakObjectPtr<AProjectXCharacter> CachedCharacter = NULL;
    TArray<FHitResult> TargetingHits;
    FTimerHandle InitialHudTimer;
    FTimerHandle LeaveVehicleTimer;
    FTimerHandle IdlePlayerTimer;
    FTimerHandle IdlePlayerWarningTimer;
    FTimerHandle IdlePlayerFifteenSecondWarningTimer;
    FTimerHandle ArmoryIdleResetTimer;
    
    bool bHasDeployedAtLeastOnce = false;
    float LastRequestedHelpTime = 0.0f;
    float AvgLostPacketPctIn = 0.0f;
    float AvgLostPacketPctOut = 0.0f;
    bool ServerNotResponding = 0.0f;
    float LastGoodConnectionTime = 0.0f;
    float LastBadConnectionTime = 0.0f;
    float IdleTimerResetCooldownTime = 2.0f;
    TArray<UObject*> HiddenWidgets;
    FRotator DesiredControlRotation = FRotator::ZeroRotator;
    float LookSensitivityRuntimeMultiplier = 1.0f;
    FVector FollowComponentTargetRelativeLocation = FVector::ZeroVector;
    bool bRegisteredWithAntiCheat = false;
    TArray<FLevelActorState> StateChangedActors;
    bool bRequestedActorStateInfo = false;
    void SendActorStateInfoToClient();
    void Client_ReceiveActorStateInfo(TArray<FLevelActorState> SendList);
    TWeakObjectPtr<UContextMenuWidget> RevivePromptWidget = nullptr;
 
public:
    /* precise camera-center trace forwards for a single blocking hit */
    UFUNCTION(BlueprintPure)
    static const FHitResult& GetPlayerViewHitResult(UObject* const WorldContextObject);
    /* returns anything hitting aim assist volumes exclusive of allies */
    UFUNCTION(BlueprintPure)
    static const FHitResult& GetPlayerAimAssistHitResult(UObject* const WorldContextObject);
    /* returns anything hitting aim assist volumes inclusive of allies */
    UFUNCTION(BlueprintPure)
    static const TArray<FHitResult>& GetTargetingHitResult(UObject* const WorldContextObject);
    UFUNCTION(BlueprintPure)
    static const TArray<AActor*> GetTargetedActors(UObject* const WorldContextObject);
    /* get potential targets which are collected on tick */
    static const TArray<TWeakObjectPtr<AActor>>& GetTargets(UObject* const WorldContextObject);
 
    virtual void CurrentViewHitResultInDistance(const float Distance, FHitResult& ReturnHitResult);
 
    TWeakObjectPtr<class UFOVCameraModifier> FOVCameraModifier = nullptr;
    bool bFPMeshesVisible = true;
    float SmoothCamSpeed = -1.0f;
    bool bRestartingPlayer = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, config, Category = PlayerController)
    float InputADSYawScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, config, Category = PlayerController)
    float InputADSPitchScale;
 
    //Achievement debug DamageType
    UPROPERTY(EditDefaultsOnly, Category = PlayerController)
    TSubclassOf<class UProjectXDamageType> GrenadeDamageType;
 
    int8 DebugGrenadeKillStat = 99;
    
};