Unity打造Timer定时器框架

1: 为什么我们要自己造轮子来做定时器系统

传统的Unity做定时器的方式有三种，总结如下:

对啦！这里有个游戏开发交流小组里面聚集了一帮热爱学习游戏的零基础小白，也有一些正在从事游戏开发的技术大佬，欢迎你来交流学习。

(1) 在组件类里面定义一个变量，每次Update的时候，累积时间，当时间到达特定的阈值时, 触发函数调用。

void Update() {
        float dt = Time.deltaTime;
        this.passedTime += dt;
         if(this.passedTime >= 阈值) {
                  doSomeThing();
                  this.passedTime -= 阈值;
          }
}

(2) 使用协程,来做定时器等待。

yeild return new WaitForSecond(5.0f);

// 5秒后做相关的事情

doSomeThing();

(3) 组件类MonoBehaviour 接口 Invoke，来做定时器 this.Invoke("doSomeThing", 5);

上面三种方法都有自己的缺点，第(1)(2)种使用起来不方便, 第(3)种节点隐藏后不方便触发，不方便掉其他代码里面的回调函数,不方便传递参数。

所以我们在项目里面决定自己造轮子,来打造一个Timer模块，处理游戏种的各种定时器需求。

2: 定时器系统的核心原理是什么？

每个定时器对象是一个Timer, 添加的时候交给定时器管理系统, 定时器系统负责管理所有的定时器对象，每次游戏Update的时候，遍历里面的每个定时器对象，

把它们过去的时间增加Time.deltaTime, 当过去的时间达到定时器触发时间的时候,触发定时器调用, 如果达到Timer触发次数，就把这个Timer移除,

否则就重置时间，继续直到下一个时间的触发。

3: 如何设计的接口

(1) 编写TimerMgr Timer管理的一个单例，在游戏初始化的时候创建出来。

(2) 添加Init()接口, 在初始化的时候调用Init接口，对TimerMgr所要的数据与状态进行初始化。

(3) 编写Update函数，在每次Update的时候迭代Timer,来负责Timer的触发。

(4) 提供Schedule系列接口，来给用户加一个定时器，Schedule系列接口如下:

【参数】: func Timer时间到了以后调用的回调函数;

param: 用户给Timer触发回调函数传递的参数, 类型object,可以传任意类型的数据;

repeat: timer 要重复调用的次数;

duration: 每次timer调用的时间间隔;

delay: 第一次timer触发在多少秒以后;

【返回值】: Timer ID号，根据这个ID号可以在TimerMgr中查到这个Timer对象，用来作为删除Timer的凭证;

public int Schedule(TimerHandler func, object param, int repeat, float duration, float delay = 0.0f);

(5)提供Unschedule系列接口:

【参数】: timerId, Timer的唯一标识Id号,根据这个Id号取消Timer

public void Unschedule(int timeId);

4: 具体实现

(1) Timer对象，每一个Timer就是一个Timer对象，这个Timer对象保存到TimerMgr里面，数据结构定义如下:

class TimerNode
{
	public TimerMgr.TimerHandler callback;
	public float duration; // 定时器触发的时间间隔;
	public float delay; // 第一次触发要隔多少时间;
	public int repeat; // 你要触发的次数;
	public float passedTime; // 这个Timer过去的时间;
	public object param; // 用户要传的参数
	public bool isRemoved; // 是否已经删除了
	public int timerId; // 标识这个timer的唯一Id号;
}

(2) TimerMgr 定义一个委托类型，用来作为回调函数的类型：

public delegate void TimerHandler(object param);

(3) 定义一个字典，用来存放timeId到Timer对象的一个映射，存放游戏里面所有的Timer对象。

private Dictionary<int, TimerNode> timers = null;

(4) 两个缓存队列, 一个是新增Timer的缓存列表，一个是已删除Timer的缓存列表，这个机制非常的重要，当我们新增或删除Timer的时候，

有可能在遍历Timer 触发回调的里面来添加或删除一个Timer, 如果直接操作map里面的Timer，这样就会改变遍历时候的结构，导致出错，所以我们添加或

删除Timer的时候, 先放到缓存队列，等Update里面Timer遍历完了以后，再来添加或移除Timer到TimerMgr的map里面。

private List<TimerNode> removeTimers = null;

private List<TimerNode> newAddTimers = null;

(5) 每个Timer有一个唯一的Id号，所以我们设置一个自增长的Id号机制，在TimerMgr里面加数据成员 autoIncId, 每次创建一个Timer,就把autoIncId当前的值作为Id号，并往后加1。

private int autoIncId = 1;

(6) 初始化TimerMgr:

 public void Init()
 {
	this.timers = new Dictionary<int, TimerNode>();
	this.autoIncId = 1;
	this.removeTimers = new List<TimerNode>();
	this.newAddTimers = new List<TimerNode>();
}

(7) Schedule系列接口, 其余的都调用这个接口，传特殊的参数:

	// [repeat < 0 or repeat == 0 表示的是无限触发]
	    public int Schedule(TimerHandler func, object param, int repeat, float duration, float delay = 0.0f)
	    {
	        TimerNode timer = new TimerNode();
	        timer.callback = func;
	        timer.param = param;
	        timer.repeat = repeat;
	        timer.duration = duration;
	        timer.delay = delay;
	        timer.passedTime = timer.duration;  // 第一次只受delay影响，所以过去的时间为duration
	        timer.isRemoved = false;
	
	        timer.timerId = this.autoIncId;
	        this.autoIncId++;
	
	        // this.timers.Add(timer.timerId, timer);
	        this.newAddTimers.Add(timer); // 加到缓存队列里面，不直接加入到定时器Map
	        return timer.timerId;
	    }

(8) Unschedule系列接口:

public void Unschedule(int timerId)
{
	if (!this.timers.ContainsKey(timerId)) {
		return;
	}
	
	TimerNode timer = this.timers[timerId];
	timer.isRemoved = true;  // 先标记，不直接删除
}

(9) TimerMgr每次Update迭代Timer，并触发

 private void Update()
    {
        float dt = Time.deltaTime;

        // 把新加进来的放入到我们的表里面来
        for (int i = 0; i < this.newAddTimers.Count; i++) {
            this.timers.Add(this.newAddTimers[i].timerId, this.newAddTimers[i]);
        }
        this.newAddTimers.Clear();
        // end
        
        // 遍历迭代过程中不涉及添加or删除，避免改变map结构引发迭代错误
        foreach (TimerNode timer in this.timers.Values) {
            if (timer.isRemoved) {
                this.removeTimers.Add(timer);
                continue;
            }

            timer.passedTime += dt;
            if (timer.passedTime >= (timer.delay + timer.duration)) {
                // 做一次触发
                timer.callback(timer.param);
                timer.repeat--;
                timer.passedTime -= (timer.delay + timer.duration);
                timer.delay = 0; // 很重要;

                if (timer.repeat == 0) { // 触发次数结束，删除这个Timer, 但不马上删除; 
                    timer.isRemoved = true;
                    this.removeTimers.Add(timer);
                }
                // end 
            }
        }

        // 结束以后，清理掉要删除的Timer;
        for (int i = 0; i < this.removeTimers.Count; i++) {
            this.timers.Remove(this.removeTimers[i].timerId);
        }
        this.removeTimers.Clear();
        // end
    }