Character.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 "UObject/UObjectGlobals.h"
#include "Templates/SubclassOf.h"
#include "UObject/CoreNet.h"
#include "Engine/NetSerialization.h"
#include "Engine/EngineTypes.h"
#include "Components/ActorComponent.h"
#include "GameFramework/Actor.h"
#include "GameFramework/Pawn.h"
#include "GameFramework/CharacterMovementReplication.h"
#include "Animation/AnimationAsset.h"
#include "GameFramework/RootMotionSource.h"
#include "Character.generated.h"
 
class ACharacter;
class AController;
class FDebugDisplayInfo;
class UAnimMontage;
class UArrowComponent;
class UCapsuleComponent;
class UCharacterMovementComponent;
class UPawnMovementComponent;
class UPrimitiveComponent;
class USkeletalMeshComponent;
struct FAnimMontageInstance;
struct FCharacterAsyncInput;
struct FCharacterAsyncOutput;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FMovementModeChangedSignature, class ACharacter*, Character, EMovementMode, PrevMovementMode, uint8, PreviousCustomMode);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FCharacterMovementUpdatedSignature, float, DeltaSeconds, FVector, OldLocation, FVector, OldVelocity);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FCharacterReachedApexSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLandedSignature, const FHitResult&, Hit);
 
// CVars
namespace CharacterCVars
{   
    extern ENGINE_API int32 EnableCharacterAccelerationReplication;
}
 
USTRUCT()
struct FRepRootMotionMontage
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<UAnimSequenceBase> Animation = nullptr;
 
    UPROPERTY()
    bool bIsActive = false;
 
    UPROPERTY()
    bool bRelativePosition = false;
 
    UPROPERTY()
    bool bRelativeRotation = false;
 
    UPROPERTY()
    float Position = 0.f;
 
    UPROPERTY()
    FVector_NetQuantize100 Location;
 
    UPROPERTY()
    FRotator Rotation = FRotator(0.f);
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> MovementBase = nullptr;
 
    UPROPERTY()
    FName MovementBaseBoneName;
 
    UPROPERTY()
    FRootMotionSourceGroup AuthoritativeRootMotion;
 
    UPROPERTY()
    FVector_NetQuantize10 Acceleration;
 
    UPROPERTY()
    FVector_NetQuantize10 LinearVelocity;
 
    void Clear()
    {
        bIsActive = false;
        Animation = nullptr;
        AuthoritativeRootMotion.Clear();
    }
 
    bool HasRootMotion() const
    {
        return (Animation != nullptr);
    }
 
    UAnimMontage* GetAnimMontage() const;
};
 
USTRUCT()
struct FSimulatedRootMotionReplicatedMove
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    float Time = 0.f;
 
    UPROPERTY()
    FRepRootMotionMontage RootMotion;
};
 
 
namespace MovementBaseUtility
{
    ENGINE_API bool IsDynamicBase(const UPrimitiveComponent* MovementBase);
 
    ENGINE_API bool IsSimulatedBase(const UPrimitiveComponent* MovementBase);
 
    inline bool UseRelativeLocation(const UPrimitiveComponent* MovementBase)
    {
        return IsDynamicBase(MovementBase);
    }
 
    ENGINE_API void AddTickDependency(FTickFunction& BasedObjectTick, UPrimitiveComponent* NewBase);
 
    ENGINE_API void RemoveTickDependency(FTickFunction& BasedObjectTick, UPrimitiveComponent* OldBase);
 
    ENGINE_API FVector GetMovementBaseVelocity(const UPrimitiveComponent* MovementBase, const FName BoneName);
 
    ENGINE_API FVector GetMovementBaseTangentialVelocity(const UPrimitiveComponent* MovementBase, const FName BoneName, const FVector& WorldLocation);
 
    ENGINE_API bool GetMovementBaseTransform(const UPrimitiveComponent* MovementBase, const FName BoneName, FVector& OutLocation, FQuat& OutQuat);
 
    ENGINE_API bool TransformLocationToWorld(const UPrimitiveComponent* MovementBase, const FName BoneName, const FVector& LocalLocation, FVector& OutLocationWorldSpace);
 
