garden_client/Assets/Script/Manage/ManaAnim.cs

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;

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

public enum Curve
{
    Linear,
    EaseOutQuad,
}

public delegate float CurveFunctionF(float timer, float duration, float start, float delta);

public delegate Color CurveFunctionC(float timer, float duration, Color start, Color delta);

public delegate Vector3 CurveFunctionV(float timer, float duration, Vector3 start, Vector3 delta);

public class ManaAnim : MonoBehaviour 
{
    #region 变量

    public static List<Move> MoveList;
    public static List<Tween> TweenForList;
    public static List<Tween> TweenBacList;

    public static Dictionary<Curve, CurveFunctionF> FunctionDicF;
    public static Dictionary<Curve, CurveFunctionC> FunctionDicC;
    public static Dictionary<Curve, CurveFunctionV> FunctionDicV;

    public static Dictionary<Transform, MoveVec> MoveVecDic;
    public static Dictionary<Transform, TweenCG> TweenCgDic;
    public static Dictionary<Transform, TweenGra> TweenGraDic;
    public static Dictionary<Transform, TweenVec> TweenVecDic;
    public static Dictionary<Transform, TweenRect> TweenRectDic;
    public static Dictionary<Transform, TweenScale> TweenScaleDic;
    public static Dictionary<Transform, TweenAudio> TweenAudioDic;

    #endregion

    private void Awake()
    {
        Initializer.RegistValue += RegistValue;
    }

    private void FixedUpdate()
    {
        for (int i = 0; i < MoveList.Count; i++)
        {
            if (MoveList[i].DoMove())
            {
                i--;
            }
        }

        for (int i = 0; i < TweenForList.Count; i++)
        {
            if (TweenForList[i].DoForward())
            {
                i--;
            }
        }

        for (int i = 0; i < TweenBacList.Count; i++)
        {
            if (TweenBacList[i].DoBackward())
            {
                i--;
            }
        }
    }


    private void RegistValue()
    {
        MoveList = new List<Move>();
        TweenForList = new List<Tween>();
        TweenBacList = new List<Tween>();

        FunctionDicF = new Dictionary<Curve, CurveFunctionF>();
        FunctionDicC = new Dictionary<Curve, CurveFunctionC>();
        FunctionDicV = new Dictionary<Curve, CurveFunctionV>();

        MoveVecDic = new Dictionary<Transform, MoveVec>();
        TweenCgDic = new Dictionary<Transform, TweenCG>();
        TweenGraDic = new Dictionary<Transform, TweenGra>();
        TweenVecDic = new Dictionary<Transform, TweenVec>();
        TweenRectDic = new Dictionary<Transform, TweenRect>();
        TweenScaleDic = new Dictionary<Transform, TweenScale>();
        TweenAudioDic = new Dictionary<Transform, TweenAudio>();

        FunctionDicF.Add(Curve.Linear, Linear);
        FunctionDicF.Add(Curve.EaseOutQuad, EaseOutQuad);

        FunctionDicC.Add(Curve.Linear, Linear);
        FunctionDicC.Add(Curve.EaseOutQuad, EaseOutQuad);

        FunctionDicV.Add(Curve.Linear, Linear);
        FunctionDicV.Add(Curve.EaseOutQuad, EaseOutQuad);
    }


    #region 曲线

    public static float Linear(float timer, float duration, float start, float delta)
    {
        if (Math.Abs(duration) < 0.0005f)
        {
            return delta + start;
        }
        else
        {
            return delta * timer / duration + start;
        }
    }

    public static Color Linear(float timer, float duration, Color start, Color delta)
    {
        return new Color(Linear(timer, duration, start.r, delta.r), Linear(timer, duration, start.g, delta.g), Linear(timer, duration, start.b, delta.b), Linear(timer, duration, start.a, delta.a));
    }

