2. 程式人生 > 其它 >Unity中實現Timer定時器

Unity中實現Timer定時器

阿新 • • 發佈：2022-12-03

前言：好久沒寫部落格了，倒不是沒寫的了， 現在手裡堆著的demo和小功能很多，而是懶，我是真滴懶啊。
需求：1.延遲執行方法；2.迴圈執行，間隔可控制；3.可以改變更新模式（update、fixedupdate，lateupdate），可以決定是否會受到Unity時間縮放影響；4.呼叫簡單，可複用

思路：
1.改變更新模式和受到unity時間縮放的功能，可以使用全域性靜態變數控制

2.目前網上做定時器的方法三種：Coroutine、update、invoke，我選的第二種，使用MonoBehavior的update來做更新

3.不搞什麼單例Manager之類的，呼叫麻煩，寫的一長串，什麼Instance的，看著很low

4.Timer物件只對資料資訊做儲存之用，更新時間狀態等，集中由一個指令碼的Update處理，分割資料層和邏輯層

5.雖然大部分使用Timer都是隨用隨丟，不會暫存，但是我new物件時，仍要保留這個功能，而且還要重置、完成等功能

 實現：

第一步就是先實現UpdateRegister功能，繼承自MonoBehavior，使用Unity自己的Update方法。提供給外部註冊和取消註冊的功能

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

namespace
 
 JunFramework
{
    public enum UpdateMode
    {
        Update,
        FixedUpdate,
        LateUpdate
    }

    public enum TimeMode
    {
        Scaled,
        UnScaled
    }
    public class UpdateRegister : MonoBehaviour
    {
        /// <summary>
        /// update註冊列表
        /// </summary>
 

        private static Dictionary<int, Action> update = new Dictionary<int, Action>();

        /// <summary>
        /// fixedupfate註冊列表
        /// </summary>
        private static Dictionary<int, Action> fixedupdate = new Dictionary<int, Action>();

        /// <summary>
        /// lateupdate註冊列表
        /// </summary>
        private static Dictionary<int, Action> lateupdate = new Dictionary<int, Action>();

        /// <summary>
        /// 全域性唯一update下標
        /// </summary>
        private static int updateIndex = 0;
      
        /// <summary>
        /// 是否初始化
        /// </summary>
        private static bool isInit = false;

        /// <summary>
        /// 是否已經初始化
        /// </summary>
        public static bool IsInit
        {
            get => isInit;
        }

        /// <summary>
        /// 註冊
        /// </summary>
        /// <param name="mode"></param>
        /// <param name="handler"></param>
        /// <returns></returns>
        public static int Register(UpdateMode mode, Action handler)
        {
            ++updateIndex;
            switch (mode)
            {
                case UpdateMode.Update:
                    update.Add(updateIndex, handler);
                    break;
                case UpdateMode.FixedUpdate:
                    fixedupdate.Add(updateIndex, handler);
                    break;
                case UpdateMode.LateUpdate:
                    lateupdate.Add(updateIndex, handler);
                    break;
            }
            return updateIndex;
        }

        /// <summary>
        /// 根據updateindex取消註冊
        /// </summary>
        /// <param name="mode"></param>
        /// <param name="index"></param>
        public static void Cancle(UpdateMode mode, int index)
        {
            switch (mode)
            {
                case UpdateMode.Update:
                    update.Remove(index);
                    break;
                case UpdateMode.FixedUpdate:
                    fixedupdate.Remove(index);
                    break;
                case UpdateMode.LateUpdate:
                    lateupdate.Remove(index);
                    break;
            }
        }

        private void Awake()
        {
            isInit = true;
        }

        private void Update()
        {
            using (var e = update.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    e.Current.Value?.Invoke();
                }
            }
        }

        private void FixedUpdate()
        {
            using (var e = fixedupdate.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    e.Current.Value?.Invoke();
                }
            }
        }

        private void LateUpdate()
        {
            using (var e = lateupdate.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    e.Current.Value?.Invoke();
                }
            }
        }
    }
}

