Realization of humanoid character climbing

Implementing Character Climbing in Unity

preamble

The open-world genre has also become popular in recent years, withfree climbingIt's also become a great feature of this type of game. Climbing gives players more options to explore paths and more ideas for map design. This time, let's try to make a humanoid character climb in Unity.

Note: Climbing is a part of a character's complete action system, this article puts aside other actions, and does not involve animation, only for the implementation of the climbing logic of this point.

Primary Realization

First of all, let's realize that climbing in the game no longer has much to do with the physics system. When climbing, the character actually enters a state of "levitation" and thenwallpaperMovement. A good climbing system is all about how you can get the character to move against the wall.

Maybe that said, your mind has thought of a lot of strange climbing surfaces, but in fact, any climbing surface as long as you can catch itsnormal line a surfaceIt's all a lot easier to work out:

First write an auxiliary function that projects a vector onto somethe plane to which the normal belongs(All you get is that dark blue vector):

/// <summary>
/// Get the projection of a vector into a plane.
/// </summary> /// Get the projection of a vector onto a plane.
/// <param name="vector"> The vector to project /// </param>
/// <param name="planeNormal">The normal of the plane (to be normalized)</param>
/// <returns> Normalized projection vector in the plane</returns>
public static Vector3 GetProjectOnPlane(Vector3 vector, Vector3 planeNormal)
{
    return (vector - planeNormal * (vector, planeNormal)).normalized;
}

If we can get the normals of the climbing surface, we can translate the direction of the character's motion into the direction of motion on the climbing surface:
```
var newXAxis = GetProjectOnPlane(xAxis, contactNormal);
var newZAxis = GetProjectOnPlane(zAxis, contactNormal);
```

So now the question is how to accurately obtain the normal of the climbing surface? Perhaps you would think of using ray detection, but how do you do that when it comes to inside versus outside corners:

Is it hard to switch to other shapes for collision detection? There's no need to go through all that trouble, we can just use theCharacter's own collision body contactTo Judge. For the most part, humanoid characters use theCapsule ColliderThe average normal vector is close to 45 degrees, due to the nature of the capsule's curved surface, when the normals of all the points of contact are averaged over a more "homogeneous" contact surface, e.g., when contact is made at right angles to the interior.

private void OnCollisionEnter (Collision collision)
{
    (collision); }
}
private void OnCollisionStay(Collision collision)
private void OnCollisionStay(Collision collision) {
    (collision); }
}

/// <summary>
//// Called in OnCollisionEnter and OnCollisionStay to get valid information about the collision that was touched.
/// </summary> /// Called in OnCollisionEnter and OnCollisionStay.
/// <param name="other"> The collision body in contact </param>
public void EvaluateCollision(Collision collision)
{
    int layer = ;
    for(int i = 0; i < ; ++i) // Check the type of contact and record the normals corresponding to the type
    {
        Vector3 normal = (i).normal;
        float upDot = (upAxis, normal);
        // if currently climbable, the climbing surface level is climbable, and the angle of inclination of the climbing surface does not exceed the maximum climbing angle
        if(isAllowedClimb && ((1<<layer) & climbMask) ! = 0 && upDot >= minClimbDot)
        {
            ++climbContactCnt; //count the number of contact points for subsequent averaging
            climbNormal += normal; //Accumulate the climb normals to facilitate subsequent averaging
            lastClimbNormal = normal;
        }
    }
}

/// <summary>
/// Detecting a climb and updating and normalizing the climb normal, called when the climb occurs.
/// </summary> /// Detect climbing and update, normalize climbing normals, called when climbing.
/// <returns> true for climbable, false for unclimbable</returns>
public bool CheckClimb()
{
    if(IsClimbing)
    {
        if(climbContactCnt > 1)
        {
            ();
            // If in a crack (where the normal of the surrounding climbing surfaces sums to the ground), take the last surface detected as the climbing surface
            var upDot = (upAxis, climbNormal);
            if(upDot >= minGroundDot)
            {
                climbNormal = lastClimbNormal;
            }
        }
        contactNormal = climbNormal; }
        contactNormal = climbNormal; return true; }
    }
    return false; }
}

Two points are mentioned here:

for what reason?upDot >= minClimbDotCan it be used to determine if it is more tilted?
As I mentioned in previous articles, assuming the length of the normal is 1, we can see that as the ground gets steeper, the projection of the normal in the vertical direction, i.e. its cos value, gets smaller and smaller, until the ground is completely vertical (turns into a wall), and the value becomes 0. So, by calculating the cos value of the "maximum climbable angle" beforehand, we can convert the comparison of the angles into a numerical comparison of the values. So, by calculating the cos value of the "maximum climbable angle" in advance, we can convert the angle comparison into a numerical comparison.
```
[SerializeField, Range(90, 180), Tooltip("MaxClimbAngle")]
private float maxClimbAngle = 140f;

minClimbDot = (maxClimbAngle * Mathf.Deg2Rad);
```
Why recordlastClimbNormal？
This is to prevent situations like the one below, where the average of the character contact surface normals isIf the character is unable to climb at this point, the "last normal touched" will be used as the climbing surface normal.