    public static Vector3 Linear(float timer, float duration, Vector3 start, Vector3 delta)
    {
        return new Vector3(Linear(timer, duration, start.x, delta.x), Linear(timer, duration, start.y, delta.y), Linear(timer, duration, start.z, delta.z));
    }


    public static float EaseOutQuad(float timer, float duration, float start, float delta)
    {
        if (Math.Abs(duration) < 0.0005f)
        {
            return delta + start;
        }
        else
        {
            timer /= duration;

            return -delta * timer * (timer - 2) + start;
        }
    }

    public static Color EaseOutQuad(float timer, float duration, Color start, Color delta)
    {
        return new Color(EaseOutQuad(timer, duration, start.r, delta.r), EaseOutQuad(timer, duration, start.g, delta.g), EaseOutQuad(timer, duration, start.b, delta.b), EaseOutQuad(timer, duration, start.a, delta.a));
    }

    public static Vector3 EaseOutQuad(float timer, float duration, Vector3 start, Vector3 delta)
    {
        return new Vector3(EaseOutQuad(timer, duration, start.x, delta.x), EaseOutQuad(timer, duration, start.y, delta.y), EaseOutQuad(timer, duration, start.z, delta.z));
    }

    #endregion

    #region 播放动画

    public static void MoveVec(Transform target, Vector3 destination, float duration, Curve curve)
    {
        MoveVec moveVec;

        if (MoveVecDic.TryGetValue(target, out moveVec))
        {
            moveVec.StartMove(destination, duration, curve);
        }
        else
        {
            moveVec = CreateMoveVec(target);

            moveVec.StartMove(destination, duration, curve);
        }
    }


