ET框架之自写模块SmartTimerModule

1.代码结构图

2.SmartTimer 模块Entity：

using System;

namespace ETModel
{
    [ObjectSystem]
    public class SmartTimerAwakeSystem: AwakeSystem<SmartTimer, float, uint, Action>
    {
        public override void Awake(SmartTimer self, float a, uint b, Action c)
        {
            self.Awake(a, b, c);
        }
    }

    public sealed class SmartTimer: Entity
    {
        public const uint INFINITE = uint.MaxValue;

        private float m_Interval = 0;
        private bool m_InfiniteLoops = false;
        private uint m_LoopsCount = 1;
        private Action m_Action = null;
        private Action m_Delegate = null;
        private bool m_bIsPaused = false;
        private uint m_CurrentLoopsCount = 0;
        private float m_ElapsedTime = 0;
        private long m_TickedTime = 0;
        private float m_CurrentCycleElapsedTime = 0;

        public void Awake(float interval, uint loopsCount, Action action)
        {
            if (m_Interval < 0)
                m_Interval = 0;

            m_TickedTime = DateTime.Now.Ticks;
            m_Interval = interval;
            m_LoopsCount = Math.Max(loopsCount, 1);
            m_Delegate = action;
        }

        public override void Dispose()
        {
            if (this.IsDisposed) return;
            this.m_Delegate = null;
            this.m_Action = null;
            base.Dispose();
        }

        internal void UpdateActionFromAction()
        {
            if (m_InfiniteLoops)
                m_LoopsCount = INFINITE;

            if (m_Action != null)
                m_Delegate = delegate { m_Action.Invoke(); };
        }

        internal void UpdateTimer()
        {
            if (m_bIsPaused)
                return;

            if (m_Delegate == null || m_Interval < 0)
            {
                m_Interval = 0;
                return;
            }

            if (m_CurrentLoopsCount >= m_LoopsCount && m_LoopsCount != INFINITE)
            {
                m_ElapsedTime = m_Interval * m_LoopsCount;
                m_CurrentCycleElapsedTime = m_Interval;
            }
            else
            {
                m_ElapsedTime += (DateTime.Now.Ticks - this.m_TickedTime) / 10000000f;
                m_TickedTime = DateTime.Now.Ticks;
                m_CurrentCycleElapsedTime = m_ElapsedTime - m_CurrentLoopsCount * m_Interval;

                if (m_CurrentCycleElapsedTime > m_Interval)
                {
                    m_CurrentCycleElapsedTime -= m_Interval;
                    m_CurrentLoopsCount++;
                    m_Delegate.Invoke();
                }
            }
        }

        /// <summary>
        /// Get interval
        /// </summary>
        public float Interval() { return m_Interval; }

        /// <summary>
        /// Get total loops count (INFINITE (which is uint.MaxValue) if is constantly looping) 
        /// </summary>
        public uint LoopsCount() { return m_LoopsCount; }

        /// <summary>
        /// Get how many loops were completed
        /// </summary>
        public uint CurrentLoopsCount() { return m_CurrentLoopsCount; }

        /// <summary>
        /// Get how many loops remained to completion
        /// </summary>
        public uint RemainingLoopsCount() { return m_LoopsCount - m_CurrentLoopsCount; }

        /// <summary>
        /// Get total duration, (INFINITE if it's constantly looping)
        /// </summary>
        public float Duration() { return (m_LoopsCount == INFINITE) ? INFINITE : (m_LoopsCount * m_Interval); }

        /// <summary>
        /// Get the delegate to execute
        /// </summary>
        public Action Delegate() { return m_Delegate; }

        /// <summary>
        /// Get total remaining time
        /// </summary>
        public float RemainingTime() { return (m_LoopsCount == INFINITE && m_Interval > 0f) ? INFINITE : Math.Max(m_LoopsCount * m_Interval - m_ElapsedTime, 0f); }

        /// <summary>
        /// Get total elapsed time
        /// </summary>
        public float ElapsedTime() { return m_ElapsedTime; }

