Unity Game Engine Series Part 6: Animation & State Machines

1. Animation Basics

1.1 Animation Clips & Keyframes

An Animation Clip is a single piece of animation data — a walk cycle, an attack swing, a door opening. Each clip contains keyframes that define property values at specific points in time. Unity interpolates between keyframes to create smooth motion.

1.2 Animation Window & Recording Mode

Unity's Animation Window is a timeline-based editor for creating and modifying animation clips directly within the editor:

1.3 Animation Curves

Animation curves control the easing between keyframes — how fast or slow a property changes over time. They are what make animation feel natural rather than robotic:

using UnityEngine;

public class AnimationCurveExamples : MonoBehaviour
{
    // Expose curves in the Inspector for visual editing
    [Header("Movement Curves")]
    [SerializeField] private AnimationCurve jumpCurve;
    [SerializeField] private AnimationCurve bounceCurve;
    [SerializeField] private AnimationCurve shakeCurve;

    [Header("Settings")]
    [SerializeField] private float jumpHeight = 3f;
    [SerializeField] private float jumpDuration = 0.8f;

    private float jumpTimer = -1f;
    private Vector3 startPosition;

    public void StartJump()
    {
        jumpTimer = 0f;
        startPosition = transform.position;
    }

    private void Update()
    {
        if (jumpTimer < 0f) return;

        jumpTimer += Time.deltaTime;
        float normalizedTime = jumpTimer / jumpDuration;

        if (normalizedTime >= 1f)
        {
            // Jump complete
            transform.position = startPosition;
            jumpTimer = -1f;
            return;
        }

        // Evaluate the curve at the current normalized time (0-1)
        // The curve shape determines the jump arc:
        // - Linear: unrealistic constant speed
        // - Ease-out + ease-in: natural parabolic arc
        // - Custom: bouncy, floaty, heavy, etc.
        float heightMultiplier = jumpCurve.Evaluate(normalizedTime);
        transform.position = startPosition + Vector3.up * (heightMultiplier * jumpHeight);
    }

    // Create curves programmatically
    private void CreateBounceCurve()
    {
        bounceCurve = new AnimationCurve();
        bounceCurve.AddKey(new Keyframe(0f, 0f, 0f, 8f));     // Start: fast rise
        bounceCurve.AddKey(new Keyframe(0.3f, 1f, 0f, 0f));   // Peak
        bounceCurve.AddKey(new Keyframe(0.5f, 0.2f, 0f, 0f)); // First bounce
        bounceCurve.AddKey(new Keyframe(0.65f, 0.5f, 0f, 0f)); // Second peak
        bounceCurve.AddKey(new Keyframe(0.8f, 0.05f, 0f, 0f)); // Second bounce
        bounceCurve.AddKey(new Keyframe(1f, 0f, -0.5f, 0f));   // Settle
    }
}

2. The Animator System

2.1 Animator Controller

The Animator Controller is a visual state machine that manages which animation clip plays and how clips transition between each other. Think of it as a flowchart for your character's animations — each box is a state (idle, walk, run, attack) and each arrow is a transition with conditions.

2.2 Parameters & Transitions

using UnityEngine;

[RequireComponent(typeof(Animator))]
public class CharacterAnimatorController : MonoBehaviour
{
    private Animator animator;

    // Cache parameter hashes for performance (avoid string lookups every frame)
    private static readonly int SpeedHash = Animator.StringToHash("Speed");
    private static readonly int IsGroundedHash = Animator.StringToHash("IsGrounded");
    private static readonly int IsAttackingHash = Animator.StringToHash("IsAttacking");
    private static readonly int JumpTriggerHash = Animator.StringToHash("Jump");
    private static readonly int HurtTriggerHash = Animator.StringToHash("Hurt");
    private static readonly int DeathTriggerHash = Animator.StringToHash("Death");
    private static readonly int AttackIndexHash = Animator.StringToHash("AttackIndex");

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

    // Called from your character controller every frame
    public void UpdateAnimation(float moveSpeed, bool isGrounded)
    {
        // Float parameter: drives blend tree (idle/walk/run)
        animator.SetFloat(SpeedHash, moveSpeed, 0.1f, Time.deltaTime);

        // Bool parameter: controls ground/air state transitions
        animator.SetBool(IsGroundedHash, isGrounded);
    }

    public void TriggerJump()
    {
        // Trigger: fires once, auto-resets (perfect for one-shot actions)
        animator.SetTrigger(JumpTriggerHash);
    }

