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 = ;
         private bool m_InfiniteLoops = false;
         private uint m_LoopsCount = ;
         private Action m_Action = null;
         private Action m_Delegate = null;
         private bool m_bIsPaused = false;
         private uint m_CurrentLoopsCount = ;
         private float m_ElapsedTime = ;
         private long m_TickedTime = ;
         private float m_CurrentCycleElapsedTime = ;

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

             m_TickedTime = DateTime.Now.Ticks;
             m_Interval = interval;
             m_LoopsCount = Math.Max(loopsCount, );
             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 < )
             {
                 m_Interval = ;
                 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, ); }

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

         /// <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() ?? ; }

         /// <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() ?? ; }

         /// <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() ?? ; }

         /// <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：