🦶 Lesson 1.4: Animation Events & a Character Controller (Mini-Project)

Animation Events: Calling Code at a Keyframe

Some things need to happen at an exact moment in an animation. A footstep sound should play the frame a foot touches the ground — not on a fixed timer that drifts out of sync. A sword should register a hit only during the swing's contact frames. Spawning a dust puff, releasing an arrow, enabling a hitbox: all of these are tied to a specific point in a clip.

An Animation Event solves this. It's a marker you place on a clip's timeline that, when playback reaches it, calls a method on a script attached to the same GameObject as the Animator. The animation itself decides when your code runs.

Adding an Event on the Timeline

You add events in the Animation window (Window ▸ Animation ▸ Animation) — the clip-authoring window from Lesson 1.1, not the Animator. Select the animated object, pick the clip, scrub the playhead to the frame you want (say, the exact frame a foot plants), and click the Add Event button (the little marker icon) on the timeline. Then type the method name in the Inspector.

Here's the Animation window timeline for a Walk clip with two footstep events placed where each foot lands:

Writing the Receiver Methods

The method you name in the event must be public (or at least accessible) and live on a component attached to the same GameObject as the Animator. The signature must match the argument you pass — no argument, or exactly one float, int, string, or Object. Here's a script handling both a footstep and an attack-hit event:

using UnityEngine;

// Lives on the same GameObject as the Animator.
public class AnimationEventReceiver : MonoBehaviour
{
    [SerializeField] AudioSource audioSource;
    [SerializeField] AudioClip[] footstepClips;   // a few variations
    [SerializeField] float footstepVolume = 0.6f;

    // Called by an Animation Event on the Walk/Run clips.
    // The string argument ("left"/"right") comes from the event.
    public void Footstep(string foot)
    {
        if (footstepClips.Length == 0) return;
        AudioClip clip = footstepClips[Random.Range(0, footstepClips.Length)];
        audioSource.PlayOneShot(clip, footstepVolume);
    }

    // Called by an event on the contact frame of an Attack clip.
    public void OnAttackHit()
    {
        // e.g. enable a hitbox or do a short overlap check here
        Debug.Log("Attack connects on this frame!");
    }
}

Notice how clean the responsibility split is: the animation owns the timing (when does the foot land?) and the script owns the effect (which sound plays). Re-time the clip and the footsteps follow automatically — you never touch code.

Root Motion vs. Moving in Code

There are two ways a character can actually travel across your scene, and choosing the right one is a real design decision.

• Root Motion — the animation itself moves the character. The clip's root bone contains real forward displacement, and with Apply Root Motion ticked on the Animator, the GameObject moves exactly as the animator authored it. Feet never slide; motion looks perfect. The cost is control: your code doesn't set the speed, the clip does.
• In-code movement — you move the character yourself (via a CharacterController or Rigidbody) and use the animation only for the look of moving. Full control over speed and direction, but you must match the animation's playback to your movement speed or you get foot sliding (feet skating over the ground).

For this mini-project we'll use in-code movement with a CharacterController: it's the most common approach for responsive gameplay, and it keeps the driving code explicit so you can see exactly how input becomes both movement and animation.

💡 Rule of thumb. Use root motion for cinematic, mocap-heavy, or precisely-authored movement (a boss's lunge, a climb). Use in-code movement for responsive, player-driven characters where snappy control beats perfect footfalls. Many shipping games blend both.

Mini-Project: The Character Controller

Time to assemble everything from Module 1. We'll build a script that:

1. Reads a Move (Vector2) and a Jump action from the new Input System.
2. Moves the character with a CharacterController and applies gravity.
3. Feeds the Animator's Speed float (driving the Lesson 1.3 blend tree), the Grounded bool, and the Jump trigger (the Lesson 1.2 parameters).
4. Plays a footstep sound through the Animation Event from earlier in this lesson.

Set-up before the script: on your character, add a Character Controller component and an Audio Source, confirm the Animator has the Module 1 controller assigned, and create an Input Actions asset with a Move (Value / Vector2) and a Jump (Button) action. Then attach both scripts below (the receiver from earlier plus this driver).

using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(CharacterController), typeof(Animator))]
public class PlayerCharacterController : MonoBehaviour
{
    [Header("Input (new Input System)")]
    [SerializeField] InputActionReference moveAction; // Vector2
    [SerializeField] InputActionReference jumpAction; // Button

