CharacterMovementComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Math/RandomStream.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "Engine/NetSerialization.h"
#include "Engine/EngineTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "WorldCollision.h"
#include "AI/Navigation/NavigationTypes.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimMontage.h"
#include "GameFramework/RootMotionSource.h"
#include "AI/Navigation/NavigationAvoidanceTypes.h"
#include "AI/RVOAvoidanceInterface.h"
#include "GameFramework/PawnMovementComponent.h"
#include "GameFramework/CharacterMovementReplication.h"
#include "Interfaces/NetworkPredictionInterface.h"
#include "CharacterMovementComponentAsync.h"
#include "CharacterMovementComponent.generated.h"
 
class ACharacter;
class FDebugDisplayInfo;
class FNetworkPredictionData_Server_Character;
class FSavedMove_Character;
class UPrimitiveComponent;
class INavigationData;
class UCharacterMovementComponent;
 
DECLARE_DELEGATE_RetVal_ThreeParams(FTransform, FOnProcessRootMotion, const FTransform&, UCharacterMovementComponent*, float)
 
namespace CharacterMovementConstants
{
    extern const float MAX_STEP_SIDE_Z;
    extern const float VERTICAL_SLOPE_NORMAL_Z;
}
 
namespace CharacterMovementCVars
{
    // Is Async Character Movement enabled?
    extern ENGINE_API int32 AsyncCharacterMovement;
    extern int32 ForceJumpPeakSubstep;
}
 
USTRUCT()
struct FCharacterMovementComponentPostPhysicsTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    
    class UCharacterMovementComponent* Target;
 
    virtual void ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
 
    virtual FString DiagnosticMessage() override;
    virtual FName DiagnosticContext(bool bDetailed) override;
};
 
template<>
struct TStructOpsTypeTraits<FCharacterMovementComponentPostPhysicsTickFunction> : public TStructOpsTypeTraitsBase2<FCharacterMovementComponentPostPhysicsTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
USTRUCT()
struct FCharacterMovementComponentPrePhysicsTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    
    class UCharacterMovementComponent* Target;
 
    virtual void ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
 
    virtual FString DiagnosticMessage() override;
    
    virtual FName DiagnosticContext(bool bDetailed) override;
};
 
template<>
struct TStructOpsTypeTraits<FCharacterMovementComponentPrePhysicsTickFunction> : public TStructOpsTypeTraitsBase2<FCharacterMovementComponentPrePhysicsTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
typedef TSharedPtr<class FSavedMove_Character> FSavedMovePtr;
 
 
//=============================================================================
UCLASS(MinimalAPI)
class UCharacterMovementComponent : public UPawnMovementComponent, public IRVOAvoidanceInterface, public INetworkPredictionInterface
{
    GENERATED_BODY()
public:
 
    ENGINE_API UCharacterMovementComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
protected:
 
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<ACharacter> CharacterOwner;
 
public:
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite)
    float GravityScale;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", ForceUnits="cm"))
    float MaxStepHeight;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta=(DisplayName="Jump Z Velocity", ClampMin="0", UIMin="0", ForceUnits="cm/s"))
    float JumpZVelocity;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0"))
    float JumpOffJumpZFactor;
 
 
private:
    FCharacterMovementComponentAsyncCallback* AsyncCallback;
 
protected:
    // This is the most recent async state from simulated. Only safe for access on physics thread.
    TSharedPtr<FCharacterMovementComponentAsyncOutput, ESPMode::ThreadSafe> AsyncSimState;
    bool bMovementModeDirty = false; // Gamethread changed movement mode, need to update sim.
private:
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, meta=(ClampMin="0.0", ClampMax="90.0", UIMin = "0.0", UIMax = "90.0", ForceUnits="degrees"))
    float WalkableFloorAngle;
 
    UPROPERTY(Category="Character Movement: Walking", VisibleAnywhere)
    float WalkableFloorZ;
 
    UPROPERTY(Category="Character Movement: Gravity", VisibleAnywhere, BlueprintReadOnly, meta = (AllowPrivateAccess = true))
    FVector GravityDirection;
 
    UPROPERTY(Category="Character Movement: Gravity", VisibleAnywhere, BlueprintReadOnly, meta = (AllowPrivateAccess = true))
    FQuat WorldToGravityTransform;
 
    UPROPERTY(Category="Character Movement: Gravity", VisibleAnywhere, BlueprintReadOnly, meta = (AllowPrivateAccess = true))
    FQuat GravityToWorldTransform;
 
    bool bHasCustomGravity;
public:
    
    UPROPERTY(Category="Character Movement: MovementMode", BlueprintReadOnly)
    TEnumAsByte<enum EMovementMode> MovementMode;
 
    UPROPERTY(Category="Character Movement: MovementMode", BlueprintReadOnly)
    uint8 CustomMovementMode;
 
    static ENGINE_API const FVector DefaultGravityDirection;
 
    UPROPERTY(Category="Character Movement (Networking)", EditAnywhere, BlueprintReadOnly)
    ENetworkSmoothingMode NetworkSmoothingMode;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float GroundFriction;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    float PhysicsForceSubsteppingFactor = 1.0f;
#endif
    
 
    UPROPERTY(Transient)
    FQuat OldBaseQuat;
 
    UPROPERTY(Transient)
    FVector OldBaseLocation;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", ForceUnits="cm/s"))
    float MaxWalkSpeed;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", ForceUnits="cm/s"))
    float MaxWalkSpeedCrouched;
 
    UPROPERTY(Category="Character Movement: Swimming", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", ForceUnits="cm/s"))
    float MaxSwimSpeed;
 
    UPROPERTY(Category="Character Movement: Flying", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", ForceUnits="cm/s"))
    float MaxFlySpeed;
 
    UPROPERTY(Category="Character Movement: Custom Movement", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", ForceUnits="cm/s"))
    float MaxCustomMovementSpeed;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float MaxAcceleration;
 
    UPROPERTY(Category = "Character Movement: Walking", EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "0", UIMin = "0", ForceUnits="cm/s"))
    float MinAnalogWalkSpeed;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float BrakingFrictionFactor;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0", EditCondition="bUseSeparateBrakingFriction"))
    float BrakingFriction;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0.0166", ClampMax="0.05", UIMin="0.0166", UIMax="0.05"))
    float BrakingSubStepTime;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float BrakingDecelerationWalking;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float BrakingDecelerationFalling;
 
    UPROPERTY(Category="Character Movement: Swimming", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float BrakingDecelerationSwimming;
 
    UPROPERTY(Category="Character Movement: Flying", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float BrakingDecelerationFlying;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float AirControl;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float AirControlBoostMultiplier;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float AirControlBoostVelocityThreshold;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float FallingLateralFriction;
 
    UE_DEPRECATED_FORGAME(5.0, "Public access to this property is deprecated, and it will become private in a future release. Please use SetCrouchedHalfHeight and GetCrouchedHalfHeight instead.")
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetCrouchedHalfHeight, BlueprintGetter=GetCrouchedHalfHeight, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float CrouchedHalfHeight;
 
    UPROPERTY(Category="Character Movement: Swimming", EditAnywhere, BlueprintReadWrite)
    float Buoyancy;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float PerchRadiusThreshold;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float PerchAdditionalHeight;
 
    UPROPERTY(Category="Character Movement (Rotation Settings)", EditAnywhere, BlueprintReadWrite)
    FRotator RotationRate;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditDefaultsOnly, BlueprintReadWrite)
    uint8 bUseSeparateBrakingFriction:1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    uint8 bDontFallBelowJumpZVelocityDuringJump:1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    uint8 bApplyGravityWhileJumping:1;
    UPROPERTY(Category="Character Movement (Rotation Settings)", EditAnywhere, BlueprintReadWrite)
    uint8 bUseControllerDesiredRotation:1;
 
    UPROPERTY(Category="Character Movement (Rotation Settings)", EditAnywhere, BlueprintReadWrite)
    uint8 bOrientRotationToMovement:1;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite)
    uint8 bSweepWhileNavWalking:1;
 
private:
 
    // Tracks whether or not we need to update the bSweepWhileNavWalking flag do to an upgrade.
    uint8 bNeedsSweepWhileWalkingUpdate:1;
 
protected:
 
    UPROPERTY()
    uint8 bMovementInProgress:1;
 
public:
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, AdvancedDisplay)
    uint8 bEnableScopedMovementUpdates:1;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, AdvancedDisplay)
    uint8 bEnableServerDualMoveScopedMovementUpdates : 1;
 
    UPROPERTY()
    uint8 bForceMaxAccel:1;    
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    uint8 bRunPhysicsWithNoController:1;
 
    UPROPERTY(Category="Character Movement: Walking", VisibleInstanceOnly, BlueprintReadWrite, AdvancedDisplay)
    uint8 bForceNextFloorCheck:1;
 
    UPROPERTY()
    uint8 bShrinkProxyCapsule:1;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite)
    uint8 bCanWalkOffLedges:1;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite)
    uint8 bCanWalkOffLedgesWhenCrouching:1;
 
    uint8 bNetworkSmoothingComplete:1;
 
    uint8 bNetworkLargeClientCorrection:1;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly)
    uint8 bNetworkSkipProxyPredictionOnNetUpdate:1;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay)
    uint8 bNetworkAlwaysReplicateTransformUpdateTimestamp:1;
 
