// Use this for initialization
 void Start()
 {
     m_RootRef = gameObject;
     m_TransformRef = new TransformCache(m_RootRef.transform);
     m_ScaleFactor = (-m_RootRef.transform.localScale.x) / m_RootRef.transform.localScale.x;
     m_State = AnimationState.Idle;
 }

 void OnEnable()
 {
     MyAnimation = MyTransform.GetComponent<Animation>();
     MyAnimation.wrapMode = MyWarpMode;
     MyAnimationState = MyAnimation[MyAnimation.animation.clip.name];
     MyAnimationStateTime = 0.0f;
 }

 /// <summary>
 /// Constructor that specifies a starting state for the animation
 /// </summary>
 /// <param name="startingState">Only Showing or Hiding should be used</param>
 public Animator(UserControl animateControl, AnimationState startingState)
 {
     InitializeTimer();
     animatedControl = animateControl;
     state = startingState;
     tmrAnimate.Start();
 }

 public void ChangeAnimationState(AnimationState _NextState, float _DelayTime, bool _RestoreTransform = false)
 {
     if (m_NextState != _NextState) {
         m_NextState = _NextState;
         StartCoroutine(PerformChangeAnimationState(_NextState, _DelayTime, _RestoreTransform));
     }
 }

    // Use this for initialization
    void Start()
    {
        animation.Stop();

        // By default loop all animations
        animation.wrapMode = WrapMode.Loop;

        // Jump animation are in a higher layer:
        // Thus when a jump animation is playing it will automatically override all other animations until it is faded out.
        // This simplifies the animation script because we can just keep playing the walk / run / idle cycle without having to spcial case jumping animations.
        int jumpingLayer = 1;
        AnimationState jump = animation["jump"];
        jump.layer = jumpingLayer;
        jump.speed *= jumpAnimationSpeedModifier;
        jump.wrapMode = WrapMode.Once;

        AnimationState jumpFall = animation["jumpFall"];
        jumpFall.layer = jumpingLayer;
        jumpFall.wrapMode = WrapMode.ClampForever;

        AnimationState jumpLand = animation["jumpLand"];
        jumpLand.layer = jumpingLayer;
        jumpLand.speed *= jumpLandAnimationSpeedModifier;
        jumpLand.wrapMode = WrapMode.Once;

        //AnimationState buttStomp = animation["buttStomp"];

        run = animation["run"];
        run.speed *= runAnimationSpeedModifier;

        AnimationState walk = animation["walk"];
        walk.speed *= walkAnimationSpeedModifier;
    }

        public virtual void Update(GameTime gameTime)
        {
            //_Sprite.Update(gameTime);

            if (_AnimationState == AnimationState.Waiting)
            {
                if (_AnimationDelayCount >= _AnimationDelayInterval)
                    PreAnimation();
            }
            else if (_AnimationState == AnimationState.Animate)
            {
                StartSiblingAnimations(FireTime.AtStart);
                if (_AnimationDelayCount < _AnimationDelayInterval)
                    _AnimationDelayCount += gameTime.ElapsedGameTime.Milliseconds;
                else
                {
                    if (_AnimationCount < _AnimationInterval)
                    {
                        _AnimationCount = MathHelper.Clamp(_AnimationCount + gameTime.ElapsedGameTime.Milliseconds, 0, _AnimationInterval);
                        AnimationLogic();
                    }
                    else
                    {
                        PostAnimation();
                        _AnimationState = AnimationState.End;
                        StartSiblingAnimations(FireTime.AtEnd);
                    }
                }
            }
        }

    //    
    public void CrossfadeAnimation(AnimationState state, float fadeTime)
    {
        // ** This function is exactly like the Unity Animation.Crossfade() method
        //
        if (currentState == state)
            return;
        animationFadeTime = fadeTime;

        for (int i = 0; i < fadingStates.Count; i++) {
            if (state.name == fadingStates[i].name) {
                fadingStates.RemoveAt (i);
                if (currentState != null)
                    fadingStates.Add (currentState);
                currentState = state;
                return;
            }
        }
        //
        if (currentState != null)
            fadingStates.Add (currentState);
        //
        currentState = state;
        currentState.weight = 0;
        currentState.time = currentStateTime = 0;
        currentState.enabled = true;
        //
    }

 void Update()
 {
     if (Input.GetButton("Fire3"))
     {
         animationState = AnimationState.Falling;
     }
     switch (animationState)
     {
         case AnimationState.NotAnimated:
             break;
         case AnimationState.Falling:
             FallDown();
             break;
         case AnimationState.LayingDown:
             float vertical = CrossPlatformInputManager.GetAxis("Vertical");
             if (vertical != 0)
             {
                 animationState = AnimationState.GettingUp;
             }
             break;
         case AnimationState.GettingUp:
             GetUp();
             break;
         default:
             break;
     }
 }

    public void OnStateAnimationChange(AnimationState previousState, AnimationState actualState)
    {
        bool change = false;
        switch (actualState) {
            case AnimationState.WALK:
            case AnimationState.CHASE:
            case AnimationState.RUN_AWAY:
                if (settedFX) break;
                settedFX = true;
                change = true;
                break;

            default:
                if (!settedFX) break;
                settedFX = false;
                change = true;
                break;
        }

        if (change) {
            foreach (ParticleSystem system in walkingFX.GetComponentsInChildren<ParticleSystem>()) {
                ParticleSystem.EmissionModule emission = system.emission;
                emission.enabled = settedFX;
            }
        }
    }

 // Use this for initialization
 void Start()
 {
     mOctopusAnim = GetComponent<Animator>();
     mOctopusAnim.SetFloat(mBlendTree, 1.0f);
     mRandomRange = Random.Range(minAttackTime, maxAttackTime);
     mAnimState = AnimationState.Idle;
 }

 // Update is called once per frame
 void Update()
 {
     if (Input.GetAxis("Horizontal")>0)
     {
         animationState=AnimationState.walkRight;
         currentIdleTime=0.0f;
         startIdleTime=true;
     }
     else if (Input.GetAxis("Horizontal")<0)
     {
         animationState=AnimationState.walkLeft;
         currentIdleTime=0.0f;
         startIdleTime=true;
     }
     else if (Input.GetAxis("Vertical")>0)
     {
         animationState=AnimationState.walkBack;
         currentIdleTime=0.0f;
         startIdleTime=true;
     }
     else if (Input.GetAxis("Vertical")<0)
     {
         animationState=AnimationState.walkFront;
         currentIdleTime=0.0f;
         startIdleTime=true;
     }
     if (startIdleTime)
     {
         UpdateToIdleAnimations();
     }
     UpdateAnimation();
 }

 protected void Initialise()
 {
     // The Animation Controller feeds on AnimationStates. You've got to assign your animations to variables so that you can call them from the controller
     //
     GetComponent<Animation>()["Attack1"].speed = 2.0f;
     GetComponent<Animation>()["Attack2"].speed = 2.0f;
     //
     //
     animationAttack1Anticipation = GetComponent<Animation>()["Attack1Anticipation"];
     animationAttack1 = GetComponent<Animation>()["Attack1"];
     //
     animationAttack2Anticipation = GetComponent<Animation>()["Attack2Anticipation"];
     animationAttack2 = GetComponent<Animation>()["Attack2"];
     animationAttack3 = GetComponent<Animation>()["WhirlwindAttack"];
     //
     animationWhirlwind = GetComponent<Animation>()["Whirlwind"];
     animationIdle = GetComponent<Animation>()["Idle"];
     animationIdle.speed = 0.4f;
     animationRespawn = GetComponent<Animation>()["Resurection"];
     animationRespawn.speed = 0.8f;
     animationAttack3.speed = 0.8f;
     //
     leftSwipe.SetTime (0.0f, 0, 1);
     rightSwipe.SetTime (0.0f, 0, 1);
     //
 }

 public void GetAnimationState(Entity entity)
 {
     Entity = entity;
     State = Entity.GetAnimationState(StateName);
     State.Loop = Loop;
     State.Weight = 0;
 }

    private void LoadAnimations()
    {
        walkAnimationList = Resources.LoadAll<Sprite>("DwarfWalk").ToList();
        otherAnimationList = Resources.LoadAll<Sprite>("DwarfOther").ToList();

        spriteDirection = SpriteDirection.Down;
        animationState = AnimationState.IdleDown;
    }

		public Animation (IAnimationDrawer drawer, uint duration, Easing easing, Blocking blocking)
		{
			this.Drawer = drawer;
			this.Duration = duration;
			this.Easing = easing;
			this.Blocking = blocking;
			this.AnimationState = AnimationState.Coming;
		}

    void Start()
    {
        state = AnimationState.IDLE;

        status = Status.NOT_FOUND;

        //		RunTowards (new Vector3(transform.position.x +10f, transform.position.y, transform.position.z));
    }

 public void Attacking(Actor self, Target target)
 {
     State = AnimationState.Attacking;
     if (anim.HasSequence("shoot"))
         anim.PlayThen("shoot", () => State = AnimationState.Idle);
     else if (anim.HasSequence("heal"))
         anim.PlayThen("heal", () => State = AnimationState.Idle);
 }

 // Use this for initialization
 void Start()
 {
     walk = animation["walking"];
     foreach (AnimationState state in animation)
     {
         state.speed = 4f;
     }
 }

    void Start()
    {
        lifeValue = life.getBloodValue();
        life.addBloodValueChangeCallback(lifeChangedCall);

        fire1AnimationState = myAnimation["fire1"];
        fire2AnimationState = myAnimation["fire2"];
    }

 // set current animation and restart if it's a different animation
 public void setAnimationState(AnimationState animation)
 {
     if (currentAnimation != animation)
     {
         currentAnimation = animation;
         animationStateTime = 0;
     }
 }