MinFt/Client/Assets/Scripts/Core/UnityTimer.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using Object = UnityEngine.Object;

/// <summary>
/// Allows you to run events on a delay without the use of <see cref="Coroutine"/>s
/// or <see cref="MonoBehaviour"/>s.
///
/// To create and start a Timer, use the <see cref="Register"/> method.
/// </summary>
namespace GameCore
{
    public class Timer
    {
        #region Public Properties/Fields

        /// <summary>
        /// How long the timer takes to complete from start to finish.
        /// </summary>
        public float duration { get; private set; }

        /// <summary>
        /// Whether the timer will run again after completion.
        /// </summary>
        public bool isLooped { get; set; }

        /// <summary>
        /// Whether or not the timer completed running. This is false if the timer was canceled.
        /// </summary>
        public bool isCompleted { get; private set; }

        /// <summary>
        /// Whether the timer uses real-time or game-time. Real time is unaffected by changes to the timescale
        /// of the game(e.g. pausing, slow-mo), while game time is affected.
        /// </summary>
        public bool usesRealTime { get; private set; }

        /// <summary>
        /// Whether the timer is currently paused.
        /// </summary>
        public bool isPaused
        {
            get { return _timeElapsedBeforePause.HasValue; }
        }

        /// <summary>
        /// Whether or not the timer was canceled.
        /// </summary>
        public bool isCancelled
        {
            get { return _timeElapsedBeforeCancel.HasValue; }
        }

        /// <summary>
        /// Get whether or not the timer has finished running for any reason.
        /// </summary>
        public bool isDone
        {
            get { return isCompleted || isCancelled || isOwnerDestroyed; }
        }

        #endregion

        #region Public Static Methods
        public static void Create()
        {
            // create a manager object to update all the timers if one does not already exist.
            if (_manager != null)
            {
                Debug.LogError("[UnityTimer]Create: TimerManager already exist, ignore this call!");
                return;
            }

            Debug.Log($"[UnityTimer]Create");

            var managerObject = new GameObject { name = nameof(TimerMgr) };
            Object.DontDestroyOnLoad(managerObject);
            _manager = managerObject.AddComponent<TimerMgr>();
        }

        public static void Destroy()
        {
            Debug.Log($"[UnityTimer]Destroy");

            if (_manager != null)
            {
                GameObject.Destroy(_manager.gameObject);
                _manager = null;
            }
        }

        /// <summary>
        /// Register a new timer that should fire an event after a certain amount of time
        /// has elapsed.
        ///
        /// Registered timers are destroyed when the scene changes.
        /// </summary>
        /// <param name="duration">The time to wait before the timer should fire, in seconds.</param>
        /// <param name="onComplete">An action to fire when the timer completes.</param>
        /// <param name="onUpdate">An action that should fire each time the timer is updated. Takes the amount
        /// of time passed in seconds since the start of the timer's current loop.</param>
        /// <param name="isLooped">Whether the timer should repeat after executing.</param>
        /// <param name="useRealTime">Whether the timer uses real-time(i.e. not affected by pauses,
        /// slow/fast motion) or game-time(will be affected by pauses and slow/fast-motion).</param>
        /// <param name="autoDestroyOwner">An object to attach this timer to. After the object is destroyed,
        /// the timer will expire and not execute. This allows you to avoid annoying <see cref="NullReferenceException"/>s
        /// by preventing the timer from running and accessing its parents' components
        /// after the parent has been destroyed.</param>
        /// <returns>A timer object that allows you to examine stats and stop/resume progress.</returns>
        public static Timer Register(float duration, Action onComplete, Action<float> onUpdate = null,
            bool isLooped = false, bool useRealTime = false, MonoBehaviour autoDestroyOwner = null)
        {
            if (_manager == null)
            {
                Debug.LogError("[UnityTimer]Register: TimerManager doesn't exist yet!");
                return null;
            }

            Timer timer = new Timer(duration, onComplete, onUpdate, isLooped, useRealTime, autoDestroyOwner);
            _manager.RegisterTimer(timer);
            return timer;
        }

        /// <summary>
        /// Cancels a timer. The main benefit of this over the method on the instance is that you will not get
        /// a <see cref="NullReferenceException"/> if the timer is null.
        /// </summary>
        /// <param name="timer">The timer to cancel.</param>
        public static void Cancel(Timer timer)
        {
            timer?.Cancel();
        }

        /// <summary>
        /// Pause a timer. The main benefit of this over the method on the instance is that you will not get
        /// a <see cref="NullReferenceException"/> if the timer is null.
        /// </summary>
        /// <param name="timer">The timer to pause.</param>
        public static void Pause(Timer timer)
        {
            timer?.Pause();
        }

        /// <summary>
        /// Resume a timer. The main benefit of this over the method on the instance is that you will not get
        /// a <see cref="NullReferenceException"/> if the timer is null.
        /// </summary>
        /// <param name="timer">The timer to resume.</param>
        public static void Resume(Timer timer)
        {
            timer?.Resume();
        }

