VRSimpleCharacterMovementComponent.cpp

Go to the documentation of this file.

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    Movement.cpp: Character movement implementation
 
=============================================================================*/
 
#include "SimpleChar/VRSimpleCharacterMovementComponent.h"
#include "GameFramework/PhysicsVolume.h"
#include "GameFramework/GameNetworkManager.h"
#include "IHeadMountedDisplay.h"
#include "SimpleChar/VRSimpleCharacter.h"
#include "NavigationSystem.h"
#include "GameFramework/Character.h"
#include "GameFramework/GameState.h"
#include "Engine/Engine.h"
#include "Components/PrimitiveComponent.h"
#include "Animation/AnimMontage.h"
//#include "PhysicsEngine/DestructibleActor.h"
 
// @todo this is here only due to circular dependency to AIModule. To be removed
#include "Navigation/PathFollowingComponent.h"
#include "AI/Navigation/AvoidanceManager.h"
#include "Components/CapsuleComponent.h"
#include "Components/BrushComponent.h"
//#include "Components/DestructibleComponent.h"
 
#include "Engine/DemoNetDriver.h"
#include "Engine/NetworkObjectList.h"
 
DEFINE_LOG_CATEGORY(LogSimpleCharacterMovement);
 
DECLARE_CYCLE_STAT(TEXT("Char ReplicateMoveToServerVRSimple"), STAT_CharacterMovementReplicateMoveToServerVRSimple, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char CallServerMoveVRSimple"), STAT_CharacterMovementCallServerMoveVRSimple, STATGROUP_Character);
 
// Defines for build configs
#if DO_CHECK && !UE_BUILD_SHIPPING // Disable even if checks in shipping are enabled.
#define devCodeSimple( Code )       checkCode( Code )
#else
#define devCodeSimple(...)
#endif
 
//#include "PerfCountersHelpers.h"
//DECLARE_CYCLE_STAT(TEXT("Char PhysWalking"), STAT_CharPhysWalking, STATGROUP_Character);
//DECLARE_CYCLE_STAT(TEXT("Char PhysFalling"), STAT_CharPhysFalling, STATGROUP_Character);
//DECLARE_CYCLE_STAT(TEXT("Char PhysNavWalking"), STAT_CharPhysNavWalking, STATGROUP_Character);
const float MAX_STEP_SIDE_ZZ = 0.08f;   // maximum z value for the normal on the vertical side of steps
const float VERTICAL_SLOPE_NORMAL_ZZ = 0.001f; // Slope is vertical if Abs(Normal.Z) <= this threshold. Accounts for precision problems that sometimes angle normals slightly off horizontal for vertical surface.
 
UVRSimpleCharacterMovementComponent::UVRSimpleCharacterMovementComponent(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    PostPhysicsTickFunction.bCanEverTick = true;
    PostPhysicsTickFunction.bStartWithTickEnabled = false;
    PrimaryComponentTick.TickGroup = TG_PrePhysics;
    VRRootCapsule = NULL;
    //VRCameraCollider = NULL;
 
    this->bRequestedMoveUseAcceleration = false;
    //this->MaxAcceleration = 200048.0f;
    //this->BrakingDecelerationWalking = 200048.0f;
    this->bUpdateOnlyIfRendered = false;
    this->AirControl = 0.0f;
 
    bSkipHMDChecks = false;
    bIsFirstTick = true;
    //LastAdditionalVRInputVector = FVector::ZeroVector;
    AdditionalVRInputVector = FVector::ZeroVector;  
    CustomVRInputVector = FVector::ZeroVector;
 
    SetNetworkMoveDataContainer(VRNetworkMoveDataContainer);
    SetMoveResponseDataContainer(VRMoveResponseDataContainer);
 
    //bMaintainHorizontalGroundVelocity = true;
}
 
bool UVRSimpleCharacterMovementComponent::VRClimbStepUp(const FVector& GravDir, const FVector& Delta, const FHitResult &InHit, FStepDownResult* OutStepDownResult)
{
    //SCOPE_CYCLE_COUNTER(STAT_CharStepUp);
 
    if (!CanStepUp(InHit) || MaxStepHeight <= 0.f)
    {
        return false;
    }
 
    const FVector OldLocation = UpdatedComponent->GetComponentLocation();
    float PawnRadius, PawnHalfHeight;
    CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(PawnRadius, PawnHalfHeight);
 
    // Don't bother stepping up if top of capsule is hitting something.
    const float InitialImpactZ = InHit.ImpactPoint.Z;
    if (InitialImpactZ > OldLocation.Z + (PawnHalfHeight - PawnRadius))
    {
        return false;
    }
 
    if (GravDir.IsZero())
    {
        return false;
    }
 
    // Gravity should be a normalized direction
    ensure(GravDir.IsNormalized());
 
    float StepTravelUpHeight = MaxStepHeight;
    float StepTravelDownHeight = StepTravelUpHeight;
    const float StepSideZ = -1.f * (InHit.ImpactNormal | GravDir);
    float PawnInitialFloorBaseZ = OldLocation.Z - PawnHalfHeight;
    float PawnFloorPointZ = PawnInitialFloorBaseZ;
 
    if (IsMovingOnGround() && CurrentFloor.IsWalkableFloor())
    {
        // Since we float a variable amount off the floor, we need to enforce max step height off the actual point of impact with the floor.
        const float FloorDist = FMath::Max(0.f, CurrentFloor.GetDistanceToFloor());
        PawnInitialFloorBaseZ -= FloorDist;
        StepTravelUpHeight = FMath::Max(StepTravelUpHeight - FloorDist, 0.f);
        StepTravelDownHeight = (MaxStepHeight + MAX_FLOOR_DIST*2.f);
 
        const bool bHitVerticalFace = !IsWithinEdgeTolerance(InHit.Location, InHit.ImpactPoint, PawnRadius);
        if (!CurrentFloor.bLineTrace && !bHitVerticalFace)
        {
            PawnFloorPointZ = CurrentFloor.HitResult.ImpactPoint.Z;
        }
        else
        {
            // Base floor point is the base of the capsule moved down by how far we are hovering over the surface we are hitting.
            PawnFloorPointZ -= CurrentFloor.FloorDist;
        }
    }
 
    // Don't step up if the impact is below us, accounting for distance from floor.
    if (InitialImpactZ <= PawnInitialFloorBaseZ)
    {
        return false;
    }
 
    // Scope our movement updates, and do not apply them until all intermediate moves are completed.
    FScopedMovementUpdate ScopedStepUpMovement(UpdatedComponent, EScopedUpdate::DeferredUpdates);
 
    // step up - treat as vertical wall
    FHitResult SweepUpHit(1.f);
    const FQuat PawnRotation = UpdatedComponent->GetComponentQuat();
    MoveUpdatedComponent(-GravDir * StepTravelUpHeight, PawnRotation, true, &SweepUpHit);
 
    if (SweepUpHit.bStartPenetrating)
    {
        // Undo movement
        ScopedStepUpMovement.RevertMove();
        return false;
    }
 
    // step fwd
    FHitResult Hit(1.f);
    MoveUpdatedComponent(Delta, PawnRotation, true, &Hit);
 
    // Check result of forward movement
    if (Hit.bBlockingHit)
    {
        if (Hit.bStartPenetrating)
        {
            // Undo movement
            ScopedStepUpMovement.RevertMove();
            return false;
        }
 
        // If we hit something above us and also something ahead of us, we should notify about the upward hit as well.
        // The forward hit will be handled later (in the bSteppedOver case below).
        // In the case of hitting something above but not forward, we are not blocked from moving so we don't need the notification.
        if (SweepUpHit.bBlockingHit && Hit.bBlockingHit)
        {
            HandleImpact(SweepUpHit);
        }
 
        // pawn ran into a wall
        HandleImpact(Hit);
        if (IsFalling())
        {
            return true;
        }
 
        // Don't adjust or slide, just fail here in VR
        ScopedStepUpMovement.RevertMove();
        return false;
        /*
        // adjust and try again
        const float ForwardHitTime = Hit.Time;
        const float ForwardSlideAmount = SlideAlongSurface(Delta, 1.f - Hit.Time, Hit.Normal, Hit, true);
 
        if (IsFalling())
        {
            ScopedStepUpMovement.RevertMove();
            return false;
        }
 
        // If both the forward hit and the deflection got us nowhere, there is no point in this step up.
        if (ForwardHitTime == 0.f && ForwardSlideAmount == 0.f)
        {
            ScopedStepUpMovement.RevertMove();
            return false;
        }*/
    }
 
    // Step down
    MoveUpdatedComponent(GravDir * StepTravelDownHeight, UpdatedComponent->GetComponentQuat(), true, &Hit);
 
    // If step down was initially penetrating abort the step up
    if (Hit.bStartPenetrating)
    {
        ScopedStepUpMovement.RevertMove();
        return false;
    }
 
    FStepDownResult StepDownResult;
    if (Hit.IsValidBlockingHit())
    {
        // See if this step sequence would have allowed us to travel higher than our max step height allows.
        const float DeltaZ = Hit.ImpactPoint.Z - PawnFloorPointZ;
        if (DeltaZ > MaxStepHeight)
        {
            //UE_LOG(LogSimpleCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (too high Height %.3f) up from floor base %f to %f"), DeltaZ, PawnInitialFloorBaseZ, NewLocation.Z);
            ScopedStepUpMovement.RevertMove();
            return false;
        }
 
        // Reject unwalkable surface normals here.
        if (!IsWalkable(Hit))
        {
            // Reject if normal opposes movement direction
            const bool bNormalTowardsMe = (Delta | Hit.ImpactNormal) < 0.f;
            if (bNormalTowardsMe)
            {
                //UE_LOG(LogSimpleCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (unwalkable normal %s opposed to movement)"), *Hit.ImpactNormal.ToString());
                ScopedStepUpMovement.RevertMove();
                return false;
            }
 
            // Also reject if we would end up being higher than our starting location by stepping down.
            // It's fine to step down onto an unwalkable normal below us, we will just slide off. Rejecting those moves would prevent us from being able to walk off the edge.
            if (Hit.Location.Z > OldLocation.Z)
            {
                //UE_LOG(LogSimpleCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (unwalkable normal %s above old position)"), *Hit.ImpactNormal.ToString());
                ScopedStepUpMovement.RevertMove();
                return false;
            }
        }
 
        // Reject moves where the downward sweep hit something very close to the edge of the capsule. This maintains consistency with FindFloor as well.
        if (!IsWithinEdgeTolerance(Hit.Location, Hit.ImpactPoint, PawnRadius))
        {
            //UE_LOG(LogSimpleCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (outside edge tolerance)"));
            ScopedStepUpMovement.RevertMove();
            return false;
        }
 
        // Don't step up onto invalid surfaces if traveling higher.
        if (DeltaZ > 0.f && !CanStepUp(Hit))
        {
            //UE_LOG(LogSimpleCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (up onto surface with !CanStepUp())"));
            ScopedStepUpMovement.RevertMove();
            return false;
        }
 
        // See if we can validate the floor as a result of this step down. In almost all cases this should succeed, and we can avoid computing the floor outside this method.
        if (OutStepDownResult != NULL)
        {
            FindFloor(UpdatedComponent->GetComponentLocation(), StepDownResult.FloorResult, false, &Hit);
 
            // Reject unwalkable normals if we end up higher than our initial height.
            // It's fine to walk down onto an unwalkable surface, don't reject those moves.
            if (Hit.Location.Z > OldLocation.Z)
            {
                // We should reject the floor result if we are trying to step up an actual step where we are not able to perch (this is rare).
                // In those cases we should instead abort the step up and try to slide along the stair.
                if (!StepDownResult.FloorResult.bBlockingHit && StepSideZ < MAX_STEP_SIDE_ZZ)
                {
                    ScopedStepUpMovement.RevertMove();
                    return false;
                }
            }
 
            StepDownResult.bComputedFloor = true;
        }
    }
 
    // Copy step down result.
    if (OutStepDownResult != NULL)
    {
        *OutStepDownResult = StepDownResult;
    }
 
    // Don't recalculate velocity based on this height adjustment, if considering vertical adjustments.
    bJustTeleported |= !bMaintainHorizontalGroundVelocity;
 
    return true;
}
 
void UVRSimpleCharacterMovementComponent::PhysFlying(float deltaTime, int32 Iterations)
{
    if (deltaTime < MIN_TICK_TIME)
    {
        return;
    }
 
    RestorePreAdditiveRootMotionVelocity();
    RestorePreAdditiveVRMotionVelocity();
 
    if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
    {
        if (bCheatFlying && Acceleration.IsZero())
        {
            Velocity = FVector::ZeroVector;
        }
        const float Friction = 0.5f * GetPhysicsVolume()->FluidFriction;
        CalcVelocity(deltaTime, Friction, true, BrakingDecelerationFlying);
    }
 
    ApplyRootMotionToVelocity(deltaTime);
    ApplyVRMotionToVelocity(deltaTime);
 
    Iterations++;
    bJustTeleported = false;
 
    FVector OldLocation = UpdatedComponent->GetComponentLocation();
    const FVector Adjusted = Velocity * deltaTime;
    FHitResult Hit(1.f);
    SafeMoveUpdatedComponent(Adjusted, UpdatedComponent->GetComponentQuat(), true, Hit);
 
    if (Hit.Time < 1.f)
    {
        const FVector GravDir = FVector(0.f, 0.f, -1.f);
        const FVector VelDir = Velocity.GetSafeNormal();
        const float UpDown = GravDir | VelDir;
 
        bool bSteppedUp = false;
        if ((FMath::Abs(Hit.ImpactNormal.Z) < 0.2f) && (UpDown < 0.5f) && (UpDown > -0.2f) && CanStepUp(Hit))
        {
            float stepZ = UpdatedComponent->GetComponentLocation().Z;
            bSteppedUp = StepUp(GravDir, Adjusted * (1.f - Hit.Time), Hit);
            if (bSteppedUp)
            {
                OldLocation.Z = UpdatedComponent->GetComponentLocation().Z + (OldLocation.Z - stepZ);
            }
        }
 
        if (!bSteppedUp)
        {
            //adjust and try again
            HandleImpact(Hit, deltaTime, Adjusted);
            SlideAlongSurface(Adjusted, (1.f - Hit.Time), Hit.Normal, Hit, true);
        }
    }
 
    if (!bJustTeleported && !HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
    {
        Velocity = (UpdatedComponent->GetComponentLocation() - OldLocation) / deltaTime;
    }
}
 
void UVRSimpleCharacterMovementComponent::PhysNavWalking(float deltaTime, int32 Iterations)
{
    //SCOPE_CYCLE_COUNTER(STAT_CharPhysNavWalking);
 
    if (deltaTime < MIN_TICK_TIME)
    {
        return;
    }
 
    if ((!CharacterOwner || !CharacterOwner->Controller) && !bRunPhysicsWithNoController && !HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
    {
        Acceleration = FVector::ZeroVector;
        Velocity = FVector::ZeroVector;
        return;
    }
 
    RestorePreAdditiveRootMotionVelocity();
    RestorePreAdditiveVRMotionVelocity();
 
    // Ensure velocity is horizontal.
    MaintainHorizontalGroundVelocity();
    devCodeSimple(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysNavWalking: Velocity contains NaN before CalcVelocity (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
 
    //bound acceleration
    Acceleration.Z = 0.f;
    if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
    {
        CalcVelocity(deltaTime, GroundFriction, false, BrakingDecelerationWalking);
        devCodeSimple(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysNavWalking: Velocity contains NaN after CalcVelocity (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
    }
 
    ApplyRootMotionToVelocity(deltaTime);
    ApplyVRMotionToVelocity(deltaTime);
 
    if (IsFalling())
    {
        // Root motion could have put us into Falling
        StartNewPhysics(deltaTime, Iterations);
        return;
    }
 
    Iterations++;
 
    FVector DesiredMove = Velocity;
    DesiredMove.Z = 0.f;
 
    const FVector OldLocation = GetActorFeetLocation();
    const FVector DeltaMove = DesiredMove * deltaTime;
    const bool bDeltaMoveNearlyZero = DeltaMove.IsNearlyZero();
 
    FVector AdjustedDest = OldLocation + DeltaMove;
    FNavLocation DestNavLocation;
 
    bool bSameNavLocation = false;
    if (CachedNavLocation.NodeRef != INVALID_NAVNODEREF)
    {
        if (bProjectNavMeshWalking)
        {
            const float DistSq2D = (OldLocation - CachedNavLocation.Location).SizeSquared2D();
            const float DistZ = FMath::Abs(OldLocation.Z - CachedNavLocation.Location.Z);
 
            const float TotalCapsuleHeight = CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleHalfHeight() * 2.0f;
            const float ProjectionScale = (OldLocation.Z > CachedNavLocation.Location.Z) ? NavMeshProjectionHeightScaleUp : NavMeshProjectionHeightScaleDown;
            const float DistZThr = TotalCapsuleHeight * FMath::Max(0.f, ProjectionScale);
 
            bSameNavLocation = (DistSq2D <= KINDA_SMALL_NUMBER) && (DistZ < DistZThr);
        }
        else
        {
            bSameNavLocation = CachedNavLocation.Location.Equals(OldLocation);
        }
 
        if (bDeltaMoveNearlyZero && bSameNavLocation)
        {
            if (const INavigationDataInterface * NavData = GetNavData())
            {
                if (!NavData->IsNodeRefValid(CachedNavLocation.NodeRef))
                {
                    CachedNavLocation.NodeRef = INVALID_NAVNODEREF;
                    bSameNavLocation = false;
                }
            }
        }
    }
 
 
    if (bDeltaMoveNearlyZero && bSameNavLocation)
    {
        DestNavLocation = CachedNavLocation;
        //UE_LOG(LogNavMeshMovement, VeryVerbose, TEXT("%s using cached navmesh location! (bProjectNavMeshWalking = %d)"), *GetNameSafe(CharacterOwner), bProjectNavMeshWalking);
    }
    else
    {
    //  SCOPE_CYCLE_COUNTER(STAT_CharNavProjectPoint);
 
        // Start the trace from the Z location of the last valid trace.
        // Otherwise if we are projecting our location to the underlying geometry and it's far above or below the navmesh,
        // we'll follow that geometry's plane out of range of valid navigation.
        if (bSameNavLocation && bProjectNavMeshWalking)
        {
            AdjustedDest.Z = CachedNavLocation.Location.Z;
        }
 
        // Find the point on the NavMesh
        const bool bHasNavigationData = FindNavFloor(AdjustedDest, DestNavLocation);
        if (!bHasNavigationData)
        {
            SetMovementMode(MOVE_Walking);
            return;
        }
 
        CachedNavLocation = DestNavLocation;
    }
 
    if (DestNavLocation.NodeRef != INVALID_NAVNODEREF)
    {
        FVector NewLocation(AdjustedDest.X, AdjustedDest.Y, DestNavLocation.Location.Z);
        if (bProjectNavMeshWalking)
        {
        //  SCOPE_CYCLE_COUNTER(STAT_CharNavProjectLocation);
            const float TotalCapsuleHeight = CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleHalfHeight() * 2.0f;
            const float UpOffset = TotalCapsuleHeight * FMath::Max(0.f, NavMeshProjectionHeightScaleUp);
            const float DownOffset = TotalCapsuleHeight * FMath::Max(0.f, NavMeshProjectionHeightScaleDown);
            NewLocation = ProjectLocationFromNavMesh(deltaTime, OldLocation, NewLocation, UpOffset, DownOffset);
        }
 
        FVector AdjustedDelta = NewLocation - OldLocation;
 
        if (!AdjustedDelta.IsNearlyZero())
        {
            FHitResult HitResult;
            SafeMoveUpdatedComponent(AdjustedDelta, UpdatedComponent->GetComponentQuat(), bSweepWhileNavWalking, HitResult);
        }
 
        // Update velocity to reflect actual move
        if (!bJustTeleported && !HasAnimRootMotion() && !CurrentRootMotion.HasVelocity())
        {
            Velocity = (GetActorFeetLocation() - OldLocation) / deltaTime;
            MaintainHorizontalGroundVelocity();
        }
 
        bJustTeleported = false;
    }
    else
    {
        StartFalling(Iterations, deltaTime, deltaTime, DeltaMove, OldLocation);
    }
}
 
void UVRSimpleCharacterMovementComponent::PhysFalling(float deltaTime, int32 Iterations)
{
    //SCOPE_CYCLE_COUNTER(STAT_CharPhysFalling);
 
    if (deltaTime < MIN_TICK_TIME)
    {
        return;
    }
 
    FVector FallAcceleration = GetFallingLateralAcceleration(deltaTime);
    FallAcceleration.Z = 0.f;
    const bool bHasLimitedAirControl = ShouldLimitAirControl(deltaTime, FallAcceleration);
 
    float remainingTime = deltaTime;
    while ((remainingTime >= MIN_TICK_TIME) && (Iterations < MaxSimulationIterations))
    {
        Iterations++;
        float timeTick = GetSimulationTimeStep(remainingTime, Iterations);
        remainingTime -= timeTick;
 
        const FVector OldLocation = UpdatedComponent->GetComponentLocation();
        const FQuat PawnRotation = UpdatedComponent->GetComponentQuat();
        bJustTeleported = false;
 
        RestorePreAdditiveRootMotionVelocity();
        //RestorePreAdditiveVRMotionVelocity();
 
        const FVector OldVelocity = Velocity;
 
        // Apply input
        const float MaxDecel = GetMaxBrakingDeceleration();
        if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
        {
            // Compute Velocity
            {
                // Acceleration = FallAcceleration for CalcVelocity(), but we restore it after using it.
                TGuardValue<FVector> RestoreAcceleration(Acceleration, FallAcceleration);
                Velocity.Z = 0.f;
                CalcVelocity(timeTick, FallingLateralFriction, false, BrakingDecelerationFalling);
                Velocity.Z = OldVelocity.Z;
            }
        }
 
        // Compute current gravity
        const FVector Gravity(0.f, 0.f, GetGravityZ());
 
        float GravityTime = timeTick;
 
        // If jump is providing force, gravity may be affected.
        bool bEndingJumpForce = false;
        if (CharacterOwner->JumpForceTimeRemaining > 0.0f)
        {
            // Consume some of the force time. Only the remaining time (if any) is affected by gravity when bApplyGravityWhileJumping=false.
            const float JumpForceTime = FMath::Min(CharacterOwner->JumpForceTimeRemaining, timeTick);
            GravityTime = bApplyGravityWhileJumping ? timeTick : FMath::Max(0.0f, timeTick - JumpForceTime);
 
            // Update Character state
            CharacterOwner->JumpForceTimeRemaining -= JumpForceTime;
            if (CharacterOwner->JumpForceTimeRemaining <= 0.0f)
            {
                CharacterOwner->ResetJumpState();
                bEndingJumpForce = true;
            }
        }
 
        // Apply gravity
        Velocity = NewFallVelocity(Velocity, Gravity, GravityTime);
 
        // See if we need to sub-step to exactly reach the apex. This is important for avoiding "cutting off the top" of the trajectory as framerate varies.
        static const auto CVarForceJumpPeakSubstep = IConsoleManager::Get().FindConsoleVariable(TEXT("p.ForceJumpPeakSubstep"));
        if (CVarForceJumpPeakSubstep->GetInt() != 0 && OldVelocity.Z > 0.f && Velocity.Z <= 0.f && NumJumpApexAttempts < MaxJumpApexAttemptsPerSimulation)
        {
            const FVector DerivedAccel = (Velocity - OldVelocity) / timeTick;
            if (!FMath::IsNearlyZero(DerivedAccel.Z))
            {
                const float TimeToApex = -OldVelocity.Z / DerivedAccel.Z;
 
                // The time-to-apex calculation should be precise, and we want to avoid adding a substep when we are basically already at the apex from the previous iteration's work.
                const float ApexTimeMinimum = 0.0001f;
                if (TimeToApex >= ApexTimeMinimum && TimeToApex < timeTick)
                {
                    const FVector ApexVelocity = OldVelocity + DerivedAccel * TimeToApex;
                    Velocity = ApexVelocity;
                    Velocity.Z = 0.f; // Should be nearly zero anyway, but this makes apex notifications consistent.
 
                    // We only want to move the amount of time it takes to reach the apex, and refund the unused time for next iteration.
                    remainingTime += (timeTick - TimeToApex);
                    timeTick = TimeToApex;
                    Iterations--;
                    NumJumpApexAttempts++;
                }
            }
        }
 
        //UE_LOG(LogCharacterMovement, Log, TEXT("dt=(%.6f) OldLocation=(%s) OldVelocity=(%s) NewVelocity=(%s)"), timeTick, *(UpdatedComponent->GetComponentLocation()).ToString(), *OldVelocity.ToString(), *Velocity.ToString());
 
        ApplyRootMotionToVelocity(timeTick);
        //ApplyVRMotionToVelocity(timeTick);
 
        if (bNotifyApex && (Velocity.Z < 0.f))
        {
            // Just passed jump apex since now going down
            bNotifyApex = false;
            NotifyJumpApex();
        }
 
        // Compute change in position (using midpoint integration method).
        FVector Adjusted = (0.5f * (OldVelocity + Velocity) * timeTick) + (AdditionalVRInputVector );
 
        // Special handling if ending the jump force where we didn't apply gravity during the jump.
        if (bEndingJumpForce && !bApplyGravityWhileJumping)
        {
            // We had a portion of the time at constant speed then a portion with acceleration due to gravity.
            // Account for that here with a more correct change in position.
            const float NonGravityTime = FMath::Max(0.f, timeTick - GravityTime);
            Adjusted = ((OldVelocity * NonGravityTime) + (0.5f * (OldVelocity + Velocity) * GravityTime)) + (AdditionalVRInputVector );
        }
 
 
        // Move
        FHitResult Hit(1.f);
        SafeMoveUpdatedComponent(Adjusted, PawnRotation, true, Hit);
 
        if (!HasValidData())
        {
            return;
        }
 
        float LastMoveTimeSlice = timeTick;
        float subTimeTickRemaining = timeTick * (1.f - Hit.Time);
 
        if (IsSwimming()) //just entered water
        {
            remainingTime += subTimeTickRemaining;
            StartSwimming(OldLocation, OldVelocity, timeTick, remainingTime, Iterations);
            return;
        }
        else if (Hit.bBlockingHit)
        {
            if (IsValidLandingSpot(UpdatedComponent->GetComponentLocation(), Hit))
            {
                remainingTime += subTimeTickRemaining;
                ProcessLanded(Hit, remainingTime, Iterations);
                return;
            }
            else
            {
                // Compute impact deflection based on final velocity, not integration step.
                // This allows us to compute a new velocity from the deflected vector, and ensures the full gravity effect is included in the slide result.
                Adjusted = Velocity * timeTick;
 
                // See if we can convert a normally invalid landing spot (based on the hit result) to a usable one.
                if (!Hit.bStartPenetrating && ShouldCheckForValidLandingSpot(timeTick, Adjusted, Hit))
                {
                    const FVector PawnLocation = UpdatedComponent->GetComponentLocation();
                    FFindFloorResult FloorResult;
                    FindFloor(PawnLocation, FloorResult, false);
                    if (FloorResult.IsWalkableFloor() && IsValidLandingSpot(PawnLocation, FloorResult.HitResult))
                    {
                        remainingTime += subTimeTickRemaining;
                        ProcessLanded(FloorResult.HitResult, remainingTime, Iterations);
                        return;
                    }
                }
 
                HandleImpact(Hit, LastMoveTimeSlice, Adjusted);
 
                // If we've changed physics mode, abort.
                if (!HasValidData() || !IsFalling())
                {
                    return;
                }
 
                // Limit air control based on what we hit.
                // We moved to the impact point using air control, but may want to deflect from there based on a limited air control acceleration.
                FVector VelocityNoAirControl = OldVelocity;
                FVector AirControlAccel = Acceleration;
                if (bHasLimitedAirControl)
                {
                    // Compute VelocityNoAirControl
                    {
                        // Find velocity *without* acceleration.
                        TGuardValue<FVector> RestoreAcceleration(Acceleration, FVector::ZeroVector);
                        TGuardValue<FVector> RestoreVelocity(Velocity, OldVelocity);
                        Velocity.Z = 0.f;
                        CalcVelocity(timeTick, FallingLateralFriction, false, MaxDecel);
                        VelocityNoAirControl = FVector(Velocity.X, Velocity.Y, OldVelocity.Z);
                        VelocityNoAirControl = NewFallVelocity(VelocityNoAirControl, Gravity, GravityTime);
                    }
 
 
                    const bool bCheckLandingSpot = false; // we already checked above.
                    AirControlAccel = (Velocity - VelocityNoAirControl) / timeTick;
                    const FVector AirControlDeltaV = LimitAirControl(LastMoveTimeSlice, AirControlAccel, Hit, bCheckLandingSpot) * LastMoveTimeSlice;
                    Adjusted = (VelocityNoAirControl + AirControlDeltaV) * LastMoveTimeSlice;
                }
 
                const FVector OldHitNormal = Hit.Normal;
                const FVector OldHitImpactNormal = Hit.ImpactNormal;
                FVector Delta = ComputeSlideVector(Adjusted, 1.f - Hit.Time, OldHitNormal, Hit);
 
                // Compute velocity after deflection (only gravity component for RootMotion)
                if (subTimeTickRemaining > KINDA_SMALL_NUMBER && !bJustTeleported)
                {
                    const FVector NewVelocity = (Delta / subTimeTickRemaining);
                    Velocity = HasAnimRootMotion() || CurrentRootMotion.HasOverrideVelocityWithIgnoreZAccumulate() ? FVector(Velocity.X, Velocity.Y, NewVelocity.Z) : NewVelocity;
                }
 
                if (subTimeTickRemaining > KINDA_SMALL_NUMBER && (Delta | Adjusted) > 0.f)
                {
                    // Move in deflected direction.
                    SafeMoveUpdatedComponent(Delta, PawnRotation, true, Hit);
 
                    if (Hit.bBlockingHit)
                    {
                        // hit second wall
                        LastMoveTimeSlice = subTimeTickRemaining;
                        subTimeTickRemaining = subTimeTickRemaining * (1.f - Hit.Time);
 
                        if (IsValidLandingSpot(UpdatedComponent->GetComponentLocation(), Hit))
                        {
                            remainingTime += subTimeTickRemaining;
                            ProcessLanded(Hit, remainingTime, Iterations);
                            return;
                        }
 
                        HandleImpact(Hit, LastMoveTimeSlice, Delta);
 
                        // If we've changed physics mode, abort.
                        if (!HasValidData() || !IsFalling())
                        {
                            return;
                        }
 
                        // Act as if there was no air control on the last move when computing new deflection.
                        if (bHasLimitedAirControl && Hit.Normal.Z > VERTICAL_SLOPE_NORMAL_ZZ)
                        {
                            const FVector LastMoveNoAirControl = VelocityNoAirControl * LastMoveTimeSlice;
                            Delta = ComputeSlideVector(LastMoveNoAirControl, 1.f, OldHitNormal, Hit);
                        }
 
                        FVector PreTwoWallDelta = Delta;
                        TwoWallAdjust(Delta, Hit, OldHitNormal);
 
                        // Limit air control, but allow a slide along the second wall.
                        if (bHasLimitedAirControl)
                        {
                            const bool bCheckLandingSpot = false; // we already checked above.
                            const FVector AirControlDeltaV = LimitAirControl(subTimeTickRemaining, AirControlAccel, Hit, bCheckLandingSpot) * subTimeTickRemaining;
 
                            // Only allow if not back in to first wall
                            if (FVector::DotProduct(AirControlDeltaV, OldHitNormal) > 0.f)
                            {
                                Delta += (AirControlDeltaV * subTimeTickRemaining);
                            }
                        }
 
                        // Compute velocity after deflection (only gravity component for RootMotion)
                        if (subTimeTickRemaining > KINDA_SMALL_NUMBER && !bJustTeleported)
                        {
                            const FVector NewVelocity = (Delta / subTimeTickRemaining);
                            Velocity = HasAnimRootMotion() || CurrentRootMotion.HasOverrideVelocityWithIgnoreZAccumulate() ? FVector(Velocity.X, Velocity.Y, NewVelocity.Z) : NewVelocity;
                        }
 
                        // bDitch=true means that pawn is straddling two slopes, neither of which he can stand on
                        bool bDitch = ((OldHitImpactNormal.Z > 0.f) && (Hit.ImpactNormal.Z > 0.f) && (FMath::Abs(Delta.Z) <= KINDA_SMALL_NUMBER) && ((Hit.ImpactNormal | OldHitImpactNormal) < 0.f));
                        SafeMoveUpdatedComponent(Delta, PawnRotation, true, Hit);
                        if (Hit.Time == 0.f)
                        {
                            // if we are stuck then try to side step
                            FVector SideDelta = (OldHitNormal + Hit.ImpactNormal).GetSafeNormal2D();
                            if (SideDelta.IsNearlyZero())
                            {
                                SideDelta = FVector(OldHitNormal.Y, -OldHitNormal.X, 0).GetSafeNormal();
                            }
                            SafeMoveUpdatedComponent(SideDelta, PawnRotation, true, Hit);
                        }
 
                        if (bDitch || IsValidLandingSpot(UpdatedComponent->GetComponentLocation(), Hit) || Hit.Time == 0.f)
                        {
                            remainingTime = 0.f;
                            ProcessLanded(Hit, remainingTime, Iterations);
                            return;
                        }
                        else if (GetPerchRadiusThreshold() > 0.f && Hit.Time == 1.f && OldHitImpactNormal.Z >= GetWalkableFloorZ())
                        {
                            // We might be in a virtual 'ditch' within our perch radius. This is rare.
                            const FVector PawnLocation = UpdatedComponent->GetComponentLocation();
                            const float ZMovedDist = FMath::Abs(PawnLocation.Z - OldLocation.Z);
                            const float MovedDist2DSq = (PawnLocation - OldLocation).SizeSquared2D();
                            if (ZMovedDist <= 0.2f * timeTick && MovedDist2DSq <= 4.f * timeTick)
                            {
                                Velocity.X += 0.25f * GetMaxSpeed() * (RandomStream.FRand() - 0.5f);
                                Velocity.Y += 0.25f * GetMaxSpeed() * (RandomStream.FRand() - 0.5f);
                                Velocity.Z = FMath::Max<float>(JumpZVelocity * 0.25f, 1.f);
                                Delta = Velocity * timeTick;
                                SafeMoveUpdatedComponent(Delta, PawnRotation, true, Hit);
                            }
                        }
                    }
                }
            }
        }
 
        if (Velocity.SizeSquared2D() <= KINDA_SMALL_NUMBER * 10.f)
        {
            Velocity.X = 0.f;
            Velocity.Y = 0.f;
        }
    }
}
 
void UVRSimpleCharacterMovementComponent::PhysWalking(float deltaTime, int32 Iterations)
{
//  SCOPE_CYCLE_COUNTER(STAT_CharPhysWalking);
 
    if (deltaTime < MIN_TICK_TIME)
    {
        return;
    }
 
    if (!CharacterOwner || (!CharacterOwner->Controller && !bRunPhysicsWithNoController && !HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && (CharacterOwner->GetLocalRole() != ROLE_SimulatedProxy)))
    {
        Acceleration = FVector::ZeroVector;
        Velocity = FVector::ZeroVector;
        return;
    }
 
    if (!UpdatedComponent->IsQueryCollisionEnabled())
    {
        SetMovementMode(MOVE_Walking);
        return;
    }
 
    devCodeSimple(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysWalking: Velocity contains NaN before Iteration (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
 
    bJustTeleported = false;
    bool bCheckedFall = false;
    bool bTriedLedgeMove = false;
    float remainingTime = deltaTime;
 
    //bool bHasLastAdditiveVelocity = false;
    //FVector LastPreAdditiveVRVelocity;
    // Perform the move
    while ((remainingTime >= MIN_TICK_TIME) && (Iterations < MaxSimulationIterations) && CharacterOwner && (CharacterOwner->Controller || bRunPhysicsWithNoController || HasAnimRootMotion() || CurrentRootMotion.HasOverrideVelocity() || (CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy)))
    {
        Iterations++;
        bJustTeleported = false;
        const float timeTick = GetSimulationTimeStep(remainingTime, Iterations);
        remainingTime -= timeTick;
 
        // Save current values
        UPrimitiveComponent * const OldBase = GetMovementBase();
        const FVector PreviousBaseLocation = (OldBase != NULL) ? OldBase->GetComponentLocation() : FVector::ZeroVector;
        const FVector OldLocation = UpdatedComponent->GetComponentLocation();
        const FFindFloorResult OldFloor = CurrentFloor;
 
        RestorePreAdditiveRootMotionVelocity();
        RestorePreAdditiveVRMotionVelocity();
 
        // Ensure velocity is horizontal.
        MaintainHorizontalGroundVelocity();
        const FVector OldVelocity = Velocity;
        Acceleration.Z = 0.f;
 
        // Apply acceleration
        if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
        {
            CalcVelocity(timeTick, GroundFriction, false, BrakingDecelerationWalking);
            devCodeSimple(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysWalking: Velocity contains NaN after CalcVelocity (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
        }
 
        ApplyRootMotionToVelocity(timeTick);
        ApplyVRMotionToVelocity(deltaTime);//timeTick);
 
        devCodeSimple(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysWalking: Velocity contains NaN after Root Motion application (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
 
        //LastPreAdditiveVRVelocity = Velocity;
        //bHasLastAdditiveVelocity = true;
        //Velocity += AdditionalVRInputVector / timeTick;
 
        if (IsFalling())
        {
            // Root motion could have put us into Falling.
            // No movement has taken place this movement tick so we pass on full time/past iteration count
            StartNewPhysics(remainingTime + timeTick, Iterations - 1);
            return;
        }
 
 
        // Compute move parameters
        const FVector MoveVelocity = Velocity;
        const FVector Delta = (timeTick * MoveVelocity);// +AdditionalVRInputVector;
 
        const bool bZeroDelta = Delta.IsNearlyZero();
        FStepDownResult StepDownResult;
 
 
        if (bZeroDelta)
        {
            remainingTime = 0.f;
        }
        else
        {
            // try to move forward
            MoveAlongFloor(MoveVelocity, timeTick, &StepDownResult);
 
            if (IsFalling())
            {
                // pawn decided to jump up
                const float DesiredDist = Delta.Size();
                if (DesiredDist > KINDA_SMALL_NUMBER)
                {
                    const float ActualDist = (UpdatedComponent->GetComponentLocation() - OldLocation).Size2D();
                    remainingTime += timeTick * (1.f - FMath::Min(1.f, ActualDist / DesiredDist));
                }
                StartNewPhysics(remainingTime, Iterations);
                return;
            }
            else if (IsSwimming()) //just entered water
            {
                StartSwimming(OldLocation, OldVelocity, timeTick, remainingTime, Iterations);
                return;
            }
        }
 
        // Update floor.
        // StepUp might have already done it for us.
        if (StepDownResult.bComputedFloor)
        {
            CurrentFloor = StepDownResult.FloorResult;
        }
        else
        {
            FindFloor(UpdatedComponent->GetComponentLocation(), CurrentFloor, bZeroDelta, NULL);
        }
 
        // check for ledges here
        const bool bCheckLedges = !CanWalkOffLedges();
        if (bCheckLedges && !CurrentFloor.IsWalkableFloor())
        {
            // calculate possible alternate movement
            const FVector GravDir = FVector(0.f, 0.f, -1.f);
            const FVector NewDelta = bTriedLedgeMove ? FVector::ZeroVector : GetLedgeMove(OldLocation, Delta, GravDir);
            if (!NewDelta.IsZero())
            {
                // first revert this move
                RevertMove(OldLocation, OldBase, PreviousBaseLocation, OldFloor, false);
 
                // avoid repeated ledge moves if the first one fails
                bTriedLedgeMove = true;
 
                // Try new movement direction
                Velocity = NewDelta / timeTick;
                remainingTime += timeTick;
                continue;
            }
            else
            {
                // see if it is OK to jump
                // @todo collision : only thing that can be problem is that oldbase has world collision on
                bool bMustJump = bZeroDelta || (OldBase == NULL || (!OldBase->IsQueryCollisionEnabled() && MovementBaseUtility::IsDynamicBase(OldBase)));
                if ((bMustJump || !bCheckedFall) && CheckFall(OldFloor, CurrentFloor.HitResult, Delta, OldLocation, remainingTime, timeTick, Iterations, bMustJump))
                {
                    return;
                }
                bCheckedFall = true;
 
                // revert this move
                RevertMove(OldLocation, OldBase, PreviousBaseLocation, OldFloor, true);
                remainingTime = 0.f;
                break;
            }
        }
        else
        {
            // Validate the floor check
            if (CurrentFloor.IsWalkableFloor())
            {
                if (ShouldCatchAir(OldFloor, CurrentFloor))
                {
                    HandleWalkingOffLedge(OldFloor.HitResult.ImpactNormal, OldFloor.HitResult.Normal, OldLocation, timeTick);
                    if (IsMovingOnGround())
                    {
                        // If still walking, then fall. If not, assume the user set a different mode they want to keep.
                        StartFalling(Iterations, remainingTime, timeTick, Delta, OldLocation);
                    }
                    return;
                }
 
                AdjustFloorHeight();
                SetBase(CurrentFloor.HitResult.Component.Get(), CurrentFloor.HitResult.BoneName);
            }
            else if (CurrentFloor.HitResult.bStartPenetrating && remainingTime <= 0.f)
            {
                // The floor check failed because it started in penetration
                // We do not want to try to move downward because the downward sweep failed, rather we'd like to try to pop out of the floor.
                FHitResult Hit(CurrentFloor.HitResult);
                Hit.TraceEnd = Hit.TraceStart + FVector(0.f, 0.f, MAX_FLOOR_DIST);
                const FVector RequestedAdjustment = GetPenetrationAdjustment(Hit);
                ResolvePenetration(RequestedAdjustment, Hit, UpdatedComponent->GetComponentQuat());
                bForceNextFloorCheck = true;
            }
 
            // check if just entered water
            if (IsSwimming())
            {
                StartSwimming(OldLocation, Velocity, timeTick, remainingTime, Iterations);
                return;
            }
 
            // See if we need to start falling.
            if (!CurrentFloor.IsWalkableFloor() && !CurrentFloor.HitResult.bStartPenetrating)
            {
                const bool bMustJump = bJustTeleported || bZeroDelta || (OldBase == NULL || (!OldBase->IsQueryCollisionEnabled() && MovementBaseUtility::IsDynamicBase(OldBase)));
                if ((bMustJump || !bCheckedFall) && CheckFall(OldFloor, CurrentFloor.HitResult, Delta, OldLocation, remainingTime, timeTick, Iterations, bMustJump))
                {
                    return;
                }
                bCheckedFall = true;
            }
        }
 
 
        // Allow overlap events and such to change physics state and velocity
        if (IsMovingOnGround())
        {
            // Make velocity reflect actual move
            if (!bJustTeleported && !HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && timeTick >= MIN_TICK_TIME)
            {
                // TODO-RootMotionSource: Allow this to happen during partial override Velocity, but only set allowed axes?
                Velocity = (UpdatedComponent->GetComponentLocation() - OldLocation) / timeTick;
                MaintainHorizontalGroundVelocity();
            }
        }
 
        // If we didn't move at all this iteration then abort (since future iterations will also be stuck).
        if (UpdatedComponent->GetComponentLocation() == OldLocation)
        {
            remainingTime = 0.f;
            break;
        }
    }
 
    if (IsMovingOnGround())
    {
        MaintainHorizontalGroundVelocity();
    }
}
 
 
void UVRSimpleCharacterMovementComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
    if (!bSkipHMDChecks)
    {
        if (CharacterOwner->IsLocallyControlled())
        {
            FQuat curRot;
            bool bWasHeadset = false;
 
            if (GEngine->XRSystem.IsValid() && GEngine->XRSystem->IsHeadTrackingAllowedForWorld(*GetWorld()))
            {
                bWasHeadset = true;
 
                if (GEngine->XRSystem->GetCurrentPose(IXRTrackingSystem::HMDDeviceId, curRot, curCameraLoc))
                {
                    curCameraRot = curRot.Rotator();
                }
                else
                {
                    curCameraLoc = lastCameraLoc;
                    curCameraRot = lastCameraRot;
                }
            }
            else if (VRCameraComponent)
            {
                FVector curRelLoc = VRCameraComponent->GetRelativeLocation();
                curCameraLoc = curRelLoc;
                curCameraRot = VRCameraComponent->GetRelativeRotation();
                VRCameraComponent->SetRelativeLocation(FVector(0, 0, curRelLoc.Z));
            }
 
            if (!bIsFirstTick)
            {
                FVector DifferenceFromLastFrame = (curCameraLoc - lastCameraLoc);
 
                // Can adjust the relative tolerances to remove jitter and some update processing
                if (!DifferenceFromLastFrame.IsNearlyZero(0.001f) /*|| !(curCameraRot - lastCameraRot).IsNearlyZero(0.001f)*/)
                {
                    if (VRRootCapsule)
                    {
                        DifferenceFromLastFrame *= VRRootCapsule->GetComponentScale(); // Scale up with character
                        AdditionalVRInputVector = VRRootCapsule->GetComponentRotation().RotateVector(DifferenceFromLastFrame); // Apply over a second
                        AdditionalVRInputVector.Z = 0.0f; // Don't use the Z value anyway, and lets me repurpose it for the CapsuleHalfHeight
                    }
                }
                else
                {
                    AdditionalVRInputVector = FVector::ZeroVector;
                }
            }
            else
                bIsFirstTick = false;
 
            if (bWasHeadset)
            {
                lastCameraLoc = curCameraLoc;
                lastCameraRot = curCameraRot;
            }
            else
                lastCameraLoc = FVector::ZeroVector; // Technically this would be incorrect for Z, but we don't use Z anyway
        }
 
        Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
 
        if (AVRSimpleCharacter * owningChar = Cast<AVRSimpleCharacter>(GetOwner()))
        {
            if (VRRootCapsule)
                owningChar->VRSceneComponent->SetRelativeLocation(FVector(0, 0, -VRRootCapsule->GetUnscaledCapsuleHalfHeight()));
 
            owningChar->GenerateOffsetToWorld();
        }
    }
    else
        Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}
 
void UVRSimpleCharacterMovementComponent::SetUpdatedComponent(USceneComponent* NewUpdatedComponent)
{
    Super::SetUpdatedComponent(NewUpdatedComponent);
 
    if (UpdatedComponent)
    {
        // Fill the VRRootCapsule if we can
        VRRootCapsule = Cast<UCapsuleComponent>(UpdatedComponent);
 
        if (AVRSimpleCharacter * simpleChar = Cast<AVRSimpleCharacter>(GetOwner()))
        {
            VRCameraComponent = Cast<UCameraComponent>(simpleChar->VRReplicatedCamera);
        }
 
        // Stop the tick forcing
        //UpdatedComponent->PrimaryComponentTick.RemovePrerequisite(this, PrimaryComponentTick);
 
        // Start forcing the root to tick before this, the actor tick will still tick after the movement component
        // We want the root component to tick first because it is setting its offset location based off of tick
        //this->PrimaryComponentTick.AddPrerequisite(UpdatedComponent, UpdatedComponent->PrimaryComponentTick);
    }
}
 
 
void UVRSimpleCharacterMovementComponent::ServerMove_PerformMovement(const FCharacterNetworkMoveData& MoveData)
{
    QUICK_SCOPE_CYCLE_COUNTER(VRCharacterMovementServerMove_PerformMovement);
    //SCOPE_CYCLE_COUNTER(STAT_VRCharacterMovementServerMove);
    //CSV_SCOPED_TIMING_STAT(CharacterMovement, CharacterMovementServerMove);
 
    if (!HasValidData() || !IsActive())
    {
        return;
    }
 
    bool bAutoAcceptPacket = false;
    FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
    check(ServerData);
 
    if (MovementMode == MOVE_Custom && CustomMovementMode == (uint8)EVRCustomMovementMode::VRMOVE_Seated)
    {
        return;
    }
    else if (bJustUnseated)
    {
        ServerData->CurrentClientTimeStamp = MoveData.TimeStamp;
        bAutoAcceptPacket = true;
        bJustUnseated = false;
    }
 
    const float ClientTimeStamp = MoveData.TimeStamp;
    FVector_NetQuantize10 ClientAccel = MoveData.Acceleration;
    const uint8 ClientMoveFlags = MoveData.CompressedMoveFlags;
    const FRotator ClientControlRotation = MoveData.ControlRotation;
 
    if (!bAutoAcceptPacket && !VerifyClientTimeStamp(ClientTimeStamp, *ServerData))
    {
        const float ServerTimeStamp = ServerData->CurrentClientTimeStamp;
        // This is more severe if the timestamp has a large discrepancy and hasn't been recently reset.
        static const auto CVarNetServerMoveTimestampExpiredWarningThreshold = IConsoleManager::Get().FindConsoleVariable(TEXT("net.NetServerMoveTimestampExpiredWarningThreshold"));
        if (ServerTimeStamp > 1.0f && FMath::Abs(ServerTimeStamp - ClientTimeStamp) > CVarNetServerMoveTimestampExpiredWarningThreshold->GetFloat())
        {
            UE_LOG(LogNetPlayerMovement, Warning, TEXT("ServerMove: TimeStamp expired: %f, CurrentTimeStamp: %f, Character: %s"), ClientTimeStamp, ServerTimeStamp, *GetNameSafe(CharacterOwner));
        }
        else
        {
            UE_LOG(LogNetPlayerMovement, Log, TEXT("ServerMove: TimeStamp expired: %f, CurrentTimeStamp: %f, Character: %s"), ClientTimeStamp, ServerTimeStamp, *GetNameSafe(CharacterOwner));
        }
        return;
    }
 
 
    // Convert to our stored move data array
    const FVRCharacterNetworkMoveData* MoveDataVR = (const FVRCharacterNetworkMoveData*)&MoveData;
 
    // Scope these, they nest with Outer references so it should work fine, this keeps the update rotation and move autonomous from double updating the char
    FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
 
    bool bServerReadyForClient = true;
    APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
    if (PC)
    {
        bServerReadyForClient = PC->NotifyServerReceivedClientData(CharacterOwner, ClientTimeStamp);
        if (!bServerReadyForClient)
        {
            ClientAccel = FVector::ZeroVector;
        }
    }
 
    const UWorld* MyWorld = GetWorld();
    const float DeltaTime = ServerData->GetServerMoveDeltaTime(ClientTimeStamp, CharacterOwner->GetActorTimeDilation(*MyWorld));
 
    if (DeltaTime > 0.f)
    {
        ServerData->CurrentClientTimeStamp = ClientTimeStamp;
        ServerData->ServerAccumulatedClientTimeStamp += DeltaTime;
        ServerData->ServerTimeStamp = MyWorld->GetTimeSeconds();
        ServerData->ServerTimeStampLastServerMove = ServerData->ServerTimeStamp;
 
        if (PC)
        {
            PC->SetControlRotation(ClientControlRotation);
        }
 
        if (!bServerReadyForClient)
        {
            return;
        }
 
        // Perform actual movement
        if ((MyWorld->GetWorldSettings()->GetPauserPlayerState() == NULL))
        {
            if (PC)
            {
                PC->UpdateRotation(DeltaTime);
            }
 
            if (!MoveDataVR->ConditionalMoveReps.RequestedVelocity.IsZero())
            {
                RequestedVelocity = MoveDataVR->ConditionalMoveReps.RequestedVelocity;
                bHasRequestedVelocity = true;
            }
 
            CustomVRInputVector = MoveDataVR->ConditionalMoveReps.CustomVRInputVector;
            MoveActionArray = MoveDataVR->ConditionalMoveReps.MoveActionArray;
            AdditionalVRInputVector = MoveDataVR->LFDiff;
            VRReplicatedMovementMode = MoveDataVR->ReplicatedMovementMode;
 
            if (BaseVRCharacterOwner)
            {
                if (BaseVRCharacterOwner->VRReplicateCapsuleHeight && MoveDataVR->LFDiff.Z > 0.0f && !FMath::IsNearlyEqual(MoveDataVR->LFDiff.Z, VRRootCapsule->GetUnscaledCapsuleHalfHeight()))
                {
                    BaseVRCharacterOwner->SetCharacterHalfHeightVR(MoveDataVR->LFDiff.Z, false);
                    //  BaseChar->ReplicatedCapsuleHeight.CapsuleHeight = LFDiff.Z;
                        //VRRootCapsule->SetCapsuleHalfHeight(LFDiff.Z, false);
                }
            }
 
            MoveAutonomous(ClientTimeStamp, DeltaTime, ClientMoveFlags, ClientAccel);
            bHasRequestedVelocity = false;
        }
 
        UE_CLOG(CharacterOwner && UpdatedComponent, LogSimpleCharacterMovement, VeryVerbose, TEXT("ServerMove Time %f Acceleration %s Velocity %s Position %s Rotation %s DeltaTime %f Mode %s MovementBase %s.%s (Dynamic:%d)"),
            ClientTimeStamp, *ClientAccel.ToString(), *Velocity.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *UpdatedComponent->GetComponentRotation().ToCompactString(), DeltaTime, *GetMovementName(),
            *GetNameSafe(GetMovementBase()), *CharacterOwner->GetBasedMovement().BoneName.ToString(), MovementBaseUtility::IsDynamicBase(GetMovementBase()) ? 1 : 0);
    }
 
    // #TODO: Handle this better at some point? Client also denies it later on during correction (ApplyNetworkMovementMode in base movement)
    // Pre handling the errors, lets avoid rolling back to/from custom movement modes, they tend to be scripted and this can screw things up
    const uint8 CurrentPackedMovementMode = PackNetworkMovementMode();
    if (CurrentPackedMovementMode != MoveData.MovementMode)
    {
        TEnumAsByte<EMovementMode> NetMovementMode(MOVE_None);
        TEnumAsByte<EMovementMode> NetGroundMode(MOVE_None);
        uint8 NetCustomMode(0);
        UnpackNetworkMovementMode(MoveData.MovementMode, NetMovementMode, NetCustomMode, NetGroundMode);
 
        // Custom movement modes aren't going to be rolled back as they are client authed for our pawns
        if (NetMovementMode == EMovementMode::MOVE_Custom || MovementMode == EMovementMode::MOVE_Custom)
        {
            if (NetCustomMode == (uint8)EVRCustomMovementMode::VRMOVE_Climbing || CustomMovementMode == (uint8)EVRCustomMovementMode::VRMOVE_Climbing)
                SetMovementMode(NetMovementMode, NetCustomMode);
        }
    }
 
    // Validate move only after old and first dual portion, after all moves are completed.
    if (MoveData.NetworkMoveType == FCharacterNetworkMoveData::ENetworkMoveType::NewMove)
    {
        ServerMoveHandleClientError(ClientTimeStamp, DeltaTime, ClientAccel, MoveData.Location, MoveData.MovementBase, MoveData.MovementBaseBoneName, MoveData.MovementMode);
        //ServerMoveHandleClientError(ClientTimeStamp, DeltaTime, ClientAccel, MoveData.Location, MoveData.MovementBase, MoveData.MovementBaseBoneName, MoveData.MovementMode);
    }
}
 
void UVRSimpleCharacterMovementComponent::ReplicateMoveToServer(float DeltaTime, const FVector& NewAcceleration)
{
    SCOPE_CYCLE_COUNTER(STAT_CharacterMovementReplicateMoveToServerVRSimple);
    check(CharacterOwner != NULL);
 
    // Can only start sending moves if our controllers are synced up over the network, otherwise we flood the reliable buffer.
    APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
    if (PC && PC->AcknowledgedPawn != CharacterOwner)
    {
        return;
    }
 
    // Bail out if our character's controller doesn't have a Player. This may be the case when the local player
    // has switched to another controller, such as a debug camera controller.
    if (PC && PC->Player == nullptr)
    {
        return;
    }
 
    FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
    if (!ClientData)
    {
        return;
    }
 
    // Update our delta time for physics simulation.
    DeltaTime = ClientData->UpdateTimeStampAndDeltaTime(DeltaTime, *CharacterOwner, *this);
 
    // Find the oldest (unacknowledged) important move (OldMove).
    // Don't include the last move because it may be combined with the next new move.
    // A saved move is interesting if it differs significantly from the last acknowledged move
    FSavedMovePtr OldMove = NULL;
    if (ClientData->LastAckedMove.IsValid())
    {
        const int32 NumSavedMoves = ClientData->SavedMoves.Num();
        for (int32 i = 0; i < NumSavedMoves - 1; i++)
        {
            const FSavedMovePtr& CurrentMove = ClientData->SavedMoves[i];
            if (CurrentMove->IsImportantMove(ClientData->LastAckedMove))
            {
                OldMove = CurrentMove;
                break;
            }
        }
    }
 
    // Get a SavedMove object to store the movement in.
    FSavedMovePtr NewMovePtr = ClientData->CreateSavedMove();
    FSavedMove_Character* const NewMove = NewMovePtr.Get();
    if (NewMove == nullptr)
    {
        return;
    }
 
    NewMove->SetMoveFor(CharacterOwner, DeltaTime, NewAcceleration, *ClientData);
    const UWorld* MyWorld = GetWorld();
 
    // see if the two moves could be combined
    // do not combine moves which have different TimeStamps (before and after reset).
    if (const FSavedMove_Character* PendingMove = ClientData->PendingMove.Get())
    {
        if (PendingMove->CanCombineWith(NewMovePtr, CharacterOwner, ClientData->MaxMoveDeltaTime * CharacterOwner->GetActorTimeDilation(*MyWorld)))
        {
            //SCOPE_CYCLE_COUNTER(STAT_CharacterMovementCombineNetMove);
 
            // Only combine and move back to the start location if we don't move back in to a spot that would make us collide with something new.
            const FVector OldStartLocation = PendingMove->GetRevertedLocation();
            const bool bAttachedToObject = (NewMovePtr->StartAttachParent != nullptr);
            if (bAttachedToObject || !OverlapTest(OldStartLocation, PendingMove->StartRotation.Quaternion(), UpdatedComponent->GetCollisionObjectType(), GetPawnCapsuleCollisionShape(SHRINK_None), CharacterOwner))
            {
                // Avoid updating Mesh bones to physics during the teleport back, since PerformMovement() will update it right away anyway below.
                // Note: this must be before the FScopedMovementUpdate below, since that scope is what actually moves the character and mesh.
                AVRBaseCharacter * BaseCharacter = Cast<AVRBaseCharacter>(CharacterOwner);
                FScopedMeshBoneUpdateOverrideVR ScopedNoMeshBoneUpdate(CharacterOwner->GetMesh(), EKinematicBonesUpdateToPhysics::SkipAllBones);
 
                // Accumulate multiple transform updates until scope ends.
                FScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, EScopedUpdate::DeferredUpdates);
                UE_LOG(LogSimpleCharacterMovement, VeryVerbose, TEXT("CombineMove: add delta %f + %f and revert from %f %f to %f %f"), DeltaTime, ClientData->PendingMove->DeltaTime, UpdatedComponent->GetComponentLocation().X, UpdatedComponent->GetComponentLocation().Y, OldStartLocation.X, OldStartLocation.Y);
 
                NewMove->CombineWith(PendingMove, CharacterOwner, PC, OldStartLocation);
 
                if (PC)
                {
                    // We reverted position to that at the start of the pending move (above), however some code paths expect rotation to be set correctly
                    // before character movement occurs (via FaceRotation), so try that now. The bOrientRotationToMovement path happens later as part of PerformMovement() and PhysicsRotation().
                    CharacterOwner->FaceRotation(PC->GetControlRotation(), NewMove->DeltaTime);
                }
 
                SaveBaseLocation();
                NewMove->SetInitialPosition(CharacterOwner);
 
                // Remove pending move from move list. It would have to be the last move on the list.
                if (ClientData->SavedMoves.Num() > 0 && ClientData->SavedMoves.Last() == ClientData->PendingMove)
                {
                    const bool bAllowShrinking = false;
                    ClientData->SavedMoves.Pop(bAllowShrinking);
                }
                ClientData->FreeMove(ClientData->PendingMove);
                ClientData->PendingMove = nullptr;
                PendingMove = nullptr; // Avoid dangling reference, it's deleted above.
            }
            else
            {
                UE_LOG(LogSimpleCharacterMovement, Verbose, TEXT("Not combining move [would collide at start location]"));
            }
        }
        /*else
        {
            UE_LOG(LogSimpleCharacterMovement, Verbose, TEXT("Not combining move [not allowed by CanCombineWith()]"));
        }*/
    }
 
    // Acceleration should match what we send to the server, plus any other restrictions the server also enforces (see MoveAutonomous).
    Acceleration = NewMove->Acceleration.GetClampedToMaxSize(GetMaxAcceleration());
    AnalogInputModifier = ComputeAnalogInputModifier(); // recompute since acceleration may have changed.
 
                                                        // Perform the move locally
    CharacterOwner->ClientRootMotionParams.Clear();
    CharacterOwner->SavedRootMotion.Clear();
    PerformMovement(NewMove->DeltaTime);
 
    NewMove->PostUpdate(CharacterOwner, FSavedMove_Character::PostUpdate_Record);
 
    // Add NewMove to the list
    if (CharacterOwner->IsReplicatingMovement())
    {
        check(NewMove == NewMovePtr.Get());
        ClientData->SavedMoves.Push(NewMovePtr);
 
        //const bool bCanDelayMove = (CharacterMovementCVars::NetEnableMoveCombining != 0) && CanDelaySendingMove(NewMove);
        static const auto CVarNetEnableMoveCombiningVRSimple = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetEnableMoveCombining"));
        const bool bCanDelayMove = (CVarNetEnableMoveCombiningVRSimple->GetInt() != 0) && CanDelaySendingMove(NewMovePtr);
 
        if (bCanDelayMove && ClientData->PendingMove.IsValid() == false)
        {
            // Decide whether to hold off on move
            const float NetMoveDelta = FMath::Clamp(GetClientNetSendDeltaTime(PC, ClientData, NewMovePtr), 1.f / 120.f, 1.f / 5.f);
 
            if ((MyWorld->TimeSeconds - ClientData->ClientUpdateTime) * MyWorld->GetWorldSettings()->GetEffectiveTimeDilation() < NetMoveDelta)
            {
                // Delay sending this move.
                ClientData->PendingMove = NewMovePtr;
                return;
            }
        }
 
        // Uncomment 4.16
        ClientData->ClientUpdateTime = MyWorld->TimeSeconds;
 
        UE_CLOG(CharacterOwner&& UpdatedComponent, LogSimpleCharacterMovement, VeryVerbose, TEXT("ClientMove Time %f Acceleration %s Velocity %s Position %s Rotation %s DeltaTime %f Mode %s MovementBase %s.%s (Dynamic:%d) DualMove? %d"),
            NewMove->TimeStamp, *NewMove->Acceleration.ToString(), *Velocity.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *UpdatedComponent->GetComponentRotation().ToCompactString(), NewMove->DeltaTime, *GetMovementName(),
            *GetNameSafe(NewMove->EndBase.Get()), *NewMove->EndBoneName.ToString(), MovementBaseUtility::IsDynamicBase(NewMove->EndBase.Get()) ? 1 : 0, ClientData->PendingMove.IsValid() ? 1 : 0);
 
        bool bSendServerMove = true;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
        // Testing options: Simulated packet loss to server
        const float TimeSinceLossStart = (MyWorld->RealTimeSeconds - ClientData->DebugForcedPacketLossTimerStart);
        static const auto CVarNetForceClientServerMoveLossDuration = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetForceClientServerMoveLossDuration"));
        static const auto CVarNetForceClientServerMoveLossPercent = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetForceClientServerMoveLossPercent"));
        if (ClientData->DebugForcedPacketLossTimerStart > 0.f && (TimeSinceLossStart < CVarNetForceClientServerMoveLossDuration->GetFloat()))
        {
            bSendServerMove = false;
            UE_LOG(LogSimpleCharacterMovement, Log, TEXT("Drop ServerMove, %.2f time remains"), CVarNetForceClientServerMoveLossDuration->GetFloat() - TimeSinceLossStart);
        }
        else if (CVarNetForceClientServerMoveLossPercent->GetFloat() != 0.f && (RandomStream.FRand() < CVarNetForceClientServerMoveLossPercent->GetFloat()))
        {
            bSendServerMove = false;
            ClientData->DebugForcedPacketLossTimerStart = (CVarNetForceClientServerMoveLossDuration->GetFloat() > 0) ? MyWorld->RealTimeSeconds : 0.0f;
            UE_LOG(LogSimpleCharacterMovement, Log, TEXT("Drop ServerMove, %.2f time remains"), CVarNetForceClientServerMoveLossDuration->GetFloat());
        }
        else
        {
            ClientData->DebugForcedPacketLossTimerStart = 0.f;
        }
#endif
 
        // Send move to server if this character is replicating movement
        if (bSendServerMove)
        {
            SCOPE_CYCLE_COUNTER(STAT_CharacterMovementCallServerMoveVRSimple);
            if (ShouldUsePackedMovementRPCs())
            {
                CallServerMovePacked(NewMove, ClientData->PendingMove.Get(), OldMove.Get());
            }
            /*else
            {
                CallServerMove(NewMove, OldMove.Get());
            }*/
        }
    }
 
    ClientData->PendingMove = NULL;
}
 
FNetworkPredictionData_Client* UVRSimpleCharacterMovementComponent::GetPredictionData_Client() const
{
    // Should only be called on client or listen server (for remote clients) in network games
    check(CharacterOwner != NULL);
    checkSlow(CharacterOwner->GetLocalRole() < ROLE_Authority || (CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy && GetNetMode() == NM_ListenServer));
    checkSlow(GetNetMode() == NM_Client || GetNetMode() == NM_ListenServer);
 
    if (!ClientPredictionData)
    {
        UVRSimpleCharacterMovementComponent* MutableThis = const_cast<UVRSimpleCharacterMovementComponent*>(this);
        MutableThis->ClientPredictionData = new FNetworkPredictionData_Client_VRSimpleCharacter(*this);
    }
 
    return ClientPredictionData;
}
 
FNetworkPredictionData_Server* UVRSimpleCharacterMovementComponent::GetPredictionData_Server() const
{
    // Should only be called on server in network games
    check(CharacterOwner != NULL);
    check(CharacterOwner->GetLocalRole() == ROLE_Authority);
    checkSlow(GetNetMode() < NM_Client);
 
    if (!ServerPredictionData)
    {
        UVRSimpleCharacterMovementComponent* MutableThis = const_cast<UVRSimpleCharacterMovementComponent*>(this);
        MutableThis->ServerPredictionData = new FNetworkPredictionData_Server_VRSimpleCharacter(*this);
    }
 
    return ServerPredictionData;
}
 
 
void FSavedMove_VRSimpleCharacter::Clear()
{
    //VRCapsuleLocation = FVector::ZeroVector;
    //VRCapsuleRotation = FRotator::ZeroRotator;
    LFDiff = FVector::ZeroVector;
    //CustomVRInputVector = FVector::ZeroVector;
    //RequestedVelocity = FVector::ZeroVector;
 
    FSavedMove_VRBaseCharacter::Clear();
}
 
void FSavedMove_VRSimpleCharacter::SetInitialPosition(ACharacter* C)
{
    // See if we can get the VR capsule location
    if (AVRSimpleCharacter * VRC = Cast<AVRSimpleCharacter>(C))
    {   
        if (VRC->VRMovementReference)
        {
            LFDiff = VRC->VRMovementReference->AdditionalVRInputVector;
 
            //CustomVRInputVector = VRC->VRMovementReference->CustomVRInputVector;
 
        /*  if (VRC->VRMovementReference->HasRequestedVelocity())
                RequestedVelocity = VRC->VRMovementReference->RequestedVelocity;
            else
                RequestedVelocity = FVector::ZeroVector;*/
        }
        else
        {
            LFDiff = FVector::ZeroVector;
            //CustomVRInputVector = FVector::ZeroVector;
        //  RequestedVelocity = FVector::ZeroVector;
        }
 
    }
    FSavedMove_VRBaseCharacter::SetInitialPosition(C);
}
 
void FSavedMove_VRSimpleCharacter::PrepMoveFor(ACharacter* Character)
{
    UVRSimpleCharacterMovementComponent * CharMove = Cast<UVRSimpleCharacterMovementComponent>(Character->GetCharacterMovement());
 
    // Set capsule location prior to testing movement
    // I am overriding the replicated value here when movement is made on purpose
    if (CharMove)
    {
        CharMove->AdditionalVRInputVector = FVector(LFDiff.X, LFDiff.Y, 0.0f);
    }
    
    if (AVRBaseCharacter * BaseChar = Cast<AVRBaseCharacter>(CharMove->GetCharacterOwner()))
    {
        if (BaseChar->VRReplicateCapsuleHeight && LFDiff.Z != CharMove->VRRootCapsule->GetUnscaledCapsuleHalfHeight())
        {
            BaseChar->SetCharacterHalfHeightVR(LFDiff.Z, false);
            //CharMove->VRRootCapsule->SetCapsuleHalfHeightVR(LFDiff.Z, false);
        }
    }
 
    FSavedMove_VRBaseCharacter::PrepMoveFor(Character);
}