iTween扩展

在使用iTween时，由于参数很多，作者引入了Hashtable。我们再使用时基本都是用iTween.Hash(...)来添加参数。但是连续的字符串写起来确实有点麻烦。

首先我是看到了tkokof1的这篇博客：iTween那些事儿（二）

里面添加了iTweenHashtable这个类型，用来对iTween做改进。

我在他的基础上做了修改和完善。代码如下：

public class iTweenHashtable
{
    public delegate void iTweenCallback();

    //public delegate void iTweenCallbackParam(Object param);

    public delegate void iTweenCallbackParam(params object[] args);

    public delegate void iTweenIntCallback(int param);

    public delegate void iTweenFloatCallback(float param);

    public delegate void iTweenDoubleCallback(double param);

    private Hashtable m_innerTable = new Hashtable();

    public iTweenHashtable AudioSource(AudioSource source)
    {
        m_innerTable["audiosource"] = source;

        return this;
    }

    public iTweenHashtable AudioClip(AudioClip audioclip)
    {
        m_innerTable["audioclip"] = audioclip;

        return this;
    }

    public iTweenHashtable Volume(float volume)
    {
        m_innerTable["volume"] = volume;

        return this;
    }

    public iTweenHashtable Volume(double volume)
    {
        m_innerTable["volume"] = volume;

        return this;
    }

    public iTweenHashtable Pitch(float pitch)
    {
        m_innerTable["pitch"] = pitch;

        return this;
    }

    public iTweenHashtable Pitch(double pitch)
    {
        m_innerTable["pitch"] = pitch;

        return this;
    }

    public iTweenHashtable Color(Color color)
    {
        m_innerTable["color"] = color;

        return this;
    }

    public iTweenHashtable R(float r)
    {
        m_innerTable["r"] = r;

        return this;
    }

    public iTweenHashtable R(double r)
    {
        m_innerTable["r"] = r;

        return this;
    }

    public iTweenHashtable G(float g)
    {
        m_innerTable["g"] = g;

        return this;
    }

    public iTweenHashtable G(double g)
    {
        m_innerTable["g"] = g;

        return this;
    }

    public iTweenHashtable B(float b)
    {
        m_innerTable["b"] = b;

        return this;
    }

    public iTweenHashtable B(double b)
    {
        m_innerTable["b"] = b;

        return this;
    }

    public iTweenHashtable A(float a)
    {
        m_innerTable["a"] = a;

        return this;
    }

    public iTweenHashtable A(double a)
    {
        m_innerTable["a"] = a;

        return this;
    }

    public iTweenHashtable NamedColorValue(iTween.NamedValueColor value)
    {
        m_innerTable["namedcolorvalue"] = value;

        return this;
    }

    public iTweenHashtable NamedColorValue(string value)
    {
        m_innerTable["namedcolorvalue"] = value;

        return this;
    }

    public iTweenHashtable IncludeChildren(bool includechildren)
    {
        m_innerTable["includechildren"] = includechildren;

        return this;
    }

    public iTweenHashtable Alpha(float alpha)
    {
        m_innerTable["alpha"] = alpha;

        return this;
    }

    public iTweenHashtable Alpha(double alpha)
    {
        m_innerTable["alpha"] = alpha;

        return this;
    }

    public iTweenHashtable LookTarget(Transform looktarget)
    {
        m_innerTable["looktarget"] = looktarget;

        return this;
    }

    public iTweenHashtable LookTarget(Vector3 looktarget)
    {
        m_innerTable["looktarget"] = looktarget;

        return this;
    }

    public iTweenHashtable Axis(string axis)
    {
        m_innerTable["axis"] = axis;

        return this;
    }

    public iTweenHashtable OrientToPath(bool orienttopath)
    {
        m_innerTable["orienttopath"] = orienttopath;

        return this;
    }

    public iTweenHashtable LookTime(float looktime)
    {
        m_innerTable["looktime"] = looktime;

        return this;
    }

    public iTweenHashtable LookTime(double looktime)
    {
        m_innerTable["looktime"] = looktime;

        return this;
    }

    public iTweenHashtable Name(string name)
    {
        m_innerTable["name"] = name;

        return this;
    }

    public iTweenHashtable From(float val)
    {
        m_innerTable["from"] = val;

        return this;
    }

    public iTweenHashtable From(double val)
    {
        m_innerTable["from"] = val;

        return this;
    }