public:
 
    UPROPERTY()
    uint8 bDeferUpdateMoveComponent:1;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite)
    uint8 bEnablePhysicsInteraction:1;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    uint8 bTouchForceScaledToMass:1;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    uint8 bPushForceScaledToMass:1;
 
    UPROPERTY(Category = "Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta = (editcondition = "bEnablePhysicsInteraction"))
    uint8 bPushForceUsingZOffset:1;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    uint8 bScalePushForceToVelocity:1;
 
    UPROPERTY()
    TObjectPtr<USceneComponent> DeferredUpdatedMoveComponent;
 
    UPROPERTY(Category="Character Movement: Swimming", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float MaxOutOfWaterStepHeight;
 
    UPROPERTY(Category="Character Movement: Swimming", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ForceUnits="cm/s"))
    float OutofWaterZ;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0", UIMin="0"))
    float Mass;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float StandingDownwardForceScale;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float InitialPushForceFactor;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float PushForceFactor;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(UIMin = "-1.0", UIMax = "1.0"), meta=(editcondition = "bEnablePhysicsInteraction"))
    float PushForcePointZOffsetFactor;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float TouchForceFactor;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float MinTouchForce;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float MaxTouchForce;
 
    UPROPERTY(Category="Character Movement: Physics Interaction", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bEnablePhysicsInteraction"))
    float RepulsionForce;
 
 
public:
#if WITH_EDITORONLY_DATA
    // Deprecated properties
    UPROPERTY()
    uint32 bForceBraking_DEPRECATED:1;
 
    UPROPERTY()
    float CrouchedSpeedMultiplier_DEPRECATED;
 
    UPROPERTY()
    float UpperImpactNormalScale_DEPRECATED;
#endif
 
protected:
 
    UPROPERTY()
    FVector Acceleration;
 
    UPROPERTY()
    FQuat LastUpdateRotation;
 
    UPROPERTY()
    FVector LastUpdateLocation;
 
    UPROPERTY()
    FVector LastUpdateVelocity;
 
    UPROPERTY(Transient)
    float ServerLastTransformUpdateTimeStamp;
 
    UPROPERTY(Transient)
    float ServerLastClientGoodMoveAckTime;
 
    UPROPERTY(Transient)
    float ServerLastClientAdjustmentTime;
 
    UPROPERTY()
    FVector PendingImpulseToApply;
 
    UPROPERTY()
    FVector PendingForceToApply;
 
    UPROPERTY()
    float AnalogInputModifier;
 
    ENGINE_API virtual float ComputeAnalogInputModifier() const;
 
    float LastStuckWarningTime;
 
    uint32 StuckWarningCountSinceNotify;
 
    int32 NumJumpApexAttempts;
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    FVector GetLastUpdateLocation() const { return LastUpdateLocation; }
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    FRotator GetLastUpdateRotation() const { return LastUpdateRotation.Rotator(); }
 
    FQuat GetLastUpdateQuat() const { return LastUpdateRotation; }
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    FVector GetLastUpdateVelocity() const { return LastUpdateVelocity; }
 
    inline float GetServerLastTransformUpdateTimeStamp() const { return ServerLastTransformUpdateTimeStamp;  }
 
    ENGINE_API float GetSimulationTimeStep(float RemainingTime, int32 Iterations) const;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0.0166", ClampMax="0.50", UIMin="0.0166", UIMax="0.50"))
    float MaxSimulationTimeStep;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="1", ClampMax="25", UIMin="1", UIMax="25"))
    int32 MaxSimulationIterations;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="1", ClampMax="4", UIMin="1", UIMax="4"))
    int32 MaxJumpApexAttemptsPerSimulation;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float MaxDepenetrationWithGeometry;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float MaxDepenetrationWithGeometryAsProxy;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float MaxDepenetrationWithPawn;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ClampMin="0", UIMin="0", ForceUnits=cm))
    float MaxDepenetrationWithPawnAsProxy;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay, meta=(ClampMin="0.0", ClampMax="1.0", UIMin="0.0", UIMax="1.0", ForceUnits=s))
    float NetworkSimulatedSmoothLocationTime;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay, meta=(ClampMin="0.0", ClampMax="1.0", UIMin="0.0", UIMax="1.0", ForceUnits=s))
    float NetworkSimulatedSmoothRotationTime;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay, meta=(ClampMin="0.0", ClampMax="1.0", UIMin="0.0", UIMax="1.0", ForceUnits=s))
    float ListenServerNetworkSimulatedSmoothLocationTime;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay, meta=(ClampMin="0.0", ClampMax="1.0", UIMin="0.0", UIMax="1.0", ForceUnits=s))
    float ListenServerNetworkSimulatedSmoothRotationTime;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=cm))
    float NetProxyShrinkRadius;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, AdvancedDisplay, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=cm))
    float NetProxyShrinkHalfHeight;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=cm))
    float NetworkMaxSmoothUpdateDistance;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=cm))
    float NetworkNoSmoothUpdateDistance;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=s))
    float NetworkMinTimeBetweenClientAckGoodMoves;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=s))
    float NetworkMinTimeBetweenClientAdjustments;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=s))
    float NetworkMinTimeBetweenClientAdjustmentsLargeCorrection;
 
    UPROPERTY(Category="Character Movement (Networking)", EditDefaultsOnly, meta=(ClampMin="0.0", UIMin="0.0", ForceUnits=cm))
    float NetworkLargeClientCorrectionDistance;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, AdvancedDisplay, meta=(ForceUnits=cm))
    float LedgeCheckThreshold;
 
    UPROPERTY(Category="Character Movement: Swimming", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    float JumpOutOfWaterPitch;
 
    UPROPERTY(Category="Character Movement: Walking", VisibleInstanceOnly, BlueprintReadOnly)
    FFindFloorResult CurrentFloor;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite)
    TEnumAsByte<enum EMovementMode> DefaultLandMovementMode;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite)
    TEnumAsByte<enum EMovementMode> DefaultWaterMovementMode;
 
    UPrimitiveComponent* GetLastServerMovementBase() const { return LastServerMovementBase.Get(); };
 
private:
    UPROPERTY(Transient)
    TEnumAsByte<enum EMovementMode> GroundMovementMode;
 
    TWeakObjectPtr<UPrimitiveComponent> LastServerMovementBase = nullptr;
 
