PlayerState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Templates/SubclassOf.h"
#include "GameFramework/Actor.h"
#include "Online/CoreOnline.h"
#include "GameFramework/OnlineReplStructs.h"
#include "GameFramework/Info.h"
#include "PlayerState.generated.h"
 
struct PingAvgData
{
    uint16  PingSum : 13;
 
    uint8   PingCount : 3;
 
    PingAvgData()
        : PingSum(0)
        , PingCount(0)
    {
    }
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnPlayerStatePawnSet, APlayerState*, Player, APawn*, NewPawn, APawn*, OldPawn);
 
UCLASS(BlueprintType, Blueprintable, notplaceable, MinimalAPI)
class APlayerState : public AInfo
{
    GENERATED_UCLASS_BODY()
 
private:
 
    UPROPERTY(ReplicatedUsing = OnRep_Score, Category = PlayerState, BlueprintGetter = GetScore)
    float Score;
 
    UPROPERTY(ReplicatedUsing = OnRep_PlayerId, Category = PlayerState, BlueprintGetter = GetPlayerId)
    int32 PlayerId;
 
    UPROPERTY(Replicated, Category=PlayerState, BlueprintGetter=GetCompressedPing, meta=(AllowPrivateAccess))
    uint8 CompressedPing;
 
    uint8 CurPingBucket;
 
    UPROPERTY(EditDefaultsOnly, Category=PlayerState)
    uint8 bShouldUpdateReplicatedPing:1;
 
    UPROPERTY(Replicated, Category=PlayerState, BlueprintGetter=IsSpectator)
    uint8 bIsSpectator:1;
 
    UPROPERTY(Replicated)
    uint8 bOnlySpectator:1;
 
    UPROPERTY(Replicated, Category=PlayerState, BlueprintGetter=IsABot)
    uint8 bIsABot:1;
 
public:
    uint8 bHasBeenWelcomed:1;
 
private:
 
    UPROPERTY(ReplicatedUsing=OnRep_bIsInactive)
    uint8 bIsInactive:1;
 
    UPROPERTY(Replicated)
    uint8 bFromPreviousLevel:1;
 
public:
 
    uint8 bUseCustomPlayerNames : 1;
 
private:
 
    UPROPERTY(Replicated)
    int32 StartTime;
 
    UPROPERTY(ReplicatedUsing = OnRep_UniqueId)
    FUniqueNetIdRepl UniqueId;
 
public:
    UPROPERTY()
    TSubclassOf<class ULocalMessage> EngineMessageClass;
 
    float ExactPing;
 
    UPROPERTY()
    FString SavedNetworkAddress;
 
    FName SessionName;
 
    UPROPERTY(BlueprintAssignable, Category = "Events")
    FOnPlayerStatePawnSet OnPawnSet;
 
private:
 
    friend struct FSetPlayerStatePawn;
 
    UPROPERTY(BlueprintReadOnly, Category=PlayerState, meta=(AllowPrivateAccess="true"))
    TObjectPtr<APawn> PawnPrivate;
 
    ENGINE_API void SetPawnPrivate(APawn* InPawn);
 
    UFUNCTION()
    ENGINE_API void OnPawnPrivateDestroyed(AActor* InActor);
 
    PingAvgData     PingBucket[4];
 
    float           CurPingBucketTimestamp;
 
    UPROPERTY(ReplicatedUsing = OnRep_PlayerName)
    FString PlayerNamePrivate;
 
    FString OldNamePrivate;
 
public:
    UFUNCTION()
    ENGINE_API virtual void OnRep_Score();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_PlayerName();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_bIsInactive();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_PlayerId();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_UniqueId();
 
    //~ Begin AActor Interface
    ENGINE_API virtual void PostInitializeComponents() override; 
    ENGINE_API virtual void Destroyed() override;
    ENGINE_API virtual void Reset() override;
    ENGINE_API virtual FString GetHumanReadableName() const override;
    //~ End AActor Interface
 
    UFUNCTION(BlueprintCallable, Category = "PlayerState")
    APawn* GetPawn() const { return PawnPrivate; }
 
    template<class T>
    T* GetPawn() const { return Cast<T>(PawnPrivate); }
 
    ENGINE_API class AController* GetOwningController() const;
 
    UFUNCTION(BlueprintCallable, Category = "PlayerState")
    ENGINE_API class APlayerController* GetPlayerController() const;
    
    ENGINE_API virtual void ClientInitialize(class AController* C);
 
    ENGINE_API virtual void UpdatePing(float InPing);
 
    ENGINE_API virtual void RecalculateAvgPing();
 
    ENGINE_API virtual bool ShouldBroadCastWelcomeMessage(bool bExiting = false);
 
    ENGINE_API virtual void SetPlayerName(const FString& S);
 
    ENGINE_API virtual void SetPlayerNameInternal(const FString& S);
 
    UFUNCTION(BlueprintPure, Category = PlayerState)
    ENGINE_API FString GetPlayerName() const;
 
    ENGINE_API virtual FString GetPlayerNameCustom() const;
 
    ENGINE_API virtual FString GetOldPlayerName() const;
 