    public iTweenHashtable From(Vector3 val)
    {
        m_innerTable["from"] = val;

        return this;
    }

    public iTweenHashtable From(Vector2 val)
    {
        m_innerTable["from"] = val;

        return this;
    }

    public iTweenHashtable From(Color val)
    {
        m_innerTable["from"] = val;

        return this;
    }

    public iTweenHashtable From(Rect val)
    {
        m_innerTable["from"] = val;

        return this;
    }

    public iTweenHashtable To(float val)
    {
        m_innerTable["to"] = val;

        return this;
    }

    public iTweenHashtable To(double val)
    {
        m_innerTable["to"] = val;

        return this;
    }

    public iTweenHashtable To(Vector3 val)
    {
        m_innerTable["to"] = val;

        return this;
    }

    public iTweenHashtable To(Vector2 val)
    {
        m_innerTable["to"] = val;

        return this;
    }

    public iTweenHashtable To(Color val)
    {
        m_innerTable["to"] = val;

        return this;
    }

    public iTweenHashtable To(Rect val)
    {
        m_innerTable["to"] = val;

        return this;
    }

    public iTweenHashtable Amount(Vector3 amount)
    {
        m_innerTable["amount"] = amount;

        return this;
    }

    public iTweenHashtable X(float x)
    {
        m_innerTable["x"] = x;

        return this;
    }

    public iTweenHashtable X(double x)
    {
        m_innerTable["x"] = x;

        return this;
    }

    public iTweenHashtable Y(float y)
    {
        m_innerTable["y"] = y;

        return this;
    }

    public iTweenHashtable Y(double y)
    {
        m_innerTable["y"] = y;

        return this;
    }

    public iTweenHashtable Z(float z)
    {
        m_innerTable["z"] = z;

        return this;
    }

    public iTweenHashtable Z(double z)
    {
        m_innerTable["z"] = z;

        return this;
    }

    public iTweenHashtable Space(Space space)
    {
        m_innerTable["space"] = space;

        return this;
    }

    public iTweenHashtable Position(Vector3 position)
    {
        m_innerTable["position"] = position;

        return this;
    }

    public iTweenHashtable Position(Transform position)
    {
        m_innerTable["position"] = position;

        return this;
    }

    public iTweenHashtable Path(Vector3 path)
    {
        m_innerTable["path"] = path;

        return this;
    }

    public iTweenHashtable Path(Transform path)
    {
        m_innerTable["path"] = path;

        return this;
    }

    public iTweenHashtable Lookahead(float lookahead)
    {
        m_innerTable["lookahead"] = lookahead;

        return this;
    }

    public iTweenHashtable Lookahead(double lookahead)
    {
        m_innerTable["lookahead"] = lookahead;

        return this;
    }

    public iTweenHashtable MoveToPath(bool movetopath)
    {
        m_innerTable["movetopath"] = movetopath;

        return this;
    }

    public iTweenHashtable Rotation(Vector3 rotation)
    {
        m_innerTable["rotation"] = rotation;

        return this;
    }

    public iTweenHashtable Rotation(Transform rotation)
    {
        m_innerTable["rotation"] = rotation;

        return this;
    }

    public iTweenHashtable Scale(Vector3 scale)
    {
        m_innerTable["scale"] = scale;

        return this;
    }

    public iTweenHashtable IsLocal(bool isLocal)
    {
        m_innerTable["islocal"] = isLocal;

        return this;
    }

    public iTweenHashtable Time(float time)
    {
        m_innerTable["time"] = time;

        return this;
    }

    public iTweenHashtable Time(double time)
    {
        m_innerTable["time"] = time;

        return this;
    }

    public iTweenHashtable Speed(float speed)
    {
        m_innerTable["speed"] = speed;

        return this;
    }

    public iTweenHashtable Speed(double speed)
    {
        m_innerTable["speed"] = speed;

        return this;
    }

    public iTweenHashtable Delay(float delay)
    {
        m_innerTable["delay"] = delay;

        return this;
    }

    public iTweenHashtable Delay(double delay)
    {
        m_innerTable["delay"] = delay;

        return this;
    }

    public iTweenHashtable EaseType(iTween.EaseType easeType)
    {
        m_innerTable["easetype"] = easeType;

        return this;
    }

    public iTweenHashtable LoopType(iTween.LoopType loopType)
    {
        m_innerTable["looptype"] = loopType;

        return this;
    }

