简单Unity时间架构设计（克洛诺斯之匙）

好吧，这次的题目有点标题党之嫌，提出这个设计，是因为最近玩了鬼泣，其中有一个关卡叫做“为了自己的主人”，任务中，需要利用克洛诺斯之匙将时间变慢，便于通过激光镇。

使用克洛诺斯之匙之后，主角的行动是正常的，运走，攻击等等。而其他的如怪物，死亡特效等对象的更新都变慢了。当时我想，如何让不同的对象能够按不同频率更新呢？

在unity中，脚本按时更新的是Time.FixedUpdate,改变其速率只需要修改
Time.timeScale就行了。然而这么做非常“鲁莽”，因为这个值是全局的，所有以Time.FixedUpdate为更新的游戏对象都会受到影
响。例如实现游戏的暂停功能，很多初学者会将对象的更新使用Time.FixedUpdate，然后动态修改timeScale。这样可以将所有以
FixedUpdate为更新的游戏对象都停了。

貌似没有什么问题，然而却会影响所有以FixedUpdate更新的脚本，例如DFGUI，NGUI等。我曾经使用上面的方法，结果出了问题，就是把timeScale设为0之后，UI的监听事件竟然没反应了，当时调试很久才反应过来。

后来为了解决这个问题，以及局部对象的暂停，定义了很多变量来控制，感觉太麻烦。后来玩到鬼泣的时候，突然有了灵感，为何不自己写一个时间控制器呢？

首先要清楚需求是什么：在unity自带更新脚本的基础上设计一个时间控制器，用来控制所有对象的更新频率。

我的设计方案是这样的，写一个父类，实现Update，LateUpdate，FixedUpdate的正常更新与计时，暂停控制。然后所有需要控制更新的对象脚本继承这个控制类，复写相应的方法。

使用的时候，直接控制几个全局的静态变量就可以控制所有继承此类的游戏对象，用来实现暂停，或者局部对象的延时。这
个可以很好的扩展，你复写不同的方法就可以实现不同对象的更新频率。这个你自己发挥即可。就像鬼泣中那样，主角的行动不收时间钥匙的影响，而其他对象都会
延时。

说起来挺高大上，但是实现的代码却是很简单（我喜欢用最精简的代码来实现功能），就是使用静态变量全局控制，简单计时器，以及继承和复写。好不多说上代码：

1. using UnityEngine; 
2.  
3. public abstract class GameControllor : MonoBehaviour 
4. { 
5.  
6.  
7.     //先写一个主框架，用来声明更新的函数 
8.     public abstract void FixedUpdateGame();//一个按照FixedUpdate更新的函数，当然你可以自己定义或者添加，在子类中复写就行了，注意你的需求是基于哪个更新 
9.     public abstract void UpdateGame();//一个按照Update更新的函数，同上 
10.     public abstract void LateUpdateGame();//一个按照LateUpdate更新的函数，同上 
11.  
12.  
13.  
14.  
15. } 

using UnityEngine;

public abstract class GameControllor : MonoBehaviour
{

    //先写一个主框架，用来声明更新的函数
    public abstract void FixedUpdateGame();//一个按照FixedUpdate更新的函数，当然你可以自己定义或者添加，在子类中复写就行了，注意你的需求是基于哪个更新
    public abstract void UpdateGame();//一个按照Update更新的函数，同上
    public abstract void LateUpdateGame();//一个按照LateUpdate更新的函数，同上

}

