MVVM模式(Model–View–ViewModel)：MVVM將程式劃分為 Model ， View 與 ViewModel ，它透過觀察者模式將 View 與 ViewModel 連接在一起， 在 ViewModel 中進行資料綁定(data binding)。當 View Model 的狀態改變時自動通知 View。

• Model：主要負責管理資料邏輯。
• View：負責顯示資料以及與使用者互動。
• ViewModel：是連接 Model 和 View 的橋樑。與 MVC中的 Controller 和 MVP 中的 Presenter 不同在於 ViewModel 它會綁定(Binder) View 要顯示的資料，當資料改變時，自動通知 View 要更新UI。
  • 通常使用資料綁定(Data Binding)機制來實現這一點

graph TD
    A[ View ]
    B[ ViewModel ]
    C[ Model ]
    
    A -->| User Interaction | B
    B -->| Notify Changes | A
    B <-->| Data Binding | A
    B -->| Calls | C
    C -->| Data | B

Unity中，UGUI沒有內建Data Binding，需要自己實作一個，以下是一個簡單的範例

定義一個 Model

1
2
3
4
5

public class Model
{
    public string Name { get; set; }
    public string Job { get; set;}
}

定義一個Model Service，其職責為從PlayerPrefs拿資料，或是將資料寫入PlayerPrefs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class ModelService
{

    public Model GetData()
    {
        Model m = new Model()
        {
            Name = PlayerPrefs.GetString("name"),
            Job = PlayerPrefs.GetString("job"),
        };

        return m;
    }

    public void SaveName(string name)
    {
        PlayerPrefs.SetString("name", name);
    }

    public void SaveJob(string job)
    {
        PlayerPrefs.SetString("job", job);
    }
}

定義一個BindableProperty類，它含有一個OnValueChanged事件，當Value的值發生變化(通過set方法)時，就會呼叫 OnValueChanged ，從而通知有註冊這個事件的物件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class BindableProperty<T>
{
    public delegate void ValueChangedHandler(T oldValue, T newValue);

    public event ValueChangedHandler OnValueChanged;

    private T _value;
    public T Value
    {
        get
        {
            return _value;
        }
        set
        {
            if (!object.Equals(_value, value))
            {
                T oldValue = _value;
                _value = value;
                // 通知值發生改變
                OnValueChanged?.Invoke(oldValue, _value);
            }
        }
    }

    public override string ToString()
    {
        return (Value != null ? Value.ToString() : "null");
    }
}

接下來定義一個 ViewModel ， 這個 ViewModel 將負責為 View 提供資料，但它不知曉 View 的任何資訊，與 View 解耦，專注於資料的處理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public class ViewModel
{

    public BindableProperty<string> Name = new BindableProperty<string>();
    public BindableProperty<string> Job = new BindableProperty<string>();

    private ModelService service = new ModelService();

    public ViewModel()
    {}

    public void GetModel()
    {
        Model m = service.GetData();
        Name.Value = m.Name;
        Job.Value = m.Job;

        Debug.Log(m.Name + " " + m.Job);
    }

    public void SaveModel()
    {
        // do some check
        string name = Name.Value;
        string job = Job.Value;

        if (name == null || name.Length > 0)
        {
            return;
        }
        if (job == null || job.Length > 0)
        {
            return;
        }

        service.SaveName(Name.Value);
        service.SaveJob(Job.Value);
    }

}

最後定義一個 View ，這個 View 包含了要操控的UI元件，因此繼承了MonoBehaviour，它不處理資料邏輯，只負責顯示格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

public class View : MonoBehaviour
{
    public TMP_InputField nameInputField;
    public TextMeshProUGUI nameMessageText;

    public TMP_InputField jobInputField;
    public TextMeshProUGUI jobMessageText;

    public TextMeshProUGUI resultText;
    public Button applyButton;

    public ViewModel viewModel;

    private void Start()
    {
        viewModel = new ViewModel();
        viewModel.Name.OnValueChanged += OnNameChanged;
        nameInputField.onValueChanged.AddListener(OnNameInputChanged);

        viewModel.Job.OnValueChanged += OnJobChanged;
        jobInputField.onValueChanged.AddListener(OnJobInputChanged);

        applyButton.onClick.AddListener(OnApplyButtonClick);

        viewModel.GetModel();
    }


    private void OnDestroy()
    {
        viewModel.Name.OnValueChanged -= OnNameChanged;
        nameInputField.onValueChanged.RemoveListener(OnNameInputChanged);

        viewModel.Job.OnValueChanged -= OnJobChanged;
        jobInputField.onValueChanged.RemoveListener(OnJobInputChanged);

        applyButton.onClick.RemoveListener(OnApplyButtonClick);
    }

    private void OnNameChanged(string oldVal, string newVal)
    {
        nameMessageText.text = newVal;
    }

    private void OnNameInputChanged(string value)
    {
        viewModel.Name.Value = value;
    }

    private void OnJobChanged(string oldVal, string newVal)
    {
        jobMessageText.text = newVal;
    }

    private void OnJobInputChanged(string value)
    {
        viewModel.Job.Value = value;
    }

    private void OnApplyButtonClick()
    {
        resultText.text = viewModel.Name.Value + ", " + viewModel.Job.Value + " have been saved";
        viewModel.SaveModel();
    }
}

程式碼： https://github.com/mystudybook/Unity-MVVM

Reference: https://www.cnblogs.com/OceanEyes/p/unity3d_framework_designing_get_started_with_mvvm_part1.html

2D車輪關節(Wheel Joint 2D)：是一種物理關節，可以用它來模擬轉動的車輪，

• 可以為它施加馬達動力(motor power)，
• 它使用了懸吊彈簧(suspension spring)來保持與車輛主體(main body of the vehicle)的距離。