    public iTweenHashtable OnStart(iTweenCallback onStart)
    {
        m_innerTable["onstart"] = onStart.Method.Name;

        MonoBehaviour target = onStart.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onStart target cannot be null");
            return this;
        }

        m_innerTable["onstarttarget"] = target.gameObject;

        return this;
    }

    public iTweenHashtable OnStart(iTweenCallbackParam onStart, Object param)
    {
        m_innerTable["onstart"] = onStart.Method.Name;

        MonoBehaviour target = onStart.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onStart target cannot be null");
            return this;
        }

        m_innerTable["onstarttarget"] = target.gameObject;

        // NOTE: seems iTween can not handle this correct ...
        // in iTween.CleanArgs, it just do raw element access

        if (param == null)
        {
            Debug.LogError("onStart param cannot be null");
            return this;
        }

        m_innerTable["onstartparams"] = param;

        return this;
    }

    public iTweenHashtable OnStart(iTweenIntCallback onStart, int param)
    {
        m_innerTable["onstart"] = onStart.Method.Name;

        MonoBehaviour target = onStart.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onStart target cannot be null");
            return this;
        }

        m_innerTable["onstarttarget"] = target.gameObject;

        m_innerTable["onstartparams"] = param;

        return this;
    }

    public iTweenHashtable OnStart(iTweenFloatCallback onStart, float param)
    {
        m_innerTable["onstart"] = onStart.Method.Name;

        MonoBehaviour target = onStart.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onStart target cannot be null");
            return this;
        }

        m_innerTable["onstarttarget"] = target.gameObject;

        m_innerTable["onstartparams"] = param;

        return this;
    }

    public iTweenHashtable OnStart(iTweenDoubleCallback onStart, double param)
    {
        m_innerTable["onstart"] = onStart.Method.Name;

        MonoBehaviour target = onStart.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onStart target cannot be null");
            return this;
        }

        m_innerTable["onstarttarget"] = target.gameObject;

        m_innerTable["onstartparams"] = param;

        return this;
    }

    public iTweenHashtable OnUpdate()
    {
        m_innerTable["onupdate"] = string.Empty;
        return this;
    }

    public iTweenHashtable OnUpdate(iTweenCallback onUpdate)
    {
        m_innerTable["onupdate"] = onUpdate.Method.Name;

        MonoBehaviour target = onUpdate.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onUpdate target cannot be null");
            return this;
        }

        m_innerTable["onupdatetarget"] = target.gameObject;

        return this;
    }

    public iTweenHashtable OnUpdate(iTweenFloatCallback onUpdate)
    {
        m_innerTable["onupdate"] = onUpdate.Method.Name;

        MonoBehaviour target = onUpdate.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onUpdate target cannot be null");
            return this;
        }

        m_innerTable["onupdatetarget"] = target.gameObject;

        return this;
    }

    public iTweenHashtable OnUpdate(iTweenCallbackParam onUpdate, Object param)
    {
        m_innerTable["onupdate"] = onUpdate.Method.Name;

        MonoBehaviour target = onUpdate.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onUpdate target cannot be null");
            return this;
        }

        m_innerTable["onupdatetarget"] = target.gameObject;


        // NOTE: seems iTween can not handle this correct ...
        // in iTween.CleanArgs, it just do raw element access

        if (param == null)
        {
            Debug.LogError("onUpdate param cannot be null");
            return this;
        }

        m_innerTable["onupdateparams"] = param;

        return this;
    }

    public iTweenHashtable OnUpdate(iTweenIntCallback onUpdate, int param)
    {
        m_innerTable["onupdate"] = onUpdate.Method.Name;

        MonoBehaviour target = onUpdate.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onUpdate target cannot be null");
            return this;
        }

        m_innerTable["onupdatetarget"] = target.gameObject;

        m_innerTable["onupdateparams"] = param;

        return this;
    }

    public iTweenHashtable OnUpdate(iTweenFloatCallback onUpdate, float param)
    {
        m_innerTable["onupdate"] = onUpdate.Method.Name;

        MonoBehaviour target = onUpdate.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onUpdate target cannot be null");
            return this;
        }

        m_innerTable["onupdatetarget"] = target.gameObject;

        m_innerTable["onupdateparams"] = param;

        return this;
    }

    public iTweenHashtable OnUpdate(iTweenDoubleCallback onUpdate, double param)
    {
        m_innerTable["onupdate"] = onUpdate.Method.Name;

        MonoBehaviour target = onUpdate.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onUpdate target cannot be null");
            return this;
        }

        m_innerTable["onupdatetarget"] = target.gameObject;

        m_innerTable["onupdateparams"] = param;

        return this;
    }

    public iTweenHashtable OnComplete(iTweenCallback onComplete)
    {
        m_innerTable["oncomplete"] = onComplete.Method.Name;

        MonoBehaviour target = onComplete.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onComplete target cannot be null");
            return this;
        }

        m_innerTable["oncompletetarget"] = target.gameObject;

        return this;
    }

    public iTweenHashtable OnComplete(iTweenCallbackParam onComplete, Object param)
    {
        m_innerTable["oncomplete"] = onComplete.Method.Name;

        MonoBehaviour target = onComplete.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onComplete target cannot be null");
            return this;
        }

        m_innerTable["oncompletetarget"] = target.gameObject;


        // NOTE: seems iTween can not handle this correct ...
        //in iTween.CleanArgs, it just do raw element access

        if (param == null)
        {
            Debug.LogError("onComplete param cannot be null");
            return this;
        }

        m_innerTable["oncompleteparams"] = param;

        return this;
    }

    public iTweenHashtable OnComplete(iTweenIntCallback onComplete, int param)
    {
        m_innerTable["oncomplete"] = onComplete.Method.Name;

        MonoBehaviour target = onComplete.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onComplete target cannot be null");
            return this;
        }

        m_innerTable["oncompletetarget"] = target.gameObject;

        m_innerTable["oncompleteparams"] = param;

        return this;
    }

    public iTweenHashtable OnComplete(iTweenFloatCallback onComplete, float param)
    {
        m_innerTable["oncomplete"] = onComplete.Method.Name;

        MonoBehaviour target = onComplete.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onComplete target cannot be null");
            return this;
        }

        m_innerTable["oncompletetarget"] = target.gameObject;

        m_innerTable["oncompleteparams"] = param;

        return this;
    }

    public iTweenHashtable OnComplete(iTweenDoubleCallback onComplete, double param)
    {
        m_innerTable["oncomplete"] = onComplete.Method.Name;

        MonoBehaviour target = onComplete.Target as MonoBehaviour;

        if (target == null)
        {
            Debug.LogError("onComplete target cannot be null");
            return this;
        }

        m_innerTable["oncompletetarget"] = target.gameObject;

        m_innerTable["oncompleteparams"] = param;

        return this;
    }

    public iTweenHashtable IgnoreTimeScale(bool ignoreTimeScale)
    {
        m_innerTable["ignoretimescale"] = ignoreTimeScale;

        return this;
    }

    public void Clear()
    {
        m_innerTable.Clear();
    }

    public static implicit operator Hashtable(iTweenHashtable table)
    {
        return table.m_innerTable;
    }
}