public:
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite)
    uint8 bMaintainHorizontalGroundVelocity:1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite)
    uint8 bImpartBaseVelocityX:1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite)
    uint8 bImpartBaseVelocityY:1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite)
    uint8 bImpartBaseVelocityZ:1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite)
    uint8 bImpartBaseAngularVelocity:1;
 
    UPROPERTY(Category="Character Movement (General Settings)", Transient, VisibleInstanceOnly, BlueprintReadWrite)
    uint8 bJustTeleported:1;
 
    UPROPERTY(Transient)
    uint8 bNetworkUpdateReceived:1;
 
    UPROPERTY(Transient)
    uint8 bNetworkMovementModeChanged:1;
 
    UPROPERTY(Transient)
    uint8 bNetworkGravityDirectionChanged:1;
 
    UPROPERTY(Category="Character Movement", EditAnywhere, BlueprintReadWrite)
    uint8 bIgnoreClientMovementErrorChecksAndCorrection:1;
 
    UPROPERTY(Category="Character Movement", EditAnywhere, BlueprintReadWrite)
    uint8 bServerAcceptClientAuthoritativePosition : 1;
 
    UPROPERTY(Category="Character Movement: Jumping / Falling", VisibleAnywhere, BlueprintReadWrite)
    uint8 bNotifyApex:1;
 
    UPROPERTY()
    uint8 bCheatFlying:1;
 
    UPROPERTY(Category="Character Movement (General Settings)", VisibleInstanceOnly, BlueprintReadOnly)
    uint8 bWantsToCrouch:1;
 
    UPROPERTY(Category="Character Movement (General Settings)", VisibleInstanceOnly, BlueprintReadWrite, AdvancedDisplay)
    uint8 bCrouchMaintainsBaseLocation:1;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite)
    uint8 bIgnoreBaseRotation:1;
 
    UPROPERTY()
    uint8 bFastAttachedMove:1;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    uint8 bAlwaysCheckFloor:1;
 
    UPROPERTY(Category="Character Movement: Walking", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    uint8 bUseFlatBaseForFloorChecks:1;
 
    UPROPERTY()
    uint8 bPerformingJumpOff:1;
 
    UPROPERTY()
    uint8 bWantsToLeaveNavWalking:1;
 
    UPROPERTY(Category="Character Movement: Avoidance", EditAnywhere, BlueprintReadOnly)
    uint8 bUseRVOAvoidance:1;
 
    UPROPERTY(Category="Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite, AdvancedDisplay)
    uint8 bRequestedMoveUseAcceleration:1;
 
    uint8 bIsNavWalkingOnServer : 1;
 
    UPROPERTY(Transient)
    uint8 bWasSimulatingRootMotion:1;
 
    UPROPERTY(Category = "RootMotion", EditAnywhere, BlueprintReadWrite)
    uint8 bAllowPhysicsRotationDuringAnimRootMotion : 1;
 
    UPROPERTY(Category = "RootMotion", EditAnywhere, BlueprintReadWrite)
    float FormerBaseVelocityDecayHalfLife = 0.f;
 
protected:
 
    // AI PATH FOLLOWING
 
    UPROPERTY(Transient)
    uint8 bHasRequestedVelocity:1;
 
    UPROPERTY(Transient)
    uint8 bRequestedMoveWithMaxSpeed:1;
 
    UPROPERTY(Transient)
    uint8 bWasAvoidanceUpdated : 1;
 
    uint8 bUseRVOPostProcess : 1;
 
    uint8 bDeferUpdateBasedMovement : 1;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadOnly)
    uint8 bProjectNavMeshWalking : 1 = false;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadWrite)
    uint8 bSlideAlongNavMeshEdge : 1 = false;
 
    UPROPERTY(Category = "Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadOnly, AdvancedDisplay)
    uint8 bProjectNavMeshOnBothWorldChannels : 1;
 
    FVector AvoidanceLockVelocity;
 
    float AvoidanceLockTimer;
 
public:
 
    virtual bool ShouldCorrectRotation() const { return false; }
 
    UPROPERTY(Category="Character Movement: Avoidance", EditAnywhere, BlueprintReadOnly, meta=(ForceUnits=cm))
    float AvoidanceConsiderationRadius;
 
    UPROPERTY(Transient)
    FVector RequestedVelocity;
 
    UPROPERTY(Transient)
    FVector LastUpdateRequestedVelocity;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(Keywords="Velocity RequestedVelocity"))
    ENGINE_API FVector GetLastUpdateRequestedVelocity() const;
 
    UPROPERTY(Category="Character Movement: Avoidance", VisibleAnywhere, BlueprintReadOnly, AdvancedDisplay)
    int32 AvoidanceUID;
 
    UPROPERTY(Category="Character Movement: Avoidance", EditAnywhere, BlueprintReadOnly, AdvancedDisplay)
    FNavAvoidanceMask AvoidanceGroup;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(DeprecatedFunction, DeprecationMessage="Please use SetAvoidanceGroupMask function instead."))
    ENGINE_API void SetAvoidanceGroup(int32 GroupFlags);
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    ENGINE_API void SetAvoidanceGroupMask(const FNavAvoidanceMask& GroupMask);
 
    UPROPERTY(Category="Character Movement: Avoidance", EditAnywhere, BlueprintReadOnly, AdvancedDisplay)
    FNavAvoidanceMask GroupsToAvoid;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta = (DeprecatedFunction, DeprecationMessage = "Please use SetGroupsToAvoidMask function instead."))
    ENGINE_API void SetGroupsToAvoid(int32 GroupFlags);
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    ENGINE_API void SetGroupsToAvoidMask(const FNavAvoidanceMask& GroupMask);
 
    UPROPERTY(Category="Character Movement: Avoidance", EditAnywhere, BlueprintReadOnly, AdvancedDisplay)
    FNavAvoidanceMask GroupsToIgnore;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta = (DeprecatedFunction, DeprecationMessage = "Please use SetGroupsToIgnoreMask function instead."))
    ENGINE_API void SetGroupsToIgnore(int32 GroupFlags);
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    ENGINE_API void SetGroupsToIgnoreMask(const FNavAvoidanceMask& GroupMask);
 
    UPROPERTY(Category="Character Movement: Avoidance", EditAnywhere, BlueprintReadOnly)
    float AvoidanceWeight;
 
    UPROPERTY()
    FVector PendingLaunchVelocity;
 
    FNavLocation CachedNavLocation;
 
    FHitResult CachedProjectedNavMeshHitResult;
 
    FName LastServerMovementBaseBoneName = NAME_None;
 
    bool bLastClientIsFalling = false;
 
    bool bLastServerIsFalling = false;
 
    bool bLastServerIsWalking = false;
 
    bool bTeleportedSinceLastUpdate = false;
 
    bool bCanTrustClientOnLanding = false;
 
    float MaxServerClientErrorWhileFalling = 0.f;
 
    FVector DecayingFormerBaseVelocity = FVector::ZeroVector;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bProjectNavMeshWalking"))
    float NavMeshProjectionInterval;
 
    UPROPERTY(Transient)
    float NavMeshProjectionTimer;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bProjectNavMeshWalking", ClampMin="0", UIMin="0"))
    float NavMeshProjectionInterpSpeed;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bProjectNavMeshWalking", ClampMin="0", UIMin="0"))
    float NavMeshProjectionHeightScaleUp;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadWrite, meta=(editcondition = "bProjectNavMeshWalking", ClampMin="0", UIMin="0"))
    float NavMeshProjectionHeightScaleDown;
 
    UPROPERTY(Category="Character Movement: NavMesh Movement", EditAnywhere, BlueprintReadWrite)
    float NavWalkingFloorDistTolerance;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta = (UnsafeDuringActorConstruction = "true"))
    ENGINE_API void SetAvoidanceEnabled(bool bEnable);
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ACharacter* GetCharacterOwner() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void SetMovementMode(EMovementMode NewMovementMode, uint8 NewCustomMode = 0);
 
     ENGINE_API void SetGroundMovementMode(EMovementMode NewGroundMovementMode);
 
     EMovementMode GetGroundMovementMode() const { return GroundMovementMode; }
 
protected:
 
    ENGINE_API virtual void OnMovementModeChanged(EMovementMode PreviousMovementMode, uint8 PreviousCustomMode);
 