    ENGINE_API bool TransformLocationToLocal(const UPrimitiveComponent* MovementBase, const FName BoneName, const FVector& WorldSpaceLocation, FVector& OutLocalLocation);
 
    ENGINE_API bool TransformDirectionToWorld(const UPrimitiveComponent* MovementBase, const FName BoneName, const FVector& LocalDirection, FVector& OutDirectionWorldSpace);
 
    ENGINE_API bool TransformDirectionToLocal(const UPrimitiveComponent* MovementBase, const FName BoneName, const FVector& WorldSpaceDirection, FVector& OutLocalDirection);
}
 
USTRUCT()
struct FBasedMovementInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    uint16 BaseID = 0;
 
    UPROPERTY()
    uint8 bServerHasBaseComponent:1 = false;
 
    UPROPERTY()
    uint8 bRelativeRotation:1 = false;
 
    UPROPERTY()
    uint8 bServerHasVelocity:1 = false;
 
    UPROPERTY()
    FName BoneName;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> MovementBase = nullptr;
 
    UPROPERTY()
    FVector_NetQuantize100 Location;
 
    UPROPERTY()
    FRotator Rotation = FRotator(0.f);
 
    inline bool HasRelativeLocation() const
    {
        return MovementBaseUtility::UseRelativeLocation(MovementBase);
    }
 
    inline bool HasRelativeRotation() const
    {
        return bRelativeRotation && HasRelativeLocation();
    }
 
    inline bool IsBaseUnresolved() const
    {
        return (MovementBase == nullptr) && bServerHasBaseComponent;
    }
};
 
 
UCLASS(config=Game, BlueprintType, meta=(ShortTooltip="A character is a type of Pawn that includes the ability to walk around."), MinimalAPI)
class ACharacter : public APawn
{
    GENERATED_BODY()
public:
    ENGINE_API ACharacter(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
 
    ENGINE_API virtual void GetReplicatedCustomConditionState(FCustomPropertyConditionState& OutActiveState) const override;
 
private:
    UPROPERTY(Category=Character, VisibleAnywhere, BlueprintReadOnly, meta=(AllowPrivateAccess = "true"))
    TObjectPtr<USkeletalMeshComponent> Mesh;
 
    UPROPERTY(Category=Character, VisibleAnywhere, BlueprintReadOnly, meta=(AllowPrivateAccess = "true"))
    TObjectPtr<UCharacterMovementComponent> CharacterMovement;
 
    UPROPERTY(Category=Character, VisibleAnywhere, BlueprintReadOnly, meta=(AllowPrivateAccess = "true"))
    TObjectPtr<UCapsuleComponent> CapsuleComponent;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<UArrowComponent> ArrowComponent;
#endif
 
public:
 
    // Server RPC that passes through to CharacterMovement (avoids RPC overhead for components).
    // The base RPC function (eg 'ServerMove') is auto-generated for clients to trigger the call to the server function,
    // eventually going to the _Implementation function (which we just pass to the CharacterMovementComponent).
 
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMovePacked(const FCharacterServerMovePackedBits& PackedBits);
    ENGINE_API void ServerMovePacked_Implementation(const FCharacterServerMovePackedBits& PackedBits);
    ENGINE_API bool ServerMovePacked_Validate(const FCharacterServerMovePackedBits& PackedBits);
 
    // Client RPC that passes through to CharacterMovement (avoids RPC overhead for components).
 
    UFUNCTION(unreliable, client, WithValidation)
    ENGINE_API void ClientMoveResponsePacked(const FCharacterMoveResponsePackedBits& PackedBits);
    ENGINE_API void ClientMoveResponsePacked_Implementation(const FCharacterMoveResponsePackedBits& PackedBits);
    ENGINE_API bool ClientMoveResponsePacked_Validate(const FCharacterMoveResponsePackedBits& PackedBits);
 
 
    // BEGIN DEPRECATED RPCs that don't use variable sized payloads. Use ServerMovePacked and ClientMoveResponsePacked instead.
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMove, ServerMovePacked)
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMove(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMove_Implementation, ServerMovePacked_Implementation)
    ENGINE_API void ServerMove_Implementation(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
    ENGINE_API bool ServerMove_Validate(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveNoBase, ServerMovePacked)
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMoveNoBase(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveNoBase_Implementation, ServerMovePacked_Implementation)
    ENGINE_API void ServerMoveNoBase_Implementation(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
    ENGINE_API bool ServerMoveNoBase_Validate(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveDual, ServerMovePacked)
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMoveDual(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveDual_Implementation, ServerMovePacked_Implementation)
    ENGINE_API void ServerMoveDual_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
    ENGINE_API bool ServerMoveDual_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveDualNoBase, ServerMovePacked)
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMoveDualNoBase(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveDualNoBase_Implementation, ServerMovePacked_Implementation)
    ENGINE_API void ServerMoveDualNoBase_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
    ENGINE_API bool ServerMoveDualNoBase_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveDualHybridRootMotion, ServerMovePacked)
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMoveDualHybridRootMotion(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveDualHybridRootMotion_Implementation, ServerMovePacked_Implementation)
    ENGINE_API void ServerMoveDualHybridRootMotion_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
    ENGINE_API bool ServerMoveDualHybridRootMotion_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    /* Resending an (important) old move. Process it if not already processed. */
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveOld, ServerMovePacked)
    UFUNCTION(unreliable, server, WithValidation)
    ENGINE_API void ServerMoveOld(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveOld_Implementation, ServerMovePacked_Implementation)
    ENGINE_API void ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags);
    ENGINE_API bool ServerMoveOld_Validate(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAckGoodMove, ClientMoveResponsePacked)
    UFUNCTION(unreliable, client)
    ENGINE_API void ClientAckGoodMove(float TimeStamp);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAckGoodMove_Implementation, ClientMoveResponsePacked_Implementation)
    ENGINE_API void ClientAckGoodMove_Implementation(float TimeStamp);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustPosition, ClientMoveResponsePacked)
    UFUNCTION(unreliable, client)
    ENGINE_API void ClientAdjustPosition(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustPosition_Implementation, ClientMoveResponsePacked_Implementation)
    ENGINE_API void ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientVeryShortAdjustPosition, ClientMoveResponsePacked)
    /* Bandwidth saving version, when velocity is zeroed */
    UFUNCTION(unreliable, client)
    ENGINE_API void ClientVeryShortAdjustPosition(float TimeStamp, FVector NewLoc, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientVeryShortAdjustPosition_Implementation, ClientMoveResponsePacked_Implementation)
    ENGINE_API void ClientVeryShortAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustRootMotionPosition, ClientMoveResponsePacked)
    UFUNCTION(unreliable, client)
    ENGINE_API void ClientAdjustRootMotionPosition(float TimeStamp, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustRootMotionPosition_Implementation, ClientMoveResponsePacked_Implementation)
    ENGINE_API void ClientAdjustRootMotionPosition_Implementation(float TimeStamp, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustRootMotionSourcePosition, ClientMoveResponsePacked)
    UFUNCTION(unreliable, client)
    ENGINE_API void ClientAdjustRootMotionSourcePosition(float TimeStamp, FRootMotionSourceGroup ServerRootMotion, bool bHasAnimRootMotion, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustRootMotionSourcePosition_Implementation, ClientMoveResponsePacked_Implementation)
    ENGINE_API void ClientAdjustRootMotionSourcePosition_Implementation(float TimeStamp, FRootMotionSourceGroup ServerRootMotion, bool bHasAnimRootMotion, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    // END DEPRECATED RPCs
 
public:
    inline class USkeletalMeshComponent* GetMesh() const { return Mesh; }
 
    static ENGINE_API FName MeshComponentName;
 
    template <class T>
    inline T* GetCharacterMovement() const
    {
        return CastChecked<T>(CharacterMovement, ECastCheckedType::NullAllowed);
    }
    inline UCharacterMovementComponent* GetCharacterMovement() const { return CharacterMovement; }
 
    static ENGINE_API FName CharacterMovementComponentName;
 
    inline class UCapsuleComponent* GetCapsuleComponent() const { return CapsuleComponent; }
 
    static ENGINE_API FName CapsuleComponentName;
 
#if WITH_EDITORONLY_DATA
    class UArrowComponent* GetArrowComponent() const { return ArrowComponent; }
#endif
 
    ENGINE_API virtual void SetBase(UPrimitiveComponent* NewBase, const FName BoneName = NAME_None, bool bNotifyActor=true);
    
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API virtual void CacheInitialMeshOffset(FVector MeshRelativeLocation, FRotator MeshRelativeRotation);
 
protected:
    UPROPERTY()
    struct FBasedMovementInfo BasedMovement;
 
    UPROPERTY(ReplicatedUsing=OnRep_ReplicatedBasedMovement)
    struct FBasedMovementInfo ReplicatedBasedMovement;
 
    ENGINE_API FBasedMovementInfo& GetReplicatedBasedMovement_Mutable();
    ENGINE_API void SetReplicatedBasedMovement(const FBasedMovementInfo& InReplicatedBasedMovement);
 
public:
    UFUNCTION()
    ENGINE_API virtual void OnRep_ReplicatedBasedMovement();
 
    ENGINE_API virtual void SetReplicateMovement(bool bInReplicateMovement) override;
 
protected:
    virtual bool ShouldReplicateAcceleration() const { return CharacterCVars::EnableCharacterAccelerationReplication != 0; }
 
    UPROPERTY(Replicated)
    float ReplicatedServerLastTransformUpdateTimeStamp;
 
    UPROPERTY(ReplicatedUsing=OnRep_ReplayLastTransformUpdateTimeStamp)
    float ReplayLastTransformUpdateTimeStamp;
 
    UPROPERTY()
    FQuat BaseRotationOffset;
 
    UPROPERTY()
    FVector BaseTranslationOffset;
 
    ENGINE_API virtual void BaseChange();
 
    UPROPERTY(Replicated)
    FVector_NetQuantizeNormal ReplicatedGravityDirection;
 
    FVector_NetQuantizeNormal PreNetReceivedGravityDirection;
 
    UPROPERTY(Replicated)
    float AnimRootMotionTranslationScale;
 
    ENGINE_API void SetReplicatedServerLastTransformUpdateTimeStamp(const float InReplicatedServerLastTransformUpdateTimeStamp);
 
    ENGINE_API void SetReplayLastTransformUpdateTimeStamp(const float InReplayLastTransformUpdateTimeStamp);
 
    ENGINE_API void SetReplicatedGravityDirection(const FVector& InReplicatedGravityDirection);
public:
    UFUNCTION()
    ENGINE_API void OnRep_ReplayLastTransformUpdateTimeStamp();
 
    inline float GetReplicatedServerLastTransformUpdateTimeStamp() const { return ReplicatedServerLastTransformUpdateTimeStamp; }
 
    inline float GetReplayLastTransformUpdateTimeStamp() const { return ReplayLastTransformUpdateTimeStamp; }
 
    inline const FBasedMovementInfo& GetBasedMovement() const { return BasedMovement; }
    
    inline const FBasedMovementInfo& GetReplicatedBasedMovement() const { return ReplicatedBasedMovement; }
 
    ENGINE_API void SaveRelativeBasedMovement(const FVector& NewRelativeLocation, const FRotator& NewRotation, bool bRelativeRotation);
 
    inline uint8 GetReplicatedMovementMode() const { return ReplicatedMovementMode; }
 
    UFUNCTION(BlueprintCallable, Category=Character)
    FVector GetBaseTranslationOffset() const { return BaseTranslationOffset; }
 
    virtual FQuat GetBaseRotationOffset() const { return BaseRotationOffset; }
 
    UFUNCTION(BlueprintCallable, Category=Character, meta=(DisplayName="Get Base Rotation Offset", ScriptName="GetBaseRotationOffset"))
    FRotator GetBaseRotationOffsetRotator() const { return GetBaseRotationOffset().Rotator(); }
 
    ENGINE_API virtual FVector GetGravityDirection() const override;
 
    ENGINE_API virtual FQuat GetGravityTransform() const override;
 
    ENGINE_API virtual FVector GetReplicatedGravityDirection() const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    float CrouchedEyeHeight;
 
protected:
    UPROPERTY()
    uint8 bInBaseReplication:1;
 
public:
    UPROPERTY(BlueprintReadOnly, replicatedUsing=OnRep_IsCrouched, Category=Character)
    uint8 bIsCrouched:1;
 
    UPROPERTY(Transient, Replicated)
    uint8 bProxyIsJumpForceApplied : 1;
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_IsCrouched();
 
    UPROPERTY(BlueprintReadOnly, Category=Character)
    uint8 bPressedJump:1;
 
    UPROPERTY(Transient)
    uint8 bClientUpdating:1;
 
    UPROPERTY(Transient)
    uint8 bClientWasFalling:1; 
 
    UPROPERTY(Transient)
    uint8 bClientResimulateRootMotion:1;
 
    UPROPERTY(Transient)
    uint8 bClientResimulateRootMotionSources:1;
 
    UPROPERTY()
    uint8 bSimGravityDisabled:1;
 
    UPROPERTY(Transient)
    uint8 bClientCheckEncroachmentOnNetUpdate:1;
 
    UPROPERTY(Transient)
    uint8 bServerMoveIgnoreRootMotion:1;
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Transient, Category=Character)
    uint8 bWasJumping : 1;
 