    public void TriggerAttack(int comboIndex)
    {
        // Int parameter: select which attack in a combo chain
        animator.SetInteger(AttackIndexHash, comboIndex);
        animator.SetTrigger(JumpTriggerHash); // Reusing trigger for attack
    }

    public void TriggerHurt()
    {
        animator.SetTrigger(HurtTriggerHash);
    }

    public void TriggerDeath()
    {
        animator.SetTrigger(DeathTriggerHash);
        // Disable the animator to freeze on death pose
        // animator.enabled = false; // or use a "Dead" state with no exit
    }

    // Query current animation state
    public bool IsInState(string stateName, int layer = 0)
    {
        return animator.GetCurrentAnimatorStateInfo(layer)
            .IsName(stateName);
    }

    // Check if a transition is currently in progress
    public bool IsTransitioning(int layer = 0)
    {
        return animator.IsInTransition(layer);
    }
}

3. Blend Trees

Blend Trees are the secret weapon for creating smooth, fluid character movement. Instead of abruptly switching between walk and run animations, a blend tree smoothly interpolates between multiple clips based on parameter values.

3.1 1D Blend Trees

A 1D blend tree blends animations along a single axis — perfect for speed-based movement:

3.2 2D Blend Trees

2D blend trees blend animations along two axes — essential for directional movement (forward/backward + left/right):

using UnityEngine;

public class DirectionalMovementAnimator : MonoBehaviour
{
    private Animator animator;

    // 2D Blend Tree parameters
    private static readonly int MoveXHash = Animator.StringToHash("MoveX");
    private static readonly int MoveZHash = Animator.StringToHash("MoveZ");

    [SerializeField] private float dampTime = 0.1f;

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

    public void UpdateMovementAnimation(Vector3 localVelocity, float maxSpeed)
    {
        // Normalize velocity relative to max speed
        float normalizedX = localVelocity.x / maxSpeed; // Strafe left/right
        float normalizedZ = localVelocity.z / maxSpeed; // Forward/backward

        // Smoothly update blend tree parameters
        // dampTime creates smooth transitions instead of instant snapping
        animator.SetFloat(MoveXHash, normalizedX, dampTime, Time.deltaTime);
        animator.SetFloat(MoveZHash, normalizedZ, dampTime, Time.deltaTime);
    }
}

// Blend tree layout (configured in Animator window):
// 2D Freeform Directional blend with positions:
//
//              Forward (0, 1)
//                  Run_F
//                    |
//   Strafe_L (-1,0)-- Idle (0,0) -- Strafe_R (1,0)
//                    |
//              Backward (0, -1)
//                  Run_B
//
// Plus diagonals: RunForwardLeft (-0.7, 0.7), etc.

4. State Machines

4.1 Character State Design

A well-designed state machine is the backbone of character behavior. Each state represents a distinct mode of operation with its own animation, movement rules, and transition conditions:

using UnityEngine;

// Code-side state machine that mirrors the Animator states
// This provides game logic coordination with animation states
public class CharacterStateMachine : MonoBehaviour
{
    public enum CharacterState
    {
        Idle, Locomotion, Jumping, Attacking, Hurt, Dead
    }

    [SerializeField] private CharacterState currentState = CharacterState.Idle;
    private Animator animator;
    private CharacterAnimatorController animController;

    public CharacterState CurrentState => currentState;

    private void Awake()
    {
        animator = GetComponent<Animator>();
        animController = GetComponent<CharacterAnimatorController>();
    }

    public bool TryTransition(CharacterState newState)
    {
        // Validate transition rules
        if (!IsTransitionValid(currentState, newState))
            return false;

        CharacterState previousState = currentState;
        currentState = newState;
        OnStateEnter(newState, previousState);
        return true;
    }

    private bool IsTransitionValid(CharacterState from, CharacterState to)
    {
        // Dead is a terminal state — no transitions out
        if (from == CharacterState.Dead) return false;

        // Hurt and Death can interrupt anything
        if (to == CharacterState.Hurt || to == CharacterState.Dead) return true;

        // Can't attack while jumping (in this design)
        if (from == CharacterState.Jumping && to == CharacterState.Attacking) return false;

        // Can't move while attacking (committed animations)
        if (from == CharacterState.Attacking && to == CharacterState.Locomotion) return false;

        return true;
    }

    private void OnStateEnter(CharacterState state, CharacterState previous)
    {
        switch (state)
        {
            case CharacterState.Jumping:
                animController.TriggerJump();
                break;
            case CharacterState.Attacking:
                animController.TriggerAttack(0);
                break;
            case CharacterState.Hurt:
                animController.TriggerHurt();
                break;
            case CharacterState.Dead:
                animController.TriggerDeath();
                break;
        }

        Debug.Log($"State: {previous} -> {state}");
    }
}