第二步實現Timer物件，儲存呼叫者傳入的資訊，可獲取Timer狀態（是否完成？是否正在工作？當前進度？）。可呼叫開始、結束、暫停、繼續、重置、完成功能

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

namespace JunFramework.Timer
{
    public class Timer
    {
        #region timer設定

        /// <summary>
        /// Timer是否自動釋放
        /// </summary>
        public static bool IsAutoRelease = true;

        /// <summary>
        /// Timer更新模式
        /// </summary>
        public static UpdateMode TimerUpdateMode = UpdateMode.FixedUpdate;

        /// <summary>
        /// Timer時間是否收到Unity縮放影響
        /// </summary>
        public static TimeMode TimerScaledModel = TimeMode.UnScaled;

        #endregion

        private float currentTime = 0f;//當前時間（0 -- steptime）
        private int currentRepeat = 0;//當前重複次數
        private float stepTime = 0f;//間隔
        private int repeatTimes = 0;//重複次數
        private bool isLoop = false;//是否迴圈
        private bool isDone = false;//是否完成
        private bool isStart = false;//是否開始
        private int updateIndex = 0;//update註冊獲取的下標，用於移除update註冊
        private Action callback;//回撥
        private float timeAcceleration;//每幀增加的時間

        /// <summary>
        /// 是否完成
        /// </summary>
        public bool IsDone
        {
            get => isDone;
        }

        /// <summary>
        /// 當前進度
        /// </summary>
        public float Progress
        {
            get => currentTime / stepTime;
        }

