Ditch Canned Animations: Procedural Character Movement in Unity

Let’s ditch canned animations! Procedural animation offers unparalleled realism and adaptability. This article will walk you through creating a simple, yet powerful procedural animation system in Unity, focusing on realistic foot placement and dynamic body balancing. Forget rigid, pre-baked movements; let’s make our characters react to the world.

Laying the Groundwork: Foot Placement

The first step towards realistic movement is understanding how our character interacts with the terrain. We need to determine where the feet should be placed on each step. Raycasting is your friend here.

We’ll cast rays downwards from the character’s “foot” positions. These positions can be defined as transforms attached to your character’s rig. The raycast will hit the ground, giving us the exact position and normal of the surface.

public Transform leftFoot, rightFoot;
public LayerMask groundLayer;
public float raycastDistance = 1f;

private void UpdateFootPosition(Transform foot) {
    Ray ray = new Ray(foot.position + Vector3.up * 0.5f, Vector3.down);
    RaycastHit hit;

    if (Physics.Raycast(ray, out hit, raycastDistance + 0.5f, groundLayer)) {
        foot.position = hit.point;
        foot.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal);
    }
}

void Update() {
    UpdateFootPosition(leftFoot);
    UpdateFootPosition(rightFoot);
}

Challenge: The character jitters or the feet penetrate the ground!

Solution: Ensure your groundLayer is correctly set, and experiment with the raycastDistance. More importantly, use Vector3.Lerp to smoothly transition the foot position and rotation instead of directly setting them. This dampens the effect of sudden changes in terrain.

Balancing Act: Adjusting the Body

Simply placing the feet isn’t enough. We need to adjust the character’s body to maintain balance. This is where the magic happens!

Calculate the average position and normal of the feet. Use this average normal to orient the character’s pelvis or hips. Again, use Lerp for smooth transitions.

public Transform pelvis;
public float balanceSpeed = 5f;

void UpdateBalance() {
    Vector3 averageFootPosition = (leftFoot.position + rightFoot.position) * 0.5f;
    Vector3 averageFootNormal = (leftFoot.up + rightFoot.up).normalized;

    pelvis.rotation = Quaternion.Slerp(pelvis.rotation, Quaternion.FromToRotation(Vector3.up, averageFootNormal), Time.deltaTime * balanceSpeed);

    // Adjust pelvis height based on average foot height
    float targetPelvisHeight = averageFootPosition.y + 0.8f;  // Adjust 0.8f for desired height
    pelvis.position = new Vector3(pelvis.position.x, Mathf.Lerp(pelvis.position.y, targetPelvisHeight, Time.deltaTime * balanceSpeed), pelvis.position.z);
}

void Update() {
    UpdateFootPosition(leftFoot);
    UpdateFootPosition(rightFoot);
    UpdateBalance();
}

Pitfall: The character leans too much!

Solution: Clamp the rotation angles of the pelvis. Don’t allow it to rotate beyond a certain threshold. Experiment with the balanceSpeed to fine-tune the responsiveness.

The Art of Blending: Marrying Procedural and Keyframed Animation

Procedural animation shouldn’t replace all keyframed animation. Instead, blend the two for a more natural and nuanced result. Use Animation Layers in Unity’s Animator to override specific bone transforms with our procedural calculations.

Create a new Animation Layer in your Animator, and set its blending mode to “Override.” This layer will contain our procedural animation logic. Within your script, access the Animator and set the weight of this layer.

public Animator animator;
public int proceduralLayerIndex = 1; // Assuming your new layer is at index 1

void Update() {
    UpdateFootPosition(leftFoot);
    UpdateFootPosition(rightFoot);
    UpdateBalance();

    // Gradually blend in the procedural layer
    animator.SetLayerWeight(proceduralLayerIndex, Mathf.Lerp(animator.GetLayerWeight(proceduralLayerIndex), 1f, Time.deltaTime * 2f));
}

Common Mistake: Suddenly snapping between keyframed and procedural animation.

Solution: Use Mathf.Lerp to gradually blend the procedural animation layer in and out. Also, carefully design your keyframed animations to complement the procedural movement. For instance, use keyframes for the upper body while letting the procedural system handle the legs.

Real-World Scenarios: Beyond Flat Ground

This system shines in environments with uneven terrain. Imagine a character navigating a rocky mountain path. The procedural foot placement and body balancing ensure they adapt realistically to each step, something pre-baked animations simply can’t achieve.

Consider implementing a “step height” parameter. This allows the character to step over small obstacles procedurally, further enhancing the realism.

Optimization: Performance Matters

Procedural animation can be computationally expensive. To optimize:

• Limit Raycasts: Only raycast when necessary. For example, only raycast when the character is moving.
• Use Lower-Poly Colliders: Raycasting against complex meshes is slower. Use simpler colliders for ground detection.
• Bake Calculations: If possible, bake some of the calculations into animation curves, reducing runtime overhead.

Ultimately, procedural animation is a powerful tool for creating believable and dynamic characters. Embrace the challenge, experiment with different approaches, and you’ll be amazed at the results. Ditch the limitations of pre-baked animations and let your characters truly interact with their world!