    public static void TweenForCG(Transform target)
    {
        TweenCG tweenCG;

        if (TweenCgDic.TryGetValue(target, out tweenCG))
        {
            tweenCG.StartForward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenForGra(Transform target)
    {
        TweenGra tweenGra;

        if (TweenGraDic.TryGetValue(target, out tweenGra))
        {
            tweenGra.StartForward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenForVec(Transform target)
    {
        TweenVec tweenVec;

        if (TweenVecDic.TryGetValue(target, out tweenVec))
        {
            tweenVec.StartForward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenForRect(Transform target)
    {
        TweenRect tweenRect;

        if (TweenRectDic.TryGetValue(target, out tweenRect))
        {
            tweenRect.StartForward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenForScale(Transform target)
    {
        TweenScale tweenScale;

        if (TweenScaleDic.TryGetValue(target, out tweenScale))
        {
            tweenScale.StartForward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenForAudio(Transform target)
    {
        TweenAudio tween;

        if (TweenAudioDic.TryGetValue(target, out tween))
        {
            tween.StartForward();
        }
        else
        {
            throw new Exception();
        }
    }


    public static void TweenBacCG(Transform target)
    {
        TweenCG tweenCG;

        if (TweenCgDic.TryGetValue(target, out tweenCG))
        {
            tweenCG.StartBackward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenBacGra(Transform target)
    {
        TweenGra tweenGra;

        if (TweenGraDic.TryGetValue(target, out tweenGra))
        {
            tweenGra.StartBackward();
        }
        else
        {
            throw new Exception(target.name);
        }
    }

    public static void TweenBacVec(Transform target)
    {
        TweenVec tweenVec;

        if (TweenVecDic.TryGetValue(target, out tweenVec))
        {
            tweenVec.StartBackward();
        }
        else
        {
            throw new Exception(target.name);
        }
    }

    public static void TweenBacRect(Transform target)
    {
        TweenRect tweenRect;

        if (TweenRectDic.TryGetValue(target, out tweenRect))
        {
            tweenRect.StartBackward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenBacScale(Transform target)
    {
        TweenScale tweenScale;

        if (TweenScaleDic.TryGetValue(target, out tweenScale))
        {
            tweenScale.StartBackward();
        }
        else
        {
            throw new Exception();
        }
    }

    public static void TweenBacAudio(Transform target)
    {
        TweenAudio tween;

        if (TweenAudioDic.TryGetValue(target, out tween))
        {
            tween.StartBackward();
        }
        else
        {
            throw new Exception();
        }
    }

    #endregion

    #region 得到动画

    public static MoveVec GetMoveVec(Transform target)
    {
        MoveVec moveVec;

        if (MoveVecDic.TryGetValue(target, out moveVec))
        {
            return moveVec;
        }
        else
        {
            throw new Exception();
        }
    }


    public static TweenCG GetTweenCG(Transform target)
    {
        TweenCG tweenCG;

        if (TweenCgDic.TryGetValue(target, out tweenCG))
        {
            return tweenCG;
        }
        else
        {
            throw new Exception();
        }
    }

    public static TweenGra GetTweenGra(Transform target)
    {
        TweenGra tweenGra;

        if (TweenGraDic.TryGetValue(target, out tweenGra))
        {
            return tweenGra;
        }
        else
        {
            throw new Exception();
        }
    }

    public static TweenVec GetTweenVec(Transform target)
    {
        TweenVec tweenVec;

        if (TweenVecDic.TryGetValue(target, out tweenVec))
        {
            return tweenVec;
        }
        else
        {
            throw new Exception();
        }
    }

    public static TweenRect GetTweenRect(Transform target)
    {
        TweenRect tweenRect;

        if (TweenRectDic.TryGetValue(target, out tweenRect))
        {
            return tweenRect;
        }
        else
        {
            throw new Exception();
        }
    }

    public static TweenScale GetTweenScale(Transform target)
    {
        TweenScale tweenScale;

        if (TweenScaleDic.TryGetValue(target, out tweenScale))
        {
            return tweenScale;
        }
        else
        {
            throw new Exception();
        }
    }

    public static TweenAudio GetTweenAudio(Transform target)
    {
        TweenAudio tween;

        if (TweenAudioDic.TryGetValue(target, out tween))
        {
            return tween;
        }
        else
        {
            throw new Exception();
        }
    }

    #endregion

    #region 创建动画

    public static MoveVec CreateMoveVec(Transform target)
    {
        if (MoveVecDic.ContainsKey(target))
        {
            MoveVec move = MoveVecDic[target];

            move = new MoveVec(target);

            return move;
        }
        else
        {
            MoveVec move = new MoveVec(target);

            MoveVecDic.Add(target, move);

            return move;
        }
    }


    public static TweenCG CreateTweenCG(Transform target, float origin, float destination,  float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenCgDic.ContainsKey(target))
        {
            CanvasGroup cg = target.GetComponent<CanvasGroup>();

            TweenCG tween = TweenCgDic[target];

            tween = new TweenCG(cg, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            CanvasGroup cg = target.GetComponent<CanvasGroup>();

            TweenCG tween = new TweenCG(cg, origin, destination, duration, originActive, destActive, curve);

            TweenCgDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenCG CreateTweenCG(Transform target, float destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenCgDic.ContainsKey(target))
        {
            CanvasGroup cg = target.GetComponent<CanvasGroup>();

            TweenCG tween = TweenCgDic[target];

            tween = new TweenCG(cg, cg.alpha, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            CanvasGroup cg = target.GetComponent<CanvasGroup>();

            TweenCG tween = new TweenCG(cg, cg.alpha, destination, duration, originActive, destActive, curve);

            TweenCgDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenGra CreateTweenGra(Transform target, Color origin, Color destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenGraDic.ContainsKey(target))
        {
            Graphic graphic = target.GetComponent<Graphic>();

            TweenGra tween = TweenGraDic[target];

            tween = new TweenGra(graphic, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            Graphic graphic = target.GetComponent<Graphic>();

            TweenGra tween = new TweenGra(graphic, origin, destination, duration, originActive, destActive, curve);

            TweenGraDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenGra CreateTweenGra(Transform target, Color destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenGraDic.ContainsKey(target))
        {
            Graphic graphic = target.GetComponent<Graphic>();

            TweenGra tween = TweenGraDic[target];

            tween = new TweenGra(graphic, graphic.color, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            Graphic graphic = target.GetComponent<Graphic>();

            TweenGra tween = new TweenGra(graphic, graphic.color, destination, duration, originActive, destActive, curve);

            TweenGraDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenVec CreateTweenVec(Transform target, Vector3 origin, Vector3 destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        origin.z = target.position.z;
        destination.z = target.position.z;

        if (TweenVecDic.ContainsKey(target))
        {
            TweenVec tween = TweenVecDic[target];

            tween = new TweenVec(target, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            TweenVec tween = new TweenVec(target, origin, destination, duration, originActive, destActive, curve);

            TweenVecDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenVec CreateTweenVec(Transform target, Vector3 destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        destination.z = target.position.z;

        if (TweenVecDic.ContainsKey(target))
        {
            TweenVec tween = TweenVecDic[target];

            tween = new TweenVec(target, target.position, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            TweenVec tween = new TweenVec(target, target.position, destination, duration, originActive, destActive, curve);

            TweenVecDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenRect CreateTweenRect(Transform target, Vector2 origin, Vector2 destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenRectDic.ContainsKey(target))
        {
            RectTransform rectTra = target.GetComponent<RectTransform>();

            TweenRect tween = TweenRectDic[target];

            tween = new TweenRect(rectTra, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            RectTransform rectTra = target.GetComponent<RectTransform>();

            TweenRect tween = new TweenRect(rectTra, origin, destination, duration, originActive, destActive, curve);

            TweenRectDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenRect CreateTweenRect(Transform target, Vector2 destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenRectDic.ContainsKey(target))
        {
            RectTransform rectTra = target.GetComponent<RectTransform>();

            TweenRect tween = TweenRectDic[target];

            tween = new TweenRect(rectTra, rectTra.rect.size, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            RectTransform rectTra = target.GetComponent<RectTransform>();

            TweenRect tween = new TweenRect(rectTra, rectTra.rect.size, destination, duration, originActive, destActive, curve);

            TweenRectDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenScale CreateTweenScale(Transform target, Vector3 origin, Vector3 destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenScaleDic.ContainsKey(target))
        {
            TweenScale tween = TweenScaleDic[target];

            tween = new TweenScale(target, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            TweenScale tween = new TweenScale(target, origin, destination, duration, originActive, destActive, curve);

            TweenScaleDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenScale CreateTweenScale(Transform target, Vector3 destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenScaleDic.ContainsKey(target))
        {
            TweenScale tween = TweenScaleDic[target];

            tween = new TweenScale(target, target.lossyScale, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            TweenScale tween = new TweenScale(target, target.lossyScale, destination, duration, originActive, destActive, curve);

            TweenScaleDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenAudio CreateTweenAudio(Transform target, float origin, float destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenAudioDic.ContainsKey(target))
        {
            TweenAudio tween = TweenAudioDic[target];

            tween = new TweenAudio(target.GetComponent<AudioSource>(), origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            TweenAudio tween = new TweenAudio(target.GetComponent<AudioSource>(), origin, destination, duration, originActive, destActive, curve);

            TweenAudioDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenAudio CreateTweenAudio(Transform target, float destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenAudioDic.ContainsKey(target))
        {
            AudioSource audio = target.GetComponent<AudioSource>();

            TweenAudio tween = TweenAudioDic[target];

            tween = new TweenAudio(audio , audio.volume, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            AudioSource audio = target.GetComponent<AudioSource>();

            TweenAudio tween = new TweenAudio(audio, audio.volume, destination, duration, originActive, destActive, curve);

            TweenAudioDic.Add(target, tween);

            return tween;
        }
    }

    #endregion
}