protected:
    UPROPERTY(Replicated)
    uint8 ReplicatedMovementMode;
 
    ENGINE_API void SetReplicatedMovementMode(const uint8 InReplicatedMovementMode);
 
public:
    UPROPERTY(Transient, BlueprintReadOnly, VisibleInstanceOnly, Category=Character)
    float JumpKeyHoldTime;
 
    UPROPERTY(Transient, BlueprintReadOnly, VisibleInstanceOnly, Category=Character)
    float JumpForceTimeRemaining;
 
    UPROPERTY(Transient, BlueprintReadOnly, VisibleInstanceOnly, Category=Character)
    float ProxyJumpForceStartedTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Replicated, Category=Character, Meta=(ClampMin=0.0, UIMin=0.0))
    float JumpMaxHoldTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Replicated, Category=Character)
    int32 JumpMaxCount;
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category=Character)
    int32 JumpCurrentCount;
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Character)
    int32 JumpCurrentCountPreJump;
 
    uint32 NumActorOverlapEventsCounter;
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void PostLoad() override;
    //~ End UObject Interface
 
    //~ Begin AActor Interface.
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual void ClearCrossLevelReferences() override;
    ENGINE_API virtual void PreNetReceive() override;
    ENGINE_API virtual void PostNetReceive() override;
    ENGINE_API virtual void GatherCurrentMovement() override;
    ENGINE_API virtual void OnRep_ReplicatedMovement() override;
    ENGINE_API virtual void PostNetReceiveLocationAndRotation() override;
    ENGINE_API virtual void GetSimpleCollisionCylinder(float& CollisionRadius, float& CollisionHalfHeight) const override;
    ENGINE_API virtual UActorComponent* FindComponentByClass(const TSubclassOf<UActorComponent> ComponentClass) const override;
    ENGINE_API virtual void TornOff() override;
    ENGINE_API virtual void NotifyActorBeginOverlap(AActor* OtherActor);
    ENGINE_API virtual void NotifyActorEndOverlap(AActor* OtherActor);
    //~ End AActor Interface
 
    template<class T>
    T* FindComponentByClass() const
    {
        return AActor::FindComponentByClass<T>();
    }
 
    //~ Begin INavAgentInterface Interface
    ENGINE_API virtual FVector GetNavAgentLocation() const override;
    //~ End INavAgentInterface Interface
 
    //~ Begin APawn Interface.
    ENGINE_API virtual void PostInitializeComponents() override;
    ENGINE_API virtual UPawnMovementComponent* GetMovementComponent() const override;
    virtual UPrimitiveComponent* GetMovementBase() const override final { return BasedMovement.MovementBase; }
    ENGINE_API virtual float GetDefaultHalfHeight() const override;
    ENGINE_API virtual void TurnOff() override;
    ENGINE_API virtual void Restart() override;
    ENGINE_API virtual void PawnClientRestart() override;
    ENGINE_API virtual void PossessedBy(AController* NewController) override;
    ENGINE_API virtual void UnPossessed() override;
    ENGINE_API virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
    ENGINE_API virtual void RecalculateBaseEyeHeight() override;
    ENGINE_API virtual void UpdateNavigationRelevance() override;
    //~ End APawn Interface
 
    ENGINE_API virtual void ApplyDamageMomentum(float DamageTaken, FDamageEvent const& DamageEvent, APawn* PawnInstigator, AActor* DamageCauser);
 
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API virtual void Jump();
 
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API virtual void StopJumping();
 
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API bool CanJump() const;
 
    inline bool GetProxyIsJumpForceApplied() const { return bProxyIsJumpForceApplied; }
    ENGINE_API void SetProxyIsJumpForceApplied(const bool bInProxyIsJumpForceApplied);
 
    ENGINE_API bool IsCrouched() const;
    ENGINE_API void SetIsCrouched(const bool bInIsCrouched);
 