        /// <summary>
        /// Get elapsed time in current loop
        /// </summary>
        public float CurrentCycleElapsedTime() { return m_CurrentCycleElapsedTime; }

        /// <summary>
        /// Get remaining time in current loop
        /// </summary>
        public float CurrentCycleRemainingTime() { return Math.Max(m_Interval - m_CurrentCycleElapsedTime, 0); }

        /// <summary>
        /// Checks whether this timer is ok to be removed
        /// </summary>
        public bool ShouldClear() { return (m_Delegate == null || RemainingTime() == 0); }

        /// <summary>
        /// Checks if the timer is paused
        /// </summary>
        public bool IsPaused() { return m_bIsPaused; }

        /// <summary>
        /// Pause / Inpause timer
        /// </summary>
        public void SetPaused(bool bPause) { m_bIsPaused = bPause; }

        /// <summary>
        ///     Compare frequency (calls per second)
        /// </summary>
        public static bool operator >(SmartTimer A, SmartTimer B)     { return (A == null || B == null) || A.Interval() < B.Interval(); }

        /// <summary>
        ///     Compare frequency (calls per second)
        /// </summary>
        public static bool operator <(SmartTimer A, SmartTimer B)     { return (A == null || B == null) || A.Interval() > B.Interval(); }

        /// <summary>
        ///     Compare frequency (calls per second)
        /// </summary>
        public static bool operator >=(SmartTimer A, SmartTimer B)    { return (A == null || B == null) || A.Interval() <= B.Interval(); }

        /// <summary>
        ///     Compare frequency (calls per second)
        /// </summary>
        public static bool operator <=(SmartTimer A, SmartTimer B)    { return (A == null || B == null) || A.Interval() >= B.Interval(); }
    }
}

3.SmartTimerComponent 模块Manager：

using System;
using System.Collections.Generic;
using System.Linq;

namespace ETModel
{
    [ObjectSystem]
    public class SmartTimerComponentAwakeSystem: AwakeSystem<SmartTimerComponent>
    {
        public override void Awake(SmartTimerComponent self)
        {
            self.Awake();
        }
    }

    [ObjectSystem]
    public class SmartTimerComponentUpdateSystem: UpdateSystem<SmartTimerComponent>
    {
        public override void Update(SmartTimerComponent self)
        {
            self.Update();
        }
    }

    public class SmartTimerComponent: Component
    {
        // Ensure we only have a single instance of the SmartTimerComponent loaded (singleton pattern).
        public static SmartTimerComponent Instance = null;
        private IList<SmartTimer> smartTimers = new List<SmartTimer>();

        // Whether the game is paused
        public bool Paused { get; set; } = false;

        public void Awake()
        {
            Instance = this;
        }

        public void Update()
        {
            if (this.Paused)
                return;

            foreach (SmartTimer smartTimer in this.smartTimers.ToArray())
            {
                smartTimer.UpdateTimer();
                if (smartTimer.ShouldClear() || smartTimer.IsDisposed)
                {
                    this.smartTimers.Remove(smartTimer);
                }
            }
        }

        public void Add(SmartTimer smartTimer)
        {
            this.smartTimers.Add(smartTimer);
        }

        public SmartTimer Get(Action action)
        {
            foreach (SmartTimer smartTimer in this.smartTimers)
            {
                if (smartTimer.Delegate() == action) return smartTimer;
            }

            return null;
        }

        public void Remove(SmartTimer smartTimer)
        {
            this.smartTimers.Remove(smartTimer);
            smartTimer.Dispose();
        }

        public void Remove(Action action)
        {
            foreach (SmartTimer smartTimer in this.smartTimers.ToArray())
            {
                if (smartTimer.Delegate() == action)
                {
                    Remove(smartTimer);
                    break;
                }
            }
        }

        public int Count => this.smartTimers.Count;