4.2 Sub-State Machines & Any State

Sub-state machines help organize complex Animator Controllers by grouping related states. Any State transitions allow certain events (like taking damage) to interrupt any current state:

5. Advanced Animation

5.1 Inverse Kinematics (IK)

Inverse Kinematics procedurally adjusts bone positions to reach target points — making characters interact naturally with the environment. Instead of animating every possible hand position, IK calculates the bone chain needed to reach a target in real time.

using UnityEngine;

[RequireComponent(typeof(Animator))]
public class CharacterIK : MonoBehaviour
{
    private Animator animator;

    [Header("Foot IK")]
    [SerializeField] private bool enableFootIK = true;
    [SerializeField] private float footOffset = 0.1f;
    [SerializeField] private float raycastDistance = 1.5f;
    [SerializeField] private LayerMask groundLayer;

    [Header("Look At IK")]
    [SerializeField] private bool enableLookAt = true;
    [SerializeField] private Transform lookTarget;
    [SerializeField] [Range(0, 1)] private float lookWeight = 0.7f;

    [Header("Hand IK")]
    [SerializeField] private bool enableHandIK = false;
    [SerializeField] private Transform rightHandTarget;
    [SerializeField] private Transform leftHandTarget;

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

    // Called by Unity's animation system when IK pass is processed
    private void OnAnimatorIK(int layerIndex)
    {
        if (animator == null) return;

        // === LOOK AT IK ===
        if (enableLookAt && lookTarget != null)
        {
            animator.SetLookAtWeight(lookWeight, 0.3f, 0.6f, 0.8f, 0.5f);
            animator.SetLookAtPosition(lookTarget.position);
        }

        // === FOOT IK (ground conformity) ===
        if (enableFootIK)
        {
            AdjustFoot(AvatarIKGoal.LeftFoot);
            AdjustFoot(AvatarIKGoal.RightFoot);
        }

        // === HAND IK (grabbing objects, weapons) ===
        if (enableHandIK)
        {
            if (rightHandTarget != null)
            {
                animator.SetIKPositionWeight(AvatarIKGoal.RightHand, 1f);
                animator.SetIKRotationWeight(AvatarIKGoal.RightHand, 1f);
                animator.SetIKPosition(AvatarIKGoal.RightHand, rightHandTarget.position);
                animator.SetIKRotation(AvatarIKGoal.RightHand, rightHandTarget.rotation);
            }

            if (leftHandTarget != null)
            {
                animator.SetIKPositionWeight(AvatarIKGoal.LeftHand, 1f);
                animator.SetIKRotationWeight(AvatarIKGoal.LeftHand, 1f);
                animator.SetIKPosition(AvatarIKGoal.LeftHand, leftHandTarget.position);
                animator.SetIKRotation(AvatarIKGoal.LeftHand, leftHandTarget.rotation);
            }
        }
    }

    private void AdjustFoot(AvatarIKGoal foot)
    {
        // Raycast down from the foot bone to find the ground
        Vector3 footPos = animator.GetIKPosition(foot);
        Ray ray = new Ray(footPos + Vector3.up, Vector3.down);

        if (Physics.Raycast(ray, out RaycastHit hit, raycastDistance, groundLayer))
        {
            // Place foot on the ground surface
            Vector3 targetPos = hit.point + Vector3.up * footOffset;
            animator.SetIKPositionWeight(foot, 1f);
            animator.SetIKPosition(foot, targetPos);

            // Align foot rotation to ground normal (slopes, stairs)
            Quaternion footRotation = Quaternion.LookRotation(
                Vector3.ProjectOnPlane(transform.forward, hit.normal), hit.normal
            );
            animator.SetIKRotationWeight(foot, 1f);
            animator.SetIKRotation(foot, footRotation);
        }
    }
}

5.2 Root Motion vs Script-Driven Movement

using UnityEngine;

// Root Motion controller — animation drives movement
[RequireComponent(typeof(Animator), typeof(Rigidbody))]
public class RootMotionController : MonoBehaviour
{
    private Animator animator;
    private Rigidbody rb;

    [SerializeField] private bool useRootMotion = true;

    private void Awake()
    {
        animator = GetComponent<Animator>();
        rb = GetComponent<Rigidbody>();
        animator.applyRootMotion = useRootMotion;
    }

