Ledge Up

Ledge Up occurs when the player is near a ledge and presses the jump input while in the air.

It's purposely not automatic because I wanted to force the player to gain some skill in performing ledge ups which I find more rewarding to pull off than if it just happens automatically

Mechanic feel

Vertical

It makes sense in realistic scenarios if you're pulling yourself up a ledge you are first going to be met with gravity pulling down on you before you over power it and toss yourself on the ledge

Therefor a float curve defines the vertical behavior during the ledge up which gives the nice visual effect of "being pulled down by gravity before throwing yourself up onto the ledge"

Horizontal

When a ledge up occurs we pre-compute the final destination of where we can place the player, so we already have a target location.

Horizontal movement is just simply lerped by some configurable scale from the original location to target location.

Does player input conflict?

Input is disabled during ledge up

As a reminder, its a design decision I made that ledge ups cannot be cancelled.

No: During a ledge up player input is restricted, but the entire encounter takes nearly ¼ of a second, and input is returned to the player after so in the event they want to bail from the ledge up they can still hold the movement direction they desire.

Ledge Detection

Ledge detection is contained in its own component so that in the future any character would be given ledge up behavior simply by adding the component, calling LedgeUp , and the component will handle the rest.

class DEFT_API UClimbComponent : public UActorComponent
...
UClimbComponent::LedgeUp() // public function for external code to trigger

All the following checks occur within the LedgeUp function to determine if we can actually perform one.

void UClimbComponent::LedgeUp()
{
	// we're in a jump or fall state
	const bool isInAir = DeftMovementComponent->IsDeftJumping() || DeftMovementComponent->IsDeftFalling();
	if (!isInAir)
		return;

	FVector ledgeLocation;
	if (!IsLedgeReachable(ledgeLocation))
		return;

	FVector heightDistanceTraceEnd;
	if (!IsLedgeWithinHeightRange(ledgeLocation, heightDistanceTraceEnd))
		return;

	FHitResult surfaceHit;
	if (!IsLedgeSurfaceWalkable(heightDistanceTraceEnd, surfaceHit))
		return;

	if (!IsEnoughRoomOnLedge(surfaceHit, LedgeUpFinalLocation))
		return;

	LedgeUpStartLocation = DeftCharacter->GetActorLocation();

	// enter ledge up state
	LedgeUpLerpTime = 0.f;
	bIsLedgeUpActive = true;
	OnLedgeUpDelegate.Broadcast(bIsLedgeUpActive);
}

Check: In Air

If the player is in the air for any reason (either on their way UP or DOWN) a ledge up can be completed.

const bool isInAir = DeftMovementComponent->IsDeftJumping() || DeftMovementComponent->IsDeftFalling();
if (!isInAir)
	return;

Check: Something is Reachable

Check if there is something collidable in front of the player

In front of is purposeful; its a design decision not to allow ledge upds for ledges the player isn't looking at

bool UClimbComponent::IsLedgeReachable(FVector& outLedgeLocation)
{
// ... omited debugging and nullcheck early outs for character / component / world
		
	// check if 'something' is in range
	const FVector ledgeReachStart = DeftCharacter->GetActorLocation();
	const FVector ledgeReachEnd = ledgeReachStart + (DeftCharacter->GetActorForwardVector().GetSafeNormal() * LedgeReachDistance);
	
	FHitResult reachHit;
	const bool isBlockingHit = GetWorld()->SweepSingleByProfile(reachHit, ledgeReachStart, ledgeReachEnd, DeftCharacter->GetActorRotation().Quaternion(), DeftCharacter->GetCapsuleComponent()->GetCollisionProfileName(), CapsuleCollisionShape, CollisionQueryParams);
	if (isBlockingHit)
		outLedgeLocation = reachHit.Location;

	return isBlockingHit;
}

Check: Ledge Exists

Okay we know that there is something collidable in front of the player, now check that it's a ledge

What is a ledge?

an open space above a surface at least wide/ deep enough to stand on