這種關節可用來模擬車輪(wheels)和懸掛系統(suspension)。其目的是保持兩個點在一條延伸到無限遠的直線上，同時使它們重疊(overlap)。這兩個點可以是兩個Rigidbody2D組件，也可以是一個Rigidbody2D組件和世界中的一個固定位置（通過將Connected Rigidbody設置為None來連接到世界中的固定位置）。

• 簡單的說：2D車輪關節(Wheel Joint 2D)，讓兩個點保持在同一條直線上，而這條直線是可以延伸到無限遠的。同時，當沒有外力作用時，這兩個點會保持在一起(即重疊)。

Wheel Joint 2D類似於Slider Joint 2D（無馬達動力或限制約束）和Hinge Joint 2D（無限制約束）的組合。
這種關節對兩個連接的剛體(rigid body)物件施加線性力(linear force)，使它們保持在線上，並施加角度馬達(angular motor)以使物件在線上旋轉(rotate)，同時用彈簧(spring)來模擬車輪懸掛(wheel suspension)。

設置
Maximum Motor Speed（最大馬達速度）與Maximum Motor Force（最大馬達動力）控制角馬達速度，讓兩個剛體物體旋轉。
Maximum Motor Force（最大馬達動力）：設置角馬達的最大扭矩。

• 即馬達所能施加的最大旋轉力。這個最大扭矩的設置對於控制車輪的轉動速度和力量非常重要。例如：
  • 如果 Maximum Motor Force 設置得太小，馬達可能無法提供足夠的扭矩來驅動車輪，特別是在遇到障礙或需要加速的情況下。
  • 如果 Maximum Motor Force 設置得太大，馬達可能會施加過大的扭矩，導致車輪快速旋轉，可能會影響車輛的穩定性
    模擬懸掛
    可以設置車輪懸掛的硬度和運動，以模擬不同程度的懸掛效果。例如，模擬硬且幾乎不動的懸掛：
• 設置高頻率（Frequency）（1,000,000是最高值）== 硬懸掛。
• 設置高阻尼比（Damping Ratio）（1是最高值）== 幾乎不動的懸掛。

若要模擬有彈性且自由運動的懸掛，可以使用以下設置：

• 設置低頻率 == 鬆弛的懸掛。
• 設置低阻尼比 == 可動的懸掛。

保持零相對線性距離(zero relative linear distance)：在兩個剛體物體的錨點之間指定的線上保持零相對線性距離。
保持角速度(angular speed)：在兩個剛體物體的錨點之間保持角速度（通過Maximum Motor Speed選項設置速度，通過Maximum Motor Force設置最大扭矩）。

應用場景

• 這種關節適用於構建需要像是通過旋轉樞軸連接，但不能脫離指定線的物理對象。例如：模擬具有馬達驅動的車輪。

Damping Ratio(阻尼比)：描述系統在受到擾動後振盪及衰減的情形。阻尼比越大，物件受力振盪後越快恢復原狀。

• 無阻尼：= 0 ， 對應沒有阻尼的簡諧運動。
• 欠阻尼：< 1 ， 指數遞減且振盪
• 過阻尼：> 1 ， 沒有振盪的指數遞減
• 臨界阻尼：= 1 ， 介於過阻尼及欠阻尼之間，是許多工程應用想要的結果
• https://zh.wikipedia.org/zh-tw/%E9%98%BB%E5%B0%BC%E6%AF%94

Reference：https://docs.unity3d.com/Manual/class-WheelJoint2D.html

這本 Unity 的電子書《Level up your code with game programming patterns》 對於提升遊戲開發者的程式設計能力非常有幫助。
以下是該電子書的網址與Github
網址：https://blog.unity.com/games/level-up-your-code-with-game-programming-patterns
Github：https://github.com/Unity-Technologies/game-programming-patterns-demo/tree/main

這本書介紹了工程師必須了解的SOLID 原則(SOLID principles)，這些原則是編寫高質量程式碼的基礎，SOLID原則是以下五大原則的簡稱：

• 單一職責原則(Single responsibility)：確保類只負責一件事。
• 開閉原則(Open-closed)：在不更改現有程式碼的情況下，可以擴展一個類的功能。
• 里氏替換原則(Liskov substitution)：子類可以替代基類，而不影響程式的正確性。
• 介面隔離原則(Interface segregation)：讓介面(interface)盡可能簡單，確保實作類只需要實作其所需的介面方法。
• 依賴倒置原則(Dependency inversion)：高層模組不應依賴於低層模組，兩者都應依賴於抽象。具體實現應依賴於抽象，而不是抽象依賴於具體實現。

這些原則可以讓你的程式設計更具彈性和可維護性，但在不確定是否要使用它們時，請記住KISS（Keep It Simple, Stupid）原則，不要強迫將其應用於程式碼中。

這本電子書也介紹了以下常用在遊戲開發中的設計模式

• 工廠模式(Factory pattern)：把生成物件的邏輯封裝起來，讓一個特別的物件(工廠Factory)去建立其他物件(產品Product)。
• 物件池模式(Object Pool pattern)：預先建立一組物件並存放在池中，重用這些物件以減少資源浪費。
• 單例模式(Singleton pattern)：確保一個特別的類只有一個並可全局訪問的實體。
• 命令模式(Command Pattern)：將一系列特定動作封裝為命令物件(Command object)，讓這些命令可以撤銷(undo)或是重做(redo)
• 狀態模式(State Pattern)：讓物件的行為隨內部狀態改變而改變。
• 觀察者模式(Observer pattern)：當一個物件的狀態改變時，會自動通知所有想要接收此訊息的物件。
• MVP模式(Model-View-Presenter)：MVP模式是使用者介面設計模式的一種，它是MVC模式的一種衍生模式，在此模式中，Presenter充當了Model和View之間的橋樑。由Presenter在View與Model之間雙向通信，但View與Model不通信
• MVVM模式(Model-View-ViewModel)：MVVM模式是使用者介面設計模式的一種，它是MVC模式的一種衍生模式，它透過觀察者模式(Observer pattern)將 View 與 ViewModel 連接在一起， 在 ViewModel 中進行資料綁定(data binding)。當 View Model 的狀態改變時自動通知 View。