public:
 
    ENGINE_API virtual uint8 PackNetworkMovementMode() const;
    ENGINE_API virtual void UnpackNetworkMovementMode(const uint8 ReceivedMode, TEnumAsByte<EMovementMode>& OutMode, uint8& OutCustomMode, TEnumAsByte<EMovementMode>& OutGroundMode) const;
    ENGINE_API virtual void ApplyNetworkMovementMode(const uint8 ReceivedMode);
 
    // Begin UObject Interface
    ENGINE_API virtual void Serialize(FArchive& Archive) override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    // End UObject Interface
 
    //Begin UActorComponent Interface
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void Deactivate() override;
    ENGINE_API virtual void RegisterComponentTickFunctions(bool bRegister) override;
    ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
    //End UActorComponent Interface
 
    //BEGIN UMovementComponent Interface
    ENGINE_API virtual float GetMaxSpeed() const override;
    ENGINE_API virtual void StopActiveMovement() override;
    ENGINE_API virtual bool IsCrouching() const override;
    ENGINE_API virtual bool IsFalling() const override;
    ENGINE_API virtual bool IsMovingOnGround() const override;
    ENGINE_API virtual bool IsSwimming() const override;
    ENGINE_API virtual bool IsFlying() const override;
    ENGINE_API virtual float GetGravityZ() const override;
    ENGINE_API virtual void AddRadialForce(const FVector& Origin, float Radius, float Strength, enum ERadialImpulseFalloff Falloff) override;
    ENGINE_API virtual void AddRadialImpulse(const FVector& Origin, float Radius, float Strength, enum ERadialImpulseFalloff Falloff, bool bVelChange) override;
    //END UMovementComponent Interface
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    bool IsWalking() const;
 
    bool IsMovementInProgress() const { return bMovementInProgress; }
 
    //BEGIN UNavMovementComponent Interface
    ENGINE_API virtual FVector GetActorFeetLocation() const override;
    ENGINE_API virtual void RequestDirectMove(const FVector& MoveVelocity, bool bForceMaxSpeed) override;
    ENGINE_API virtual void RequestPathMove(const FVector& MoveInput) override;
    ENGINE_API virtual bool CanStartPathFollowing() const override;
    ENGINE_API virtual bool CanStopPathFollowing() const override;
    ENGINE_API virtual float GetPathFollowingBrakingDistance(float MaxSpeed) const override;
    //END UNaVMovementComponent Interface
 
    //Begin UPawnMovementComponent Interface
    ENGINE_API virtual void NotifyBumpedPawn(APawn* BumpedPawn) override;
    //End UPawnMovementComponent Interface
 
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void DisableMovement();
 
    ENGINE_API virtual bool HasValidData() const;
 
    ENGINE_API virtual void PerformAirControlForPathFollowing(FVector Direction, float ZDiff);
 
    ENGINE_API virtual bool ShouldPerformAirControlForPathFollowing() const;
 
    ENGINE_API virtual void StartFalling(int32 Iterations, float remainingTime, float timeTick, const FVector& Delta, const FVector& subLoc);
 
    ENGINE_API virtual bool ShouldCatchAir(const FFindFloorResult& OldFloor, const FFindFloorResult& NewFloor);
 
    ENGINE_API virtual void HandleWalkingOffLedge(const FVector& PreviousFloorImpactNormal, const FVector& PreviousFloorContactNormal, const FVector& PreviousLocation, float TimeDelta);
 
    ENGINE_API virtual void AdjustFloorHeight();
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API UPrimitiveComponent* GetMovementBase() const;
 
    ENGINE_API virtual void MaybeUpdateBasedMovement(float DeltaSeconds);
 
    ENGINE_API virtual void UpdateBasedMovement(float DeltaSeconds);
 
    ENGINE_API virtual void UpdateBasedRotation(FRotator& FinalRotation, const FRotator& ReducedRotation);
 
    ENGINE_API virtual void MaybeSaveBaseLocation();
 
    ENGINE_API virtual void SaveBaseLocation();
 
    ENGINE_API virtual void ApplyImpartedMovementBaseVelocity();
 
    UPROPERTY(Category = "Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite)
    bool bBasedMovementIgnorePhysicsBase = false;
 
    UPROPERTY(Category = "Character Movement (General Settings)", EditAnywhere, BlueprintReadWrite)
    bool bBaseOnAttachmentRoot = false;
 
    UPROPERTY(Category = "Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite)
    bool bStayBasedInAir = false;
 
    UPROPERTY(Category = "Character Movement: Jumping / Falling", EditAnywhere, BlueprintReadWrite, meta = (editcondition = "bStayBasedInAir"))
    float StayBasedInAirHeight = 1000.0f;
 
 
    ENGINE_API virtual void StartNewPhysics(float deltaTime, int32 Iterations);
    
    UE_DEPRECATED_FORGAME(5.5, "This function has been deprecated. Please call DoJump(bool bReplayingMoves, float DeltaTime)")
    ENGINE_API virtual bool DoJump(bool bReplayingMoves);
 
    ENGINE_API virtual bool DoJump(bool bReplayingMoves, float DeltaTime);
 
    ENGINE_API virtual bool CanAttemptJump() const;
 
    ENGINE_API virtual void Launch(FVector const& LaunchVel);
 
    ENGINE_API virtual bool HandlePendingLaunch();
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual FVector GetImpartedMovementBaseVelocity() const;
 
    ENGINE_API virtual void JumpOff(AActor* MovementBaseActor);
 
    ENGINE_API virtual FVector GetBestDirectionOffActor(AActor* BaseActor) const; // Calculates the best direction to go to "jump off" an actor.
 
    ENGINE_API virtual bool ShouldJumpOutOfWater(FVector& JumpDir);
 
    ENGINE_API virtual void JumpOutOfWater(FVector WallNormal);
 
    ENGINE_API virtual FRotator GetDeltaRotation(float DeltaTime) const;
 
    ENGINE_API virtual FRotator ComputeOrientToMovementRotation(const FRotator& CurrentRotation, float DeltaTime, FRotator& DeltaRotation) const;
 
    ENGINE_API virtual bool ApplyRequestedMove(float DeltaTime, float MaxAccel, float MaxSpeed, float Friction, float BrakingDeceleration, FVector& OutAcceleration, float& OutRequestedSpeed);
 
    ENGINE_API virtual void NotifyJumpApex();
 
    ENGINE_API virtual FVector NewFallVelocity(const FVector& InitialVelocity, const FVector& Gravity, float DeltaTime) const;
 
    /* Determine how deep in water the character is immersed.
     * @return float in range 0.0 = not in water, 1.0 = fully immersed
     */
    ENGINE_API virtual float ImmersionDepth() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void CalcVelocity(float DeltaTime, float Friction, bool bFluid, float BrakingDeceleration);
    
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual float GetMaxJumpHeight() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual float GetMaxJumpHeightWithJumpTime() const;
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Components|CharacterMovement")
    ENGINE_API virtual float GetMinAnalogSpeed() const;
    
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual float GetMaxAcceleration() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual float GetMaxBrakingDeceleration() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(Keywords="Acceleration GetAcceleration"))
    ENGINE_API FVector GetCurrentAcceleration() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API float GetAnalogInputModifier() const;
    
    ENGINE_API virtual bool CanStepUp(const FHitResult& Hit) const;
 
    ENGINE_API virtual bool StepUp(const FVector& GravDir, const FVector& Delta, const FHitResult &Hit, FStepDownResult* OutStepDownResult = NULL);
 
    ENGINE_API virtual void SetBase(UPrimitiveComponent* NewBase, const FName BoneName = NAME_None, bool bNotifyActor=true);
 
    ENGINE_API void SetBaseFromFloor(const FFindFloorResult& FloorResult);
 
    ENGINE_API virtual void ApplyDownwardForce(float DeltaSeconds);
 
    ENGINE_API virtual void ApplyRepulsionForce(float DeltaSeconds);
    
    ENGINE_API virtual void ApplyAccumulatedForces(float DeltaSeconds);
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void ClearAccumulatedForces();
 
    ENGINE_API virtual void UpdateCharacterStateBeforeMovement(float DeltaSeconds);
 
    ENGINE_API virtual void UpdateCharacterStateAfterMovement(float DeltaSeconds);
 
    virtual void UpdateVelocityBeforeMovement(float DeltaSeconds) {}
 
    ENGINE_API virtual void StartSwimming(FVector OldLocation, FVector OldVelocity, float timeTick, float remainingTime, int32 Iterations);
 
    /* Swimming uses gravity - but scaled by (1.f - buoyancy) */
    ENGINE_API float Swim(FVector Delta, FHitResult& Hit);
 
    ENGINE_API FVector FindWaterLine(FVector Start, FVector End);
 
    ENGINE_API virtual void PhysFalling(float deltaTime, int32 Iterations);
 
    // Helpers for PhysFalling
 
    ENGINE_API virtual FVector GetFallingLateralAcceleration(float DeltaTime);
    
    ENGINE_API virtual bool ShouldLimitAirControl(float DeltaTime, const FVector& FallAcceleration) const;
 
    ENGINE_API virtual FVector GetAirControl(float DeltaTime, float TickAirControl, const FVector& FallAcceleration);
 
    // Gravity Direction
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void SetGravityDirection(const FVector& GravityDir);
 
    UFUNCTION(BlueprintPure, Category="Pawn|Components|CharacterMovement")
    bool HasCustomGravity() const { return bHasCustomGravity; }
 
    UFUNCTION(BlueprintPure, Category="Pawn|Components|CharacterMovement")
    FVector GetGravityDirection() const { return GravityDirection; }
 
    FQuat GetWorldToGravityTransform() const { return WorldToGravityTransform; }
 
    FQuat GetGravityToWorldTransform() const { return GravityToWorldTransform; }
 
    FVector RotateGravityToWorld(const FVector& World) const { return WorldToGravityTransform.RotateVector(World); }
 
    FVector RotateWorldToGravity(const FVector& Gravity) const { return GravityToWorldTransform.RotateVector(Gravity); }
 
    FVector ProjectToGravityFloor(const FVector& Vector) const { return FVector::VectorPlaneProject(Vector, GetGravityDirection()); }
 
    FVector::FReal GetGravitySpaceZ(const FVector& Vector) const { return Vector.Dot(-GetGravityDirection()); }
 
    FVector GetGravitySpaceComponentZ(const FVector& Vector) const { return Vector.Dot(GetGravityDirection()) * GetGravityDirection(); }
 
    void SetGravitySpaceZ(FVector& Vector, const FVector::FReal Z) const { Vector = ProjectToGravityFloor(Vector) - Z * GetGravityDirection(); }
    
protected:
 
    ENGINE_API virtual float BoostAirControl(float DeltaTime, float TickAirControl, const FVector& FallAcceleration);
 
    ENGINE_API virtual FVector LimitAirControl(float DeltaTime, const FVector& FallAcceleration, const FHitResult& HitResult, bool bCheckForValidLandingSpot);
    
 
    ENGINE_API virtual void ProcessLanded(const FHitResult& Hit, float remainingTime, int32 Iterations);
 
    ENGINE_API virtual void SetPostLandedPhysics(const FHitResult& Hit);
 
    ENGINE_API virtual void ControlledCharacterMove(const FVector& InputVector, float DeltaSeconds);
 
    ENGINE_API virtual void SetNavWalkingPhysics(bool bEnable);
 
    ENGINE_API const class INavigationDataInterface* GetNavData() const;
 
    ENGINE_API virtual bool TryToLeaveNavWalking();
 
    ENGINE_API virtual FVector ProjectLocationFromNavMesh(float DeltaSeconds, const FVector& CurrentFeetLocation, const FVector& TargetNavLocation, float UpOffset, float DownOffset);
 
    ENGINE_API virtual void FindBestNavMeshLocation(const FVector& TraceStart, const FVector& TraceEnd, const FVector& CurrentFeetLocation, const FVector& TargetNavLocation, FHitResult& OutHitResult) const;
 
    ENGINE_API virtual bool ShouldComputeAccelerationToReachRequestedVelocity(const float RequestedSpeed) const;
public:
 
    ENGINE_API virtual void OnTeleported() override;
 
    ENGINE_API virtual void Crouch(bool bClientSimulation = false);
    
    ENGINE_API virtual void UnCrouch(bool bClientSimulation = false);
 
    ENGINE_API virtual bool CanCrouchInCurrentState() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetCrouchedHalfHeight(const float NewValue);
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API float GetCrouchedHalfHeight() const;
 
    ENGINE_API virtual bool CheckLedgeDirection(const FVector& OldLocation, const FVector& SideStep, const FFindFloorResult& OldFloor) const;
 
    ENGINE_API virtual FVector GetLedgeMove(const FVector& OldLocation, const FVector& Delta, const FFindFloorResult& OldFloor) const;
 
    ENGINE_API virtual bool CheckFall(const FFindFloorResult& OldFloor, const FHitResult& Hit, const FVector& Delta, const FVector& OldLocation, float remainingTime, float timeTick, int32 Iterations, bool bMustJump);
    
    ENGINE_API void RevertMove(const FVector& OldLocation, UPrimitiveComponent* OldBase, const FVector& InOldBaseLocation, const FFindFloorResult& OldFloor, bool bFailMove);
 
    ENGINE_API virtual void PhysicsRotation(float DeltaTime);
 
    ENGINE_API virtual bool ShouldRemainVertical() const;
 
    ENGINE_API virtual void PhysicsVolumeChanged(class APhysicsVolume* NewVolume) override;
 
    ENGINE_API virtual void SetDefaultMovementMode();
 
    ENGINE_API virtual void MoveSmooth(const FVector& InVelocity, const float DeltaSeconds, FStepDownResult* OutStepDownResult = NULL );
 
    ENGINE_API virtual void UpdateProxyAcceleration();
    
    ENGINE_API virtual void SetUpdatedComponent(USceneComponent* NewUpdatedComponent) override;
    
    ENGINE_API virtual FString GetMovementName() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void AddImpulse( FVector Impulse, bool bVelocityChange = false );
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual void AddForce( FVector Force );
 
    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);
 
    ENGINE_API virtual float VisualizeMovement() const;
 
    ENGINE_API virtual bool CheckWaterJump(FVector CheckPoint, FVector& WallNormal);
 
    ENGINE_API virtual bool CanWalkOffLedges() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API float GetPerchRadiusThreshold() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API float GetValidPerchRadius() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API virtual bool IsWalkable(const FHitResult& Hit) const;
 
    inline float GetWalkableFloorAngle() const { return WalkableFloorAngle; }
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(DisplayName = "GetWalkableFloorAngle", ScriptName = "GetWalkableFloorAngle"))
    ENGINE_API float K2_GetWalkableFloorAngle() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API void SetWalkableFloorAngle(float InWalkableFloorAngle);
 
    inline float GetWalkableFloorZ() const { return WalkableFloorZ; }
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(DisplayName = "GetWalkableFloorZ", ScriptName = "GetWalkableFloorZ"))
    ENGINE_API float K2_GetWalkableFloorZ() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement")
    ENGINE_API void SetWalkableFloorZ(float InWalkableFloorZ);
    
    struct FCharacterMovementComponentPrePhysicsTickFunction PrePhysicsTickFunction;
 
    ENGINE_API virtual void PrePhysicsTickComponent(float DeltaTime, FCharacterMovementComponentPrePhysicsTickFunction& ThisTickFunction);
 
    UPROPERTY()
    struct FCharacterMovementComponentPostPhysicsTickFunction PostPhysicsTickFunction;
 
    ENGINE_API virtual void PostPhysicsTickComponent(float DeltaTime, FCharacterMovementComponentPostPhysicsTickFunction& ThisTickFunction);
 
