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 ShakeFunctionF(float timer, float duration, int repeat, float start, float strength);

public delegate Color ShakeFunctionC(float timer, float duration, int repeat, Color start, Color strength);

public delegate Vector3 ShakeFunctionV(float timer, float duration, int repeat, Vector3 start, Vector3 strength);


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 : Regist 
{
    #region 变量

    public static List<Anim> AnimList;
    public static List<Tween> TweenForList;
    public static List<Tween> TweenBacList;

    public static Dictionary<Curve, ShakeFunctionF> ShakeFunctionDicF;
    public static Dictionary<Curve, ShakeFunctionC> ShakeFunctionDicC;
    public static Dictionary<Curve, ShakeFunctionV> ShakeFunctionDicV;
    public static Dictionary<Curve, CurveFunctionF> CurveFunctionDicF;
    public static Dictionary<Curve, CurveFunctionC> CurveFunctionDicC;
    public static Dictionary<Curve, CurveFunctionV> CurveFunctionDicV;
    
    public static Dictionary<Transform, Move> MoveDic;
    public static Dictionary<Transform, Shake> ShakeDic;
    public static Dictionary<Transform, TweenSr> TweenSrDic;
    public static Dictionary<Transform, TweenCG> TweenCgDic;
    public static Dictionary<Transform, TweenGra> TweenGraDic;
    public static Dictionary<Transform, TweenVec> TweenVecDic;
    public static Dictionary<Transform, TweenText> TweenTextDic;
    public static Dictionary<Transform, TweenRect> TweenRectDic;
    public static Dictionary<Transform, TweenScale> TweenScaleDic;
    public static Dictionary<Transform, TweenAudio> TweenAudioDic;

    #endregion

    private void FixedUpdate()
    {
        for (int i = 0; i < AnimList.Count; i++)
        {
            if (AnimList[i].Do())
            {
                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--;
            }
        }
    }


    public override void RegistValueA()
    {
        AnimList = new List<Anim>();
        TweenForList = new List<Tween>();
        TweenBacList = new List<Tween>();

        CurveFunctionDicF = new Dictionary<Curve, CurveFunctionF>();
        CurveFunctionDicC = new Dictionary<Curve, CurveFunctionC>();
        CurveFunctionDicV = new Dictionary<Curve, CurveFunctionV>();
        ShakeFunctionDicF = new Dictionary<Curve, ShakeFunctionF>();
        ShakeFunctionDicC = new Dictionary<Curve, ShakeFunctionC>();
        ShakeFunctionDicV = new Dictionary<Curve, ShakeFunctionV>();

        MoveDic = new Dictionary<Transform, Move>();
        ShakeDic = new Dictionary<Transform, Shake>();
        TweenSrDic = new Dictionary<Transform, TweenSr>();
        TweenCgDic = new Dictionary<Transform, TweenCG>();
        TweenGraDic = new Dictionary<Transform, TweenGra>();
        TweenVecDic = new Dictionary<Transform, TweenVec>();
        TweenTextDic = new Dictionary<Transform, TweenText>();
        TweenRectDic = new Dictionary<Transform, TweenRect>();
        TweenScaleDic = new Dictionary<Transform, TweenScale>();
        TweenAudioDic = new Dictionary<Transform, TweenAudio>();

        ShakeFunctionDicF.Add(Curve.Linear, ShakeLinear);
        ShakeFunctionDicF.Add(Curve.EaseOutQuad, ShakeEaseOutQuad);

        ShakeFunctionDicC.Add(Curve.Linear, ShakeLinear);
        ShakeFunctionDicC.Add(Curve.EaseOutQuad, ShakeEaseOutQuad);

        ShakeFunctionDicV.Add(Curve.Linear, ShakeLinear);
        ShakeFunctionDicV.Add(Curve.EaseOutQuad, ShakeEaseOutQuad);

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

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

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


    #region 曲线

    public static float LinearTimer(float value, float duration, float start, float delta)
    {
        return (value - start) * duration / delta;
    }

    public static float EaseOutQuadTimer(float value, float duration, float start, float delta)
    {
        return ((2 - Mathf.Sqrt(4 - 4*(value - start)/delta))/2)*duration;
    }


    public static float ShakeLinear(float timer, float duration, int repeat, float start, float strength)
    {
        float sliceTime = duration/(4*repeat);

        for (int i = 0; i < repeat*4; i += 4)
        {
            if (timer > duration)
            {
                return start;
            }

            if (timer <= (i + 1) * sliceTime)
            {
                timer -= (i)*sliceTime;

                return Linear(timer, sliceTime, start, strength/(i/4 + 1));
            }
            else if (timer <= (i + 3)*sliceTime)
            {
                timer -= (i + 1)*sliceTime;

                return Linear(timer, 2*sliceTime, start + strength/(i/4 + 1), -2*strength/(i/4 + 1));
            }
            else if (timer <= (i + 4)*sliceTime)
            {
                timer -= (i + 3)*sliceTime;

                return Linear(timer, sliceTime, start - strength/(i/4 + 1), strength/(i/4 + 1));
            }
        }

        throw new Exception();
    }

    public static Color ShakeLinear(float timer, float duration, int repeat, Color start, Color strength)
    {
        float sliceTime = duration / (4 * repeat);

        for (int i = 0; i < repeat * 4; i += 4)
        {
            if (timer > duration)
            {
                return start;
            }

            if (timer <= (i + 1) * sliceTime)
            {
                timer -= (i) * sliceTime;

                return Linear(timer, sliceTime, start, strength / (i / 4 + 1));
            }
            else if (timer <= (i + 3) * sliceTime)
            {
                timer -= (i + 1) * sliceTime;

                return Linear(timer, 2 * sliceTime, start + strength / (i / 4 + 1), -2 * strength / (i / 4 + 1));
            }
            else if (timer <= (i + 4) * sliceTime)
            {
                timer -= (i + 3) * sliceTime;

                return Linear(timer, sliceTime, start - strength / (i / 4 + 1), strength / (i / 4 + 1));
            }
        }

        throw new Exception();
    }

    public static Vector3 ShakeLinear(float timer, float duration, int repeat, Vector3 start, Vector3 strength)
    {
        float sliceTime = duration / (4 * repeat);

        for (int i = 0; i < repeat * 4; i += 4)
        {
            if (timer > duration)
            {
                return start;
            }

            if (timer <= (i + 1) * sliceTime)
            {
                timer -= (i) * sliceTime;

                return Linear(timer, sliceTime, start, strength / (i / 4 + 1));
            }
            else if (timer <= (i + 3) * sliceTime)
            {
                timer -= (i + 1) * sliceTime;

                return Linear(timer, 2 * sliceTime, start + strength / (i / 4 + 1), -2 * strength / (i / 4 + 1));
            }
            else if (timer <= (i + 4) * sliceTime)
            {
                timer -= (i + 3) * sliceTime;

                return Linear(timer, sliceTime, start - strength / (i / 4 + 1), strength / (i / 4 + 1));
            }
        }

        throw new Exception();
    }


    public static float ShakeEaseOutQuad(float timer, float duration, int repeat, float start, float strength)
    {
        float sliceTime = duration / (4 * repeat);

        for (int i = 0; i < repeat * 4; i += 4)
        {
            if (timer > duration)
            {
                return start;
            }

            if (timer <= (i + 1) * sliceTime)
            {
                timer -= (i) * sliceTime;

                return EaseOutQuad(timer, sliceTime, start, strength / (i / 4 + 1));
            }
            else if (timer <= (i + 3) * sliceTime)
            {
                timer -= (i + 1) * sliceTime;

                return EaseOutQuad(timer, 2 * sliceTime, start + strength / (i / 4 + 1), -2 * strength / (i / 4 + 1));
            }
            else if (timer <= (i + 4) * sliceTime)
            {
                timer -= (i + 3) * sliceTime;

                return EaseOutQuad(timer, sliceTime, start - strength / (i / 4 + 1), strength / (i / 4 + 1));
            }
        }

        throw new Exception();
    }

    public static Color ShakeEaseOutQuad(float timer, float duration, int repeat, Color start, Color strength)
    {
        float sliceTime = duration / (4 * repeat);

        for (int i = 0; i < repeat * 4; i += 4)
        {
            if (timer > duration)
            {
                return start;
            }

            if (timer <= (i + 1) * sliceTime)
            {
                timer -= (i) * sliceTime;

                return EaseOutQuad(timer, sliceTime, start, strength / (i / 4 + 1));
            }
            else if (timer <= (i + 3) * sliceTime)
            {
                timer -= (i + 1) * sliceTime;

                return EaseOutQuad(timer, 2 * sliceTime, start + strength / (i / 4 + 1), -2 * strength / (i / 4 + 1));
            }
            else if (timer <= (i + 4) * sliceTime)
            {
                timer -= (i + 3) * sliceTime;

                return EaseOutQuad(timer, sliceTime, start - strength / (i / 4 + 1), strength / (i / 4 + 1));
            }
        }

        throw new Exception();
    }

    public static Vector3 ShakeEaseOutQuad(float timer, float duration, int repeat, Vector3 start, Vector3 strength)
    {
        float sliceTime = duration / (4 * repeat);

        for (int i = 0; i < repeat * 4; i += 4)
        {
            if (timer > duration)
            {
                return start;
            }

            if (timer <= (i + 1) * sliceTime)
            {
                timer -= (i) * sliceTime;

                return EaseOutQuad(timer, sliceTime, start, strength / (i / 4 + 1));
            }
            else if (timer <= (i + 3) * sliceTime)
            {
                timer -= (i + 1) * sliceTime;

                return EaseOutQuad(timer, 2 * sliceTime, start + strength / (i / 4 + 1), -2 * strength / (i / 4 + 1));
            }
            else if (timer <= (i + 4) * sliceTime)
            {
                timer -= (i + 3) * sliceTime;

                return EaseOutQuad(timer, sliceTime, start - strength / (i / 4 + 1), strength / (i / 4 + 1));
            }
        }

        throw new Exception();
    }


    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 Move(Transform target, Vector3 destination, float duration, bool local, Curve curve)
    {
        Move move;

        if (MoveDic.TryGetValue(target, out move))
        {
            move.StartMove(destination, duration, local, curve);
        }
        else
        {
            move = CreateMove(target);

            move.StartMove(destination, duration, local, curve);
        }
    }

    public static void Shake(Transform target, float duration, int repeat, Vector3 strength, Curve curve)
    {
        Shake shake;

        if (ShakeDic.TryGetValue(target, out shake))
        {
            shake.StartShake(repeat, duration, strength, curve);
        }
        else
        {
            shake = CreateShake(target);

            shake.StartShake(repeat, duration, strength, curve);
        }
    }


    public static void TweenForSr(Transform target)
    {
        TweenSr tweenSr;

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

    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 TweenForText(Transform target)
    {
        TweenText tweenText;

        if (TweenTextDic.TryGetValue(target, out tweenText))
        {
            tweenText.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 TweenBacSr(Transform target)
    {
        TweenSr tweenSr;

        if (TweenSrDic.TryGetValue(target, out tweenSr))
        {
            tweenSr.StartBackward();
        }
        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 TweenBacText(Transform target)
    {
        TweenText tweenText;

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

    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();
        }
    }


    public static void TweenConForSr(Transform target)
    {
        TweenSr tweenSr;

        if (TweenSrDic.TryGetValue(target, out tweenSr))
        {
            tweenSr.ConfineForward();
        }
        else
        {
            throw new Exception();
        }
    }

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

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

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

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

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

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

    public static void TweenConForText(Transform target)
    {
        TweenText tweenText;

        if (TweenTextDic.TryGetValue(target, out tweenText))
        {
            tweenText.ConfineForward();
        }
        else
        {
            throw new Exception();
        }
    }

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

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

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

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

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

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


    public static void TweenConBacSr(Transform target)
    {
        TweenSr tweenSr;

        if (TweenSrDic.TryGetValue(target, out tweenSr))
        {
            tweenSr.ConfineBackward();
        }
        else
        {
            throw new Exception();
        }
    }

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

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

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

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

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

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

    public static void TweenConBacText(Transform target)
    {
        TweenText tweenText;

        if (TweenTextDic.TryGetValue(target, out tweenText))
        {
            tweenText.ConfineBackward();
        }
        else
        {
            throw new Exception();
        }
    }

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

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

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

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

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

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

    #endregion

    #region 得到动画

    public static Move GetMove(Transform target)
    {
        Move move;

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

    public static Shake GetShake(Transform target)
    {
        Shake shake;

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


    public static TweenSr GetTweenSr(Transform target)
    {
        TweenSr tweenSr;

        if (TweenSrDic.TryGetValue(target, out tweenSr))
        {
            return tweenSr;
        }
        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 TweenText GetTweenText(Transform target)
    {
        TweenText tweenText;

        if (TweenTextDic.TryGetValue(target, out tweenText))
        {
            return tweenText;
        }
        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 Move CreateMove(Transform target)
    {
        if (MoveDic.ContainsKey(target))
        {
            Move move = MoveDic[target];

            move = new Move(target);

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

            MoveDic.Add(target, move);

            return move;
        }
    }

    public static Shake CreateShake(Transform target)
    {
        if (ShakeDic.ContainsKey(target))
        {
            Shake shake = ShakeDic[target];

            shake = new Shake(target);

            return shake;
        }
        else
        {
            Shake shake = new Shake(target);

            ShakeDic.Add(target, shake);

            return shake;
        }
    }


    public static TweenSr CreateTweenSr(Transform target, Color origin, Color destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenSrDic.ContainsKey(target))
        {
            SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

            TweenSr tween = TweenSrDic[target];

            tween = new TweenSr(sr, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

            TweenSr tween = new TweenSr(sr, origin, destination, duration, originActive, destActive, curve);

            TweenSrDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenSr CreateTweenSr(Transform target, Color destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenSrDic.ContainsKey(target))
        {
            SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

            TweenSr tween = TweenSrDic[target];

            tween = new TweenSr(sr, sr.color, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

            TweenSr tween = new TweenSr(sr, sr.color, destination, duration, originActive, destActive, curve);

            TweenSrDic.Add(target, tween);

            return tween;
        }
    }

    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 local, 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, local, originActive, destActive, curve);

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

            TweenVecDic.Add(target, tween);

            return tween;
        }
    }

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

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

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

            return tween;
        }
        else
        {
            TweenVec tween;

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

            TweenVecDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenText CreateTweenText(Transform target, float origin, float destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenRectDic.ContainsKey(target))
        {
            Text text = target.GetComponent<Text>();

            TweenText tween = TweenTextDic[target];

            tween = new TweenText(text, origin, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            Text text = target.GetComponent<Text>();

            TweenText tween = new TweenText(text, origin, destination, duration, originActive, destActive, curve);

            TweenTextDic.Add(target, tween);

            return tween;
        }
    }

    public static TweenText CreateTweenText(Transform target, float destination, float duration, bool originActive, bool destActive, Curve curve)
    {
        if (TweenRectDic.ContainsKey(target))
        {
            Text text = target.GetComponent<Text>();

            TweenText tween = TweenTextDic[target];

            tween = new TweenText(text, text.fontSize, destination, duration, originActive, destActive, curve);

            return tween;
        }
        else
        {
            Text text = target.GetComponent<Text>();

            TweenText tween = new TweenText(text, text.fontSize, destination, duration, originActive, destActive, curve);

            TweenTextDic.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
}