Unity封装延时调用定时器-猿码集

1. 引言

在游戏开发过程中，经常需要使用定时器来处理一些延迟调用的情况，比如在一定时间间隔内执行某个函数或者在延迟一定时间后执行某个任务。在Unity中，可以使用Coroutines（协程）来实现定时器的功能。

2. Unity中的Coroutines

在Unity中，Coroutines是一种特殊的函数，可以在运行过程中的某个时间间隔内被暂停和继续执行。在使用Coroutines实现定时器功能之前，首先需要了解一些基本概念。

2.1 StartCoroutine和yield return

在Unity中使用Coroutines，需要使用StartCoroutine函数来启动一个协程，并使用yield return语句来控制协程的执行流程。


IEnumerator MyCoroutine()
{
    // 执行一些操作
    yield return null; // 等待一帧后继续执行
    // 执行一些其他操作
}

在上面的代码中，通过yield return null语句可以暂停当前协程的执行，等待一帧后再继续执行，从而实现定时器的效果。

2.2 WaitForSeconds

除了使用yield return null来等待一帧后继续执行，Unity还提供了WaitForSeconds类来实现以秒为单位的延迟。


IEnumerator MyCoroutine()
{
    // 执行一些操作
    yield return new WaitForSeconds(1.0f); // 等待1秒后继续执行
    // 执行一些其他操作
}

在上面的代码中，通过new WaitForSeconds(1.0f)可以等待1秒后再继续执行。

2.3 使用Coroutines封装定时器

根据上述的基本概念，可以使用Coroutines来封装一个简单的定时器。


IEnumerator TimerCoroutine(float delay, Action callback)
{
    yield return new WaitForSeconds(delay);
    callback?.Invoke();
}

在上面的代码中，TimerCoroutine函数接受一个延时参数和一个回调函数作为参数，通过使用WaitForSeconds来等待指定的延时时间后执行回调函数。

3. 延时调用定时器的封装

除了简单的定时器，有时候还需要对定时器进行封装，使其支持延时调用的功能。下面将介绍一个延时调用定时器的封装方案。

3.1 延时调用定时器的需求

延时调用定时器可以实现在一定时间间隔后执行某个函数。比如在游戏中，可以使用延时调用定时器来实现技能的冷却时间、敌人的攻击间隔等功能。

3.2 延时调用定时器的封装

延时调用定时器的封装可以通过使用Coroutine和Dictionary来实现。


public class TimerManager : MonoBehaviour
{
    private static TimerManager instance;
    private Dictionary<float, List<Action>> timerDictionary;
    private void Awake()
    {
        if (instance == null)
        {
            instance = this;
            timerDictionary = new Dictionary<float, List<Action>>();
        }
        else
        {
            Destroy(gameObject);
        }
    }
    public static void StartTimer(float delay, Action callback)
    {
        if (!instance.timerDictionary.ContainsKey(delay))
        {
            instance.timerDictionary.Add(delay, new List<Action>());
            instance.StartCoroutine(instance.TimerCoroutine(delay));
        }
        instance.timerDictionary[delay].Add(callback);
    }
    private IEnumerator TimerCoroutine(float delay)
    {
        yield return new WaitForSeconds(delay);
        if (instance.timerDictionary.ContainsKey(delay))
        {
            foreach (Action callback in instance.timerDictionary[delay])
            {
                callback?.Invoke();
            }
            instance.timerDictionary.Remove(delay);
        }
    }
}

在上面的代码中，通过使用Dictionary来存储定时器的延时时间和对应的回调函数列表。在StartTimer函数中，首先判断是否已经存在相同延时时间的定时器，如果不存在则启动一个新的定时器协程，并将回调函数添加到对应的列表中。

在TimerCoroutine函数中，通过等待指定的延时时间后执行对应的回调函数列表，并在执行完毕后从Dictionary中移除延时时间。

4. 使用示例

下面给出一个使用延时调用定时器的示例。


public class Test : MonoBehaviour
{
    private void Start()
    {
        TimerManager.StartTimer(2.0f, () => {
            Debug.Log("Delayed callback!");
        });
    }
}

在上面的代码中，调用TimerManager的StartTimer函数来延时2秒后执行回调函数，在回调函数中输出"Delayed callback!"。

5. 总结

通过使用Coroutines和Dictionary，可以很方便地封装延时调用定时器，实现在一定时间间隔后执行某个函数的功能。使用定时器可以方便地处理游戏中的延迟调用需求，提高代码的可读性和维护性。

Unity封装延时调用定时器