SuperSprite.cs

//-----------------------------------------------------------------
//  Copyright 2010 Brady Wright and Above and Beyond Software
//      All rights reserved
//-----------------------------------------------------------------



using UnityEngine;
using System.Collections;
using System.Collections.Generic;


[System.Serializable]
public class SuperSpriteAnimElement
{
        public AutoSpriteBase sprite;

        public string animName;

        // The actual reference to the desired
        // animation.
        [HideInInspector]
        public UVAnimation anim;

        public void Init()
        {
                bool wasDeactivated = false;

                if (sprite != null)
                {
                        // See if we need to activate our sprite
                        // to work with it:
#if UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_4_8 || UNITY_4_9
                        if (!sprite.gameObject.activeInHierarchy)
                        {
                                wasDeactivated = true;
                                sprite.gameObject.SetActive(true);
                        }
#else
                        if (!sprite.gameObject.active)
                        {
                                wasDeactivated = true;
                                sprite.gameObject.active = true;
                        }
#endif

                        anim = sprite.GetAnim(animName);

                        if (anim == null)
                                Debug.LogError("SuperSprite error: No animation by the name of \"" + animName + "\" was found on sprite \"" + sprite.name + "\". Please verify the spelling and capitalization of the name, including any extra spaces, etc.");

                        if (wasDeactivated)
#if UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_4_8 || UNITY_4_9
                                sprite.gameObject.SetActive(false);
#else
                                sprite.gameObject.active = false;
#endif
                }
        }

        public void Play()
        {
                sprite.PlayAnim(anim);
        }

        public void PlayInReverse()
        {
                sprite.PlayAnimInReverse(anim);
        }
}


[System.Serializable]
public class SuperSpriteAnim
{
        public enum ANIM_END_ACTION
        {
                Do_Nothing,

                Play_Default_Anim,

                Deactivate,

                Destroy
        };

        public delegate void AnimCompletedDelegate(SuperSpriteAnim anim);

        [HideInInspector]
        public int index;

        public string name;

        public SuperSpriteAnimElement[] spriteAnims = new SuperSpriteAnimElement[0];

        public int loopCycles = 0;

        public bool pingPong = false;

        public ANIM_END_ACTION onAnimEnd = ANIM_END_ACTION.Do_Nothing;

        public bool deactivateNonPlaying = false;

        public bool deactivateRecursively = false;

        protected int curAnim = 0;              // The index of the current anim being played.
        protected int stepDir = 1;              // The direction we're moving through our list.
        protected int numLoops = 0;             // The number of loop iterations that have passed
        protected bool isRunning;               // Tells whether we're running or not.
        AnimCompletedDelegate endDelegate;


        public void Init(int idx, AnimCompletedDelegate del, SpriteBase.AnimFrameDelegate frameDel)
        {
                endDelegate = del;
                index = idx;

                List<SuperSpriteAnimElement> anims = new List<SuperSpriteAnimElement>();

                for (int i = 0; i < spriteAnims.Length; ++i)
                        if (spriteAnims[i] != null)
                                if (spriteAnims[i].sprite != null)
                                {
                                        spriteAnims[i].Init();

                                        // Only save the ones that are valid
                                        // so we don't have to check them
                                        // constantly later on:
                                        anims.Add(spriteAnims[i]);

                                        if (frameDel != null)
                                                spriteAnims[i].sprite.SetAnimFrameDelegate(frameDel);

                                        // Hide each sprite by default:
                                        HideSprite(spriteAnims[i].sprite, true);
                                }

                spriteAnims = anims.ToArray();
        }

        public void SetAnimFrameDelegate(SpriteBase.AnimFrameDelegate frameDel)
        {
                for (int i = 0; i < spriteAnims.Length; ++i)
                        if (spriteAnims[i] != null)
                                if (spriteAnims[i].sprite != null)
                                        spriteAnims[i].sprite.SetAnimFrameDelegate(frameDel);
        }

