Third Person Controller Issues With Attack Animations NOT Being Found!?

I am unable to play several attack animations on my character… It says “The animation state attackOne could not be played because it couldn’t be found!” I just want my character to play the animations I assign to him on the Alpha1,2,3,4,5 keys. I can walk, run, trot, and jump, but not attack… Please Help!! Here is the script.

// Require a character controller to be attached to the same game object
@script RequireComponent(CharacterController)

public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;

//added by Anshul
public var attack1Animation : AnimationClip;
public var attack2Animation : AnimationClip;
public var attack3Animation : AnimationClip;
public var attack4Animation : AnimationClip;
public var attack5Animation : AnimationClip;

public var attack1AnimationSpeed : float = 1.0;
public var attack2AnimationSpeed : float = 1.0;
public var attack3AnimationSpeed : float = 1.0;
public var attack4AnimationSpeed : float = 1.0;
public var attack5AnimationSpeed : float = 1.0;

//End here

public var walkMaxAnimationSpeed : float = 0.75;
public var trotMaxAnimationSpeed : float = 1.0;
public var runMaxAnimationSpeed : float = 1.0;
public var jumpAnimationSpeed : float = 1.15;
public var landAnimationSpeed : float = 1.0;

private var _animation : Animation;

enum CharacterState {
        Idle = 0,
        Walking = 1,
        Trotting = 2,
        Running = 3,
        Jumping = 4,
}

private var _characterState : CharacterState;

// The speed when walking
var walkSpeed = 2.0;
// after trotAfterSeconds of walking we trot with trotSpeed
var trotSpeed = 4.0;
// when pressing "Fire3" button (cmd) we start running
var runSpeed = 6.0;

var inAirControlAcceleration = 3.0;

// How high do we jump when pressing jump and letting go immediately
var jumpHeight = 0.5;

// The gravity for the character
var gravity = 20.0;
// The gravity in controlled descent mode
var speedSmoothing = 10.0;
var rotateSpeed = 500.0;
var trotAfterSeconds = 3.0;

var canJump = true;

private var jumpRepeatTime = 0.05;
private var jumpTimeout = 0.15;
private var groundedTimeout = 0.25;

// The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
private var lockCameraTimer = 0.0;

// The current move direction in x-z
private var moveDirection = Vector3.zero;
// The current vertical speed
private var verticalSpeed = 0.0;
// The current x-z move speed
private var moveSpeed = 0.0;

// The last collision flags returned from controller.Move
private var collisionFlags : CollisionFlags; 

// Are we jumping? (Initiated with jump button and not grounded yet)
private var jumping = false;
private var jumpingReachedApex = false;

// Are we moving backwards (This locks the camera to not do a 180 degree spin)
private var movingBack = false;
// Is the user pressing any keys?
private var isMoving = false;
// When did the user start walking (Used for going into trot after a while)
private var walkTimeStart = 0.0;
// Last time the jump button was clicked down
private var lastJumpButtonTime = -10.0;
// Last time we performed a jump
private var lastJumpTime = -1.0;


// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
private var lastJumpStartHeight = 0.0;


private var inAirVelocity = Vector3.zero;

private var lastGroundedTime = 0.0;


private var isControllable = true;

function Awake ()
{
        moveDirection = transform.TransformDirection(Vector3.forward);
        
        _animation = GetComponent(Animation);
        if(!_animation)
                Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");
        
        /*
public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;   
        */
        if(!idleAnimation) {
                _animation = null;
                Debug.Log("No idle animation found. Turning off animations.");
        }
        if(!walkAnimation) {
                _animation = null;
                Debug.Log("No walk animation found. Turning off animations.");
        }
        if(!runAnimation) {
                _animation = null;
                Debug.Log("No run animation found. Turning off animations.");
        }
        if(!jumpPoseAnimation && canJump) {
                _animation = null;
                Debug.Log("No jump animation found and the character has canJump enabled. Turning off animations.");
        }
                        
}


