Unity计时器

       在Unity中有三种主要的处理定时器的方法：

       1.使用带有WaitForSeconds方法的协程。
       2.将计时器启动的时间存储在私有变量中（例如m_startTime = Time.time），检查更新调用 If(Time.time - m_startTime >= m_timerDuration)。

       3.调用Invoke相关方法

       第一种方法很冗长，可能还需要重构代码以使用IEnumerator函数。此外，它需要访问MonoBehaviour实例来启动协程，这意味着该解决方案不适用于非MonoBehaviour类。最后，没有办法阻止WaitForSeconds受到TimeScale变化的影响。
       第二种方法容易出错，并且隐藏了表达的实际游戏逻辑，使代码不易于阅读。

       第三种方法和第一种方法一样，也会受到TimeScale变化的影响。

       此工具缓解了上述问题，可以轻松地在项目中的任何自定义类里添加可靠方便的计时器。

       工具链接:https://download.csdn.net/download/abc1090275833/10989879

 

       另附上一个计时器的实现：

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

public class SupportTask
{
    public Action m_cb;
    public float m_duration;
    public bool m_unTimeScale = false;
    public SupportTask(Action cb, float f, bool unTimeScale)
    {
        m_cb = cb;
        m_duration = f;
        m_unTimeScale = unTimeScale;
    }
}

/// <summary>
/// 文件名(File Name): SupportBehavior.cs
/// 作者(Author): 
/// 日期(Create Data): 2016
/// </summary>

public class SupportBehavior : MonoBehaviour
{

    private static SupportBehavior m_inst;
    private static bool appDestroyed = false;

    public static SupportBehavior inst
    {
        get
        {
            if (appDestroyed)
            {
                return null;
            }
            if (m_inst == null)
            {
                GameObject supportBehavior = new GameObject("SupBehavior");
                m_inst = supportBehavior.AddComponent<SupportBehavior>();
                GameObject.DontDestroyOnLoad(supportBehavior);
            }
            return m_inst;
        }
    }

    public List<Action> m_onUpdate = new List<Action>();
    public List<Action> m_onFixedUpdate = new List<Action>();
    public List<Action> m_onLateUpdate = new List<Action>();

    public List<SupportTask> m_cbs = new List<SupportTask>();

    private void Awake()
    {
        m_inst = this;
    }

    void Update()
    {
        for (int i = 0; i < m_onUpdate.Count; i++)
        {
            try
            {
                m_onUpdate[i]();
            }
            catch (Exception e)
            {
                Debug.LogError(e.ToString());
            }
        }
        if (m_cbs.Count > 0)
        {
            for (int i = m_cbs.Count - 1; i > -1; i--)
            {
                SupportTask task = m_cbs[i];
                if (task.m_unTimeScale)
                {
                    task.m_duration = task.m_duration - Time.unscaledDeltaTime;
                    if (task.m_duration <= 0)
                    {
                        try
                        {
                            task.m_cb();
                        }
                        catch (Exception e)
                        {
                            Debug.LogError(e.ToString());
                        }
                        if (m_cbs.Contains(task))
                        {
                            m_cbs.Remove(task);
                        }
                        RemoveCb(task.m_cb);
                    }
                }
            }
        }
    }

    void FixedUpdate()
    {
        for (int i = 0; i < m_onFixedUpdate.Count; i++)
        {
            try
            {
                m_onFixedUpdate[i]();
            }
            catch (Exception e)
            {
                //Debug.LogError(e.ToString());
            }
        }
        if (m_cbs.Count > 0)
        {
            for (int i = m_cbs.Count - 1; i > -1; i--)
            {
                if (i >= m_cbs.Count)
                {
                    continue;
                }
                SupportTask task = m_cbs[i];
                if (!task.m_unTimeScale)
                {
                    task.m_duration = task.m_duration - Time.deltaTime;
                    if (task.m_duration <= 0)
                    {
                        try
                        {
                            task.m_cb();
                        }
                        catch (Exception e)
                        {
                            Debug.LogError(e.ToString());
                        }
                        //这里可能会导致重复addcallback时remove刚加入的callback导致bug
                        if (m_cbs.Contains(task))
                        {
                            m_cbs.Remove(task);
                        }
                        RemoveCb(task.m_cb);
                    }
                }

            }
        }
    }

    void LateUpdate()
    {
        for (int i = 0; i < m_onLateUpdate.Count; i++)
        {
            try
            {
                m_onLateUpdate[i]();
            }
            catch (Exception e)
            {
                Debug.LogError(e.ToString());
            }
        }
    }

    public void AddCbAfter(float s, Action cb, bool unscaleTime = false)
    {
        m_cbs.Add(new SupportTask(cb, s, unscaleTime));
    }

    public void RemoveCb(Action cb)
    {
        for (int i = m_cbs.Count - 1; i > -1; i--)
        {
            if (m_cbs[i].m_cb == cb)
            {
                m_cbs.RemoveAt(i);
            }
        }
    }

    private void OnApplicationQuit()
    {
        appDestroyed = true;
    }
}