protected:
    UFUNCTION(BlueprintNativeEvent, Category=Character, meta=(DisplayName="CanJump"))
    ENGINE_API bool CanJumpInternal() const;
    ENGINE_API virtual bool CanJumpInternal_Implementation() const;
    ENGINE_API bool JumpIsAllowedInternal() const;
 
public:
 
    ENGINE_API virtual void ResetJumpState();
 
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API virtual bool IsJumpProvidingForce() const;
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    ENGINE_API virtual float PlayAnimMontage(class UAnimMontage* AnimMontage, float InPlayRate = 1.f, FName StartSectionName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    ENGINE_API virtual void StopAnimMontage(class UAnimMontage* AnimMontage = nullptr);
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    ENGINE_API class UAnimMontage* GetCurrentMontage() const;
 
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API virtual void LaunchCharacter(FVector LaunchVelocity, bool bXYOverride, bool bZOverride);
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void OnLaunched(FVector LaunchVelocity, bool bXYOverride, bool bZOverride);
 
    UFUNCTION(BlueprintNativeEvent, Category=Character)
    ENGINE_API void OnJumped();
    ENGINE_API virtual void OnJumped_Implementation();
 
    virtual void Falling() {}
 
    ENGINE_API virtual void NotifyJumpApex();
 
    UPROPERTY(BlueprintAssignable, Category=Character)
    FCharacterReachedApexSignature OnReachedJumpApex;
 
    ENGINE_API virtual void Landed(const FHitResult& Hit);
 
    UPROPERTY(BlueprintAssignable, Category=Character)
    FLandedSignature LandedDelegate;
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void OnLanded(const FHitResult& Hit);
 
    UFUNCTION(BlueprintNativeEvent, Category=Character)
    ENGINE_API void OnWalkingOffLedge(const FVector& PreviousFloorImpactNormal, const FVector& PreviousFloorContactNormal, const FVector& PreviousLocation, float TimeDelta);
    ENGINE_API virtual void OnWalkingOffLedge_Implementation(const FVector& PreviousFloorImpactNormal, const FVector& PreviousFloorContactNormal, const FVector& PreviousLocation, float TimeDelta);
 
    virtual void MoveBlockedBy(const FHitResult& Impact) {};
 
    UFUNCTION(BlueprintCallable, Category=Character, meta=(HidePin="bClientSimulation"))
    ENGINE_API virtual void Crouch(bool bClientSimulation = false);
 
    UFUNCTION(BlueprintCallable, Category=Character, meta=(HidePin="bClientSimulation"))
    ENGINE_API virtual void UnCrouch(bool bClientSimulation = false);
 
    UFUNCTION(BlueprintCallable, Category=Character)
    ENGINE_API virtual bool CanCrouch() const;
 
    ENGINE_API virtual void OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="OnEndCrouch", ScriptName="OnEndCrouch"))
    ENGINE_API void K2_OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
 
    ENGINE_API virtual void OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="OnStartCrouch", ScriptName="OnStartCrouch"))
    ENGINE_API void K2_OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
 
    ENGINE_API void RecalculateCrouchedEyeHeight();
 
    ENGINE_API virtual void OnMovementModeChanged(EMovementMode PrevMovementMode, uint8 PreviousCustomMode = 0);
 
    UPROPERTY(BlueprintAssignable, Category=Character)
    FMovementModeChangedSignature MovementModeChangedDelegate;
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="OnMovementModeChanged", ScriptName="OnMovementModeChanged"))
    ENGINE_API void K2_OnMovementModeChanged(EMovementMode PrevMovementMode, EMovementMode NewMovementMode, uint8 PrevCustomMode, uint8 NewCustomMode);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="UpdateCustomMovement", ScriptName="UpdateCustomMovement"))
    ENGINE_API void K2_UpdateCustomMovement(float DeltaTime);
 
    UPROPERTY(BlueprintAssignable, Category=Character)
    FCharacterMovementUpdatedSignature OnCharacterMovementUpdated;
 
    ENGINE_API virtual bool ShouldNotifyLanded(const struct FHitResult& Hit);
 
    ENGINE_API virtual void CheckJumpInput(float DeltaTime);
 
    ENGINE_API virtual void ClearJumpInput(float DeltaTime);
 
    ENGINE_API virtual float GetJumpMaxHoldTime() const;
 
    UFUNCTION(Reliable, Client)
    ENGINE_API void ClientCheatWalk();
    ENGINE_API virtual void ClientCheatWalk_Implementation();
 
    UFUNCTION(Reliable, Client)
    ENGINE_API void ClientCheatFly();
    ENGINE_API virtual void ClientCheatFly_Implementation();
 
    UFUNCTION(Reliable, Client)
    ENGINE_API void ClientCheatGhost();
    ENGINE_API virtual void ClientCheatGhost_Implementation();
 
    UFUNCTION(Reliable, Client)
    ENGINE_API void RootMotionDebugClientPrintOnScreen(const FString& InString);
    ENGINE_API virtual void RootMotionDebugClientPrintOnScreen_Implementation(const FString& InString);
 
    // Root Motion
 
    UPROPERTY(Transient)
    FRootMotionSourceGroup SavedRootMotion;
 
    UPROPERTY(Transient)
    FRootMotionMovementParams ClientRootMotionParams;
 
    UPROPERTY(Transient)
    TArray<FSimulatedRootMotionReplicatedMove> RootMotionRepMoves;
    
    ENGINE_API int32 FindRootMotionRepMove(const FAnimMontageInstance& ClientMontageInstance) const;
 
    ENGINE_API bool CanUseRootMotionRepMove(const FSimulatedRootMotionReplicatedMove& RootMotionRepMove, const FAnimMontageInstance& ClientMontageInstance) const;
 
    ENGINE_API bool RestoreReplicatedMove(const FSimulatedRootMotionReplicatedMove& RootMotionRepMove);
    
    ENGINE_API virtual void OnUpdateSimulatedPosition(const FVector& OldLocation, const FQuat& OldRotation);
 
    UPROPERTY(ReplicatedUsing=OnRep_RootMotion)
    struct FRepRootMotionMontage RepRootMotion;
 
    inline const FRepRootMotionMontage& GetRepRootMotion() const { return RepRootMotion; }
 
    ENGINE_API FRepRootMotionMontage& GetRepRootMotion_Mutable();
    ENGINE_API void SetRepRootMotion(const FRepRootMotionMontage& InRepRootMotion);
    
    UFUNCTION()
    ENGINE_API void OnRep_RootMotion();
 
    ENGINE_API void SimulatedRootMotionPositionFixup(float DeltaSeconds);
 
    ENGINE_API FAnimMontageInstance * GetRootMotionAnimMontageInstance() const;
 
    UFUNCTION(BlueprintCallable, Category=Animation, meta=(DisplayName="Is Playing Anim Root Motion"))
    ENGINE_API bool IsPlayingRootMotion() const;
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    ENGINE_API bool HasAnyRootMotion() const;
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    ENGINE_API bool IsPlayingNetworkedRootMotionMontage() const;
 
    ENGINE_API void SetAnimRootMotionTranslationScale(float InAnimRootMotionTranslationScale = 1.f);
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    ENGINE_API float GetAnimRootMotionTranslationScale() const;
 
    ENGINE_API virtual void PreReplication(IRepChangedPropertyTracker & ChangedPropertyTracker) override;
 
    ENGINE_API virtual void PreReplicationForReplay(IRepChangedPropertyTracker& ChangedPropertyTracker) override;
 
    ENGINE_API void FillAsyncInput(FCharacterAsyncInput& Input) const;
    ENGINE_API void InitializeAsyncOutput(FCharacterAsyncOutput& Output) const;
    ENGINE_API void ApplyAsyncOutput(const FCharacterAsyncOutput& Output);
};