TrackingMove

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;
}