        // Delegate that is called when an animation finishes:
        void AnimFinished(SpriteBase sp)
        {
                // See if we can't advance to the next animation:
                if ((curAnim + stepDir) >= spriteAnims.Length || (curAnim + stepDir) < 0)
                {
                        // See if we need to loop (if we're reversing, we don't loop until we get back to the beginning):
                        if (stepDir > 0 && pingPong)
                        {
                                stepDir = -1;   // Reverse direction of playback

                                // Bounce back from the end:
                                ((AutoSpriteBase)sp).PlayAnimInReverse(spriteAnims[curAnim].anim, spriteAnims[curAnim].anim.GetFrameCount() - 2);
                                return;

                                // See if we need to tell our first animation
                                // to loop us back again in anticipation of
                                // another loop iteration:
                                //                              if(loopCycles == -1 || numLoops < loopCycles)
                                //                              {
                                //                                      spriteAnims[0].anim.loopReverse = true;
                                //                              }

                                // Proceed
                        }
                        else
                        {
                                // See if we can't loop:
                                if (numLoops + 1 > loopCycles && loopCycles != -1)
                                {
                                        isRunning = false;

                                        // Unset our delegate:
                                        sp.SetAnimCompleteDelegate(null);

                                        // Notify that we're ending:
                                        if (endDelegate != null)
                                                endDelegate(this);
                                        return;
                                }
                                else
                                {
                                        // Loop the animation:
                                        ++numLoops;

                                        if (pingPong)
                                        {
                                                // Bounce back from the first frame:
                                                spriteAnims[curAnim].sprite.PlayAnim(spriteAnims[curAnim].anim, 1);
                                                stepDir *= -1;
                                                return;
                                        }
                                        else
                                        {
                                                // Hide the current sprite
                                                HideSprite(sp, true);

                                                // Unset our delegate:
                                                sp.SetAnimCompleteDelegate(null);

                                                // Start back at the first animation:
                                                curAnim = 0;
                                        }
                                }
                        }
                }
                else
                {
                        // Unset our delegate:
                        sp.SetAnimCompleteDelegate(null);
                        HideSprite(sp, true);
                        curAnim += stepDir;
                }

                // Proceed to play the next animation:
                HideSprite(spriteAnims[curAnim].sprite, false);
                spriteAnims[curAnim].sprite.SetAnimCompleteDelegate(AnimFinished);
                if (stepDir > 0)
                        spriteAnims[curAnim].Play();
                else
                        spriteAnims[curAnim].PlayInReverse();
        }


        public void Reset()
        {
                Stop();

                curAnim = 0;
                stepDir = 1;
                numLoops = 0;

                // Hide all but the first:
                for (int i = 1; i < spriteAnims.Length; ++i)
                        HideSprite(spriteAnims[i].sprite, true);
        }

        public void Play()
        {
                //              if(pingPong)
                //              {       // Setup our last anim to loop back properly:
                //                      spriteAnims[spriteAnims.Length - 1].anim.loopReverse = true;
                //              }

                isRunning = true;

                // Register our ending delegate:
                spriteAnims[curAnim].sprite.SetAnimCompleteDelegate(AnimFinished);

                HideSprite(spriteAnims[curAnim].sprite, false);
                spriteAnims[curAnim].Play();
        }

        public void Stop()
        {
                isRunning = false;
                spriteAnims[curAnim].sprite.StopAnim();

                // Unset our delegate:
                spriteAnims[curAnim].sprite.SetAnimCompleteDelegate(null);
        }

        public void Pause()
        {
                isRunning = false;
                spriteAnims[curAnim].sprite.PauseAnim();
        }

        public void Unpause()
        {
                isRunning = true;
                spriteAnims[curAnim].sprite.UnpauseAnim();
        }

        public bool IsRunning
        {
                get { return isRunning; }
        }

        public SpriteBase CurrentSprite
        {
                get
                {
                        if (curAnim < 0 || curAnim >= spriteAnims.Length)
                                return null;

                        return spriteAnims[curAnim].sprite;
                }
        }

        public void Hide(bool tf)
        {
                if (curAnim < 0 || curAnim >= spriteAnims.Length)
                        return;

                HideSprite(spriteAnims[curAnim].sprite, tf);
        }

        public bool IsHidden()
        {
                if (curAnim < 0 || curAnim >= spriteAnims.Length)
                        return false; // Assume no

                return spriteAnims[curAnim].sprite.IsHidden();
        }

        // Helper method that hides a sprite using the method
        // set for this animation (hiding vs deactivation).
        protected void HideSprite(SpriteBase sp, bool tf)
        {
                if (deactivateNonPlaying)
                {
#if UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_4_8 || UNITY_4_9
                        sp.gameObject.SetActive(!tf);   
#else
                        if (deactivateRecursively)
                                sp.gameObject.SetActiveRecursively(!tf);
                        else
                                sp.gameObject.active = !tf;
#endif
                }
                else
                        sp.Hide(tf);
        }

        public void Delete()
        {
                for (int i = 0; i < spriteAnims.Length; ++i)
                        if (spriteAnims[i].sprite != null)
                        {
                                spriteAnims[i].sprite.Delete();
                                UnityEngine.Object.Destroy(spriteAnims[i].sprite);
                        }
        }
}


[System.Serializable]
public class SuperSprite : MonoBehaviour
{
        public delegate void AnimCompleteDelegate(SuperSprite sprite);


        public bool playDefaultAnimOnStart = false;

        public int defaultAnim = 0;

        public SuperSpriteAnim[] animations = new SuperSpriteAnim[0];

        // The current animation.
        protected SuperSpriteAnim curAnim;