function UpdateSmoothedMovementDirection ()
{
        var cameraTransform = Camera.main.transform;
        var grounded = IsGrounded();
        
        // Forward vector relative to the camera along the x-z plane    
        var forward = cameraTransform.TransformDirection(Vector3.forward);
        forward.y = 0;
        forward = forward.normalized;

        // Right vector relative to the camera
        // Always orthogonal to the forward vector
        var right = Vector3(forward.z, 0, -forward.x);

        var v = Input.GetAxisRaw("Vertical");
        var h = Input.GetAxisRaw("Horizontal");

        // Are we moving backwards or looking backwards
        if (v < -0.2)
                movingBack = true;
        else
                movingBack = false;
        
        var wasMoving = isMoving;
        isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
                
        // Target direction relative to the camera
        var targetDirection = h * right + v * forward;
        
        // Grounded controls
        if (grounded)
        {
                // Lock camera for short period when transitioning moving & standing still
                lockCameraTimer += Time.deltaTime;
                if (isMoving != wasMoving)
                        lockCameraTimer = 0.0;

                // We store speed and direction seperately,
                // so that when the character stands still we still have a valid forward direction
                // moveDirection is always normalized, and we only update it if there is user input.
                if (targetDirection != Vector3.zero)
                {
                        // If we are really slow, just snap to the target direction
                        if (moveSpeed < walkSpeed * 0.9 && grounded)
                        {
                                moveDirection = targetDirection.normalized;
                        }
                        // Otherwise smoothly turn towards it
                        else
                        {
                                moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
                                
                                moveDirection = moveDirection.normalized;
                        }
                }
                
                // Smooth the speed based on the current target direction
                var curSmooth = speedSmoothing * Time.deltaTime;
                
                // Choose target speed
                //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
                var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);
        
                _characterState = CharacterState.Idle;
                
                // Pick speed modifier
                if (Input.GetKey (KeyCode.LeftShift) || Input.GetKey (KeyCode.RightShift))
                {
                        targetSpeed *= runSpeed;
                        _characterState = CharacterState.Running;
                }
                else if (Time.time - trotAfterSeconds > walkTimeStart)
                {
                        targetSpeed *= trotSpeed;
                        _characterState = CharacterState.Trotting;
                }
                else
                {
                        targetSpeed *= walkSpeed;
                        _characterState = CharacterState.Walking;
                }
                
                moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
                
                // Reset walk time start when we slow down
                if (moveSpeed < walkSpeed * 0.3)
                        walkTimeStart = Time.time;
        }
        // In air controls
        else
        {
                // Lock camera while in air
                if (jumping)
                        lockCameraTimer = 0.0;

                if (isMoving)
                        inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
        }
        

                
}


function ApplyJumping ()
{
        // Prevent jumping too fast after each other
        if (lastJumpTime + jumpRepeatTime > Time.time)
                return;

        if (IsGrounded()) {
                // Jump
                // - Only when pressing the button down
                // - With a timeout so you can press the button slightly before landing         
                if (canJump && Time.time < lastJumpButtonTime + jumpTimeout) {
                        verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);
                        SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
                }
        }
}


function ApplyGravity ()
{
        if (isControllable)     // don't move player at all if not controllable.
        {
                // Apply gravity
                var jumpButton = Input.GetButton("Jump");
                
                
                // When we reach the apex of the jump we send out a message
                if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0)
                {
                        jumpingReachedApex = true;
                        SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
                }
        
                if (IsGrounded ())
                        verticalSpeed = 0.0;
                else
                        verticalSpeed -= gravity * Time.deltaTime;
        }
}

function CalculateJumpVerticalSpeed (targetJumpHeight : float)
{
        // From the jump height and gravity we deduce the upwards speed 
        // for the character to reach at the apex.
        return Mathf.Sqrt(2 * targetJumpHeight * gravity);
}

function DidJump ()
{
        jumping = true;
        jumpingReachedApex = false;
        lastJumpTime = Time.time;
        lastJumpStartHeight = transform.position.y;
        lastJumpButtonTime = -10;
        
        _characterState = CharacterState.Jumping;
}