接下来是一个工具类：

public static class iTweenEx
{
    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长(秒)</param>
    /// <param name="onComplete">计时结束要执行的委托</param>
    public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenCallback onComplete)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnComplete(onComplete).OnUpdate();
        iTween.ValueTo(target, hash);
    }

    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长(秒)</param>
    /// <param name="onStart">计时开始要执行的委托</param>
    /// <param name="onComplete">计时结束要执行的委托</param>
    public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenCallback onStart,
        iTweenHashtable.iTweenCallback onComplete)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnComplete(onComplete).OnStart(onStart).OnUpdate();
        iTween.ValueTo(target, hash);
    }

    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长(秒)</param>
    /// <param name="onStart">计时开始要执行的委托</param>
    /// <param name="onComplete">计时结束要执行的委托</param>
    /// <param name="onUpdate">计时中要执行的委托</param>
    public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenCallback onStart,
        iTweenHashtable.iTweenCallback onComplete,
        iTweenHashtable.iTweenCallback onUpdate)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnComplete(onComplete).OnStart(onStart).OnUpdate(onUpdate);
        iTween.ValueTo(target, hash);
    }

    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长(秒)</param>
    /// <param name="onStart">计时开始要执行的委托</param>
    /// <param name="onComplete">计时结束要执行的委托</param>
    /// <param name="onUpdate">计时中要执行的委托</param>
    public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenCallback onStart,
        iTweenHashtable.iTweenCallback onComplete,
        iTweenHashtable.iTweenFloatCallback onUpdate)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnComplete(onComplete).OnStart(onStart).OnUpdate(onUpdate);
        iTween.ValueTo(target, hash);
    }

    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长(秒)</param>
    /// <param name="onComplete">计时结束要执行的委托</param>
    /// <param name="onUpdate">计时中要执行的委托</param>
    public static void CountExecute(GameObject target, float time,iTweenHashtable.iTweenCallback onComplete,
        iTweenHashtable.iTweenFloatCallback onUpdate)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnComplete(onComplete).OnUpdate(onUpdate);
        iTween.ValueTo(target, hash);
    }

    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长(秒)</param>
    /// <param name="delay">延迟时长(秒),即开始计时之前的时长</param>
    /// <param name="onStart">计时开始要执行的委托</param>
    /// <param name="onComplete">计时结束要执行的委托</param>
    public static void CountExecute(GameObject target, float time, float delay, iTweenHashtable.iTweenCallback onStart,
        iTweenHashtable.iTweenCallback onComplete)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).Delay(delay).OnComplete(onComplete).OnStart(onStart).OnUpdate();
        iTween.ValueTo(target, hash);
    }


    ///// <summary>
    ///// 计时委托
    ///// </summary>
    ///// <param name="target">脚本所在对象</param>
    ///// <param name="time">计时时长</param>
    ///// <param name="onUpdate">计时委托</param>
    //public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenCallback onUpdate)
    //{
    //    iTweenHashtable hash = new iTweenHashtable();
    //    hash.From(0).To(time).Time(time).OnUpdate(onUpdate);
    //    iTween.ValueTo(target, hash);
    //}

    /// <summary>
    /// 计时委托
    /// </summary>
    /// <param name="target">脚本所在对象</param>
    /// <param name="time">计时时长</param>
    /// <param name="onUpdate">计时委托</param>
    public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenFloatCallback onUpdate)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnUpdate(onUpdate);
        iTween.ValueTo(target, hash);
    }
}