bool UClimbComponent::IsLedgeWithinHeightRange(const FVector& aLedgeLocation, FVector& outHeightDistanceTraceEnd)
{
// ... omited debugging and nullcheck early outs for character / component / world

	// check if a "ledge" exists i.e. open space above a surface wide enough to stand on
	const FVector actorFwdNormal = DeftCharacter->GetActorForwardVector().GetSafeNormal();
	const FVector actorLocation = DeftCharacter->GetActorLocation();
	const FVector ledgeTraceStart = FVector(aLedgeLocation.X, aLedgeLocation.Y, actorLocation.Z) +		// push actor's loc to the wall
									FVector(0.f, 0.f, LedgeHeightMin) +	// raise it up our minimum acceptable ledge height
									(actorFwdNormal * CapsuleRadius);	// extend out by at least out capsul size 
	outHeightDistanceTraceEnd = ledgeTraceStart + (actorFwdNormal * LedgeWidthRequirement);

	FHitResult ledgeHeightHit;
	const bool isBlockingHit = GetWorld()->LineTraceSingleByChannel(ledgeHeightHit, ledgeTraceStart, outHeightDistanceTraceEnd, ECC_WorldStatic, CollisionQueryParams);
	if (isBlockingHit)
		outHeightDistanceTraceEnd = ledgeHeightHit.Location;
		
	return !isBlockingHit;
}

Check: Ledge Surface is Walkable

Check that there is surface we can stand on by reaching out and raycasting down to check we collide within a certain distance

Could also do a surface normal check to make sure the surface isn't angled such that you can't stand on it

bool UClimbComponent::IsLedgeSurfaceWalkable(const FVector& aHeightDistanceTraceEnd, FHitResult& outSurfaceHit)
{
// ... omited debugging and nullcheck early outs for character / component / world

	// check that it's not a drop off and/or not walkable
	const FVector surfaceTraceEnd = aHeightDistanceTraceEnd + (FVector::DownVector * LedgeHeightMin * 2.f);

	const bool isBlockingHit = GetWorld()->LineTraceSingleByChannel(outSurfaceHit, aHeightDistanceTraceEnd, surfaceTraceEnd, ECC_WorldStatic, CollisionQueryParams);

	return isBlockingHit;
}

Check: Ledge has room for player

Check that there is enough room for the players capsul component on the ledge

bool UClimbComponent::IsEnoughRoomOnLedge(const FHitResult& aSurfaceHit, FVector& outFinalDestination)
{
// ... omited debugging and nullcheck early outs for character / component / world

	outFinalDestination = FVector::ZeroVector;

	// check that there is enough space on the ledge for the player's capsule component
	const FVector widthStart = aSurfaceHit.Location								// Start at the surface collision 
		+ (FVector::UpVector * CapsuleCollisionShape.GetCapsuleHalfHeight());	// raise it by half the height of the capsule since the origin is in the middle

	const FVector widthEnd = widthStart - DeftCharacter->GetActorForwardVector().GetSafeNormal(); // making the end a very small distance _closer_ to the player because of an issue with UE you can't sweep a shape literally in the exact same location
	FHitResult ledgeWidthHit;
	FCollisionQueryParams excludeSurfaceActor;
	excludeSurfaceActor.AddIgnoredActor(DeftCharacter.Get());
	excludeSurfaceActor.AddIgnoredActor(aSurfaceHit.GetActor());

	const bool isBlockingHit = GetWorld()->SweepSingleByProfile(ledgeWidthHit, widthStart, widthEnd, DeftCharacter->GetActorRotation().Quaternion(), DeftCharacter->GetCapsuleComponent()->GetCollisionProfileName(), CapsuleCollisionShape, excludeSurfaceActor);
	outFinalDestination = isBlockingHit ? ledgeWidthHit.Location : widthStart;

	return !isBlockingHit;
}

Ledge Found

As mentioned, when the player attempts to perform a ledge up we pre-calculate everything to see if they can, and thus know where the should end up.

Once we deem that a ledge up can occur (via all the checks below) the component modifies the character's position by lerping their position according to the LedgeUpLoc and LedgeUpHeightCurve