function Update() {
        
        if (!isControllable)
        {
                // kill all inputs if not controllable.
                Input.ResetInputAxes();
        }

        if (Input.GetButtonDown ("Jump"))
        {
                lastJumpButtonTime = Time.time;
        }
		
		//Added by Anshul
		if(Input.GetKeyUp(KeyCode.Alpha1))
		{
			animation.Play("attack1");
		}
		if(Input.GetKeyUp(KeyCode.Alpha2))
		{
			animation.Play("attack2");
		}
		if(Input.GetKeyUp(KeyCode.Alpha3))
		{
			animation.Play("attack3");
		}
		if(Input.GetKeyUp(KeyCode.Alpha4))
		{
			animation.Play("attack4");
		}
		if(Input.GetKeyUp(KeyCode.Alpha5))
		{
			animation.Play("attack5");
		}
		//Ends here
		
        UpdateSmoothedMovementDirection();
        
        // Apply gravity
        // - extra power jump modifies gravity
        // - controlledDescent mode modifies gravity
        ApplyGravity ();

        // Apply jumping logic
        ApplyJumping ();
        
        // Calculate actual motion
        var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;
        movement *= Time.deltaTime;
        
        // Move the controller
        var controller : CharacterController = GetComponent(CharacterController);
        collisionFlags = controller.Move(movement);
        
        // ANIMATION sector
        if(_animation) {
                if(_characterState == CharacterState.Jumping) 
                {
                        if(!jumpingReachedApex) {
                                _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
                                _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
                                _animation.CrossFade(jumpPoseAnimation.name);
                        } else {
                                _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
                                _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
                                _animation.CrossFade(jumpPoseAnimation.name);                           
                        }
                } 
                else 
                {
                        if(controller.velocity.sqrMagnitude < 0.1) {
                                _animation.CrossFade(idleAnimation.name);
                        }
                        else 
                        {
                                if(_characterState == CharacterState.Running) {
                                        _animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
                                        _animation.CrossFade(runAnimation.name);        
                                }
                                else if(_characterState == CharacterState.Trotting) {
                                        _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed);
                                        _animation.CrossFade(walkAnimation.name);       
                                }
                                else if(_characterState == CharacterState.Walking) {
                                        _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);
                                        _animation.CrossFade(walkAnimation.name);       
                                }
                                
                        }
                }
        }
        // ANIMATION sector
        
        // Set rotation to the move direction
        if (IsGrounded())
        {
                
                transform.rotation = Quaternion.LookRotation(moveDirection);
                        
        }       
        else
        {
                var xzMove = movement;
                xzMove.y = 0;
                if (xzMove.sqrMagnitude > 0.001)
                {
                        transform.rotation = Quaternion.LookRotation(xzMove);
                }
        }       
        
        // We are in jump mode but just became grounded
        if (IsGrounded())
        {
                lastGroundedTime = Time.time;
                inAirVelocity = Vector3.zero;
                if (jumping)
                {
                        jumping = false;
                        SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
                }
        }
}

function OnControllerColliderHit (hit : ControllerColliderHit )
{
//      Debug.DrawRay(hit.point, hit.normal);
        if (hit.moveDirection.y > 0.01) 
                return;
}

function GetSpeed () {
        return moveSpeed;
}

function IsJumping () {
        return jumping;
}

function IsGrounded () {
        return (collisionFlags & CollisionFlags.CollidedBelow) != 0;
}

function GetDirection () {
        return moveDirection;
}

function IsMovingBackwards () {
        return movingBack;
}

function GetLockCameraTimer () 
{
        return lockCameraTimer;
}

function IsMoving ()  : boolean
{
        return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5;
}

function HasJumpReachedApex ()
{
        return jumpingReachedApex;
}

function IsGroundedWithTimeout ()
{
        return lastGroundedTime + groundedTimeout > Time.time;
}

function Reset ()
{
        gameObject.tag = "Player";
}

It normally doesn’t matter what script the animation get’s played from.

Well let’s go back to the exception as it is the main cause of the problem:

The exception means either that the animation does not exist or i think it can also pop up when the animation doesn’t belong to the Model/gameobject.

Did you already try to call the animation with a string instead of a variable of type animationclip?

Other things you may try if nothing else works:

Reimport the model.

http://forum.unity3d.com/threads/94707-Animation-could-not-be-played-because-animation-could-not-be-found

http://forum.unity3d.com/threads/179220-Animation-State-Could-Not-Be-found

In Update(), instead of this:

animation.Play("attack1");

Use this:

animation.Play(attack1Animation.name);

The problem is that you’re telling the Animation component to try to play an animation named “attack1”, but your attack1 animation is named “punch”. If this works for attack1, make the same for attack2-5.

Also, as ExTheSea wrote, consider using CrossFade() instead of Play(). By itself, CrossFade() won’t fix your problem, but it will make your animation look better by transitioning more smoothly.