MVC模式(Model-View-Controller)：MVC模式在開發UI中是一種非常受歡迎的設計模式。

• MVC主要想法為：將程式劃分為模型（Model）、視圖（View）和控制器（Controller）
  • Model：主要負責管理資料邏輯。Model拿到資料後將資料交給View。
    • 在此可以直接與資料庫、API 或其他資料來源交互。
    • 在此不執行遊戲邏輯或是執行運算。
  • View：負責顯示資料。
    • 它從Model中獲取資料，並將這些資料呈現給使用者。View僅關注如何顯示資料。
  • Controller：充當Model和View之間的溝通的橋樑。
    • 它接收使用者的輸入，呼叫Model來處理這些輸入，然後選擇適當的View來顯示處理結果。
    • 可以把它想像為大腦，它處理遊戲資料並在執行期間計算資料是如何改變的。
• MVC模式符合單一職責原則，每個部分都只負責自己的部分。
• 在Unity中，UI Toolkit或是Unity UI很自然地負責擔任View
• 缺點
  • MVC模式中三者相互依賴，一但更新了其中一個，另外兩個也須跟著修改。
  • Controller的程式碼會隨著功能的添加越來越臃腫。

graph TD
    A[ User ] -->| Interacts with | B[ View ]
    B -->| Sends user input to | C[ Controller ]
    C -->| Updates | D[ Model ]
    D -->| Notifies changes to | B[ View ]
    B -->| Displays data from | D[ Model ]

MVP模式(Model-View-Presenter)：MVP是MVC的一種變體

• MVP將Controller改爲Presenter，並改變了通信方向。當Model拿到資料之後，不直接給View更新，而是交給Presenter，之後Presenter再把資料交給View，View再更新畫面。
  • View：只負責收到使用者回饋，之後呼叫Presenter拿取資料，並在接收到資料時，更新畫面。
  • Model：被動的接收到Presenter命令，拿取資料，並回傳給Presenter。
  • Presenter：Model和View之間的的橋樑，與View和Model溝通。
• 從三者相互依賴變成都只依賴Presenter
  • M <=> P <=> V 之間雙向通信但View與Model不通信
• Presenter的程式碼會隨著功能的添加越來越臃腫。

graph TD
    A[ User ] -->| Interacts with  | B[ View ]
    B -->| Sends user input to | C[ Presenter ]
    C -->| Updates | D[ Model ]
    D -->| Notifies changes to | C[ Presenter ]
    C -->| Updates | B[ View ]
    B -->| Displays data from | C[ Presenter ]

使用MVP模式製作生命條UI：
Health類

• 在此Health類的身份是Model，保存真正的生命資料
• 含有一個HealthChanged event，每當有更改生命值的動作時，都會呼叫這個event。
• Health類只負責增加，減少生命值，符合符合單一職責原則

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

  public class Health : MonoBehaviour { public event Action HealthChanged; private const int minHealth = 0; private const int maxHealth = 100; private int currentHealth; public int CurrentHealth { get => currentHealth; set => currentHealth = value; } public int MinHealth => minHealth; public int MaxHealth => maxHealth; public void Increment(int amount) { currentHealth += amount; currentHealth = Mathf.Clamp(currentHealth, minHealth, maxHealth); UpdateHealth(); } public void Decrement(int amount) { currentHealth -= amount; currentHealth = Mathf.Clamp(currentHealth, minHealth, maxHealth); UpdateHealth(); } public void Restore() { currentHealth = maxHealth; UpdateHealth(); } private void UpdateHealth() { HealthChanged?.Invoke(); } }

HealthPresenter類

• HealthPresenter類含有Health類的依賴，用來操控Health
• 其他物件不會直接操控Health類，而是透過HealthPresenter類暴露的Damage與Heal以及Reset來操控

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

  public class HealthPresenter : MonoBehaviour { // 在MVP中的Model [SerializeField] private Health health; // 在MVP中的View [SerializeField] private Slider healthSlider; private void Start() { if (health != null) { health.HealthChanged += OnHealthChanged; } UpdateView(); } private void OnDestroy() { if (health != null) { health.HealthChanged -= OnHealthChanged; } } public void Damage(int amount) { health?.Decrement(amount); } public void Heal(int amount) { health?.Increment(amount); } public void Reset() { health?.Restore(); } public void UpdateView() { if (health == null) return; if (healthSlider != null && health.MaxHealth != 0) { healthSlider.value = (float)health.CurrentHealth / health.MaxHealth; } } private void OnHealthChanged() { UpdateView(); } }

ClickDamage類：為使用HealthPresenter的類

• 不直接操控 Model (Health)與 View (healthSlider)而是透過HealthPresenter

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  [RequireComponent(typeof(HealthPresenter), typeof(Collider))] public class ClickDamage : MonoBehaviour { private Collider collider; private HealthPresenter healthPresenter; [SerializeField] private LayerMask layerToClick; [SerializeField] private int damageValue = 10; private void Start() { collider = GetComponent<Collider>(); healthPresenter = GetComponent<HealthPresenter>(); } private void Update() { if (Input.GetMouseButtonDown(0)) { Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, Mathf.Infinity, layerToClick)) { healthPresenter?.Damage(damageValue); } } } }

Reference: https://github.com/Unity-Technologies/game-programming-patterns-demo/tree/main/Assets/12%20MVP
https://github.com/push-pop/Unity-MVVM/blob/main/Docs/Architechture.md

狀態模式(State pattern)：

• 當物件的內部狀態改變時，物件的行為也會隨之改變，即物件會根據當前狀態執行不同的行為。
• 每個狀態的行為是獨立定義的。添加新狀態不會影響現有狀態的行為。