项目里经常会用到一些小计时。比如3秒后执行一个操作。比如先执行一个操作，完成后在执行一个操作。这里直接用我的工具类就方便多了。

测试类如下：

public class ItweenTest : MonoBehaviour
{
    private float count;
    private string tip;
    private int complextCount;

    private void OnGUI()
    {
        if (GUILayout.Button("Count up to 10"))
        {
            iTweenEx.CountExecute(gameObject, 10, Tick);
        }

        GUILayout.Label("Time elapsed: " + count);

        if (GUILayout.Button("Count down form 10"))
        {
            iTweenEx.CountExecute(gameObject, 10, OnStart, OnComplete, OnUpdate);
        }

        GUILayout.Label(tip);

        if (GUILayout.Button("Complex Count"))
        {
            iTweenEx.CountExecute(gameObject, 5, () =>
            {
                complextCount = 0;
            }, () => iTweenEx.CountExecute(gameObject, 5, time =>
            {
                complextCount = 5 - (int) time;
            }), time =>
            {
                complextCount = (int) time;
            });
        }

        GUILayout.Label("Complex Count: " + complextCount);
    }

    private void OnUpdate(float time)
    {
        tip = "Time left: " + (10 - (int) time);
    }

    private void OnComplete()
    {
        tip = "Done!";
    }

    private void OnStart()
    {
        tip = "Started!";
    }


    private void Tick(float time)
    {
        //if ((float) tick - count >= 1)
        //{
        //    count++;
        //}
        count = (int) time;
    }
}

第一个按钮是顺数10秒，并显示已过去时间。这里Tick传入的time是从计时开始算起，已过的时间哦。转成整型即为数整秒。

第二个操作是倒数10秒，开始和结束都给出提示，并显示剩余时间。

第三个按钮是先顺数到5，再倒数到0。第三个例子用到了匿名委托和Lambda表达式，而且在iTween里进行了嵌套。是不是很方便？

CountExecute实际上用到的是iTween.ValueTo。在使用ValueTo时必须要有update，于是我在iTweenHashtable里添加了一个空Update

    public iTweenHashtable OnUpdate()
    {
        m_innerTable["onupdate"] = string.Empty;
        return this;
    }

iTweenHashtable的使用可以参考上面的工具类。

public static void CountExecute(GameObject target, float time, iTweenHashtable.iTweenCallback onComplete)
    {
        iTweenHashtable hash = new iTweenHashtable();
        hash.From(0).To(time).Time(time).OnComplete(onComplete).OnUpdate();
        iTween.ValueTo(target, hash);
    }