    ENGINE_API virtual void SetOldPlayerName(const FString& S);
 
    ENGINE_API virtual void RegisterPlayerWithSession(bool bWasFromInvite);
 
    ENGINE_API virtual void UnregisterPlayerWithSession();
 
    ENGINE_API virtual class APlayerState* Duplicate();
 
    ENGINE_API virtual void OnDeactivated();
 
    ENGINE_API virtual void OnReactivated();
 
    ENGINE_API virtual void SeamlessTravelTo(class APlayerState* NewPlayerState);
 
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const override;
 
    ENGINE_API void DispatchOverrideWith(APlayerState* PlayerState);
 
    ENGINE_API void DispatchCopyProperties(APlayerState* PlayerState);
 
protected:
 
    ENGINE_API virtual void OverrideWith(APlayerState* PlayerState);
 
    ENGINE_API virtual void CopyProperties(APlayerState* PlayerState);
 
    /*
    * Can be implemented in Blueprint Child to move more properties from old to new PlayerState when reconnecting
    *
    * @param OldPlayerState     Old PlayerState, which we use to fill the new one with
    */
    UFUNCTION(BlueprintImplementableEvent, Category = PlayerState, meta = (DisplayName = "OverrideWith"))
    ENGINE_API void ReceiveOverrideWith(APlayerState* OldPlayerState);
 
    /*
    * Can be implemented in Blueprint Child to move more properties from old to new PlayerState when traveling to a new level
    *
    * @param NewPlayerState     New PlayerState, which we fill with the current properties
    */
    UFUNCTION(BlueprintImplementableEvent, Category = PlayerState, meta = (DisplayName = "CopyProperties"))
    ENGINE_API void ReceiveCopyProperties(APlayerState* NewPlayerState);
 
    void SetShouldUpdateReplicatedPing(bool bInShouldUpdateReplicatedPing) { bShouldUpdateReplicatedPing = bInShouldUpdateReplicatedPing; }
 
    ENGINE_API virtual void HandleWelcomeMessage();
 
private:
    // Hidden functions that don't make sense to use on this class.
    HIDE_ACTOR_TRANSFORM_FUNCTIONS();
 
    //~ Begin Methods for Replicated Members.
public:
 
    UFUNCTION(BlueprintGetter)
    float GetScore() const
    {
        return Score;
    }
 
    ENGINE_API void SetScore(const float NewScore);
 
    UFUNCTION(BlueprintGetter)
    int32 GetPlayerId() const
    {
        return PlayerId;
    }
 
    ENGINE_API void SetPlayerId(const int32 NewId);
 
    UFUNCTION(BlueprintGetter)
    uint8 GetCompressedPing() const
    {
        return CompressedPing;
    }
 
    ENGINE_API void SetCompressedPing(const uint8 NewPing);
 
    UFUNCTION(BlueprintCallable, Category = "PlayerState")
    ENGINE_API float GetPingInMilliseconds() const;
 
    UFUNCTION(BlueprintGetter)
    bool IsSpectator() const
    {
        return bIsSpectator;
    }
 
    ENGINE_API void SetIsSpectator(const bool bNewSpectator);
 
    UFUNCTION(BlueprintCallable, Category = "PlayerState")
    bool IsOnlyASpectator() const
    {
        return bOnlySpectator;
    }
 
    ENGINE_API void SetIsOnlyASpectator(const bool bNewSpectator);
 
    UFUNCTION(BlueprintGetter)
    bool IsABot() const
    {
        return bIsABot;
    }
 
    ENGINE_API void SetIsABot(const bool bNewIsABot);
 
    bool IsInactive() const
    {
        return bIsInactive;
    }
 
    ENGINE_API void SetIsInactive(const bool bNewInactive);
 
    bool IsFromPreviousLevel() const
    {
        return bFromPreviousLevel;
    }
 
    ENGINE_API void SetIsFromPreviousLevel(const bool bNewFromPreviousLevel);
 
    int32 GetStartTime() const
    {
        return StartTime;
    }
 
    ENGINE_API void SetStartTime(const int32 NewStartTime);
 
    const FUniqueNetIdRepl& GetUniqueId() const
    {
        return UniqueId;
    }
 
    UFUNCTION(BlueprintCallable, Category = "PlayerState", meta = (DisplayName = "Get Unique Net Id"))
    ENGINE_API FUniqueNetIdRepl BP_GetUniqueId() const;
 
    ENGINE_API void SetUniqueId(const FUniqueNetIdRepl& NewUniqueId);
    
    ENGINE_API void SetUniqueId(FUniqueNetIdRepl&& NewUniqueId);
 
    ENGINE_API virtual void OnSetUniqueId();
 
    //~ End Methods for Replicated Members.
};
 
struct FSetPlayerStatePawn
{
private:
 
    friend APawn;
 
    FSetPlayerStatePawn(APlayerState* PlayerState, APawn* Pawn)
    {
        APawn* OldPawn = PlayerState->PawnPrivate;
        PlayerState->SetPawnPrivate(Pawn);
        PlayerState->OnPawnSet.Broadcast(PlayerState, PlayerState->PawnPrivate, OldPawn); 
    }
};