在遊戲中會需要不斷地追蹤遊戲中的各種狀態，例如玩家走路(Walking)，跳躍(Jumping)，待命(Idle或Standing)等。若你把它畫成流程圖(flowchart)可能會發現

• 一次只有一個狀態會被啟用(Active)
• 狀態會依據不同的條件去轉換到另外一個狀態
• 當轉換發生時，新的狀態會成為啟用狀態(Active state)
• 這種狀態轉換圖被稱為有限狀態機(Finite state machine，FSM)

以下是一個使用Enum去實作的簡單有限狀態機：

1
2
3
4
5
6

public enum PlayerControllerState
{
    Idle,
    Walk,
    Jump
}

在這個Controller類中，使用switch轉換狀態，很快你會發現當狀態越來越多後，Controller會變得一團亂，例如增加幾個狀態，就必須要不斷的更改Controller：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class UnrefactoredPlayerController : MonoBehaviour
{
    private PlayerControllerState state;
    private void Update()
    {
        GetInput();
        switch (state)
        {
            case PlayerControllerState.Idle:
                Idle();
                break;
            case PlayerControllerState.Walk:
                Walk();
                break;
            case PlayerControllerState.Jump:
                Jump();
                break;
        }
    }
    private void GetInput()
    {
        // 處理行走和跳躍控制
    }
    private void Walk()
    {
        // 行走邏輯
    }
    private void Idle()
    {
        // 待命邏輯
    }
    private void Jump()
    {
        // 跳躍邏輯
    }
}

使用狀態模式，在遊戲中，你可以想像處理角色狀態需要：

1. 當條件滿足時，第一次進入(Enter)這個狀態時需要處理一些事。
2. 在遊戲迴圈中根據這個狀態不斷的更新(Update)角色的值。
3. 當條件不滿足或是滿足某些離開條件時，離開(Exit)這個狀態時，要在離開前處理一些事。
   因此根據這樣的流程定義一個抽象介面(Interface)，IState並定義它有以下方法：

