项目记录29--unity-tolua框架 c#导出定时器lua

昨天回到宿舍想了想公司现在的项目很多时候都用到定时器，卡牌游戏在玩的时候就要计算时间，还要知道什么时候结束。之前写的定时器确实不怎么好，没有抽离出来，越想越不爽，这难道就是传说中的程序员的执着。那就重构下吧，所谓重构就是今晚你写完了功能需求，明天一睡醒来看到昨晚写的总感觉有点不爽，就开始......(哈哈，所以在动手写代码之前最好就是想好功能，最好可以动手在本只里面写写思路再动手，能抽离开来的尽量抽，也许现在用不到后面总会用到的。)

也许现在写完了明天，后天也许又要重了哈哈哈，而且导到lua里面测试不知道效率如何。个人水平有限，真的只是打杂的，没说笑，只是想学学大神们也分享自己的东西，好坏自己判断。

/**************************************************


 * 创建人   ：XingHua


 * 创建时间 ：2016-3-10


 * 模块名字 ：MTimerManager


 * 基本功能 ：定时器


************************************************/


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


public delegate void TimerCallBack(float time);
public delegate void TimerOverCall(float time);
public class TimerInfo
{
    public bool stop;                       //停止
    public bool delete;                     //删除


    public int timerID;                     //计时间ID
    public int m_Repeats;                   //重复次数
    public float m_TimeInterval;            //时间间隔
    public float m_TempTimeVal;             //临时计算时间   
    public TimerCallBack m_Callback;        //回调
    public TimerOverCall m_timeOverCall;    //倒计时结束回调


    public TimerInfo(int itemID, int Repeats, int TimeInterval, TimerCallBack callBack,TimerOverCall overCall = null)
    {
        this.timerID = itemID;
        this.m_Repeats = Repeats;
        this.m_TimeInterval = TimeInterval;
        this.m_Callback = callBack;
        this.m_timeOverCall = overCall;
        m_TempTimeVal = 0;
        stop = false;
        delete = false;
    }


}


public class MTimerManager : AllSceneSingle<MTimerManager>
{
    
    private float interval = 0;
    private Dictionary<int, TimerInfo> m_TimerManager = new Dictionary<int, TimerInfo>();


    public float Interval
    {
        get { return interval; }
        set { interval = value; }
    }
    /// <summary>
    /// 启动定时
    /// </summary>
    /// <param name="value"></param>
    public void StartTimer(float value)
    {
        interval = value;
        InvokeRepeating("Run", 0, interval);
    }


    /// <summary>
    /// 停止定时器
    /// </summary>
    public void StopTimer()
    {
        CancelInvoke("Run");
    }


    /// <summary>
    /// 创建定时器
    /// </summary>
    /// <param name="timerID">定时器ID</param>
    /// <param name="Repeats">重复次数</param>
    /// <param name="TiemInterval">时间间隔</param>
    /// <param name="call">回调</param>
    /// <returns></returns>
    public bool CreateTimer(int timerID, int Repeats, int TiemInterval, TimerCallBack call,TimerOverCall overCall = null)
    {
        TimerInfo timeInfo = null;
        lock (m_TimerManager)
        {
            if (m_TimerManager.TryGetValue(timerID, out timeInfo) && timeInfo != null)
            {
                timeInfo.m_Repeats = Repeats;
                timeInfo.m_TimeInterval = TiemInterval;
                timeInfo.m_Callback = call;
                timeInfo.m_timeOverCall = overCall;
                timeInfo.m_TempTimeVal = 0;
                return true;
            }
        }


        timeInfo = new TimerInfo(timerID, Repeats, TiemInterval, call,overCall);


        lock (m_TimerManager)
        {
            m_TimerManager.Add(timerID, timeInfo);
        }
        return true;
    }
    
    /// <summary>
    /// 删除定时器
    /// </summary>
    /// <param name="timeID">定时器ID</param>
    /// <returns></returns>
    public bool DelTimer(int timeID)
    {
         
        TimerInfo timerInfo = null;
        lock (m_TimerManager)
        {
            if (m_TimerManager.TryGetValue(timeID, out timerInfo) && timerInfo != null)
            {
                timerInfo.delete = true;
                return true;
            }
        }
        return true;
    }
    /// <summary>
    /// 停止定时器
    /// </summary>
    /// <param name="timeID">定时器ID</param>
    /// <returns></returns>
    public bool StopTimer(int timeID)
    {


        TimerInfo timerInfo = null;
        lock (m_TimerManager)
        {
            if (m_TimerManager.TryGetValue(timeID, out timerInfo) && timerInfo != null)
            {
                timerInfo.stop = true;
                return true;
            }
        }
        return true;
    }


    /// <summary>
    /// 重新开启定时器
    /// </summary>
    /// <param name="timeID">定时器ID</param>
    /// <returns></returns>
    public bool ResumeTimer(int timeID)
    {


        TimerInfo timerInfo = null;
        lock (m_TimerManager)
        {
            if (m_TimerManager.TryGetValue(timeID, out timerInfo) && timerInfo != null)
            {
                timerInfo.stop = false;
                return true;
            }
        }
        return true;
    }


    /// <summary>
    /// 定时器跑
    /// </summary>
    void Run()
    {
        if (m_TimerManager.Count <= 0) return;
        lock (m_TimerManager)
        {
            List<int> timerKey = new List<int>();
            IEnumerator enumerator = m_TimerManager.Values.GetEnumerator();
            while (enumerator.MoveNext())
            {
                TimerInfo timerInfo = enumerator.Current as TimerInfo;
                if (timerInfo == null)
                    continue;
                // 校验是否到期
                if (timerInfo.stop)
                    continue;
                if (timerInfo.delete)
                {
                    timerKey.Add(timerInfo.timerID);
                    continue;
                }
                //时间++
                timerInfo.m_TempTimeVal += interval;
                //时间还没到一个间隔
                if (timerInfo.m_TempTimeVal < timerInfo.m_TimeInterval)
                    continue;
                // 运行间隔(持续次数)
                --timerInfo.m_Repeats;
                timerInfo.m_TempTimeVal = 0;
                //回调
                if (timerInfo.m_Callback != null)
                {
                    timerInfo.m_Callback(timerInfo.m_TimeInterval);
                }
                //运行间隔(持续次数)
                if (timerInfo.m_Repeats <= 0)
                {
                    timerInfo.delete = true;
                    timerKey.Add(timerInfo.timerID);
                    if (timerInfo.m_timeOverCall != null)
                    {
                        timerInfo.m_timeOverCall(timerInfo.m_TimeInterval);
                    }
                }
            }
            //按照key移除
            for (int i = 0; i < timerKey.Count; i++)
            {
                TimerInfo temp = null;
                if (m_TimerManager.TryGetValue(timerKey[i], out temp) && temp != null)
                {
                    
                    m_TimerManager.Remove(timerKey[i]);
                }
            }
            timerKey.Clear();
            timerKey = null;
        }
    }
    /// <summary>
    /// unity 生命周期函数
    /// </summary>
    void OnDestroy()
    {
        m_TimerManager.Clear();
        m_TimerManager = null;
    }
}