        protected bool animating;

        protected AnimCompleteDelegate animCompleteDelegate;

        protected SpriteBase.AnimFrameDelegate animFrameDelegate;

        protected bool m_started = false;


        // Use this for initialization
        public void Start()
        {
                if (m_started)
                        return;
                m_started = true;

                // Initialize animations:
                for (int i = 0; i < animations.Length; ++i)
                        if (animations[i] != null)
                        {
                                animations[i].Init(i, AnimFinished, animFrameDelegate);
                        }

                if (playDefaultAnimOnStart)
                        PlayAnim(animations[defaultAnim]);
        }

        public void PlayAnim(SuperSpriteAnim anim)
        {
                if (!m_started)
                        Start();

                if (curAnim != null)
                {
                        curAnim.Stop();
                        curAnim.Hide(true);
                }

                curAnim = anim;
                curAnim.Reset();

                animating = true;
                anim.Play();
        }

        public void PlayAnim(int index)
        {
                if (index < 0 || index >= animations.Length)
                        return;

                PlayAnim(animations[index]);
        }

        public void PlayAnim(string anim)
        {
                for (int i = 0; i < animations.Length; ++i)
                        if (animations[i].name == anim)
                        {
                                PlayAnim(animations[i]);
                                return;
                        }
        }

        public void DoAnim(SuperSpriteAnim anim)
        {
                if (curAnim != anim | !animating)
                        PlayAnim(anim);
        }

        public void DoAnim(int index)
        {
                if (curAnim == null)
                        PlayAnim(index);
                else if (curAnim.index != index || !animating)
                        PlayAnim(index);
        }

        public void DoAnim(string name)
        {
                if (curAnim == null)
                        PlayAnim(name);
                else if (curAnim.name != name || !animating)
                        PlayAnim(name);
        }

        public void StopAnim()
        {
                if (curAnim != null)
                        curAnim.Stop();

                animating = false;
        }

        public void PauseAnim()
        {
                if (curAnim != null)
                        curAnim.Pause();

                animating = false;
        }

        public void UnpauseAnim()
        {
                if (curAnim != null)
                {
                        curAnim.Unpause();
                        animating = true;
                }
        }

        public void Hide(bool tf)
        {
                if (curAnim != null)
                {
                        curAnim.Hide(tf);

                        if (!tf)
                        {
                                if (animating)
                                        curAnim.Pause();
                        }
                        else
                        {
                                if (animating)
                                        curAnim.Unpause();
                        }
                }
        }

        public bool IsHidden()
        {
                if (curAnim == null)
                {
                        // Assume unhidden:
                        return false;
                }

                return curAnim.IsHidden();
        }

        public SuperSpriteAnim GetCurAnim()
        {
                return curAnim;
        }


        public SpriteRoot CurrentSprite
        {
                get
                {
                        if (curAnim == null)
                                return null;

                        return curAnim.CurrentSprite;
                }
        }

        public SuperSpriteAnim GetAnim(int index)
        {
                if (index < 0 || index >= animations.Length)
                        return null;

                return animations[index];
        }

        public SuperSpriteAnim GetAnim(string name)
        {
                for (int i = 0; i < animations.Length; ++i)
                        if (animations[i].name == name)
                                return animations[i];

                return null;
        }

        public bool IsAnimating()
        {
                return animating;
        }

        // Is called when the animation finishes:
        protected void AnimFinished(SuperSpriteAnim anim)
        {
                animating = false;

                if (animCompleteDelegate != null)
                        animCompleteDelegate(this);

                // Handle the OnAnimEnd action:
                if (curAnim != null)
                {
                        switch (curAnim.onAnimEnd)
                        {
                                case SuperSpriteAnim.ANIM_END_ACTION.Play_Default_Anim:
                                        PlayAnim(defaultAnim);
                                        break;
                                case SuperSpriteAnim.ANIM_END_ACTION.Deactivate:
#if UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_4_8 || UNITY_4_9                              
                                        gameObject.SetActive(false);
#else
                                        gameObject.SetActiveRecursively(false);
#endif
                                        break;
                                case SuperSpriteAnim.ANIM_END_ACTION.Destroy:
                                        for (int i = 0; i < animations.Length; ++i)
                                                animations[i].Delete();

                                        Destroy(gameObject);
                                        break;
                                default:
                                        // Do nothing
                                        break;
                        }
                }
        }


        public void SetAnimCompleteDelegate(AnimCompleteDelegate del)
        {
                animCompleteDelegate = del;
        }

        public void SetAnimFrameDelegate(SpriteBase.AnimFrameDelegate del)
        {
                animFrameDelegate = del;

                for (int i = 0; i < animations.Length; ++i)
                {
                        animations[i].SetAnimFrameDelegate(animFrameDelegate);
                }
        }
}