        public override void Dispose()
        {
            if (this.IsDisposed) return;
            base.Dispose();

            foreach (SmartTimer smartTimer in this.smartTimers)
            {
                smartTimer.Dispose();
            }
            this.smartTimers.Clear();
            Instance = null;
        }

        /// <summary>
        /// Get timer interval. Returns 0 if not found.
        /// </summary>
        /// <param name="action">Delegate name</param>
        public float Interval(Action action) { SmartTimer timer = this.Get(action); return timer?.Interval() ?? 0f; }

        /// <summary>
        /// Get total loops count (INFINITE (which is uint.MaxValue) if is constantly looping) 
        /// </summary>
        /// <param name="action">Delegate name</param>
        public uint LoopsCount(Action action) { SmartTimer timer = this.Get(action); return timer?.LoopsCount() ?? 0; }

        /// <summary>
        /// Get how many loops were completed
        /// </summary>
        /// <param name="action">Delegate name</param>
        public uint CurrentLoopsCount(Action action) { SmartTimer timer = this.Get(action); return timer?.CurrentLoopsCount() ?? 0; }

        /// <summary>
        /// Get how many loops remained to completion
        /// </summary>
        /// <param name="action">Delegate name</param>
        public uint RemainingLoopsCount(Action action) { SmartTimer timer = this.Get(action); return timer?.RemainingLoopsCount() ?? 0; }

        /// <summary>
        /// Get total remaining time
        /// </summary>
        /// <param name="action">Delegate name</param>
        public float RemainingTime(Action action) { SmartTimer timer = this.Get(action); return timer?.RemainingTime() ?? -1f; }

        /// <summary>
        /// Get total elapsed time
        /// </summary>
        /// <param name="action">Delegate name</param>
        public float ElapsedTime(Action action) { SmartTimer timer = this.Get(action); return timer?.ElapsedTime() ?? -1f; }

        /// <summary>
        /// Get elapsed time in current loop
        /// </summary>
        /// <param name="action">Delegate name</param>
        public float CurrentCycleElapsedTime(Action action) { SmartTimer timer = this.Get(action); return timer?.CurrentCycleElapsedTime() ?? -1f; }

        /// <summary>
        /// Get remaining time in current loop
        /// </summary>
        /// <param name="action">Delegate name</param>
        public float CurrentCycleRemainingTime(Action action) { SmartTimer timer = this.Get(action); return timer?.CurrentCycleRemainingTime() ?? -1f; }

        /// <summary>
        /// Verifies whether the timer exits
        /// </summary>
        /// <param name="action">Delegate name</param>
        public bool IsTimerActive(Action action) { SmartTimer timer = this.Get(action); return timer != null; }

        /// <summary>
        /// Checks if the timer is paused
        /// </summary>
        /// <param name="action">Delegate name</param>
        public bool IsTimerPaused(Action action) { SmartTimer timer = this.Get(action); return timer?.IsPaused() ?? false; }

        /// <summary>
        /// Pause / Unpause timer
        /// </summary>
        /// <param name="action">Delegate name</param>
        ///  <param name="bPause">true - pause, false - unpause</param>
        public void SetPaused(Action action, bool bPause) { SmartTimer timer = this.Get(action); if (timer != null) timer.SetPaused(bPause); }

        /// <summary>
        /// Get total duration, (INFINITE if it's constantly looping)
        /// </summary>
        /// <param name="action">Delegate name</param>
        public float Duration(Action action) { SmartTimer timer = this.Get(action); return timer?.Duration() ?? 0f; }
    }
}

4.SmartTimerFactory 模块工厂：

using System;

namespace ETModel
{
    public static class SmartTimerFactory
    {
        public static SmartTimer Create(float interval, uint loopsCount, Action action)
        {
            SmartTimer smartTimer = ComponentFactory.Create<SmartTimer, float, uint, Action>(interval, loopsCount, action);
            SmartTimerComponent smartTimerComponent = Game.Scene.GetComponent<SmartTimerComponent>();
            smartTimerComponent.Add(smartTimer);
            return smartTimer;
        }
    }
}

5.Example：