• Enter：第一次進入這個狀態時需要做的邏輯
• Update： 在每一幀中需要執行的邏輯(有時也稱Exceute或Tick)。它會根據這個狀態在每一幀中不斷的更新角色的值。
• Exit：在離開這個狀態前要做的邏輯

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  public interface IState { public void Enter() { // 當第一次進入狀態時運行的邏輯 } public void Update() { // 每幀邏輯，包括轉換到新狀態的條件 } public void Exit() { // 當離開狀態時運行的邏輯 } }

行走狀態：在這個狀態中，Update()會不斷地移動這個角色，另外也會判斷是否要切換到其他狀態。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class WalkState : IState
{
    private Color meshColor = Color.blue;
    public Color MeshColor { get => meshColor; set => meshColor = value; }

    private PlayerController player;

    // 可以在建構子中傳遞任何需要的參數
    public WalkState(PlayerController player)
    {
        this.player = player;
    }

    public void Enter()
    {
        //Debug.Log("Entering Walk State");
    }
    
    public void Update()
    {
        // 如果不再在地面上，轉換到跳躍狀態
        if (!player.IsGrounded)
        {
            player.PlayerStateMachine.TransitionTo(player.PlayerStateMachine.jumpState);
        }

        // 如果速度降到最低臨界值以內，轉換到待命狀態
        if (Mathf.Abs(player.CharController.velocity.x) < 0.1f && Mathf.Abs(player.CharController.velocity.z) < 0.1f)
        {
            player.PlayerStateMachine.TransitionTo(player.PlayerStateMachine.idleState);
        }
    }

    public void Exit()
    {
        //Debug.Log("Exiting Walk State");
    }

}

待命狀態

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class IdleState : IState
{
    private PlayerController player;

    private Color meshColor = Color.gray;
    public Color MeshColor { get => meshColor; set => meshColor = value; }

    public IdleState(PlayerController player)
    {
        this.player = player;
    }

    public void Enter()
    {
        Debug.Log("Entering Idle State");
    }
    
    public void Update()
    {
        // 如果不再在地面上，轉換到跳躍狀態
        if (!player.IsGrounded)
        {
            player.PlayerStateMachine.TransitionTo(player.PlayerStateMachine.jumpState);
        }

        // 如果速度超過臨界值，轉換到移動狀態
        if (Mathf.Abs(player.CharController.velocity.x) > 0.1f || Mathf.Abs(player.CharController.velocity.z) > 0.1f)
        {
            player.PlayerStateMachine.TransitionTo(player.PlayerStateMachine.walkState);
        }
    }

    public void Exit()
    {
        Debug.Log("Exiting Idle State");
    }
}

StateMachine負責管理這些狀態

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class StateMachine
{
    public IState CurrentState { get; private set; } // 目前狀態

    // 狀態物件的引用
    public WalkState walkState;
    public JumpState jumpState;
    public IdleState idleState;

    // 用於通知其他物件狀態改變的事件
    public event Action<IState> stateChanged;

    // 由於沒有繼承 MonoBehaviour，因此需要通過建構子將 PlayerController 傳入 
    public StateMachine(PlayerController player)
    {
        // 建立每個狀態的實體並傳遞 PlayerController
        this.walkState = new WalkState(player);
        this.jumpState = new JumpState(player);
        this.idleState = new IdleState(player);
    }

    // 設置初始狀態
    public void Initialize(IState state)
    {
        CurrentState = state;
        state.Enter();

        // 通知其他物件狀態已改變
        stateChanged?.Invoke(state);
    }

    // 退出目前狀態並進入另一個狀態
    public void TransitionTo(IState nextState)
    {
        CurrentState.Exit();
        CurrentState = nextState;
        nextState.Enter();

        // 通知其他物件狀態已改變
        stateChanged?.Invoke(nextState);
    }

    public void Update()
    {
        if (CurrentState != null)
        {
            CurrentState.Update();
        }
    }
}

在Controller中使用StateMachine

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

[RequireComponent(typeof(PlayerInput), typeof(CharacterController))]
public class PlayerController : MonoBehaviour
{
    [SerializeField] private PlayerInput playerInput;
    private StateMachine playerStateMachine;

    [Header("Movement")]
    [Tooltip("Horizontal speed")]
    [SerializeField] private float moveSpeed = 5f;
    [Tooltip("Rate of change for move speed")]
    [SerializeField] private float acceleration = 10f;
    [Tooltip("Max height to jump")]
    [SerializeField] private float jumpHeight = 1.25f;

    [Tooltip("Custom gravity for player")]
    [SerializeField] private float gravity = -15f;
    [Tooltip("Time between jumps")]
    [SerializeField] private float jumpTimeout = 0.1f;

    [SerializeField] private bool isGrounded = true; // 是否在地面上
    [SerializeField] private float groundedRadius = 0.5f; // 檢查是否在地面的半徑
    [SerializeField] private float groundedOffset = 0.15f;
    [SerializeField] private LayerMask groundLayers;

    public CharacterController CharController => charController;
    public bool IsGrounded => isGrounded;
    public StateMachine PlayerStateMachine => playerStateMachine;

    private CharacterController charController;
    private float targetSpeed;
    private float verticalVelocity;
    private float jumpCooldown;

    private void Awake()
    {
        playerInput = GetComponent<PlayerInput>(); 
        charController = GetComponent<CharacterController>();

        // 初始化狀態機
        playerStateMachine = new StateMachine(this);
    }

    private void Start()
    {
        playerStateMachine.Initialize(playerStateMachine.idleState); // 設置初始狀態為 idleState
    }

    private void Update()
    {
        // 使用目前狀態更新角色資料
        playerStateMachine.Update();
    }

    private void LateUpdate()
    {
        CalculateVertical();
        Move();
    }

    private void Move()
    {
        Vector3 inputVector = playerInput.InputVector;

        if (inputVector == Vector3.zero)
        {
            targetSpeed = 0;
        }

        float currentHorizontalSpeed = new Vector3(charController.velocity.x, 0.0f, charController.velocity.z).magnitude;
        float tolerance = 0.1f;

        if (currentHorizontalSpeed < targetSpeed - tolerance || currentHorizontalSpeed > targetSpeed + tolerance)
        {
            targetSpeed = Mathf.Lerp(currentHorizontalSpeed, targetSpeed, Time.deltaTime * acceleration);
            targetSpeed = Mathf.Round(targetSpeed * 1000f) / 1000f;
        }
        else
        {
            targetSpeed = moveSpeed;
        }

        charController.Move((inputVector.normalized * targetSpeed * Time.deltaTime) + new Vector3(0f, verticalVelocity, 0f) * Time.deltaTime);
    }

    private void CalculateVertical()
    {
        if (isGrounded)
        {
            if (verticalVelocity < 0f)
            {
                verticalVelocity = -2f;
            }

            if (playerInput.IsJumping && jumpCooldown <= 0f)
            {
                verticalVelocity = Mathf.Sqrt(jumpHeight * -2f * gravity);
            }

            if (jumpCooldown >= 0f)
            {
                jumpCooldown -= Time.deltaTime;
            }
        }
        else
        {
            jumpCooldown = jumpTimeout;
            playerInput.IsJumping = false;
        }

        verticalVelocity += gravity * Time.deltaTime;

        Vector3 spherePosition = new Vector3(transform.position.x, transform.position.y + groundedOffset, transform.position.z);
        isGrounded = Physics.CheckSphere(spherePosition, 0.5f, groundLayers, QueryTriggerInteraction.Ignore);
    }

    private void OnDrawGizmosSelected()
    {
        Color transparentGreen = new Color(0.0f, 1.0f, 0.0f, 0.35f);
        Color transparentRed = new Color(1.0f, 0.0f, 0.0f, 0.35f);

        Gizmos.color = isGrounded ? transparentGreen : transparentRed;

        Gizmos.DrawSphere(new Vector3(transform.position.x, transform.position.y + groundedOffset, transform.position.z), groundedRadius);
    }
}

Reference: https://github.com/Unity-Technologies/game-programming-patterns-demo/tree/main/Assets/10%20State/Scripts

依賴（Dependency）：通常指的是一個類別依賴於另一個類別或介面來完成其功能。

• 依賴使得類別之間的耦合度增加，讓系統變得難以維護和測試。

依賴關係的方向性可以分為單向依賴(Unidirectional Dependency)和雙向依賴(Bidirectional Dependency)。

• 單向依賴(Unidirectional Dependency)：是指一個類別或模組依賴於另一個類別或模組，但相反的依賴關係不存在。這種依賴關係是單向的，即依賴的方向是單一的，這種依賴的程式碼較容易維護和擴展。

  • 在下面例子中，Car 類別依賴於 Engine 類別，但 Engine 類別並不依賴 Car 類別。這就是一個單向依賴的例子。

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

    public class Engine { public void Start() { Console.WriteLine("Engine started."); } } public class Car { private Engine _engine; public Car(Engine engine) { _engine = engine; } public void Start() { _engine.Start(); } }

• 雙向依賴(Bidirectional Dependency)：是指兩個類別或模組互相依賴，形成了雙向的依賴關係。這種依賴關係會增加系統的耦合度，使得程式碼難以維護和測試。

  • 通常在設計中應該盡量避免雙向依賴，或者使用依賴注入和接口等技術來減少耦合度。
  • 在這個例子中，Engine 類別依賴於 Car 類別，並且 Car 類別也依賴於 Engine 類別，形成了雙向依賴。這種設計會使得類別之間的關係變得複雜，難以維護和測試。

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

    public class Engine { private Car _car; public Engine(Car car) { _car = car; } public void Start() { Console.WriteLine("Engine started."); _car.NotifyEngineStarted(); } } public class Car { private Engine _engine; public Car() { _engine = new Engine(this); } public void Start() { _engine.Start(); } public void NotifyEngineStarted() { Console.WriteLine("Car notified: Engine started."); } } public class Program { public static void Main(string[] args) { Car car = new Car(); car.Start(); } }

命令模式(Command Pattern)：當你想要追蹤一系列特定動作時，可以使用命令模式（command pattern）。如果你玩過帶有撤銷(undo)/重做(redo)功能或是能夠在列表中保留輸入歷史的遊戲，你很可能已經見過命令模式。想像一個策略遊戲，玩家可以在實際執行之前計劃多個動作，這就是命令模式。

在設計模式中，命令模式有以下角色參與其中

• Command：抽象命令，可能為一個介面(Interface)或是抽象類(Abstract Class)，例如ICommand
• ConcreteCommand：具體命令，即實作抽象命令的Class
• Invoker：命令的調用者，發起者，管理者
• Receiver：接收者，實際執行命令者，被Command訪問與操作
• 使用命令的客戶端(Client)

命令模式特點：

• 命令模式不直接呼叫方法(method)而是會將單個或多個方法封裝為命令物件(command object)。
• 命令物件會存放到一個容器(像是Stack或是Queue)中，讓你可以在想要的時間點去執行或是撤銷這些命令物件。
• 新增命令不會影響其他地方，符合了開閉原則(Open-closed principle)
• 除了撤銷(undo)/重做(redo)功能，也可以用來實現回放(Play back)功能

接收者(Receiver)類：PlayerMover，在命令物件執行時真正執行動作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class PlayerMover : MonoBehaviour
{
    [SerializeField] private LayerMask obstacleLayer;
    
    private const float boardSpacing = 1f;
    private PlayerPath playerPath;
    public PlayerPath PlayerPath => playerPath;

    private void Start()
    {
        playerPath = gameObject.GetComponent<PlayerPath>();
    }

    public void Move(Vector3 movement)
    {
        Vector3 destination = transform.position + movement;
        transform.position = destination;
    }

    public bool IsValidMove(Vector3 movement)
    {
        return !Physics.Raycast(transform.position, movement, boardSpacing, obstacleLayer);
    }
}

定義一個抽象命令介面(ICommand)

1
2
3
4
5

public interface ICommand
{
  void Execute();
  void Undo();
}

定義一個具體命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class MoveCommand : ICommand
{
    private PlayerMover _playerMover;
    private Vector3 _movement;

    public MoveCommand(PlayerMover player, Vector3 moveVector)
    {
        this._playerMover = player;
        this._movement = moveVector;
    }

    public void Execute()
    {
        _playerMover?.PlayerPath.AddToPath(_playerMover.transform.position + _movement);
        _playerMover.Move(_movement);
    }

    public void Undo()
    {
        _playerMover.Move(-_movement);
        _playerMover?.PlayerPath.RemoveFromPath();
    }
}

定義一個使用命令的命令调用者類CommandInvoker，它只負責執行(ExecuteCommand())和撤銷(UndoCommand())命令。

• 它含有一個容器(undoStack)，用來儲存一系列的命令。
• 當執行命令時，從容器中取出一個命令物件執行方法(Execute)
• 當撤消命令時，從容器中取出一個命令物件，並執行撤銷方法(Undo)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  public class CommandInvoker { private static Stack<ICommand> _undoStack = new Stack<ICommand>(); private static Stack<ICommand> _redoStack = new Stack<ICommand>(); public static void ExecuteCommand(ICommand command) { command.Execute(); _undoStack.Push(command); _redoStack.Clear(); } public static void UndoCommand() { if (_undoStack.Count > 0) { ICommand activeCommand = _undoStack.Pop(); _redoStack.Push(activeCommand); activeCommand.Undo(); } } public static void RedoCommand() { if (_redoStack.Count > 0) { ICommand activeCommand = _redoStack.Pop(); _undoStack.Push(activeCommand); activeCommand.Execute(); } } }

使用命令的客戶端(Client)類，InputManager，它透過CommandInvoker執行命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class InputManager : MonoBehaviour
{
    [Header("Button Controls")]
    [SerializeField] Button forwardButton;
    [SerializeField] Button backButton;
    [SerializeField] Button leftButton;
    [SerializeField] Button rightButton;
    [SerializeField] Button undoButton;
    [SerializeField] Button redoButton;

    [SerializeField] private PlayerMover player;

    private void Start()
    {
        forwardButton.onClick.AddListener(OnForwardInput);
        backButton.onClick.AddListener(OnBackInput);
        rightButton.onClick.AddListener(OnRightInput);
        leftButton.onClick.AddListener(OnLeftInput);
        undoButton.onClick.AddListener(OnUndoInput);
        redoButton.onClick.AddListener(OnRedoInput);
    }

    private void RunPlayerCommand(PlayerMover playerMover, Vector3 movement)
    {
        if (playerMover == null) return;
        if (playerMover.IsValidMove(movement))
        {
            ICommand command = new MoveCommand(playerMover, movement);
            CommandInvoker.ExecuteCommand(command);
        }
    }

    private void OnLeftInput() { RunPlayerCommand(player, Vector3.left); }
    private void OnRightInput() { RunPlayerCommand(player, Vector3.right); }
    private void OnForwardInput() { RunPlayerCommand(player, Vector3.forward); }
    private void OnBackInput() { RunPlayerCommand(player, Vector3.back); }
    private void OnUndoInput() { CommandInvoker.UndoCommand(); }
    private void OnRedoInput() { CommandInvoker.RedoCommand(); }
}

Reference: https://github.com/Unity-Technologies/game-programming-patterns-demo/tree/main/Assets/9%20Command

泛型約束是使用where關鍵字讓泛型的類型有一定的限制

• where T:struct ：結構類型的約束，只能接收結構類型作為泛型

  1 2 3 4 5 6 7 8 9 10

  class Test1<T> where T:struct { public T value; public void TestFun<K>(K v) where K: struct } // 這句會報錯，因為他不是結構類型 //-- Test1<object> t = new Test1<object>(); // 這句可以 Test1<int> t2 = new Test1<int>();

• where T:class ：引用類型約束

  1 2 3 4 5 6 7 8 9 10 11

  class Test2<T> where T : class { public T value; public void TestFun<K>(K k) where K : class {} } // 這句可以 Test2<object> t = new Test2<object>(); // 這句會報錯，因為 int 不是引用類型 //-- Test2<int> t2 = new Test2<int>();

• where T: new() ：這個泛型一定要有一個無參數public的建構子(constructor)，此外若是組合使用的話new()要放到最後

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  class Test3<T> where T : new() { public T value; } class PubC1 {} class PubC2 { public PubC2(int i) {} } // 這句可以 Test3<PubC1> t = new Test3<PubC1>(); // 這句不可以，因為 PubC2 沒有無參數的 public 建構子 //-- Test3<PubC2> t2 = new Test3<PubC2>();

• where T: 類名 ：泛型參數必須要是其類或者是其子類

• where T: 介面名 ：泛型參數必須要是其介面的衍伸類型

• where T:U：泛型參數為另一個泛型本身或是其衍伸類型

  1 2 3

  class Test6<T,U> where T:U{ public T value; }

• 多個泛型皆有約束

  1	class Test8<K,V> where K:class,new() where K:struct{}

單例模式(Singleton pattern)：確保應用程式中只有一個實例，並且提供簡單的全局訪問方式。

然而，單例模式在一些設計模式中被認為弊大於利，被列為反模式(anti-pattern)，這是因為單例模式太容易使用了導致開發人員很容易設計出不必要的全域狀態或是全域依賴。

優點

• 使用簡單，單例是全域可存取的，很容易的就可以取道該單例並在程式中使用。
• 由於單例是全域可存取因此你不需要去想使否需要暫存它。

缺點

• 全局存取：單例是全域可存取的，違反了 SOLD原則。
• 測試困難：單例模式使得測試必須互相獨立變得困難，因為單例可以直接改變狀態。
• 強依賴性：單例造成的依賴性太強，如果你想更改某個單例，就需要更改所有有使用到它的地方。

以下是一個簡單的單例模式

• public static Instance用來保存Sence中的單例實體
• 在Awake()中檢查是否已有這個實例，如果沒有則將其設為實例；如果有則表示有重複設定，需要將它銷毀，以確保在這個場景中只有一個實例。
• 這個SimpleSingleton有一些缺陷
  • 當載入新Scene時會銷毀這個GameObject(可以使用 DontDestroyOnLoad 告訴Unity不要摧毀它)
  • 在使用時需要將它附加到Scene結構中

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

    using UnityEngine; public class SimpleSingleton : MonoBehaviour { public static SimpleSingleton Instance; private void Awake() { if (Instance == null) { Instance = this; } else { Destroy(gameObject); } } }

也可以使用延遲初始化(Lazy initialization)的方式，來建立單例，下面例子中

• 使用 DontDestroyOnLoad(gameObject) 告訴 Unity 不要銷毀它，因此即使切換場景也不會清除這個單例。
• 不需要手動附加到Scene結構中，因為使用了 SetupInstance()，如果目前還沒有建立這個單例，它會自動建立一個 GameObject 並附加到它身上。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

  public class Singleton : MonoBehaviour { private static Singleton instance; public static Singleton Instance { get { if (instance == null) { SetupInstance(); } return instance; } } private void Awake() { if (instance == null) { instance = this; DontDestroyOnLoad(this.gameObject); } else { Destroy(gameObject); } } private static void SetupInstance() { instance = FindObjectOfType<Singleton>(); if (instance == null) { GameObject gameObj = new GameObject(); gameObj.name = "Singleton"; instance = gameObj.AddComponent<Singleton>(); DontDestroyOnLoad(gameObj); } } }

更進一步地將它一般化。在上面的單例模式中，如果需要多個不同的單例，例如 AudioManager 和 GameManager，那麼會複製很多相同的程式碼來建立單例。因此，可以將這個步驟一般化，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
{
    private static T instance;
    public static T Instance
    {
        get
        {
            if (instance == null)
            {
                instance = FindFirstObjectByType<T>();
                if (instance == null)
                {
                    SetupInstance();
                }
            }
            return instance;
        }
    }

    public virtual void Awake()
    {
        RemoveDuplicates();
    }
    private static void SetupInstance()
    {
        instance = FindFirstObjectByType<T>();
        if (instance == null)
        {
            GameObject gameObj = new();
            gameObj.name = typeof(T).Name;
            instance = gameObj.AddComponent<T>();
            DontDestroyOnLoad(gameObj);
        }
    }
    private void RemoveDuplicates()
    {
        if (instance == null)
        {
            instance = this as T;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

之後你在使用時，只需要繼承他即可

1
2
3
4

public class GameManager: Singleton<GameManager>
{
 // ...
}

Reference: https://github.com/Unity-Technologies/game-programming-patterns-demo/tree/main/Assets/8%20Singleton

物件池(Object Pool)：是一種減輕大量建立並銷毀物件時 CPU 負擔的設計模式。使用物件池時，物件會先被建立並放入池中等待，需要時應用程式不會新建物件，而是從物件池中取得並啟用它。當使用完畢後，物件不會被銷毀，而是被放回物件池中。

改進

• 可以在程式載入時建立物件池，這樣使用者就不會感到卡頓。
• 考慮將物件池設為static或是singleton的：這樣可以在所有情況下方便呼叫使用。
• 使用Dictionary來管理多個物件池：如果有多個物件池，可以使用 Key-Value 的資料結構（如 Dictionary）來管理，只需根據對應的 Key 就能方便地取得所需的物件池。
• 注意釋放物件池中的物件：確保物件在物件池中時不會被釋放，避免執行期間發生錯誤。
• 設定物件池上限：物件過多會消耗大量記憶體，因此需要為物件池設定一個上限，避免物件池中物件過多。

以下是一個簡單的物件池，

• 這個物件池使用Stack
• SetupPool()用來產生一些物件放到物件池中
• GetPooledObject()用來啟用物件並取得，當物件不足(stack.Count == 0)時，會再產生一個新物件
• ReturnToPool()用來將物件停用，並返回物件到物件池
• 注意不要直接使用，因為這個例子沒有設定Stack上限，可能會產生過多的物件

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

  public class ObjectPool : MonoBehaviour { [SerializeField] private uint initPoolSize; [SerializeField] private PooledObject objectToPool; // 存儲物件池中的物件 private Stack<PooledObject> stack; private void Start() { SetupPool(); } // 建立物件池（在卡頓不明顯時調用） private void SetupPool() { stack = new Stack<PooledObject>(); PooledObject instance = null; for (int i = 0; i < initPoolSize; i++) { instance = Instantiate(objectToPool); instance.Pool = this; instance.gameObject.SetActive(false); stack.Push(instance); } } // 從物件池中返回第一個可用的物件 public PooledObject GetPooledObject() { // 如果物件不夠，則實例化新的物件 if (stack.Count == 0) { PooledObject newInstance = Instantiate(objectToPool); newInstance.Pool = this; return newInstance; } // 否則，從物件池中取得下一個物件 PooledObject nextInstance = stack.Pop(); nextInstance.gameObject.SetActive(true); return nextInstance; } public void ReturnToPool(PooledObject pooledObject) { stack.Push(pooledObject); pooledObject.gameObject.SetActive(false); } }

建立一個 PooledObject 類別，讓它依賴 ObjectPool，這樣可以在使用完畢後返回物件池：

1
2
3
4
5
6
7
8
9

public class PooledObject : MonoBehaviour
{
 private ObjectPool pool;
 public ObjectPool Pool { get => pool; set => pool = value; }
 public void Release()
 {
 pool.ReturnToPool(this);
 }
}

在Unity 2021後，有內建 UnityEngine.Pool 物件池，它提供了多種容器的Pool，像是

• ObjectPool：是一個Stack
• DictionaryPool<T0,T1>
• GenericPool
• HashSetPool
• LinkedPool
• ListPool
  使用內建 UnityEngine.Pool 物件池有許多好處，包含
• 可以快速的使用物件池，不需要重複造輪子
• 有多種容器供你選用
• 當到達最大物件數量後會摧毀該物件，不建立過多的物件

以下是UnityEngine.Pool的範例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

using UnityEngine.Pool;
public class RevisedGun : MonoBehaviour
{
    // 使用基於 Stack 的 ObjectPool
    private IObjectPool<RevisedProjectile> objectPool;
    // 如果嘗試返回已經存在於池中的物件，則拋出異常
    [SerializeField] private bool collectionCheck = true;
    // 控制池的預設容量和最大大小
    [SerializeField] private int defaultCapacity = 20;
    [SerializeField] private int maxSize = 100;

    private void Awake()
    {
        objectPool = new ObjectPool<RevisedProjectile>(CreateProjectile,
            OnGetFromPool, OnReleaseToPool, OnDestroyPooledObject,
            collectionCheck, defaultCapacity, maxSize);
    }

    // 在new ObjectPool建構子中使用，主要是先建立物件以填充物件池
    private RevisedProjectile CreateProjectile()
    {
        RevisedProjectile projectileInstance = Instantiate(projectilePrefab);
        projectileInstance.ObjectPool = objectPool;
        return projectileInstance;
    }

    // 在new ObjectPool建構子中使用，告訴物件池在將物件返回時要做什麼動作
    private void OnReleaseToPool(RevisedProjectile pooledObject)
    {
        pooledObject.gameObject.SetActive(false);
    }

    // 在new ObjectPool建構子中使用，告訴物件池在物件池中取出物件時要做什麼初始化動作
    private void OnGetFromPool(RevisedProjectile pooledObject)
    {
        pooledObject.gameObject.SetActive(true);
    }

    // 在new ObjectPool建構子中使用，告訴物件池在超過最大物件數量時如何銷毀物件
    private void OnDestroyPooledObject(RevisedProjectile pooledObject)
    {
        Destroy(pooledObject.gameObject);
    }

    private void FixedUpdate()
    {
        // 省略其他代碼
    }
}

與上面簡單的ObjectPool相同，讓RevisedProjectile依賴 IObjectPool<RevisedProjectile>，在使用完畢後呼叫objectPool.Release(this)返回物件池：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class RevisedProjectile : MonoBehaviour
{
    // 延遲後停用
    [SerializeField] private float timeoutDelay = 3f;

    private IObjectPool<RevisedProjectile> objectPool;

    // 公共屬性，用於給 projectile 一個 ObjectPool 的引用
    public IObjectPool<RevisedProjectile> ObjectPool { set => objectPool = value; }

    public void Deactivate()
    {
        StartCoroutine(DeactivateRoutine(timeoutDelay));
    }

    private IEnumerator DeactivateRoutine(float delay)
    {
        yield return new WaitForSeconds(delay);

        // 重置移動中的 Rigidbody
        Rigidbody rBody = GetComponent<Rigidbody>();
        rBody.velocity = Vector3.zero;
        rBody.angularVelocity = Vector3.zero;

        // 將 projectile 返回到物件池
        objectPool.Release(this);
    }
}

Reference: https://github.com/Unity-Technologies/game-programming-patterns-demo/tree/main/Assets/7%20Object%20Pool