protected:
    ENGINE_API virtual void PhysWalking(float deltaTime, int32 Iterations);
 
    ENGINE_API virtual void PhysNavWalking(float deltaTime, int32 Iterations);
 
    ENGINE_API virtual void PhysFlying(float deltaTime, int32 Iterations);
 
    ENGINE_API virtual void PhysSwimming(float deltaTime, int32 Iterations);
 
    ENGINE_API virtual void PhysCustom(float deltaTime, int32 Iterations);
 
    /* Allow custom handling when character hits a wall while swimming. */
    ENGINE_API virtual void HandleSwimmingWallHit(const FHitResult& Hit, float DeltaTime);
 
    ENGINE_API virtual FVector ComputeGroundMovementDelta(const FVector& Delta, const FHitResult& RampHit, const bool bHitFromLineTrace) const;
 
    ENGINE_API virtual void MoveAlongFloor(const FVector& InVelocity, float DeltaSeconds, FStepDownResult* OutStepDownResult = NULL);
 
    ENGINE_API virtual void OnCharacterStuckInGeometry(const FHitResult* Hit);
 
    ENGINE_API virtual void MaintainHorizontalGroundVelocity();
 
    ENGINE_API virtual FVector GetPenetrationAdjustment(const FHitResult& Hit) const override;
 
    ENGINE_API virtual bool ResolvePenetrationImpl(const FVector& Adjustment, const FHitResult& Hit, const FQuat& NewRotation) override;
 
    ENGINE_API virtual void HandleImpact(const FHitResult& Hit, float TimeSlice=0.f, const FVector& MoveDelta = FVector::ZeroVector) override;
 
    ENGINE_API virtual void ApplyImpactPhysicsForces(const FHitResult& Impact, const FVector& ImpactAcceleration, const FVector& ImpactVelocity);
 
    ENGINE_API virtual float SlideAlongSurface(const FVector& Delta, float Time, const FVector& Normal, FHitResult& Hit, bool bHandleImpact) override;
 
    ENGINE_API virtual void TwoWallAdjust(FVector& WorldSpaceDelta, const FHitResult& Hit, const FVector& OldHitNormal) const override;
 
    ENGINE_API virtual FVector ComputeSlideVector(const FVector& Delta, const float Time, const FVector& Normal, const FHitResult& Hit) const override;
 
    ENGINE_API virtual FVector HandleSlopeBoosting(const FVector& SlideResult, const FVector& Delta, const float Time, const FVector& Normal, const FHitResult& Hit) const;
 
    ENGINE_API virtual void ApplyVelocityBraking(float DeltaTime, float Friction, float BrakingDeceleration);
 
 
public:
 
    ENGINE_API virtual bool IsWithinEdgeTolerance(const FVector& CapsuleLocation, const FVector& TestImpactPoint, const float CapsuleRadius) const;
 
    ENGINE_API virtual void FindFloor(const FVector& CapsuleLocation, FFindFloorResult& OutFloorResult, bool bCanUseCachedLocation, const FHitResult* DownwardSweepResult = NULL) const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(DisplayName="FindFloor", ScriptName="FindFloor"))
    ENGINE_API virtual void K2_FindFloor(FVector CapsuleLocation, FFindFloorResult& FloorResult) const;
 
    ENGINE_API virtual void ComputeFloorDist(const FVector& CapsuleLocation, float LineDistance, float SweepDistance, FFindFloorResult& OutFloorResult, float SweepRadius, const FHitResult* DownwardSweepResult = NULL) const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Components|CharacterMovement", meta=(DisplayName="ComputeFloorDistance", ScriptName="ComputeFloorDistance"))
    ENGINE_API virtual void K2_ComputeFloorDist(FVector CapsuleLocation, float LineDistance, float SweepDistance, float SweepRadius, FFindFloorResult& FloorResult) const;
 
    ENGINE_API virtual bool FloorSweepTest(
        struct FHitResult& OutHit,
        const FVector& Start,
        const FVector& End,
        ECollisionChannel TraceChannel,
        const struct FCollisionShape& CollisionShape,
        const struct FCollisionQueryParams& Params,
        const struct FCollisionResponseParams& ResponseParam
        ) const;
 
    ENGINE_API virtual bool IsValidLandingSpot(const FVector& CapsuleLocation, const FHitResult& Hit) const;
 
    ENGINE_API virtual bool ShouldCheckForValidLandingSpot(float DeltaTime, const FVector& Delta, const FHitResult& Hit) const;
 
    ENGINE_API virtual bool ShouldComputePerchResult(const FHitResult& InHit, bool bCheckRadius = true) const;
 
    ENGINE_API virtual bool ComputePerchResult(const float TestRadius, const FHitResult& InHit, const float InMaxFloorDist, FFindFloorResult& OutPerchFloorResult) const;
 
 
