SpriteAnimator.cs

using UnityEngine;
using System.Collections;

public class SpriteAnimator : MonoBehaviour
{
    [System.Serializable]
    public class AnimationTrigger
    {
        public string name;
        public int frame;
    }

    [System.Serializable]
    public class Animation
    {
        public string name;
        public int fps;
        public Sprite[] frames;

        public string sequenceCode;
        public string cue;

        public AnimationTrigger[] triggers;
    }

    // sequence code example:
    // 0-1:3 2-3:3 4-5:4 6-7:4 8:3 9:3

    public string setAnimationName;
    public string setAnimationPath;
    public string setAnimationSpriteName;
    public int setAnimationStartFrame;

    public SpriteRenderer spriteRenderer;
    public Animation[] animations;

    public bool playing { get; private set; }
    public Animation currentAnimation { get; private set; }
    public int currentFrame { get; private set; }
    [HideInInspector]
    public bool loop;

    public string playAnimationOnStart;

    bool looped;

    /*
    void Start()
    {
        if (playAnimationOnStart != "")
            Play(playAnimationOnStart);
    }
    */

    void Start()
    {
        if (!spriteRenderer)
            spriteRenderer = GetComponent<SpriteRenderer>();

        if (playAnimationOnStart != "")
            Play(playAnimationOnStart);
    }

    void OnDisable()
    {
        playing = false;
        currentAnimation = null;
    }

    public void Play(string name, bool loop = true, int startFrame = 0)
    {
        Animation animation = GetAnimation(name);
        if (animation != null )
        {
            if (animation != currentAnimation)
            {
                ForcePlay(name, loop, startFrame);
            }
        }
        else
        {
            Debug.LogWarning("could not find animation: " + name);
        }
    }

    public void ForcePlay(string name, bool loop = true, int startFrame = 0)
    {
        Animation animation = GetAnimation(name);
        if (animation != null )
        {
            this.loop = loop;
            currentAnimation = animation;
            playing = true;
            currentFrame = startFrame;
            spriteRenderer.sprite = animation.frames[currentFrame];
            StopAllCoroutines();
            StartCoroutine(PlayAnimation(currentAnimation));
        }
    }

    public void SlipPlay(string name, int wantFrame, params string[] otherNames)
    {
        for (int i = 0; i < otherNames.Length; i++)
        {
            if (currentAnimation != null && currentAnimation.name == otherNames[i])
            {
                Play(name, true, currentFrame);
                break;
            }
        }
        Play(name, true, wantFrame);
    }

    public bool IsPlaying(string name)
    {
        return (currentAnimation != null && currentAnimation.name == name);
    }

    public Animation GetAnimation(string name)
    {
        foreach (Animation animation in animations)
        {
            if (animation.name == name)
            {
                return animation;
            }
        }
        return null;
    }

    IEnumerator CueAnimation(string animationName, float minTime, float maxTime)
    {
        yield return new WaitForSeconds(Random.Range(minTime, maxTime));
        ForcePlay(animationName, false);
    }

    IEnumerator PlayAnimation(Animation animation)
    {
        playing = true;
        //Debug.Log("Playing animation: " + animation.name);

        float timer = 0f;
        float delay = 1f / (float)animation.fps;
        string cueOnComplete = "";

        if (animation.cue != null && animation.cue != "")
        {
            if (animation.cue.IndexOf(':') != -1)
            {
                string[] dataBits = animation.cue.Trim().Split(':');

                string animationName = dataBits[1];
                dataBits = dataBits[0].Split('-');

                float minTime = float.Parse(dataBits[0], System.Globalization.CultureInfo.InvariantCulture);
                float maxTime = minTime;

                if (dataBits.Length > 1)
                    maxTime = float.Parse(dataBits[1], System.Globalization.CultureInfo.InvariantCulture);

                StartCoroutine(CueAnimation(animationName, minTime, maxTime));

                loop = true;
            }
            else
            {
                cueOnComplete = animation.cue.Trim();
            }
        }

        if (animation.sequenceCode != null && animation.sequenceCode != "")
        {
            while (true)
            {
                string[] split = animation.sequenceCode.Split(',');
                foreach (string data in split)
                {
                    string[] dataBits = data.Trim().Split(':');
                    float duration = float.Parse(dataBits[1], System.Globalization.CultureInfo.InvariantCulture);
                    dataBits = dataBits[0].Split('-');

                    int startFrame = int.Parse(dataBits[0], System.Globalization.CultureInfo.InvariantCulture);
                    int endFrame = startFrame;

                    if (dataBits.Length > 1)
                        endFrame = int.Parse(dataBits[1], System.Globalization.CultureInfo.InvariantCulture);

                    currentFrame = startFrame;

                    Debug.Log ("startFrame: " + startFrame + " endFrame: " + endFrame + " duration: " + duration);

                    while (duration > 0f)
                    {
                        while (timer < delay)
                        {
                            duration -= Time.deltaTime;
                            timer += Time.deltaTime;
                            yield return null;
                        }
                        while (timer >= delay)
                        {
                            timer -= delay;
                            currentFrame++;
                            if (currentFrame > endFrame)
                                currentFrame = startFrame;
                        }

                        spriteRenderer.sprite = animation.frames[currentFrame];
                    }
                }
                if (cueOnComplete != "")
                    ForcePlay(cueOnComplete, loop);
            }
        }
        else
        {
            while (loop || currentFrame < animation.frames.Length-1)
            {
                while (timer < delay)
                {
                    timer += Time.deltaTime;
                    yield return null;
                }

                while (timer >= delay)
                {
                    timer -= delay;
                    NextFrame(animation);
                }

                spriteRenderer.sprite = animation.frames[currentFrame];
            }
            if (cueOnComplete != "")
                ForcePlay(cueOnComplete, loop);
        }

        currentAnimation = null;
        playing = false;
    }

    void NextFrame(Animation animation)
    {
        looped = false;
        currentFrame++;
        foreach (AnimationTrigger animationTrigger in animation.triggers)
        {
            if (animationTrigger.frame == currentFrame)
            {
                gameObject.SendMessageUpwards(animationTrigger.name);
            }
        }

        if (currentFrame >= animation.frames.Length)
        {
            if (loop)
                currentFrame = 0;
            else
                currentFrame = animation.frames.Length - 1;
        }
    }

    public int GetFacing()
    {
        return (int)Mathf.Sign(spriteRenderer.transform.localScale.x);
    }

    public void FlipTo(float dir)
    {
        if (dir < 0f)
            spriteRenderer.transform.localScale = new Vector3(-1f, 1f, 1f);
        else
            spriteRenderer.transform.localScale = new Vector3(1f, 1f, 1f);
    }

    public void FlipTo(Vector3 position)
    {
        float diff = position.x - transform.position.x;
        if (diff < 0f)
            spriteRenderer.transform.localScale = new Vector3(-1f, 1f, 1f);
        else
            spriteRenderer.transform.localScale = new Vector3(1f, 1f, 1f);
    }
}