1. using UnityEngine; 
2. public abstract class MyGameControllor : GameControllor 
3. { 
4.     //为什么要写成抽象类的，因为这个控制器本身没有具体的意义，只是控制时间，而且直接控制属性就行了。 
5.     private static bool isStopGame = false;//控制是否暂停 
6.  
7.     public static bool IsStopGame 
8.     { 
9.         get { return MyGameControllor.isStopGame; } 
10.         set { MyGameControllor.isStopGame = value; } 
11.     } 
12.     private static float gameTime = 0;//脚本更新的时间，0为正常更新，1代表1秒更新一次 
13.  
14.     public static float GameTime 
15.     { 
16.         get { return MyGameControllor.gameTime; } 
17.         set { MyGameControllor.gameTime = value; } 
18.     } 
19.     private static float runtime = 0;//计时器 
20.     private bool IsOnTime = false; 
21.  
22.     void Update()//Update更新 
23.     { 
24.         if (IsOnTime) 
25.         { 
26.             UpdateGame(); 
27.  
28.         } 
29.     } 
30.     void FixedUpdate()//FixedUpdate更新 
31.     { 
32.         if (IsOnTime = (IsRun())) 
33.         { 
34.             FixedUpdateGame(); 
35.         } 
36.     } 
37.  
38.     void LateUpdate() 
39.     { 
40.         if (IsOnTime) 
41.         { 
42.             LateUpdateGame(); 
43.         } 
44.  
45.  
46.     } 
47.     private bool LateTime()//这个判断是否到了更新的时间 
48.     { 
49.         if (GameTime <= 0) return true; 
50.         runtime += Time.fixedDeltaTime; 
51.         if (runtime >= GameTime) 
52.         { 
53.             runtime = 0; 
54.             return true; 
55.         } 
56.         return false; 
57.     } 
58.     private bool IsRun()//判断是否暂停 
59.     { 
60.         if (!IsStopGame) 
61.         { 
62.             if (LateTime())//不是暂停时判断是否到了更新的时间 
63.             { 
64.                 return true; 
65.             } 
66.         } 
67.         return false; 
68.     } 
69.     public override void FixedUpdateGame() { } 
70.     public override void UpdateGame() { } 
71.     public override void LateUpdateGame() { } 
72. } 

using UnityEngine;
public abstract class MyGameControllor : GameControllor
{
    //为什么要写成抽象类的，因为这个控制器本身没有具体的意义，只是控制时间，而且直接控制属性就行了。
    private static bool isStopGame = false;//控制是否暂停

public static bool IsStopGame
    {
        get { return MyGameControllor.isStopGame; }
        set { MyGameControllor.isStopGame = value; }
    }
    private static float gameTime = 0;//脚本更新的时间，0为正常更新，1代表1秒更新一次

public static float GameTime
    {
        get { return MyGameControllor.gameTime; }
        set { MyGameControllor.gameTime = value; }
    }
    private static float runtime = 0;//计时器
    private bool IsOnTime = false;

    void Update()//Update更新
    {
        if (IsOnTime)
        {
            UpdateGame();

        }
    }
    void FixedUpdate()//FixedUpdate更新
    {
        if (IsOnTime = (IsRun()))
        {
            FixedUpdateGame();
        }
    }

    void LateUpdate()
    {
        if (IsOnTime)
        {
            LateUpdateGame();
        }

    }
    private bool LateTime()//这个判断是否到了更新的时间
    {
        if (GameTime <= 0) return true;
        runtime += Time.fixedDeltaTime;
        if (runtime >= GameTime)
        {
            runtime = 0;
            return true;
        }
        return false;
    }
    private bool IsRun()//判断是否暂停
    {
        if (!IsStopGame)
        {
            if (LateTime())//不是暂停时判断是否到了更新的时间
            {
                return true;
            }
        }
        return false;
    }
    public override void FixedUpdateGame() { }
    public override void UpdateGame() { }
    public override void LateUpdateGame() { }
}

代码很简单，关键是方案和思路。怎么使用呢？所有逻辑更新的脚本继承这个MyGameControllor，然后复写你更新的方法就行了，好吧，测试一下（这是照顾一下小白）：

1. using UnityEngine; 
2. using System.Collections; 
3.  
4. public class PlayerMove : MyGameControllor { 
5.     //继承MyGameControllor，并复写UpdateGame方法 
6.     public void Move() { 
7.         //一个简单移动的方法，用来观察测试 
8.         transform.Translate(new Vector3(Random.Range(-1, 1), Random.Range(-1, 1), Random.Range(-1, 1))*Time.deltaTime); 
9.     } 
10.     public override void UpdateGame() 
11.     { 
12.         //复写UpdateGame 
13.         Move(); 
14.     } 
15. } 

最后是一个时间控制器代码，就是按下esc暂停的，代码很简单，好再给小白看一下：

1. using UnityEngine; 
2. using System.Collections; 
3.  
4. public class SystemTimeControl : MonoBehaviour 
5. { 
6.  
7.      
8.     void Update() 
9.     { 
10.         if (Input.GetKeyDown(KeyCode.Escape)) 
11.         { 
12.             MyGameControllor.IsStopGame = !MyGameControllor.IsStopGame; 
13.         } 
14.  
15.     } 
16.      
17. } 

好了，关于时间的架构设计就介绍到这了，方案简单实用，也许有更好的方法，欢迎交流。打个广告：大三软件工程专业（java方向），擅长面向对象设计，常用算法。自学js，C#，以及unity3D引擎，擅长前端开发以及系统架构优化。

作者：决晴谷

来源：51CTO