protected:
 
    UFUNCTION()
    ENGINE_API virtual void CapsuleTouched(UPrimitiveComponent* OverlappedComp, AActor* Other, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
 
 
    ENGINE_API FVector GetPawnCapsuleExtent(const EShrinkCapsuleExtent ShrinkMode, const float CustomShrinkAmount = 0.f) const;
    
    ENGINE_API FCollisionShape GetPawnCapsuleCollisionShape(const EShrinkCapsuleExtent ShrinkMode, const float CustomShrinkAmount = 0.f) const;
 
    ENGINE_API virtual void AdjustProxyCapsuleSize();
 
    ENGINE_API virtual FVector ConstrainInputAcceleration(const FVector& InputAcceleration) const;
 
    ENGINE_API virtual FVector ScaleInputAcceleration(const FVector& InputAcceleration) const;
 
    ENGINE_API virtual void OnMovementUpdated(float DeltaSeconds, const FVector& OldLocation, const FVector& OldVelocity);
 
    ENGINE_API virtual void CallMovementUpdateDelegate(float DeltaSeconds, const FVector& OldLocation, const FVector& OldVelocity);
 
    ENGINE_API virtual void OnUnableToFollowBaseMove(const FVector& DeltaPosition, const FVector& OldLocation, const FHitResult& MoveOnBaseHit);
 
 
protected:
    /* Prepare root motion to be passed on to physics thread */
    ENGINE_API virtual void AccumulateRootMotionForAsync(float DeltaSeconds, FRootMotionAsyncData& RootMotion);
    /* Prepare inputs for asynchronous simulation on physics thread */ 
    ENGINE_API virtual void FillAsyncInput(const FVector& InputVector, FCharacterMovementComponentAsyncInput& AsyncInput);
    ENGINE_API virtual void BuildAsyncInput();
    ENGINE_API virtual void PostBuildAsyncInput();
    /* Apply outputs from async sim. */
    ENGINE_API virtual void ApplyAsyncOutput(FCharacterMovementComponentAsyncOutput& Output);
    ENGINE_API virtual void ProcessAsyncOutput();
    
    /* Register async callback with physics system. */
    ENGINE_API virtual void RegisterAsyncCallback();
    ENGINE_API virtual bool IsAsyncCallbackRegistered() const;
    
public:
 
    ENGINE_API virtual bool FindNavFloor(const FVector& TestLocation, FNavLocation& NavFloorLocation) const;
 
protected:
 
    // Movement functions broken out based on owner's network Role.
    // TickComponent calls the correct version based on the Role.
    // These may be called during move playback and correction during network updates.
    //
 
    ENGINE_API virtual void PerformMovement(float DeltaTime);
 
    ENGINE_API virtual void SimulatedTick(float DeltaSeconds);
 
    ENGINE_API virtual void SimulateMovement(float DeltaTime);
 
    virtual void ServerAutonomousProxyTick(float DeltaSeconds) { }
 
public:
 
    ENGINE_API virtual void ForceReplicationUpdate();
 
    ENGINE_API void ForceClientAdjustment();
    
    ENGINE_API virtual float GetNetworkSafeRandomAngleDegrees() const;
 
    ENGINE_API virtual FVector RoundAcceleration(FVector InAccel) const;
 
    //--------------------------------
    // INetworkPredictionInterface implementation
 
    //--------------------------------
    // Server hook
    //--------------------------------
    ENGINE_API virtual void SendClientAdjustment() override;
    ENGINE_API virtual bool ForcePositionUpdate(float DeltaTime) override;
 
    //--------------------------------
    // Client hook
    //--------------------------------
 
    ENGINE_API virtual void SmoothCorrection(const FVector& OldLocation, const FQuat& OldRotation, const FVector& NewLocation, const FQuat& NewRotation) override;
 
    ENGINE_API virtual class FNetworkPredictionData_Client* GetPredictionData_Client() const override;
    ENGINE_API virtual class FNetworkPredictionData_Server* GetPredictionData_Server() const override;
 
    ENGINE_API class FNetworkPredictionData_Client_Character* GetPredictionData_Client_Character() const;
    ENGINE_API class FNetworkPredictionData_Server_Character* GetPredictionData_Server_Character() const;
 
    ENGINE_API virtual bool HasPredictionData_Client() const override;
    ENGINE_API virtual bool HasPredictionData_Server() const override;
 
    ENGINE_API virtual void ResetPredictionData_Client() override;
    ENGINE_API virtual void ResetPredictionData_Server() override;
 
    static uint32 PackYawAndPitchTo32(const float Yaw, const float Pitch);
 
protected:
    class FNetworkPredictionData_Client_Character* ClientPredictionData;
    class FNetworkPredictionData_Server_Character* ServerPredictionData;
 
    FRandomStream RandomStream;
 
    ENGINE_API virtual void SmoothClientPosition(float DeltaSeconds);
 
    ENGINE_API void SmoothClientPosition_Interpolate(float DeltaSeconds);
 
    ENGINE_API void SmoothClientPosition_UpdateVisuals();
 
    /*
    ========================================================================
    Here's how player movement prediction, replication and correction works in network games:
    
    Every tick, the TickComponent() function is called.  It figures out the acceleration and rotation change for the frame,
    and then calls PerformMovement() (for locally controlled Characters), or ReplicateMoveToServer() (if it's a network client).
    
    ReplicateMoveToServer() saves the move (in the PendingMove list), calls PerformMovement(), and then replicates the move
    to the server by calling the replicated function ServerMove() - passing the movement parameters, the client's
    resultant position, and a timestamp.
    
    ServerMove() is executed on the server.  It decodes the movement parameters and causes the appropriate movement
    to occur.  It then looks at the resulting position and if enough time has passed since the last response, or the
    position error is significant enough, the server calls ClientAdjustPosition(), a replicated function.
    
    ClientAdjustPosition() is executed on the client.  The client sets its position to the servers version of position,
    and sets the bUpdatePosition flag to true.
    
    When TickComponent() is called on the client again, if bUpdatePosition is true, the client will call
    ClientUpdatePosition() before calling PerformMovement().  ClientUpdatePosition() replays all the moves in the pending
    move list which occurred after the timestamp of the move the server was adjusting.
    */
 
    ENGINE_API virtual void ReplicateMoveToServer(float DeltaTime, const FVector& NewAcceleration);
 
    ENGINE_API virtual bool ClientUpdatePositionAfterServerUpdate();
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(CallServerMove, CallServerMovePacked)
    ENGINE_API virtual void CallServerMove(const FSavedMove_Character* NewMove, const FSavedMove_Character* OldMove);
 
    ENGINE_API virtual void CallServerMovePacked(const FSavedMove_Character* NewMove, const FSavedMove_Character* PendingMove, const FSavedMove_Character* OldMove);
 
    ENGINE_API virtual void ServerMoveHandleClientError(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& RelativeClientLocation, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    ENGINE_API virtual bool ServerCheckClientError(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& ClientWorldLocation, const FVector& RelativeClientLocation, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    ENGINE_API virtual bool ServerExceedsAllowablePositionError(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& ClientWorldLocation, const FVector& RelativeClientLocation, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    ENGINE_API virtual bool ServerShouldUseAuthoritativePosition(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& ClientWorldLocation, const FVector& RelativeClientLocation, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode);
 
    /* Process a move at the given time stamp, given the compressed flags representing various events that occurred (ie jump). */
    ENGINE_API virtual void MoveAutonomous( float ClientTimeStamp, float DeltaTime, uint8 CompressedFlags, const FVector& NewAccel);
 
    ENGINE_API virtual void UpdateFromCompressedFlags(uint8 Flags);
 
    ENGINE_API virtual bool CanDelaySendingMove(const FSavedMovePtr& NewMove);
 
    ENGINE_API virtual float GetClientNetSendDeltaTime(const APlayerController* PC, const FNetworkPredictionData_Client_Character* ClientData, const FSavedMovePtr& NewMove) const;
 
    ENGINE_API virtual void TickCharacterPose(float DeltaTime);
 
    ENGINE_API virtual bool ShouldCancelAdaptiveReplication() const;
 
public:
 
    ENGINE_API virtual void UpdateFloorFromAdjustment();
 
    UPROPERTY()
    float MinTimeBetweenTimeStampResets;
 
    ENGINE_API virtual bool VerifyClientTimeStamp(float TimeStamp, FNetworkPredictionData_Server_Character & ServerData);
 
protected:
 
    float LastTimeStampResetServerTime;
 
    ENGINE_API bool IsClientTimeStampValid(float TimeStamp, const FNetworkPredictionData_Server_Character& ServerData, bool& bTimeStampResetDetected) const;
 
    ENGINE_API virtual void OnClientTimeStampResetDetected();
 
    ENGINE_API virtual void ProcessClientTimeStampForTimeDiscrepancy(float ClientTimeStamp, FNetworkPredictionData_Server_Character& ServerData);
 
    ENGINE_API virtual void OnTimeDiscrepancyDetected(float CurrentTimeDiscrepancy, float LifetimeRawTimeDiscrepancy, float Lifetime, float CurrentMoveError);
 
public:
 
    ENGINE_API void ServerMovePacked_ClientSend(const FCharacterServerMovePackedBits& PackedBits);
 
    ENGINE_API void ServerMovePacked_ServerReceive(const FCharacterServerMovePackedBits& PackedBits);
 
    ENGINE_API virtual bool ShouldUsePackedMovementRPCs() const;
 
    /* Sends a move response from the server to the client (through character to avoid component RPC overhead), eventually calling MoveResponsePacked_ClientReceive() on the client. */
    ENGINE_API void MoveResponsePacked_ServerSend(const FCharacterMoveResponsePackedBits& PackedBits);
 
    /* On the client, receives a packed move response from the server, unpacks it by serializing into the MoveResponseContainer from GetMoveResponseDataContainer(), and passes the data container to ClientHandleMoveResponse(). */
    ENGINE_API void MoveResponsePacked_ClientReceive(const FCharacterMoveResponsePackedBits& PackedBits);
 
    /* If no client adjustment is needed after processing received ServerMove(), ack the good move so client can remove it from SavedMoves */
    ENGINE_API virtual void ClientAckGoodMove_Implementation(float TimeStamp);
 
    /* Replicate position correction to client, associated with a timestamped servermove.  Client will replay subsequent moves after applying adjustment. */
    ENGINE_API virtual void ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode, TOptional<FRotator> OptionalRotation = TOptional<FRotator>());
 
    /* Bandwidth saving version, when velocity is zeroed */
    ENGINE_API virtual void ClientVeryShortAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    /* Replicate position correction to client when using root motion for movement. (animation root motion specific) */
    ENGINE_API virtual void ClientAdjustRootMotionPosition_Implementation(float TimeStamp, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    /* Replicate root motion source correction to client when using root motion for movement. */
    ENGINE_API virtual 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);
 
    ENGINE_API virtual void ServerMove_HandleMoveData(const FCharacterNetworkMoveDataContainer& MoveDataContainer);
 
    ENGINE_API virtual void ServerMove_PerformMovement(const FCharacterNetworkMoveData& MoveData);
 
    ENGINE_API void ServerSendMoveResponse(const FClientAdjustment& PendingAdjustment);
 
    ENGINE_API virtual void ClientHandleMoveResponse(const FCharacterMoveResponseDataContainer& MoveResponse);
 
 
public:
 
    // BEGIN DEPRECATED movement RPCs. Use the Packed versions above instead. 
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMove, ServerMovePacked_ClientSend)
    ENGINE_API virtual 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, ServerMove_PerformMovement)
    ENGINE_API virtual 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 virtual 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(ServerMoveDual, ServerMovePacked_ClientSend)
    ENGINE_API virtual 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, ServerMove_PerformMovement)
    ENGINE_API virtual 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 virtual 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(ServerMoveDualHybridRootMotion, ServerMovePacked_ClientSend)
    ENGINE_API virtual 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, ServerMove_PerformMovement)
    ENGINE_API virtual 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 virtual 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_ClientSend)
    ENGINE_API virtual void ServerMoveOld(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags);
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ServerMoveOld_Implementation, ServerMove_PerformMovement)
    ENGINE_API virtual void ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags);
    ENGINE_API virtual bool ServerMoveOld_Validate(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags);
    
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAckGoodMove, ClientHandleMoveResponse)
    ENGINE_API virtual void ClientAckGoodMove(float TimeStamp);
 
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustPosition, ClientHandleMoveResponse)
    ENGINE_API virtual void ClientAdjustPosition(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
 
    /* Bandwidth saving version, when velocity is zeroed */
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientVeryShortAdjustPosition, ClientHandleMoveResponse)
    ENGINE_API virtual void ClientVeryShortAdjustPosition(float TimeStamp, FVector NewLoc, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
    
    DEPRECATED_CHARACTER_MOVEMENT_RPC(ClientAdjustRootMotionPosition, ClientHandleMoveResponse)
    ENGINE_API virtual 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(ClientAdjustRootMotionSourcePosition, ClientHandleMoveResponse)
    ENGINE_API virtual 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);
 
    // END DEPRECATED movement RPCs
 