        /// <summary>
        /// 是否正在工作
        /// </summary>
        public bool IsWokring
        {
            get => !isDone && isStart;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="stepTime">間隔時長</param>
        /// <param name="repeatTimes">重複次數</param>
        /// <param name="callback">回撥</param>
        public Timer(float stepTime, int repeatTimes, Action callback)
        {
            this.currentTime = 0f;
            this.currentRepeat = 0;
            this.stepTime = stepTime;
            this.repeatTimes = repeatTimes;
            this.isLoop = false;
            this.isDone = false;
            this.timeAcceleration = GetPerTime();
            this.callback = callback;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="stepTime">間隔</param>
        /// <param name="callback">回撥</param>
        public Timer(float stepTime, Action callback)
        {
            this.currentTime = 0f;
            this.currentRepeat = 0;
            this.stepTime = stepTime;
            this.repeatTimes = 1;
            this.isLoop = false;
            this.isDone = false;
            this.timeAcceleration = GetPerTime();
            this.callback = callback;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="stepTime">間隔</param>
        /// <param name="isLoop">是否迴圈</param>
        /// <param name="callback">回撥</param>
        public Timer(float stepTime, bool isLoop, Action callback)
        {
            this.currentTime = 0f;
            this.currentRepeat = 0;
            this.stepTime = stepTime;
            this.isLoop = isLoop;
            if (!isLoop)
            {
                this.repeatTimes = 1;
            }
            this.timeAcceleration = GetPerTime();
            this.isDone = false;
            this.callback = callback;
        }

        /// <summary>
        /// 每幀更新
        /// </summary>
        /// <param name="addTime">每幀增加的時間</param>
        private void Update(float addTime)
        {
            if (isDone)
                return;
            if (!isStart)
                return;

            currentTime += addTime;
            if (currentTime >= stepTime)
            {
                callback?.Invoke();
                currentTime = 0f;
                if (!isLoop)
                {
                    ++currentRepeat;
                    if (currentRepeat >= repeatTimes)
                    {
                        isDone = true;
                        if (IsAutoRelease)
                        {
                            Stop();
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 開始計時器
        /// </summary>
        public void Start()
        {
            if (!UpdateRegister.IsInit)
            {
                Debug.LogWarning("UpdateRegister is not init, so this action will not works, please init UpdateRegister first!!!");
                return;
            }
            isStart = true;
            this.updateIndex = UpdateRegister.Register(TimerUpdateMode, () => this.Update(timeAcceleration));
        }

        /// <summary>
        /// 停止計時器（如果只是想暫停可用Pause，stop操作不可恢復）
        /// </summary>
        public void Stop()
        {
            isStart = false;
            isDone = true;
            UpdateRegister.Cancle(TimerUpdateMode, this.updateIndex);
        }

        /// <summary>
        /// 暫停
        /// </summary>
        public void Pause()
        {
            isStart = false;
        }

        /// <summary>
        /// 繼續
        /// </summary>
        public void Resume()
        {
            isStart = true;
        }

        /// <summary>
        /// 重置
        /// </summary>
        public void Reset()
        {
            isStart = false;
            isDone = false;
            currentTime = 0f;
            currentRepeat = 0;
        }

        /// <summary>
        /// 不用等待，直接完成
        /// </summary>
        public void Complete()
        {
            if (isLoop)
                return;
            isDone = true;

            int tempRepeat = repeatTimes;
            while (tempRepeat > 0)
            {
                callback?.Invoke();
                --tempRepeat;
            }
            Stop();

        }

        /// <summary>
        /// 通過更新模式和time模式獲取每幀更新時間
        /// </summary>
        /// <returns></returns>
        private float GetPerTime()
        {
            float resultTime = 0f;
            if (TimerScaledModel == TimeMode.Scaled && TimerUpdateMode == UpdateMode.FixedUpdate)
            {
                resultTime = Time.fixedDeltaTime;
            }
            else if (TimerScaledModel == TimeMode.UnScaled && TimerUpdateMode == UpdateMode.FixedUpdate)
            {
                resultTime = Time.fixedUnscaledDeltaTime;
            }
            else if (TimerScaledModel == TimeMode.Scaled && TimerUpdateMode == UpdateMode.Update)
            {
                resultTime = Time.deltaTime;
            }
            else if (TimerScaledModel == TimeMode.UnScaled && TimerUpdateMode == UpdateMode.FixedUpdate)
            {
                resultTime = Time.unscaledDeltaTime;
            }
            return resultTime;
        }
    }
}

第三步，簡單編寫測試程式碼

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using JunFramework.Timer;

public class TimerExample : MonoBehaviour
{
    private Timer timer = null;
    // Start is called before the first frame update
    void Start()
    {
        Timer.IsAutoRelease = true;
        Timer.TimerScaledModel = JunFramework.TimeMode.UnScaled;
        Timer.TimerUpdateMode = JunFramework.UpdateMode.FixedUpdate;

        //Example1
        //int i = 0;
        //Timer timer = new Timer(2, 2, () => Debug.Log(i++));
        //timer.Start();

        //Example2
        //timer = new Timer(2, true, () => Debug.Log("執行"));
        //timer.Start();

        //Example3
        timer = new Timer(2, 3, () => Debug.Log("看我看我"));
        timer.Start();
        timer.Complete();

        timer.Reset();
        timer.Start();
    }

    // Update is called once per frame
    void Update()
    {
        //Example2
        //if (Input.GetKeyDown(KeyCode.Space))
        //{
        //    timer.Pause();
        //}
        //else if (Input.GetKeyDown(KeyCode.A))
        //{
        //    timer.Resume();
        //}
    }
}

 總結：

本次Timer參考的是公司的lua Timer，其實這Timer也是大神蒙佔志寫的。我這個是C#寫的，用於自己的遊戲Demo。接受各種改進建議

相關推薦

Unity中實現Timer定時器

前言：好久沒寫部落格了，倒不是沒寫的了， 現在手裡堆著的demo和小功能很多，而是懶，我是真滴懶啊。需求：1.延遲執行方法；2.迴圈執行，間隔可控制；3.可以改變更新模式（update、fixedupdate，lateupdate），可以

轉-- Golang中timer定時器實現原理

一般我們匯入import (\"time\")包，然後呼叫time.NewTicker(1 * time.Second) 實現一個定時器：

[經驗棧]C#中幾種定時器(timer)的區別

目錄1、前言2、官方介紹3、個人體會System.Threading.Timer ClassSystem.Windows.Forms.Timer ClassSystem.Timers.Timer Class4、後記參考資料

iOS中幾種定時器的實現小結

在軟體開發過程中，我們常常需要在某個時間後執行某個方法，或者是按照某個週期一直執行某個方法。在這個時候，我們就需要用到定時器。

Kubernetes定時任務的實現 Golang定時器——Timer 和 Ticker 

1、概述 Kubernetes 的各個元件都有一定的定時任務，比如任務的定時輪詢、高可用的實現、日誌處理、快取使用等，Kubernetes 中的定時任務都是通過 wait 包實現的。

C#中timer定時器的用法

Timer定時器，如果沒有stop，是會按指定間隔時間一直重複執行的， 所以如果只想執行一次，必須得關閉。

Python timer定時器兩種常用方法解析

這篇文章主要介紹了Python timer定時器兩種常用方法解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

JS實現的定時器展示簡單秒錶、頁面彈框及跳轉操作完整示例

本文例項講述了JS實現的定時器展示簡單秒錶、頁面彈框及跳轉操作。分享給大家供大家參考，具體如下：

Java執行緒Timer定時器用法詳細總結

定時/計劃功能主要使用的就是Timer物件，它在內部還是使用多執行緒的方式進行處理，所以它和執行緒技術還是有非常大的關聯。

js實現時鐘定時器

本文例項為大家分享了js實現時鐘定時器的具體程式碼，供大家參考，具體內容如下

C++11實現簡易定時器的示例程式碼

定時器timer是多執行緒程式設計中經常設計到的工具類 定時器的原理其實很簡單：

java迴圈呼叫多個timer定時器

通常在使用java實現定時任務時，有兩種方法，一種是spring中的schedule(cron = \" */5 * * * ?\")，另一種就是java中的timer,

Spring+Quartz 實現簡單定時器

環境/條件： JDK1.7 jar包 spring-context-support 4.2.6.RELEASE jar包 spring-org.quartz-scheduler 2.2.1

WPF DataGrid顯示網格 和TImer定時器

WPF DataGrid顯示網格 和TImer定時器 DataGrid表格中滑鼠右鍵選中一行不放往下拖導致全部選中問題

使用timer定時器，防止事件重入

首先簡單介紹一下timer，這裡所說的timer是指的System.Timers.timer，顧名思義，就是可以在指定的間隔是引發事件。官方介紹在這裡，摘抄如下：

拾遺Timer定時器

一 Timer介紹 在開發中我們經常會遇到一些簡單定時任務的需求，而不需要量級較重的定時任務就可以採取java定時器；

【Swift】Timer定時器到底準不準確？

　　在開發過程中，Timer可以說是比較常見的了，用來做一些定時性的操作。可實際過成功，Timer的時間真的準嗎？下面寫幾個程式碼來做驗證。

利用A* Pathfinding專案在unity中實現自動尋路

A* Pathfinding 專案地址: https://arongranberg.com/astar/ 學習視訊：Unity 2D AI自動尋路功能 [風農譯製]_嗶哩嗶哩 (゜-゜)つロ 乾杯~-bilibili

【Java學習筆記（八十四）】 之 Timer定時器，TimerTask任務

技術標籤：# 多執行緒Java學習筆記java佇列 本文章由公號【開發小鴿】釋出！歡迎關注！！！

crontab 週日_【Python】300行程式碼實現crontab定時器功能

技術標籤：crontab 週日python 定時器python定時器python每隔幾秒執行一次 熟悉Linux的都知道在Linux下有一個crontab的定時任務，可以很方便的進行各種定時、計劃任務的執行。有時候寫程式碼也需要用到定時器業