    // Called by Unity when root motion is calculated
    private void OnAnimatorMove()
    {
        if (useRootMotion)
        {
            // Apply the animation's root motion delta to the Rigidbody
            // This gives physically correct, animation-driven movement
            rb.MovePosition(rb.position + animator.deltaPosition);
            rb.MoveRotation(rb.rotation * animator.deltaRotation);
        }
    }
}

5.3 Timeline & Cinemachine

Timeline is Unity's visual sequencing tool for creating cutscenes, cinematics, and scripted gameplay sequences. Think of it as a non-linear video editor built into Unity:

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;

public class CutsceneController : MonoBehaviour
{
    [SerializeField] private PlayableDirector cutsceneDirector;
    [SerializeField] private PlayableDirector introCutscene;
    [SerializeField] private PlayableDirector bossCutscene;

    private bool cutscenePlaying = false;

    public void PlayCutscene(PlayableDirector director)
    {
        if (cutscenePlaying) return;

        cutscenePlaying = true;

        // Disable player controls during cutscene
        FindObjectOfType<CharacterStateMachine>().enabled = false;

        director.stopped += OnCutsceneComplete;
        director.Play();
    }

    private void OnCutsceneComplete(PlayableDirector director)
    {
        director.stopped -= OnCutsceneComplete;
        cutscenePlaying = false;

        // Re-enable player controls
        FindObjectOfType<CharacterStateMachine>().enabled = true;

        Debug.Log("Cutscene complete — returning control to player");
    }

    // Skip cutscene functionality
    private void Update()
    {
        if (cutscenePlaying && Input.GetKeyDown(KeyCode.Escape))
        {
            cutsceneDirector.time = cutsceneDirector.duration;
            cutsceneDirector.Evaluate();
            cutsceneDirector.Stop();
        }
    }
}

5.4 Animation Events

Animation Events fire C# methods at precise frames during an animation clip — essential for synchronizing SFX, VFX, and gameplay logic with animation:

using UnityEngine;

public class AnimationEventReceiver : MonoBehaviour
{
    [Header("Audio")]
    [SerializeField] private AudioSource audioSource;
    [SerializeField] private AudioClip[] footstepSounds;
    [SerializeField] private AudioClip swordSwingSound;
    [SerializeField] private AudioClip impactSound;

    [Header("VFX")]
    [SerializeField] private ParticleSystem dustParticle;
    [SerializeField] private ParticleSystem swordTrail;
    [SerializeField] private Transform weaponHitbox;

    // Called by Animation Event on foot-down frames
    public void OnFootstep()
    {
        if (footstepSounds.Length == 0) return;
        AudioClip clip = footstepSounds[Random.Range(0, footstepSounds.Length)];
        audioSource.PlayOneShot(clip, 0.5f);
        dustParticle.Play();
    }

    // Called at the start of an attack swing
    public void OnAttackStart()
    {
        swordTrail.Play();
        audioSource.PlayOneShot(swordSwingSound, 0.7f);
    }

    // Called at the peak damage frame of an attack
    public void OnAttackHit()
    {
        // Enable the weapon's damage collider for a brief window
        weaponHitbox.gameObject.SetActive(true);
    }

    // Called at the end of the attack recovery
    public void OnAttackEnd()
    {
        swordTrail.Stop();
        weaponHitbox.gameObject.SetActive(false);
    }

    // Called when a landing animation plays
    public void OnLand(float intensity)
    {
        // The float parameter comes from the Animation Event's data
        audioSource.PlayOneShot(impactSound, intensity);
        CameraShake.Instance?.Shake(intensity * 0.3f, 0.2f);
    }
}

6. History: Legacy Animation to Mecanim

Exercises & Self-Assessment

Conclusion & Next Steps

You now have a comprehensive understanding of Unity's animation systems. Here are the key takeaways from Part 6:

• Animation Clips store keyframed data — understand keyframes, interpolation curves, and looping for both imported and editor-created animations
• Animator Controllers are visual state machines that manage animation flow — states, transitions, parameters (bool/int/float/trigger), and layers
• Blend Trees create fluid movement by interpolating between clips — 1D for speed, 2D for directional movement, with proper damping for smooth transitions
• State Machines should mirror your game logic — validate transitions, handle interrupts properly, and use sub-state machines for organization
• Inverse Kinematics adds procedural realism — foot placement on terrain, hand grip on objects, head tracking for look-at behavior
• Root Motion vs Script-Driven is a fundamental design choice — root motion for realistic weight, script-driven for responsive arcade feel
• Timeline & Cinemachine enable cinematic sequences — combine them for cutscenes, camera animations, and scripted events
• Animation Events synchronize gameplay with animation — footstep sounds, attack hitbox activation, VFX triggers