protected:
 
    ENGINE_API virtual void OnClientCorrectionReceived(class FNetworkPredictionData_Client_Character& ClientData, float TimeStamp, FVector NewLocation, FVector NewVelocity, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode, FVector ServerGravityDirection);
 
    void SetNetworkMoveDataContainer(FCharacterNetworkMoveDataContainer& PersistentDataStorage) { NetworkMoveDataContainerPtr = &PersistentDataStorage; }
 
    FCharacterNetworkMoveDataContainer& GetNetworkMoveDataContainer() const { return *NetworkMoveDataContainerPtr; }
 
    FCharacterNetworkMoveData* GetCurrentNetworkMoveData() const { return CurrentNetworkMoveData; }
 
    void SetCurrentNetworkMoveData(FCharacterNetworkMoveData* CurrentData) { CurrentNetworkMoveData = CurrentData; }
 
    void SetMoveResponseDataContainer(FCharacterMoveResponseDataContainer& PersistentDataStorage) { MoveResponseDataContainerPtr = &PersistentDataStorage; }
 
    FCharacterMoveResponseDataContainer& GetMoveResponseDataContainer() const { return *MoveResponseDataContainerPtr; }
 
    void SetCurrentReplayedSavedMove(FSavedMove_Character* SavedMove) { CurrentReplayedSavedMove = SavedMove; }
    
public:
 
    const FSavedMove_Character* GetCurrentReplayedSavedMove() const { return CurrentReplayedSavedMove; }
 
private:
 
    FSavedMove_Character* CurrentReplayedSavedMove = nullptr;
 
    // Server move data
 
    FCharacterNetworkMoveDataContainer DefaultNetworkMoveDataContainer;
 
    FCharacterNetworkMoveDataContainer* NetworkMoveDataContainerPtr;
 
    FNetBitWriter ServerMoveBitWriter;
 
    FNetBitReader ServerMoveBitReader;
 
    FCharacterNetworkMoveData* CurrentNetworkMoveData;
 
    // Server response data
 
    FCharacterMoveResponseDataContainer DefaultMoveResponseDataContainer;
 
    FCharacterMoveResponseDataContainer* MoveResponseDataContainerPtr;
 
    FNetBitWriter MoveResponseBitWriter;
 
    FNetBitReader MoveResponseBitReader;
 
public:
 
    // Root Motion
 
    UPROPERTY(Transient)
    FRootMotionSourceGroup CurrentRootMotion;
 
    UPROPERTY(Transient)
    FRootMotionSourceGroup ServerCorrectionRootMotion;
 
    FRootMotionAsyncData AsyncRootMotion;
 
    ENGINE_API bool HasRootMotionSources() const;
 
    ENGINE_API uint16 ApplyRootMotionSource(TSharedPtr<FRootMotionSource> SourcePtr);
 
    ENGINE_API virtual void OnRootMotionSourceBeingApplied(const FRootMotionSource* Source);
 
    ENGINE_API TSharedPtr<FRootMotionSource> GetRootMotionSource(FName InstanceName);
 
    ENGINE_API TSharedPtr<FRootMotionSource> GetRootMotionSourceByID(uint16 RootMotionSourceID);
 
    ENGINE_API void RemoveRootMotionSource(FName InstanceName);
 
    ENGINE_API void RemoveRootMotionSourceByID(uint16 RootMotionSourceID);
 
    ENGINE_API void ConvertRootMotionServerIDsToLocalIDs(const FRootMotionSourceGroup& LocalRootMotionToMatchWith, FRootMotionSourceGroup& InOutServerRootMotion, float TimeStamp);
 
    enum class ERootMotionMapping : uint32 { MapSize = 16 };
    TArray<FRootMotionServerToLocalIDMapping, TInlineAllocator<(uint32)ERootMotionMapping::MapSize> > RootMotionIDMappings;
 
protected:
    ENGINE_API virtual void RestorePreAdditiveRootMotionVelocity();
 
    ENGINE_API virtual void ApplyRootMotionToVelocity(float deltaTime);
 
    ENGINE_API void DecayFormerBaseVelocity(float deltaTime);
 
public:
 
    UPROPERTY(Transient)
    FRootMotionMovementParams RootMotionParams;
 
    UPROPERTY(Transient)
    FVector AnimRootMotionVelocity;
 
    bool HasAnimRootMotion() const
    {
        return RootMotionParams.bHasRootMotion;
    }
 
    // Takes component space root motion and converts it to world space
    ENGINE_API FTransform ConvertLocalRootMotionToWorld(const FTransform& InLocalRootMotion, float DeltaSeconds);
 
    // Delegate for modifying root motion pre conversion from component space to world space.
    FOnProcessRootMotion ProcessRootMotionPreConvertToWorld;
    
    // Delegate for modifying root motion post conversion from component space to world space.
    FOnProcessRootMotion ProcessRootMotionPostConvertToWorld;
 
    ENGINE_API void SimulateRootMotion(float DeltaSeconds, const FTransform& LocalRootMotionTransform);
 
    ENGINE_API virtual FVector CalcAnimRootMotionVelocity(const FVector& RootMotionDeltaMove, float DeltaSeconds, const FVector& CurrentVelocity) const;
 
    ENGINE_API virtual FVector ConstrainAnimRootMotionVelocity(const FVector& RootMotionVelocity, const FVector& CurrentVelocity) const;
 
    // RVO Avoidance
 
    ENGINE_API virtual void CalcAvoidanceVelocity(float DeltaTime);
 
    ENGINE_API virtual void PostProcessAvoidanceVelocity(FVector& NewVelocity);
 
    ENGINE_API virtual void FlushServerMoves();
 
    ENGINE_API ETeleportType GetTeleportType() const;
 
protected:
 
    ENGINE_API void UpdateDefaultAvoidance();
 
public:
    ENGINE_API void SetAvoidanceVelocityLock(class UAvoidanceManager* Avoidance, float Duration);
 
    ENGINE_API virtual void SetRVOAvoidanceUID(int32 UID) override;
    ENGINE_API virtual int32 GetRVOAvoidanceUID() override;
    ENGINE_API virtual void SetRVOAvoidanceWeight(float Weight) override;
    ENGINE_API virtual float GetRVOAvoidanceWeight() override;
    ENGINE_API virtual FVector GetRVOAvoidanceOrigin() override;
    ENGINE_API virtual float GetRVOAvoidanceRadius() override;
    ENGINE_API virtual float GetRVOAvoidanceHeight() override;
    ENGINE_API virtual float GetRVOAvoidanceConsiderationRadius() override;
    ENGINE_API virtual FVector GetVelocityForRVOConsideration() override;
    ENGINE_API virtual void SetAvoidanceGroupMask(int32 GroupFlags) override;
    ENGINE_API virtual int32 GetAvoidanceGroupMask() override;
    ENGINE_API virtual void SetGroupsToAvoidMask(int32 GroupFlags) override;
    ENGINE_API virtual int32 GetGroupsToAvoidMask() override;
    ENGINE_API virtual void SetGroupsToIgnoreMask(int32 GroupFlags) override;
    ENGINE_API virtual int32 GetGroupsToIgnoreMask() override;
    int32 GetRVOAvoidanceUIDFast() const { return AvoidanceUID; }
 
public:
 
    static ENGINE_API const float MIN_TICK_TIME;
 
    static ENGINE_API const float MIN_FLOOR_DIST;
 
    static ENGINE_API const float MAX_FLOOR_DIST;
 
    static ENGINE_API const float SWEEP_EDGE_REJECT_DISTANCE;
 
    static ENGINE_API const float BRAKE_TO_STOP_VELOCITY;
};
 
 
inline ACharacter* UCharacterMovementComponent::GetCharacterOwner() const
{
    return CharacterOwner;
}
 
inline bool UCharacterMovementComponent::IsWalking() const
{
    return IsMovingOnGround();
}
 
inline uint32 UCharacterMovementComponent::PackYawAndPitchTo32(const float Yaw, const float Pitch)
{
    const uint32 YawShort = FRotator::CompressAxisToShort(Yaw);
    const uint32 PitchShort = FRotator::CompressAxisToShort(Pitch);
    const uint32 Rotation32 = (YawShort << 16) | PitchShort;
    return Rotation32;
}
 
class FSavedMove_Character_FixLayout
{
public:
    virtual ~FSavedMove_Character_FixLayout() = default;
};
 
class FSavedMove_Character : public FSavedMove_Character_FixLayout
{
public:
    ENGINE_API FSavedMove_Character();
    ENGINE_API virtual ~FSavedMove_Character();
 
    // UE_DEPRECATED_FORGAME(4.20)
    FSavedMove_Character(const FSavedMove_Character&);
    FSavedMove_Character(FSavedMove_Character&&);
    FSavedMove_Character& operator=(const FSavedMove_Character&);
    FSavedMove_Character& operator=(FSavedMove_Character&&);
 
    ACharacter* CharacterOwner;
 
    uint8 bPressedJump:1;
    uint8 bWantsToCrouch:1;
    uint8 bForceMaxAccel:1;
 
    uint8 bForceNoCombine:1;
 
    uint8 bOldTimeStampBeforeReset:1;
 
    uint8 bWasJumping:1;
 
    UE_DEPRECATED_FORGAME(4.20, "This property is deprecated, use StartPackedMovementMode or EndPackedMovementMode instead.")
    uint8 MovementMode;
 