        public static void CancelAllRegisteredTimers()
        {
            if (_manager != null)
            {
                _manager.CancelAllTimers();
            }

            // if the manager doesn't exist, we don't have any registered timers yet, so don't
            // need to do anything in this case
        }

        public static void PauseAllRegisteredTimers()
        {
            if (_manager != null)
            {
                _manager.PauseAllTimers();
            }

            // if the manager doesn't exist, we don't have any registered timers yet, so don't
            // need to do anything in this case
        }

        public static void ResumeAllRegisteredTimers()
        {
            if (_manager != null)
            {
                _manager.ResumeAllTimers();
            }

            // if the manager doesn't exist, we don't have any registered timers yet, so don't
            // need to do anything in this case
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Stop a timer that is in-progress or paused. The timer's on completion callback will not be called.
        /// </summary>
        public void Cancel()
        {
            if (isDone)
            {
                return;
            }

            _timeElapsedBeforeCancel = GetTimeElapsed();
            _timeElapsedBeforePause = null;
        }

        /// <summary>
        /// Pause a running timer. A paused timer can be resumed from the same point it was paused.
        /// </summary>
        public void Pause()
        {
            if (isPaused || isDone)
            {
                return;
            }

            _timeElapsedBeforePause = GetTimeElapsed();
        }

        /// <summary>
        /// Continue a paused timer. Does nothing if the timer has not been paused.
        /// </summary>
        public void Resume()
        {
            if (!isPaused || isDone)
            {
                return;
            }

            _timeElapsedBeforePause = null;
        }

        /// <summary>
        /// Get how many seconds have elapsed since the start of this timer's current cycle.
        /// </summary>
        /// <returns>The number of seconds that have elapsed since the start of this timer's current cycle, i.e.
        /// the current loop if the timer is looped, or the start if it isn't.
        ///
        /// If the timer has finished running, this is equal to the duration.
        ///
        /// If the timer was cancelled/paused, this is equal to the number of seconds that passed between the timer
        /// starting and when it was cancelled/paused.</returns>
        public float GetTimeElapsed()
        {
            if (isCompleted || GetWorldTime() >= GetFireTime())
            {
                return duration;
            }

            return _timeElapsedBeforeCancel ??
                   _timeElapsedBeforePause ??
                   GetWorldTime() - _startTime;
        }

        /// <summary>
        /// Get how many seconds remain before the timer completes.
        /// </summary>
        /// <returns>The number of seconds that remain to be elapsed until the timer is completed. A timer
        /// is only elapsing time if it is not paused, cancelled, or completed. This will be equal to zero
        /// if the timer completed.</returns>
        public float GetTimeRemaining()
        {
            return duration - GetTimeElapsed();
        }

        /// <summary>
        /// Get how much progress the timer has made from start to finish as a ratio.
        /// </summary>
        /// <returns>A value from 0 to 1 indicating how much of the timer's duration has been elapsed.</returns>
        public float GetRatioComplete()
        {
            return GetTimeElapsed() / duration;
        }

        /// <summary>
        /// Get how much progress the timer has left to make as a ratio.
        /// </summary>
        /// <returns>A value from 0 to 1 indicating how much of the timer's duration remains to be elapsed.</returns>
        public float GetRatioRemaining()
        {
            return GetTimeRemaining() / duration;
        }

        #endregion

        #region Private Static Properties/Fields

        // responsible for updating all registered timers
        private static TimerMgr _manager;

        #endregion

        #region Private Properties/Fields

        private bool isOwnerDestroyed
        {
            get { return _hasAutoDestroyOwner && _autoDestroyOwner == null; }
        }

        private readonly Action _onComplete;
        private readonly Action<float> _onUpdate;
        private float _startTime;
        private float _lastUpdateTime;

        // for pausing, we push the start time forward by the amount of time that has passed.
        // this will mess with the amount of time that elapsed when we're cancelled or paused if we just
        // check the start time versus the current world time, so we need to cache the time that was elapsed
        // before we paused/cancelled
        private float? _timeElapsedBeforeCancel;
        private float? _timeElapsedBeforePause;

        // after the auto destroy owner is destroyed, the timer will expire
        // this way you don't run into any annoying bugs with timers running and accessing objects
        // after they have been destroyed
        private readonly MonoBehaviour _autoDestroyOwner;
        private readonly bool _hasAutoDestroyOwner;

        #endregion

        #region Private Constructor (use static Register method to create new timer)

        private Timer(float duration, Action onComplete, Action<float> onUpdate,
            bool isLooped, bool usesRealTime, MonoBehaviour autoDestroyOwner)
        {
            this.duration = duration;
            _onComplete = onComplete;
            _onUpdate = onUpdate;

            this.isLooped = isLooped;
            this.usesRealTime = usesRealTime;

            _autoDestroyOwner = autoDestroyOwner;
            _hasAutoDestroyOwner = autoDestroyOwner != null;

            _startTime = GetWorldTime();
            _lastUpdateTime = _startTime;
        }

        #endregion

        #region Private Methods

        private float GetWorldTime()
        {
            return usesRealTime ? Time.realtimeSinceStartup : Time.time;
        }

        private float GetFireTime()
        {
            return _startTime + duration;
        }

        private float GetTimeDelta()
        {
            return GetWorldTime() - _lastUpdateTime;
        }

        private void Update()
        {
            if (isDone)
            {
                return;
            }

            if (isPaused)
            {
                _startTime += GetTimeDelta();
                _lastUpdateTime = GetWorldTime();
                return;
            }

            _lastUpdateTime = GetWorldTime();

            try
            {
                _onUpdate?.Invoke(GetTimeElapsed());
            }
            catch (Exception ex)
            {
                Debug.LogError($"[Timer]Update: onUpdate error! {ex.Message}");
            }

            if (GetWorldTime() >= GetFireTime())
            {
                try
                {
                    _onComplete?.Invoke();
                }
                catch (Exception ex)
                {
                    Debug.LogError($"[Timer]Update: onComplete error! {ex.Message}");
                }

                if (isLooped)
                {
                    _startTime = GetWorldTime();
                }
                else
                {
                    isCompleted = true;
                }
            }
        }

        #endregion

        #region Manager Class (implementation detail, spawned automatically and updates all registered timers)

        /// <summary>
        /// Manages updating all the <see cref="Timer"/>s that are running in the application.
        /// This will be instantiated the first time you create a timer -- you do not need to add it into the
        /// scene manually.
        /// </summary>
        private class TimerMgr : MonoBehaviour
        {
            public int TimerCount { get; private set; }

            private ulong _timerID;
            private Dictionary<ulong, Timer> _timers = new Dictionary<ulong, Timer>();
            // buffer adding timers so we don't edit a collection during iteration
            private List<Timer> _timersToAdd = new List<Timer>();
            // buffer removing timers
            private List<ulong> _timersToRemove = new List<ulong>();

            public void RegisterTimer(Timer timer)
            {
                _timersToAdd.Add(timer);
                Debug.Log($"[TimerMgr]RegisterTimer: {TimerCount + _timersToAdd.Count} timers in total");
            }

            public void CancelAllTimers()
            {
                Debug.Log($"[TimerMgr]CancelAllTimers");

                var etor = _timers.GetEnumerator();
                while (etor.MoveNext())
                {
                    var timer = etor.Current.Value;

                    timer.Cancel();
                }

                _timers.Clear();
                _timersToAdd.Clear();
                TimerCount = 0;
            }

            public void PauseAllTimers()
            {
                Debug.Log($"[TimerMgr]PauseAllTimers");

                var etor = _timers.GetEnumerator();
                while (etor.MoveNext())
                {
                    var timer = etor.Current.Value;

                    timer.Pause();
                }
            }

            public void ResumeAllTimers()
            {
                Debug.Log($"[TimerMgr]ResumeAllTimers");

                var etor = _timers.GetEnumerator();
                while (etor.MoveNext())
                {
                    var timer = etor.Current.Value;

                    timer.Resume();
                }
            }

            // update all the registered timers on every frame
            private void Update()
            {
                if (_timersToAdd.Count > 0)
                {
                    for (int i = 0; i < _timersToAdd.Count; i++)
                    {
                        _timers.Add(_timerID++, _timersToAdd[i]);
                    }

                    _timersToAdd.Clear();
                }

                _timersToRemove.Clear();

                var etor = _timers.GetEnumerator();
                while (etor.MoveNext())
                {
                    var timer = etor.Current.Value;

                    timer.Update();

                    if (timer.isDone)
                    {
                        _timersToRemove.Add(etor.Current.Key);
                    }
                }

                if (_timersToRemove.Count > 0)
                {
                    for (int i = 0; i < _timersToRemove.Count; i++)
                    {
                        _timers.Remove(_timersToRemove[i]);
                    }
                }

                TimerCount = _timers.Count;
            }
        }

        #endregion

    }

    public static class TimerExtensions
    {
        /// <summary>
        /// Attach a timer on to the behaviour. If the behaviour is destroyed before the timer is completed,
        /// e.g. through a scene change, the timer callback will not execute.
        /// </summary>
        /// <param name="behaviour">The behaviour to attach this timer to.</param>
        /// <param name="duration">The duration to wait before the timer fires.</param>
        /// <param name="onComplete">The action to run when the timer elapses.</param>
        /// <param name="onUpdate">A function to call each tick of the timer. Takes the number of seconds elapsed since
        /// the start of the current cycle.</param>
        /// <param name="isLooped">Whether the timer should restart after executing.</param>
        /// <param name="useRealTime">Whether the timer uses real-time(not affected by slow-mo or pausing) or
        /// game-time(affected by time scale changes).</param>
        public static Timer AttachTimer(this MonoBehaviour behaviour, float duration, Action onComplete,
            Action<float> onUpdate = null, bool isLooped = false, bool useRealTime = false)
        {
            return Timer.Register(duration, onComplete, onUpdate, isLooped, useRealTime, behaviour);
        }
    }
}