Unity Animator Not Working - Animation System Fix

Problem: Your Unity Animator is not doing anything. Animations do not play in Play mode, parameters in the Animator window change but the character stays in the idle pose, or transitions never fire even though you call SetTrigger or SetBool in code.

Root cause: In most cases the Animator is set up incorrectly rather than broken. Common issues include missing or wrong Animator Controller references, default state misconfigured, transitions with impossible conditions, avatar or rig mismatches, or scripts driving the wrong Animator component.

This guide walks you through the most common causes and fixes so your animations play reliably again.

Quick Fix Checklist

Before deep debugging, verify these basics:

The animated GameObject has an Animator component (not just an Animation component).
The Animator has a valid Controller asset assigned.
The Controller has a Default State set (orange state) that points to a clip.
The animation clips actually have motion (not empty) and are compatible with the rig type.
Any script that calls SetTrigger or SetBool is referencing the same Animator that drives your character.

If any of these are wrong, fix them and test again. If the Animator still appears to do nothing, continue with the steps below.

Solution 1: Animator Controller Not Assigned Or Wrong Object

Symptom: In Play mode the character stays in the T-pose or idle mesh even though you have animation clips in your project.

Step 1: Check the Animator component

Select the GameObject that should animate.
In the Inspector, look at the Animator component.
Ensure Controller is set to the correct *.controller asset.
If it says None (Runtime Animator Controller), assign your controller asset.

Step 2: Confirm the correct object has the Animator

Skinned meshes are often children of a root GameObject.
The Animator should be on the root that holds the avatar, not on an unrelated parent.
If your scripts reference GetComponent<Animator>() on a different object, they may be driving the wrong Animator.

Verification: In Play mode, open the Animator window. The orange highlight should move through the states as time passes. If it stays on Entry with no motion, the controller is not assigned or not running.

Solution 2: Default State Or Transitions Misconfigured

Symptom: Animator is assigned, but no state change happens or only one animation ever plays.

Step 1: Check the default state

Open the Animator window for your controller.
The state with the orange color is the Default State.
Ensure this state points to a clip that actually animates your character.
If you expect an idle animation but it is not default, right-click the correct state and choose Set as Layer Default State.

Step 2: Inspect transition conditions

Select transitions between states.
In the Inspector, look at Conditions:
- Are they using the correct parameter names?
- Is the logic reachable (for example, a float parameter must be greater than a value that is ever set)?
Remove overly strict conditions while testing. Simplify to a single trigger or bool to verify the path works.

Step 3: Check “Has Exit Time” and interruption

For transitions that should happen immediately when a trigger is set:
- Disable Has Exit Time if you do not want to wait for the clip to finish.
- Ensure Transition Duration is not so long that the change looks like it never happens.

Verification: In Play mode, change parameters manually in the Animator window and watch the state machine. If states now transition correctly, your logic and transitions are wired properly.

Solution 3: Parameters Not Matching Script Calls

Symptom: You call animator.SetTrigger("Jump") or set a bool in code, but the Animator never leaves the current state.

Step 1: Confirm parameter names

In the Animator window, open the Parameters tab.
Check exact spelling and case (e.g. JumpTrigger vs jumpTrigger).
In code, call:

animator.SetTrigger("JumpTrigger");

Use copy-paste from the Animator window into code to avoid typos.

Step 2: Ensure the correct parameter type

If a transition expects a Trigger, do not use a bool or int from code.
In the Conditions list for a transition, confirm it uses the same parameter you are setting.

Step 3: Check script timing

If you set parameters before the Animator is fully enabled (e.g. in Awake on a disabled GameObject), they may be consumed before any state change is visible.
Prefer setting parameters in Start or in response to input events during Play mode.

Verification: Add a Debug.Log near your SetTrigger or SetBool call and watch the Animator window. You should see the parameter flash or change when the log fires.

Solution 4: Avatar, Rig, Or Import Settings Mismatch

Symptom: Animation state appears to play in the Animator window but the mesh does not move in the Scene view.

Step 1: Check rig type

Select your character model in the Project window.
In the Inspector, open the Rig tab.
Ensure Animation Type matches how the clip was authored (e.g. Humanoid vs Generic).
If your clips are Humanoid, your character should also be Humanoid with a configured avatar.

Step 2: Check avatar configuration

In the Rig tab, click Configure.
Verify bones are mapped correctly and there are no major errors.
If the avatar is broken, fix the mapping or reimport the model.

Step 3: Ensure clip is bound to correct skeleton

If you use animations from a different model, make sure the rig and avatar are compatible.
In some cases you may need to retarget animations or use a common avatar.

Verification: In the Scene or Game view, play the game. If the Animator state changes and the avatar now moves, the rig and avatar configuration were the issue.

Solution 5: Animator Layer Or Mask Issues

Symptom: Only part of the character animates, or upper-body animations never blend correctly.

Step 1: Inspect layers

In the Animator window, check if you are using multiple layers (Base Layer, UpperBody, etc.).
Each layer can have its own weight and avatar mask.

Step 2: Check layer weights

In the Animator, click the Layers tab.
Make sure the layer that should drive the animation has Weight > 0.
If the base layer has full weight and the upper layer is at 0, upper-body animations will never show.

Step 3: Review avatar masks

If a layer uses an Avatar Mask, confirm the correct body parts are enabled.
For example, an upper-body mask should include spine and arms, not just head.

Verification: Adjust layer weights in Play mode and watch the effect. If increasing weight suddenly makes the animation visible, your layer configuration was the problem.

Solution 6: Animator Update Order And Time Scale

Symptom: Animations appear to update inconsistently or stop entirely during slow motion or pause logic.

Step 1: Check Animator update mode

On the Animator component, check Update Mode:
- Normal – Uses Time.timeScale.
- Animate Physics – Tied to the physics timestep.
- Unscaled Time – Ignores timeScale changes.
If you pause the game by setting Time.timeScale = 0, Normal animators will stop, which may be intentional or not.

Step 2: Confirm time scale usage

Search your code for Time.timeScale changes.
If you are using slow motion or pause systems, ensure the Animator mode matches your intent.

Verification: Temporarily set Update Mode to Unscaled Time and test while adjusting Time.timeScale. If animations now behave as expected, clean up your pause and slow-motion logic accordingly.

How To Confirm The Fix Worked

After applying the relevant solution:

Enter Play mode.
Open the Animator window and dock it.
Perform the action that should trigger the animation (input, script event, etc.).
Watch:
- Does the state machine move between states as expected?
- Does the character or object visually animate in the Scene or Game view?

If both the state and visual animation behave correctly, your Animator is working.

Prevention Tips

Keep Animators simple for small characters; avoid unnecessary layers and complex conditions.
Use consistent naming for parameters and share a short naming convention document within your team.
When importing new animations, test them in isolation on a sample scene before wiring them into a large state machine.
Document common patterns (idle → move → attack → hurt → death) so future Animators follow a known structure.