    // Information at the start of the move
    uint8 StartPackedMovementMode;
    uint8 EndPackedMovementMode;
 
    float TimeStamp;    // Time of this move.
    float DeltaTime;    // amount of time for this move
    float CustomTimeDilation;
    float JumpKeyHoldTime;
    float JumpForceTimeRemaining;
    int32 JumpMaxCount;
    int32 JumpCurrentCount;
    
    FVector StartLocation;
    FVector StartRelativeLocation;
    FVector StartVelocity;
    FFindFloorResult StartFloor;
    FRotator StartRotation;
    FRotator StartControlRotation;
    FQuat StartBaseRotation;    // rotation of the base component (or bone), only saved if it can move.
    float StartCapsuleRadius;
    float StartCapsuleHalfHeight;
    TWeakObjectPtr<UPrimitiveComponent> StartBase;
    FName StartBoneName;
    uint32 StartActorOverlapCounter;
    uint32 StartComponentOverlapCounter;
    TWeakObjectPtr<USceneComponent> StartAttachParent;
    FName StartAttachSocketName;
    FVector StartAttachRelativeLocation;
    FRotator StartAttachRelativeRotation;
 
    // Information after the move has been performed
    FVector SavedLocation;
    FRotator SavedRotation;
    FVector SavedVelocity;
    FVector SavedRelativeLocation;
    FVector SavedRelativeAcceleration;
    FRotator SavedControlRotation;
    TWeakObjectPtr<UPrimitiveComponent> EndBase;
    FName EndBoneName;
    uint32 EndActorOverlapCounter;
    uint32 EndComponentOverlapCounter;
    TWeakObjectPtr<USceneComponent> EndAttachParent;
    FName EndAttachSocketName;
    FVector EndAttachRelativeLocation;
    FRotator EndAttachRelativeRotation;
 
    FVector Acceleration;
    float MaxSpeed;
 
    // Cached to speed up iteration over IsImportantMove().
    FVector AccelNormal;
    float AccelMag;
 
    mutable TWeakObjectPtr<class UAnimMontage> RootMotionMontage;
    float RootMotionTrackPosition;
    float RootMotionPreviousTrackPosition;
    float RootMotionPlayRateWithScale;
    FRootMotionMovementParams RootMotionMovement;
 
    FRootMotionSourceGroup SavedRootMotion;
 
    float AccelDotThreshold;    
    float AccelMagThreshold;    
    float AccelDotThresholdCombine;
    float MaxSpeedThresholdCombine;
    
    ENGINE_API virtual void Clear();
 
    ENGINE_API virtual void SetMoveFor(ACharacter* C, float InDeltaTime, FVector const& NewAccel, class FNetworkPredictionData_Client_Character & ClientData);
 
    ENGINE_API virtual void SetInitialPosition(ACharacter* C);
 
    ENGINE_API virtual bool IsImportantMove(const FSavedMovePtr& LastAckedMove) const;
    
    ENGINE_API virtual FVector GetRevertedLocation() const;
 
    enum EPostUpdateMode
    {
        PostUpdate_Record,      // Record a move after having run the simulation
        PostUpdate_Replay,      // Update after replaying a move for a client correction
    };
 
    ENGINE_API virtual void PostUpdate(ACharacter* C, EPostUpdateMode PostUpdateMode);
    
    ENGINE_API virtual bool CanCombineWith(const FSavedMovePtr& NewMove, ACharacter* InCharacter, float MaxDelta) const;
 
    ENGINE_API virtual void CombineWith(const FSavedMove_Character* OldMove, ACharacter* InCharacter, APlayerController* PC, const FVector& OldStartLocation);
    
    ENGINE_API virtual void PrepMoveFor(ACharacter* C);
 
    ENGINE_API virtual uint8 GetCompressedFlags() const;
 
    ENGINE_API virtual bool IsMatchingStartControlRotation(const APlayerController* PC) const;
 
    ENGINE_API virtual void GetPackedAngles(uint32& YawAndPitchPack, uint8& RollPack) const;
 
    ENGINE_API virtual void AddStructReferencedObjects(FReferenceCollector& Collector) const;
 
    // Bit masks used by GetCompressedFlags() to encode movement information.
    enum CompressedFlags
    {
        FLAG_JumpPressed    = 0x01, // Jump pressed
        FLAG_WantsToCrouch  = 0x02, // Wants to crouch
        FLAG_Reserved_1     = 0x04, // Reserved for future use
        FLAG_Reserved_2     = 0x08, // Reserved for future use
        // Remaining bit masks are available for custom flags.
        FLAG_Custom_0       = 0x10,
        FLAG_Custom_1       = 0x20,
        FLAG_Custom_2       = 0x40,
        FLAG_Custom_3       = 0x80,
    };
};
 
//UE_DEPRECATED_FORGAME(4.20)
PRAGMA_DISABLE_DEPRECATION_WARNINGS
inline FSavedMove_Character::FSavedMove_Character(const FSavedMove_Character&) = default;
inline FSavedMove_Character::FSavedMove_Character(FSavedMove_Character&&) = default;
inline FSavedMove_Character& FSavedMove_Character::operator=(const FSavedMove_Character&) = default;
inline FSavedMove_Character& FSavedMove_Character::operator=(FSavedMove_Character&&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
 
class FNetworkPredictionData_Client_Character : public FNetworkPredictionData_Client, protected FNoncopyable
{
    using Super = FNetworkPredictionData_Client;
 
public:
 
    ENGINE_API FNetworkPredictionData_Client_Character(const UCharacterMovementComponent& ClientMovement);
    ENGINE_API virtual ~FNetworkPredictionData_Client_Character();
 
    ENGINE_API void AddStructReferencedObjects(FReferenceCollector& Collector) const override;
 
    float ClientUpdateRealTime;
 
    float CurrentTimeStamp;
 
    float LastReceivedAckRealTime;
 
    TArray<FSavedMovePtr> SavedMoves;       // Buffered moves pending position updates, orderd oldest to newest. Moves that have been acked by the server are removed.
    TArray<FSavedMovePtr> FreeMoves;        // freed moves, available for buffering
    FSavedMovePtr PendingMove;              // PendingMove already processed on client - waiting to combine with next movement to reduce client to server bandwidth
    FSavedMovePtr LastAckedMove;            // Last acknowledged sent move.
 
    int32 MaxFreeMoveCount;                 // Limit on size of free list
    int32 MaxSavedMoveCount;                // Limit on the size of the saved move buffer
 
    uint32 bUpdatePosition:1; // when true, update the position (via ClientUpdatePosition)
 
    // Mesh smoothing variables (for network smoothing)
    //
    
    FVector OriginalMeshTranslationOffset;
 
    FVector MeshTranslationOffset;
 
    FQuat OriginalMeshRotationOffset;
 
    FQuat MeshRotationOffset;
 
    FQuat MeshRotationTarget;
 
    float LastCorrectionDelta;
 
    float LastCorrectionTime;
 
    float MaxClientSmoothingDeltaTime;
 
    double SmoothingServerTimeStamp;
 
    double SmoothingClientTimeStamp;
 
    float MaxSmoothNetUpdateDist;
 
    float NoSmoothNetUpdateDist;
 
    float SmoothNetUpdateTime;
 
    float SmoothNetUpdateRotationTime;
    
    float MaxMoveDeltaTime;
 
    FVector LastSmoothLocation;
    FVector LastServerLocation;
    float   SimulatedDebugDrawTime;
 
    ENGINE_API int32 GetSavedMoveIndex(float TimeStamp) const;
 
    ENGINE_API void AckMove(int32 AckedMoveIndex, UCharacterMovementComponent& CharacterMovementComponent);
 
    ENGINE_API virtual FSavedMovePtr AllocateNewMove();
 
    ENGINE_API virtual void FreeMove(const FSavedMovePtr& Move);
 
    ENGINE_API virtual FSavedMovePtr CreateSavedMove();
 
    ENGINE_API float UpdateTimeStampAndDeltaTime(float DeltaTime, ACharacter & CharacterOwner, class UCharacterMovementComponent & CharacterMovementComponent);
 
    float DebugForcedPacketLossTimerStart;
};
 
 
class FNetworkPredictionData_Server_Character : public FNetworkPredictionData_Server, protected FNoncopyable
{
public:
 
    ENGINE_API FNetworkPredictionData_Server_Character(const UCharacterMovementComponent& ServerMovement);
    ENGINE_API virtual ~FNetworkPredictionData_Server_Character();
 
    FClientAdjustment PendingAdjustment;
 
    float CurrentClientTimeStamp;
 
    float LastReceivedClientTimeStamp;
 
    double ServerAccumulatedClientTimeStamp;
 
    float LastUpdateTime;
 
    float ServerTimeStampLastServerMove;
    
    float MaxMoveDeltaTime;
 
    uint32 bForceClientUpdate:1;
 
    float LifetimeRawTimeDiscrepancy;
 
    float TimeDiscrepancy;
 
    bool bResolvingTimeDiscrepancy;
 
    float TimeDiscrepancyResolutionMoveDeltaOverride;
 
    float TimeDiscrepancyAccumulatedClientDeltasSinceLastServerTick;
 
    float WorldCreationTime;
 
    ENGINE_API float GetServerMoveDeltaTime(float ClientTimeStamp, float ActorTimeDilation) const;
 
    ENGINE_API float GetBaseServerMoveDeltaTime(float ClientTimeStamp, float ActorTimeDilation) const;
 
    ENGINE_API virtual void Serialize(FArchive& Archive);
 
};