void UMover::KinematicTrackingMove(const FVector DirectionVector, const float MoveDistance, const FQuat NewRotation, const int MaxRetraces, const float RetraceDistance, float& ActualDistanceMoved, bool& HitOccurred)
{
    float DistanceMoved = 0.0f;
    int RetracesRemaining = MaxRetraces + 2;

    TraceAndResolvePenetration(DirectionVector * MoveDistance, NewRotation, DistanceMoved, RetracesRemaining); // Perform the initial trace
    if (HitResult->bBlockingHit)
    {
        HitOccurred = true;
        const FVector WorldTargetLocation = HitResult->TraceEnd;
        FVector DirectionVectorToWorldTarget = DirectionVector;
        float DistanceToWorldTarget = MoveDistance - DistanceMoved;

        while (RetracesRemaining > 0)
        {
            const float DistanceToTarget = (HitResult->TraceEnd - HitResult->Location).Size();
            //const FVector PreviousSlideVector = NewMoveVector;

            float VelocityScale;
            const FVector SlideVector = CalculateSlideMovementVector(DirectionVectorToWorldTarget, DistanceToWorldTarget, HitResult->Normal, VelocityScale).GetSafeNormal();
            const float SlideDistanceUncapped = DistanceToWorldTarget * VelocityScale;
            const float SlideDistance = FMath::Min(SlideDistanceUncapped, RetraceDistance); // Cap the slide distance at the RetraceDistance

            TraceAndResolvePenetration(SlideVector * SlideDistance, NewRotation, DistanceMoved, RetracesRemaining); // Perform a slide

            if (HitResult->bBlockingHit) // Slide hit
            {
                DirectionVectorToWorldTarget =
                // If the slide vectors are moving in an angle >=90* and there was little movement, the trace is stuck bouncing in a corner
                //if (HitResult->Distance < SMALL_NUMBER) // && (NewMoveVector | PreviousSlideVector) > SMALL_NUMBER)
                {
                    // Break
                    //RetracesRemaining = 0;
                }
                // Otherwise, slide again
            }
            else // No hit while sliding
            {
                CurrentDirectionVector = WorldTargetLocation - HitResult->Location;
                TraceAndResolvePenetration(CurrentDirectionVector, NewRotation, DistanceMoved, RetracesRemaining); // Try to move directly to NewLocation
                CurrentDirectionVector.Normalize();
                if (!HitResult->bBlockingHit) // Reached NewLocation
                {
                    RetracesRemaining = 0;
                }
                // Otherwise, a hit. Slide again
            }
        }
    }
    ActualDistanceMoved += DistanceMoved;
}
const FVector CalculateSlideMovementVector(const FVector TraceDirection, const float TraceDistanceRemaining, const FVector HitNormal, float& VelocityScale)
{
    const float NegNewVelocityScale = TraceDirection | HitNormal;
    VelocityScale = 1.0f + NegNewVelocityScale;
    const FVector ScaledDirectionVector = TraceDirection + HitNormal * VelocityScale;
    return ScaledDirectionVector * TraceDistanceRemaining;
}