    [Header("Movement")]
    [SerializeField] float moveSpeed = 6f;    // matches the Run threshold
    [SerializeField] float jumpHeight = 1.2f;
    [SerializeField] float gravity = -18f;
    [SerializeField] float turnSpeed = 12f;

    CharacterController controller;
    Animator animator;
    Vector3 velocity;    // vertical only; horizontal is from input

    // Cache parameter hashes (the Lesson 1.2 tip).
    static readonly int SpeedHash    = Animator.StringToHash("Speed");
    static readonly int GroundedHash = Animator.StringToHash("Grounded");
    static readonly int JumpHash     = Animator.StringToHash("Jump");

    void Awake()
    {
        controller = GetComponent<CharacterController>();
        animator   = GetComponent<Animator>();
    }

    void OnEnable()
    {
        moveAction.action.Enable();
        jumpAction.action.Enable();
        jumpAction.action.performed += OnJump;   // event callback, not polling
    }

    void OnDisable()
    {
        jumpAction.action.performed -= OnJump;
        moveAction.action.Disable();
        jumpAction.action.Disable();
    }

    void Update()
    {
        bool grounded = controller.isGrounded;
        animator.SetBool(GroundedHash, grounded);
        if (grounded && velocity.y < 0f) velocity.y = -2f; // stick to ground

        // 1) Read input and build a world-space move direction.
        Vector2 input = moveAction.action.ReadValue<Vector2>();
        Vector3 move = new Vector3(input.x, 0f, input.y);

        // 2) Rotate toward the move direction so the character faces travel.
        if (move.sqrMagnitude > 0.001f)
        {
            Quaternion target = Quaternion.LookRotation(move);
            transform.rotation = Quaternion.Slerp(
                transform.rotation, target, turnSpeed * Time.deltaTime);
        }

        // 3) Move horizontally, then apply gravity.
        controller.Move(move * moveSpeed * Time.deltaTime);
        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);

        // 4) Feed the Animator: one float drives the whole blend tree.
        float speed = input.magnitude * moveSpeed;
        animator.SetFloat(SpeedHash, speed, 0.1f, Time.deltaTime);
    }

    // Fired once per press by the Input System (Jump is a Button action).
    void OnJump(InputAction.CallbackContext ctx)
    {
        if (!controller.isGrounded) return;
        velocity.y = Mathf.Sqrt(jumpHeight * -2f * gravity);
        animator.SetTrigger(JumpHash);   // the Lesson 1.2 Any State -> Jump
    }
}

Every technique from the module shows up here: the Speed float feeds the blend tree (1.3), the Jump trigger fires the Any State → Jump transition (1.2), the hashes come from the fragile-strings tip (1.2), and the footstep audio arrives through an Animation Event (this lesson). Because the driver only sets parameters, the animation system and gameplay stay cleanly separated.

How It All Connects

Here's the data flow of the finished mini-project — from the player's input all the way to sound and motion on screen:

Figure 2: Input drives the controller, which both moves the body and sets Animator parameters; the animation then fires the footstep event.

Hands-on Challenge

Summary

🚀 What's Next?

Your character works, but notice how much the driver script knows about — input, movement, animation, audio all tangled in one class. As projects grow, that coupling becomes the enemy. In Module 2: Architecture & ScriptableObjects, starting with Lesson 2.1: Thinking in Systems: Decoupling & Interfaces, you'll learn to pull these responsibilities apart so your systems stay flexible and testable.