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

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

public enum Curve
{
    Linear,
    EaseOutQuad,
}

public enum EventType
{
    ForwardStart,
    BackwardStart,
    ForwardFinish,
    BackwardFinish,
}


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<Move> MoveList = new List<Move>();
    public static List<Tween> TweenForList = new List<Tween>();
    public static List<Tween> TweenBacList = new List<Tween>();

    public static Dictionary<Curve, ShakeFunctionF> ShakeFuncDicF = new Dictionary<Curve, ShakeFunctionF>();
    public static Dictionary<Curve, ShakeFunctionC> ShakeFuncDicC = new Dictionary<Curve, ShakeFunctionC>();
    public static Dictionary<Curve, ShakeFunctionV> ShakeFuncDicV = new Dictionary<Curve, ShakeFunctionV>();

    public static Dictionary<Curve, CurveFunctionF> CurveFuncDicF = new Dictionary<Curve, CurveFunctionF>();
    public static Dictionary<Curve, CurveFunctionC> CurveFuncDicC = new Dictionary<Curve, CurveFunctionC>();
    public static Dictionary<Curve, CurveFunctionV> CurveFuncDicV = new Dictionary<Curve, CurveFunctionV>();

    public static Dictionary<Transform, Shake> ShakeDic = new Dictionary<Transform, Shake>();
    public static Dictionary<Transform, Move2D> MoveDic2D = new Dictionary<Transform, Move2D>();
    public static Dictionary<Transform, Move3D> MoveDic3D = new Dictionary<Transform, Move3D>();
    public static Dictionary<Transform, Zoom2D> ZoomDic2D = new Dictionary<Transform, Zoom2D>();

    public static Dictionary<Transform, TweenSr> TweenSrDic = new Dictionary<Transform, TweenSr>();
    public static Dictionary<Transform, TweenCG> TweenCgDic = new Dictionary<Transform, TweenCG>();
    public static Dictionary<Transform, TweenGra> TweenGraDic = new Dictionary<Transform, TweenGra>();
    public static Dictionary<Transform, TweenVec> TweenVecDic = new Dictionary<Transform, TweenVec>();
    public static Dictionary<Transform, TweenText> TweenTextDic = new Dictionary<Transform, TweenText>();
    public static Dictionary<Transform, TweenRect> TweenRectDic = new Dictionary<Transform, TweenRect>();
    public static Dictionary<Transform, TweenScale> TweenScaleDic = new Dictionary<Transform, TweenScale>();
    public static Dictionary<Transform, TweenAudio> TweenAudioDic = new Dictionary<Transform, TweenAudio>();
    public static Dictionary<Transform, TweenNumber> TweenNumberDic = new Dictionary<Transform, TweenNumber>();

    #endregion

    public void FixedUpdate()
    {
        for (int i = 0; i < MoveList.Count; i++)
        {
            Move move = MoveList[i];

            if (move.Do())
            {
                if (MoveList.Remove(move))
                {
                    i--;
                }
            }
        }

        for (int i = 0; i < TweenForList.Count; i++)
        {
            Tween tween = TweenForList[i];

            if (tween.DoForward())
            {
                if (TweenForList.Remove(tween))
                {
                    i--;
                }
            }
        }

        for (int i = 0; i < TweenBacList.Count; i++)
        {
            Tween tween = TweenBacList[i];

            if (tween.DoBackward())
            {
                if (TweenBacList.Remove(tween))
                {
                    i--;
                }
            }
        }
    }


    public override void RegistImmed()
    {
        ShakeFuncDicF.Add(Curve.Linear, ShakeLinear);
        ShakeFuncDicF.Add(Curve.EaseOutQuad, ShakeEaseOutQuad);

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

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

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

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

        CurveFuncDicV.Add(Curve.Linear, Linear);
        CurveFuncDicV.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 Shake Shake(Transform target, float duration, int repeat, Vector3 strength, Curve curve)
    {
        Shake move;

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

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

        return move;
    }

    public static Move2D Move2D(Transform target, Vector3 destination, float duration, bool local, Curve curve)
    {
        Move2D move;

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

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

        return move;
    }

    public static Move3D Move3D(Transform target, Vector3 destination, float duration, bool local, Curve curve)
    {
        Move3D move;

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

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

        return move;
    }

    public static Zoom2D Zoom2D(Transform target, float origin, float destination, float duration, float stay, Transform targetZoom, Curve curve)
    {
        Zoom2D move;

        if (ZoomDic2D.TryGetValue(target, out move))
        {
            move.StartZoom(origin, destination, duration, stay, targetZoom, curve);
        }
        else
        {
            move = CreateZoom2D(target);

            move.StartZoom(origin, destination, duration, stay, targetZoom, curve);
        }

        return move;
    }

    public static Zoom2D Zoom2D(Transform target, float destination, float duration, float stay, Transform targetZoom, Curve curve)
    {
        Zoom2D move;

        Camera camera = target.GetComponent<Camera>();

        if (ZoomDic2D.TryGetValue(target, out move))
        {
            move.StartZoom(camera.orthographicSize, destination, duration, stay, targetZoom, curve);
        }
        else
        {
            move = CreateZoom2D(target);

            move.StartZoom(camera.orthographicSize, destination, duration, stay, targetZoom, curve);
        }

        return move;
    }


    public static TweenSr TweenForSr(Transform target)
    {
        TweenSr tween;

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

        return tween;
    }

    public static TweenCG TweenForCG(Transform target)
    {
        TweenCG tween;

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

        return tween;
    }

    public static TweenGra TweenForGra(Transform target)
    {
        TweenGra tween;

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

        return tween;
    }

    public static TweenVec TweenForVec(Transform target)
    {
        TweenVec tween;

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

        return tween;
    }

    public static TweenText TweenForText(Transform target)
    {
        TweenText tween;

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

        return tween;
    }

    public static TweenRect TweenForRect(Transform target)
    {
        TweenRect tween;

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

        return tween;
    }

    public static TweenScale TweenForScale(Transform target)
    {
        TweenScale tween;

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

        return tween;
    }

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

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

        return tween;
    }

    public static TweenNumber TweenForNumber(Transform target)
    {
        TweenNumber tween;

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

        return tween;
    }


    public static TweenSr TweenBacSr(Transform target)
    {
        TweenSr tween;

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

        return tween;
    }

    public static TweenCG TweenBacCG(Transform target)
    {
        TweenCG tween;

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

        return tween;
    }

    public static TweenGra TweenBacGra(Transform target)
    {
        TweenGra tween;

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

        return tween;
    }

    public static TweenVec TweenBacVec(Transform target)
    {
        TweenVec tween;

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

        return tween;
    }

    public static TweenText TweenBacText(Transform target)
    {
        TweenText tween;

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

        return tween;
    }

    public static TweenRect TweenBacRect(Transform target)
    {
        TweenRect tween;

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

        return tween;
    }

    public static TweenScale TweenBacScale(Transform target)
    {
        TweenScale tween;

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

        return tween;
    }

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

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

        return tween;
    }

    public static TweenNumber TweenBacNumber(Transform target)
    {
        TweenNumber tween;

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

        return tween;
    }


    public static TweenSr TweenConForSr(Transform target)
    {
        TweenSr tween;

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

        return tween;
    }

    public static TweenCG TweenConForCG(Transform target)
    {
        TweenCG tween;

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

        return tween;
    }

    public static TweenGra TweenConForGra(Transform target)
    {
        TweenGra tween;

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

        return tween;
    }

    public static TweenVec TweenConForVec(Transform target)
    {
        TweenVec tween;

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

        return tween;
    }

    public static TweenText TweenConForText(Transform target)
    {
        TweenText tween;

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

        return tween;
    }

    public static TweenRect TweenConForRect(Transform target)
    {
        TweenRect tween;

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

        return tween;
    }

    public static TweenScale TweenConForScale(Transform target)
    {
        TweenScale tween;

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

        return tween;
    }

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

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

        return tween;
    }

    public static TweenNumber TweenConForNumber(Transform target)
    {
        TweenNumber tween;

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

        return tween;
    }


    public static TweenSr TweenConBacSr(Transform target)
    {
        TweenSr tween;

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

        return tween;
    }

    public static TweenCG TweenConBacCG(Transform target)
    {
        TweenCG tween;

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

        return tween;
    }

    public static TweenGra TweenConBacGra(Transform target)
    {
        TweenGra tween;

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

        return tween;
    }

    public static TweenVec TweenConBacVec(Transform target)
    {
        TweenVec tween;

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

        return tween;
    }

    public static TweenText TweenConBacText(Transform target)
    {
        TweenText tween;

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

        return tween;
    }

    public static TweenRect TweenConBacRect(Transform target)
    {
        TweenRect tween;

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

        return tween;
    }

    public static TweenScale TweenConBacScale(Transform target)
    {
        TweenScale tween;

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

        return tween;
    }

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

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

        return tween;
    }

    public static TweenNumber TweenConBacNumber(Transform target)
    {
        TweenNumber tween;

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

        return tween;
    }

    #endregion

    #region 得到动画

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

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

    public static Move2D GetMove2D(Transform target)
    {
        Move2D move;

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

    public static Move3D GetMove3D(Transform target)
    {
        Move3D move;

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

    public static Zoom2D GetZoom2D(Transform target)
    {
        Zoom2D move;

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


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

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

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

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

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

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

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

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

    public static TweenText GetTweenText(Transform target)
    {
        TweenText tween;

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

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

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

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

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

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

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

    public static TweenNumber GetTweenNumber(Transform target)
    {
        TweenNumber tween;

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

    #endregion

    #region 创建动画

    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 Move2D CreateMove2D(Transform target)
    {
        if (MoveDic2D.ContainsKey(target))
        {
            Move2D move2D = MoveDic2D[target];

            move2D = new Move2D(target);

            return move2D;
        }
        else
        {
            Move2D move2D = new Move2D(target);

            MoveDic2D.Add(target, move2D);

            return move2D;
        }
    }

    public static Move3D CreateMove3D(Transform target)
    {
        if (MoveDic3D.ContainsKey(target))
        {
            Move3D move3D = MoveDic3D[target];

            move3D = new Move3D(target);

            return move3D;
        }
        else
        {
            Move3D move3D = new Move3D(target);

            MoveDic3D.Add(target, move3D);

            return move3D;
        }
    }

    public static Zoom2D CreateZoom2D(Transform target)
    {
        if (ZoomDic2D.ContainsKey(target))
        {
            Zoom2D zoom2D = ZoomDic2D[target];

            zoom2D = new Zoom2D(target.GetComponent<Camera>());

            return zoom2D;
        }
        else
        {
            Zoom2D zoom2D = new Zoom2D(target.GetComponent<Camera>());

            ZoomDic2D.Add(target, zoom2D);

            return zoom2D;
        }
    }


    public static TweenSr CreateTweenSr(Transform target, float originAlpha, float destinationAlpha, float duration, bool originActive, bool destActive, Curve curve, bool cg = false, bool group = false)
    {
        TweenSr tweenSr;
        SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

        Color origin = sr.color;
        Color destination = sr.color;

        origin.a = originAlpha;
        destination.a = destinationAlpha;

        if (TweenSrDic.ContainsKey(target))
        {
            tweenSr = TweenSrDic[target];

            tweenSr = new TweenSr(sr, origin, destination, duration, originActive, destActive, curve, cg, group);

            return tweenSr;
        }
        else
        {
            tweenSr = new TweenSr(sr, origin, destination, duration, originActive, destActive, curve, cg, group);

            TweenSrDic.Add(target, tweenSr);

            return tweenSr;
        }
    }

    public static TweenSr CreateTweenSr(Transform target, float destinationAlpha, float duration, bool originActive, bool destActive, Curve curve, bool cg = false, bool group = false)
    {
        TweenSr tweenSr;
        SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

        Color destination = sr.color;

        destination.a = destinationAlpha;

        if (TweenSrDic.ContainsKey(target))
        {
            tweenSr = TweenSrDic[target];

            tweenSr = new TweenSr(sr, sr.color, destination, duration, originActive, destActive, curve, cg, group);

            return tweenSr;
        }
        else
        {
            tweenSr = new TweenSr(sr, sr.color, destination, duration, originActive, destActive, curve, cg, group);

            TweenSrDic.Add(target, tweenSr);

            return tweenSr;
        }
    }

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

        if (TweenSrDic.ContainsKey(target))
        {
            tweenSr = TweenSrDic[target];

            tweenSr = new TweenSr(sr, origin, destination, duration, originActive, destActive, curve, cg, group);

            return tweenSr;
        }
        else
        {
            tweenSr = new TweenSr(sr, origin, destination, duration, originActive, destActive, curve, cg, group);

            TweenSrDic.Add(target, tweenSr);

            return tweenSr;
        }
    }

    public static TweenSr CreateTweenSr(Transform target, Color destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false, bool group = false)
    {
        TweenSr tweenSr;
        SpriteRenderer sr = target.GetComponent<SpriteRenderer>();

        if (TweenSrDic.ContainsKey(target))
        {
            tweenSr = TweenSrDic[target];

            tweenSr = new TweenSr(sr, sr.color, destination, duration, originActive, destActive, curve, cg, group);

            return tweenSr;
        }
        else
        {
            tweenSr = new TweenSr(sr, sr.color, destination, duration, originActive, destActive, curve, cg, group);

            TweenSrDic.Add(target, tweenSr);

            return tweenSr;
        }
    }
    

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

        if (TweenCgDic.ContainsKey(target))
        {
            tweenCg = TweenCgDic[target];

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

            return tweenCg;
        }
        else
        {
            tweenCg = new TweenCG(cg, origin, destination, duration, originActive, destActive, curve);

            TweenCgDic.Add(target, tweenCg);

            return tweenCg;
        }
    }

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

        if (TweenCgDic.ContainsKey(target))
        {
            tweenCg = TweenCgDic[target];

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

            return tweenCg;
        }
        else
        {
            tweenCg = new TweenCG(cg, cg.alpha, destination, duration, originActive, destActive, curve);

            TweenCgDic.Add(target, tweenCg);

            return tweenCg;
        }
    }


    public static TweenGra CreateTweenGra(Transform target, float originAlpha, float destinationAlpha, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        Graphic graphic = target.GetComponent<Graphic>();
        TweenGra tweenGra;

        Color origin = graphic.color;
        Color destination = graphic.color;

        origin.a = originAlpha;
        destination.a = destinationAlpha;

        if (TweenGraDic.ContainsKey(target))
        {
            tweenGra = TweenGraDic[target];

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

            return tweenGra;
        }
        else
        {
            tweenGra = new TweenGra(graphic, origin, destination, duration, originActive, destActive, curve, cg);

            TweenGraDic.Add(target, tweenGra);

            return tweenGra;
        }
    }

    public static TweenGra CreateTweenGra(Transform target, float destinationAlpha, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        Graphic graphic = target.GetComponent<Graphic>();
        TweenGra tweenGra;

        Color destination = graphic.color;

        destination.a = destinationAlpha;

        if (TweenGraDic.ContainsKey(target))
        {
            tweenGra = TweenGraDic[target];

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

            return tweenGra;
        }
        else
        {
            tweenGra = new TweenGra(graphic, graphic.color, destination, duration, originActive, destActive, curve, cg);

            TweenGraDic.Add(target, tweenGra);

            return tweenGra;
        }
    }

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

        if (TweenGraDic.ContainsKey(target))
        {
            tweenGra = TweenGraDic[target];

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

            return tweenGra;
        }
        else
        {
            tweenGra = new TweenGra(graphic, origin, destination, duration, originActive, destActive, curve, cg);

            TweenGraDic.Add(target, tweenGra);

            return tweenGra;
        }
    }

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

        if (TweenGraDic.ContainsKey(target))
        {
            tweenGra = TweenGraDic[target];

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

            return tweenGra;
        }
        else
        {
            tweenGra = new TweenGra(graphic, graphic.color, destination, duration, originActive, destActive, curve, cg);

            TweenGraDic.Add(target, tweenGra);

            return tweenGra;
        }
    }


    public static TweenVec CreateTweenVec2D(Transform target, Vector3 origin, Vector3 destination, float duration, bool local, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenVec tweenVec2D;

        origin.z = target.position.z;
        destination.z = target.position.z;

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

            tweenVec2D = new TweenVec(target, origin, destination, duration, local, originActive, destActive, curve, cg);

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

            TweenVecDic.Add(target, tweenVec2D);

            return tweenVec2D;
        }
    }

    public static TweenVec CreateTweenVec2D(Transform target, Vector3 destination, float duration, bool local, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenVec tweenVec2D;

        destination.z = target.position.z;

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

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

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

            TweenVecDic.Add(target, tweenVec2D);

            return tweenVec2D;
        }
    }


    public static TweenVec CreateTweenVec3D(Transform target, Vector3 origin, Vector3 destination, float duration, bool local, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenVec tweenVec3D;

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

            tweenVec3D = new TweenVec(target, origin, destination, duration, local, originActive, destActive, curve, cg);

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

            TweenVecDic.Add(target, tweenVec3D);

            return tweenVec3D;
        }
    }

    public static TweenVec CreateTweenVec3D(Transform target, Vector3 destination, float duration, bool local, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenVec tweenVec3D;

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

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

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

            TweenVecDic.Add(target, tweenVec3D);

            return tweenVec3D;
        }
    }


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

        if (TweenRectDic.ContainsKey(target))
        {
            tweenText = TweenTextDic[target];

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

            return tweenText;
        }
        else
        {
            tweenText = new TweenText(text, origin, destination, duration, originActive, destActive, curve, cg);

            TweenTextDic.Add(target, tweenText);

            return tweenText;
        }
    }

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

        if (TweenRectDic.ContainsKey(target))
        {
            tweenText = TweenTextDic[target];

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

            return tweenText;
        }
        else
        {
            tweenText = new TweenText(text, text.fontSize, destination, duration, originActive, destActive, curve, cg);

            TweenTextDic.Add(target, tweenText);

            return tweenText;
        }
    }


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

        if (TweenRectDic.ContainsKey(target))
        {
            tweenRect = TweenRectDic[target];

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

            return tweenRect;
        }
        else
        {
            tweenRect = new TweenRect(rectTra, origin, destination, duration, originActive, destActive, curve, cg);

            TweenRectDic.Add(target, tweenRect);

            return tweenRect;
        }
    }

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

        if (TweenRectDic.ContainsKey(target))
        {
            tweenRect = TweenRectDic[target];

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

            return tweenRect;
        }
        else
        {
            tweenRect = new TweenRect(rectTra, rectTra.rect.size, destination, duration, originActive, destActive, curve, cg);

            TweenRectDic.Add(target, tweenRect);

            return tweenRect;
        }
    }


    public static TweenScale CreateTweenScale(Transform target, Vector3 origin, Vector3 destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenScale tweenScale;

        if (TweenScaleDic.ContainsKey(target))
        {
            tweenScale = TweenScaleDic[target];

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

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

            TweenScaleDic.Add(target, tweenScale);

            return tweenScale;
        }
    }

    public static TweenScale CreateTweenScale(Transform target, Vector3 destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenScale tweenScale;

        if (TweenScaleDic.ContainsKey(target))
        {
            tweenScale = TweenScaleDic[target];

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

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

            TweenScaleDic.Add(target, tweenScale);

            return tweenScale;
        }
    }


    public static TweenAudio CreateTweenAudio(Transform target, float origin, float destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        TweenAudio tweenAudio;
        AudioSource audio = target.GetComponent<AudioSource>();

        if (TweenAudioDic.ContainsKey(target))
        {
            tweenAudio = TweenAudioDic[target];

            tweenAudio = new TweenAudio(audio, origin, destination, duration, originActive, destActive, curve, cg);

            return tweenAudio;
        }
        else
        {
            tweenAudio = new TweenAudio(audio, origin, destination, duration, originActive, destActive, curve, cg);

            TweenAudioDic.Add(target, tweenAudio);

            return tweenAudio;
        }
    }

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

        if (TweenAudioDic.ContainsKey(target))
        {
            tweenAudio = TweenAudioDic[target];

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

            return tweenAudio;
        }
        else
        {
            tweenAudio = new TweenAudio(audio, audio.volume, destination, duration, originActive, destActive, curve, cg);

            TweenAudioDic.Add(target, tweenAudio);

            return tweenAudio;
        }
    }


    public static TweenNumber CreateTweenNumber(Transform target, int origin, int destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        Text text = target.GetComponent<Text>();
        TweenNumber tweenNumber;

        if (TweenNumberDic.ContainsKey(target))
        {
            tweenNumber = TweenNumberDic[target];

            tweenNumber = new TweenNumber(text, origin, destination, duration, originActive, destActive, curve, cg);

            return tweenNumber;
        }
        else
        {
            tweenNumber = new TweenNumber(text, origin, destination, duration, originActive, destActive, curve, cg);

            TweenNumberDic.Add(target, tweenNumber);

            return tweenNumber;
        }
    }

    public static TweenNumber CreateTweenNumber(Transform target, int destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false)
    {
        Text text = target.GetComponent<Text>();
        TweenNumber tweenNumber;

        if (TweenNumberDic.ContainsKey(target))
        {
            tweenNumber = TweenNumberDic[target];

            tweenNumber = new TweenNumber(text, int.Parse(text.text), destination, duration, originActive, destActive, curve, cg);

            return tweenNumber;
        }
        else
        {
            tweenNumber = new TweenNumber(text, int.Parse(text.text), destination, duration, originActive, destActive, curve, cg);

            TweenNumberDic.Add(target, tweenNumber);

            return tweenNumber;
        }
    }

    #endregion
}