All of the above will be close enough for the inside corners, but the outside corners will need a little extra treatment - thesqueezesWhile climbing, apply a continuousAlong the normal to the wallThe force:

float maxClimbAcceleration = 40f;//acceleration while climbing
//Used for climbing outside corners to stay close to the wall
Velocity -= contactNormal * (0.9f * maxClimbAcceleration * );

Taking 90% of the acceleration of the climbing motion as the magnitude of this force ensures that the squeezing force won't allow the character to move. Now, the inside and outside corners of the climb will not be too much of a problem (the red is the contact surface normal):

Additional adjustments

However, it doesn't end there. We also usually keep the character facing the climbing surface at all times when climbing, which requires us to rotate the character at the right time while climbing, which isn't difficult:

public void ClimbForward() //Rotate to face the climbing wall
{
    if( != )
    {
        var forwardQ = (-climbNormal, upAxis);
         = forwardQ;
    }
}

And once that's done, then when you try to climb the following shaped faces, you'll find the character jerking and quitting the climb frequently:

Why is that? Let's analyze the process:

Characters climbing up the wall. All clear.
When the top of the character touches the upward sloping surface, the calculated normals change and the character is also rotated to face the new normals
Here's where the problem occurs, the characters areencapsulant, after rotating it might just * with the wall. And the area that touches the wall changes after rotation, the normal changes again, and once the normal changes, the character has to rotate again, and once rotated ......

It's not hard to see that the culprit is actually the capsule body (if the logic of the climb implementation doesn't change (. ・ω・.)) ! Capsule bodies will inevitably affect the contact area when rotated laterally, leading to a change in the calculated normals, which can lead to a host of problems. Unless your character is aball-shapedso that random rotations won't affect the contact area ......

Yeah! It might be worthwhile to 'morph' your character's collision body from a capsule body to a sphere while climbing only:

private void SetClimbCollider(bool isClimbing)
{
    if(isClimbing)//when you are climbing, set the height of the capsule body to 0, it will become a sphere
    {
         = 0;
         = climbColliderRadius.
         = climbColliderCenter;
    }
    else // when exiting the climb, restore the parameters to return to the original capsule body
    {
         = colliderHeight; = colliderRadius; = colliderColliderCenter; } else
         = colliderRadius.
         = colliderCenter.
    }
}

In addition to setting the capsule body height to 0, we also moderately increased the capsule body radius, as well as shifted the center offset, usually to a point where we couldCovering the upper half of the character's bodypresent situation~~Legs really don't matter when climbing~~ ：

Is everything all right? One more step to go, and it's still a matter of spinning.

A normal humanoid character's root object position is just at the center of the character's bottom, and the usual movement involved is around that point, but nowadays we want the character to be able to rotate around the center of the adjusted spherical collision body, since just rotating around the root position is likely to cause the character to lose collision contact (in the schematic, the character model has been simplified to a lollipop shape):

This is equivalent to change the root object position to the center of the ball ah, which is still a bit of trouble, after all, will interfere with the original motion logic. Unless there is any clever rotation strategy, I have an idea, certainly not the best, if you have their own ideas, you can also skip this paragraph, the code is as follows:

//Rotate around the center of the ball when climbing (the capsule body will become a sphere when climbing) to face the climbing wall
public void ClimbForward()
{
    /* General idea: first rotate around the root position to adjust the direction of the face, but the rotation point is not the center of the ball.
    But the point of rotation is not the center of the sphere.
    So we need to have the playerTransform make up that distance to get the center of the ball back to where it was before the rotation.
    This way: the ball is oriented towards the climb normal, but the center of the ball doesn't change = rotate around the center of the ball*/
    if( ! = )
    {
        var originCenter = + * ;
        var forwardQ = (-, ); var forwardQ = (-, ); var forwardQ = (-, ); var forwardQ = (-, )
         = forwardQ; var newCenter = + * ; var forwardQ
        
         += originCenter - newCenter; }
    }
}

coda

The core implementation of the climbing about these, re-emphasize that this is part of the complete action system, I realized a project from their own stripped out, it seems less complete (because the complete will involve a lot in order to match the other actions and set some variables, a bit of noise over the main body), itself is just an idea to share, the guys have more ideas can be shared out ah ~ of course, there is dissatisfaction! Of course, there is dissatisfaction can also be pointed out (. I'm just sharing my thoughts.