在遊戲中，會發生很多事，例如擊敗一個敵人，玩家升級等，如果直接將這些行為直接在各個物件中執行，會增加很多依賴，當程式碼成長到一定程度時，會變得很難維護。

觀察者模式(Observer pattern)通常會用來解決此問題。它使用一種one-to-many依賴(dependency)，讓你的物件之間的溝通可以保持在一種低耦合(loosely coupled)的關係，當一個物件的狀態改變時，會自動通知所有想要接收此訊息的物件。例如廣播系統，廣播會向外發送音樂給收聽者，廣播不需要知道誰在收聽，它只要使用固定的頻道發送音樂即可，而收聽者只需要將頻道調整到該廣播系統的頻道即可收到音樂。

• 發送消息的物件稱為subject
• 其他接收此消息的物件稱為observers

優點：

• 發送消息的物件(subject)與接收此消息的物件(observers)解耦(Loose coupling)
  • 發送消息的物件不需要知道關於接收此消息的物件的資訊，它只需要負責將消息發送出去；
  • 接收此消息的物件會有一個發送消息物件的依賴，但是接收此消息的物件之間互相不知道彼此
• 將observer需要對訊息做出反應的邏輯放到對應的observer中，讓他們各自維護。變得較容易測試與除錯
• 非常適合使用者介面(User Interface)，MVP與MVC patterns就是使用觀察者模式(Observer pattern)

缺點：

• 增加程式複雜度，
• 如果要刪除Subject的話會比較麻煩
• Observer仍然會對Subject有依賴，
  • 可以使用一個static EventManager除去
• 會消耗一些效能

在C#中已經有實作Observer pattern => Event

• publisher(即subject)：有一個或多個event，在執行時，會將訊息發送給註冊這些event的物件
• observers：這些物件會有一些event handler的方法，當publisher發送訊息時，便會執行對應的event handler方法

以下是一個最簡單的例子
Subject有一個 event ThingHappened，它暴露給其他物件讓它們可以註冊

1
2
3
4
5
6
7
8
9

public class Subject
{
    public event Action ThingHappened;

    public void DoThing()
    {
        ThingHappened?.Invoke();
    }
}

Observer有一個Subject依賴，用來註冊；並且有一個OnEventHandler，當Subject發送訊息時，便會執行這個方法

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

public class Observer
{
    private Subject subjectToObserve;
    
    public Observer(Subject subject) 
    {
        subjectToObserve = subject;
        subjectToObserve.ThingHappened += OnEventHandle;
    }

    private void OnEventHandler()
    {
        // any logic that responds to event goes here
        Debug.Log("Observer responds");
    }
}

Reference: https://unity.com/how-to/create-modular-and-maintainable-code-observer-pattern

以下將示範如何使用UI Builder與ScriptableObject來建立DataBinding

1. 在Unity編輯器中，建立一個Script
   
2. 建立一個名為ExampleObject的ScriptableObject(檔案會是 ExampleObject.cs)，它包含了
   • 一個string vector3Label，
   • 一個Vector3 vector3Value
   • 一個float sumOfVector3Properties，這個sumOfVector3Properties是一個readonly的屬性其值來自於vector3Label中的x，y與z之和，
   • 一個float dangerLevel是一個 0 ~ 1之間的數值。之後在UI Builder中更改使用Value To Progress設定，讓它可以根據ConverterGroup顯示對應的值

     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

     using Unity.Properties; using UnityEditor; using UnityEngine; using UnityEngine.UIElements; [CreateAssetMenu] public class ExampleObject : ScriptableObject { [InitializeOnLoadMethod] public static void RegisterConverters() { // Create local Converters var group = new ConverterGroup("Value To Progress"); // Converter groups can have multiple converters. This example converts a float to both a color and a string. group.AddConverter((ref float v) => new StyleColor(Color.Lerp(Color.red, Color.green, v))); group.AddConverter((ref float value) => { return value switch { >= 0 and < 1.0f / 3.0f => "Danger", >= 1.0f / 3.0f and < 2.0f / 3.0f => "Neutral", _ => "Good" }; }); // Register the converter group in InitializeOnLoadMethod to make it accessible from the UI Builder. ConverterGroups.RegisterConverterGroup(group); } [Header("Bind to multiple properties")] public string vector3Label; public Vector3 vector3Value; [CreateProperty] public float sumOfVector3Properties => vector3Value.x + vector3Value.y + vector3Value.z; [Header("Binding using a converter group")] [Range(0, 1)] public float dangerLevel; }

3. 在Unity編輯器中，選擇 Create > Example Object ，建立一個Example Object並命名為Object1 (檔案會是 Object1.asset)
   
4. 建立一個UXML，命名為ExampleObject(檔案會是ExampleObject.uxml)
   
5. 點擊剛剛建立的ExampleObject.uxml，開啟UI Builder
6. 在Hierarchy panel中，加入一個VisualElement
7. 在剛剛建立的VisualElement中加入Vector3Field，FloatField與Label
8. 最後Hierarchy panel畫面為
   
9. 選擇最上層的VisualElement UI Element，在右邊找到Data Source，選擇之前建立的Object1.asset，這樣做，會將它的Child Elements都預設綁定Object1
   
10. 選擇Vector3Field UI Element，在右邊找到Label，對Label按一下滑鼠右鍵，點選Add binding...，在Data Source Path中找到並選擇vector3Label，Binding Mode選擇To Target
    
11. 接下來，對Vector3Field的Value按一下滑鼠右鍵，點選Add binding...，在Data Source Path中找到並選擇vector3Value，Binding Mode選擇To Target
    
12. 選擇Float UI Element，在右邊找到Value按一下滑鼠右鍵，點選Add binding...，在Data Source Path中找到並選擇sumOfVector3Properties，Binding Mode選擇To Target
    
13. 選擇Label UI Element，
    • 在右邊找到Text，對Text按一下滑鼠右鍵，點選Add binding...，在Data Source Path中找到並選擇dangerLevel，Binding Mode選擇To Target
    • 接著打開Advanced Settings 找到 Converters > To target property (UI) 選擇 Value To Progress
      
    • 接下來，在右邊找到Color，對Color按一下滑鼠右鍵，點選Add binding...，在Data Source Path中勾選Show only compatible之後才會出現可以選擇的相容屬性，選擇dangerLevel，Binding Mode選擇To Target
    • 接著打開Advanced Settings 找到 Converters > To target property (UI) 選擇 Value To Progress
      
14. 至此，這個UI與 ExampleObject的綁定就算完成了，UXML可能會為

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

    <engine:UXML xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:engine="UnityEngine.UIElements" xmlns:editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False"> <engine:VisualElement data-source="project://database/Assets/UI/Custom/Object1.asset?fileID=11400000&amp;guid=a0e72bbf894f04543b805067235fe91c&amp;type=2#Object1" style="flex-grow: 1;"> <engine:Vector3Field name="Vector3Field" focusable="false"> <Bindings> <engine:DataBinding property="label" binding-mode="ToTarget" data-source-path="vector3Label" /> <engine:DataBinding property="value" binding-mode="ToTarget" data-source-path="vector3Value" /> </Bindings> </engine:Vector3Field> <engine:FloatField label="Float Field" name="FloatField"> <Bindings> <engine:DataBinding property="value" binding-mode="ToTarget" data-source-path="sumOfVector3Properties" /> <engine:DataBinding property="text" binding-mode="ToTarget" data-source-path="dangerLevel" source-to-ui-converters="Value To Progress" /> <engine:DataBinding property="text" binding-mode="ToTarget" data-source-path="dangerLevel" source-to-ui-converters="Value To Progress" /> </Bindings> </engine:FloatField> <engine:Label text="Label" name="Label" enable-rich-text="false" parse-escape-sequences="true"> <Bindings> <engine:DataBinding property="value" binding-mode="ToTarget" data-source-path="sumOfVector3Properties" /> <engine:DataBinding property="text" binding-mode="ToTarget" data-source-path="dangerLevel" source-to-ui-converters="Value To Progress" /> <engine:DataBinding property="text" binding-mode="ToTarget" data-source-path="dangerLevel" source-to-ui-converters="Value To Progress" /> </Bindings> </engine:Label> </engine:VisualElement> </engine:UXML>

15. 可以調整Object1來觀察UI的變化
    
16. 結果
    

Reference: https://docs.unity3d.com/2023.2/Documentation/Manual/UIE-get-started-runtime-binding.html

以下是Eclipse常用快速鍵(shortcuts)

格式化程式碼(auto-format code)：

• Windows 或是 Linux : Ctrl + Shift + f
• Mac : ⇧ + ⌘ + f

轉為大寫(Upper case)

• Windows 或是 Linux : Ctrl + Shift + x
• Mac : ⌘ + ⇧ + x

轉為小寫(Lower case)

• Windows 或是 Linux : Ctrl + Shift + y
• Mac : ⌘ + ⇧ + y

Reference: https://www.shortcutfoo.com/app/dojos/eclipse-mac/cheatsheet

1. 自訂control需要繼承VisualElement並且這個自訂control需要有一個預設constructor

   1 2 3 4 5 6 7 8 9 10 11

   class StatusBar : VisualElement { // 需要有一個預設constructor public StatusBar() { m_Status = String.Empty; } string m_Status; public string status { get; set; } }

2. 為了讓你自訂的control可以在UXML中使用，你需要定義一個factory class，如果沒有特殊的需求，可以直接繼承UxmlFactory<T>

   1 2 3 4 5 6 7

   class StatusBar : VisualElement { // 建議直接將factory class放在自訂的control中 public new class UxmlFactory : UxmlFactory<StatusBar> {} // ... }

3. UxmlTraits：定義在UXML中可以使用的特徵(UXML traits)，
   • UxmlTraits的目的有
     • factory建立新物件時使用它們。
     • 在schema產生時，會分析它們以取得關於該Element的資訊，之後將這些資訊轉換為XML schema directive。
   • 以下範例
     • 宣告了一個m_Status，用來定義一個XML attribute status
     • uxmlChildElementsDescription回傳一個空IEnumerable，用來表明這個自訂的StatusBar沒有child。
     • Init()中，XML parser從property bag讀出的值設定給StatusBar.status
     • UxmlTraits class定義在StatusBar class中，讓Init()可以存取StatusBar的私有變數。
     • UxmlTraits繼承了VisualElement.UxmlTraits，它也擁有VisualElement.UxmlTraits的屬性
     • Init()會呼叫base.Init()以初始化base class的屬性

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

class StatusBar : VisualElement
{
    public new class UxmlFactory : UxmlFactory<StatusBar, UxmlTraits> {}

    public new class UxmlTraits : VisualElement.UxmlTraits
    {
        UxmlStringAttributeDescription m_Status = new UxmlStringAttributeDescription { name = "status" };

        public override IEnumerable<UxmlChildElementDescription> uxmlChildElementsDescription
        {
            get { yield break; }
        }

        public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
        {
            base.Init(ve, bag, cc);
            ((StatusBar)ve).status = m_Status.GetValueFromBag(bag, cc);
        }
    }

    // ...
}

- 注意：在UI Builder中創作時，UI Builder可能會多次呼叫`UxmlTraits.Init()`來同步UXML檔案中的值，建議使用`GetValueFromBag`而不是`TryGetValueFromBag`以確保當UI Builder取消設定(unset)element的值時，這個element不會殘留先前的值。

4. 若想要有child的話，需要override uxmlChildElementsDescription，

   1 2 3 4 5 6 7

   public override IEnumerable<UxmlChildElementDescription> uxmlChildElementsDescription { get { yield return new UxmlChildElementDescription(typeof(VisualElement)); } }

5. 可以將你自訂的control放到namespace中來分類它們

   1 2	[assembly: UxmlNamespacePrefix("My.First.Namespace", "first")] [assembly: UxmlNamespacePrefix("My.Second.Namespace", "second")]

Reference:https://docs.unity3d.com/Manual/UIE-expose-custom-control-to-uxml.html#define-a-factory

建立自訂的Control需要建立一個control C# class，然後將它暴露給UXML

1. 建立一個繼承VisualElement的Class

2. 若是要建立可綁定(Binding)的自訂Control，可以繼承自BaseField基底類別，而非 BindableElement。繼承BaseField有以下好處

   • 有實作一個泛型的INotifyValueChanged
   • 預設focusable
   • 提供一個水平佈局(horizontal layout)，左側為label element，右側為input element

3. VisualElement不會綁定到GameObject的生命週期函數，也就是說它不會收到以下callbacks

   • Awake()
   • OnEnable()
   • OnDisable()
   • OnDestroy()

4. 可以在自訂control中的constructor做初始化的動作，但是如果你想要將初始化的動作延遲到這個自訂的control被加到UI之後，可以把初始化的動作加到AttachToPanelEvent callback

5. 使用DetachFromPanelEvent callback可以偵測你自訂的control是否已經從UI上移除

   1 2 3 4 5 6 7 8

   public CustomControl() { var myCustomElement = rootVisualElement.Q(className: "my-custom-element"); myCustomElement.RegisterCallback<AttachToPanelEvent>(e => { /* 此處放置當這個elemenet被加入到UI上要做的事 */ }); myCustomElement.RegisterCallback<DetachFromPanelEvent>(e => { /* 此處放置當這個elemenet從UI上移除後要做的事 */ }); }

6. UI Toolkit會分派這兩個事件(AttachToPanelEvent與DetachFromPanelEvent)給所有element

7. 要讓UXML與UI Builder使用你自訂的control，需要定義一個繼承UxmlFactory<T>的factory class將你自訂的control暴露給他們。

8. 綁定資料需要實作INotifyValueChanged並根據需要監聽ChangeEvent。繼承BindableElement或是實作IBindable。

9. 你可以創建USS custom properties以設定自訂控制項的樣式。

Reference: https://docs.unity3d.com/Manual/UIE-create-custom-controls.html

有兩種方式回應Action

1. Polling(輪詢)：Polling方法是不斷的檢查你感興趣Action目前的狀態，通常會在MonoBehaviour script中的Update()方法去做輪詢。
2. Event-driven(事件驅動)：Event-driven則是建立要執行的方法，當Action執行時，就會自動呼叫並執行。

Polling

在大部分的場景，特別是動作遊戲，使用者的輸入必須平滑順暢的控制遊戲中的角色，使用Polling通常是比較容易去實作。

使用InputAction提供的ReadValue<>()便可以取得目前Action的值

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

using UnityEngine;
using UnityEngine.InputSystem;

public class Example : MonoBehaviour
{
    InputAction moveAction;

    private void Start()
    {
        moveAction = InputSystem.actions.FindAction("Move");
    }

    void Update()
    {
        // 取得action的值
        Vector2 moveValue = moveAction.ReadValue<Vector2>();
        // 取得值之後，便可以將其應用到GameObject上，讓其移動。
    }
}

以下程式碼使用了預設的Interact Action，它包含一個「按住」(Hold)交互(interaction)，使得只有綁定的控件被按住一段時間 (例如 0.4 秒) 後才會執行該動作。

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

using UnityEngine;
using UnityEngine.InputSystem;

public class Example : MonoBehaviour
{
    InputAction interactAction;

    private void Start()
    {
        interactAction = InputSystem.actions.FindAction("Interact");
    }

    void Update()
    {
        if (interactAction.WasPerformedThisFrame())
        {
            // 在此執行的程式碼滿足：Interact action按住足夠長時間的第一幀
        }

        if (interactAction.WasCompletedThisFrame())
        {
            // 在此執行的程式碼滿足：Interact action被按住足夠長時間後釋放的那一幀
        }
    }
}

以下方法可以用來輪詢按鈕是否被按下或是釋放

以下範例有三個Actions，分別為Shield，Teleport與Submit(它們不是預設的action)

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

using UnityEngine;
using UnityEngine.InputSystem;

public class Example : MonoBehaviour
{
    InputAction shieldAction;
    InputAction teleportAction;
    InputAction submitAction;

    private void Start()
    {
        shieldAction = InputSystem.actions.FindAction("Shield");
        teleportAction = InputSystem.actions.FindAction("Teleport");
        submitAction = InputSystem.actions.FindAction("Submit");
    }

    void Update()
    {
        if (shieldAction.IsPressed())
        {
            // shield會在shield action被按下的每一幀都處於激活狀態

        if (teleportAction.WasPressedThisFrame())
        {
            // teleport會在 按下動作的第一幀 發生，直到 按鈕釋放 後才會再次生效。
        }

        if (submit.WasReleasedThisFrame())
        {
            // submit會在 動作釋放的幀 發生，這是一種常用于 UI 控制按鈕的常見技巧。
        }
    }
}

Event-driven

可以為Action註冊一些callback，當某些輸入發生時，Action就會通知你，讓你可以做出相應的回應。
有以下方式可以使用callback

1. 透過PlayerInput Component註冊callback
2. 使用Action的started，performed與canceled callback
3. 使用ActionMap的actionTriggered callback
4. 使用Input System的全域InputSystem.onActionChange callback
5. InputActionTrace可以記錄Actions上的改變

PlayerInput Component

使用PlayerInput component可以在inspector中直接設定callback。此外也可以透過程式碼來設定

Action callbacks

可以透過 InputAction.phase 來取得目前的階段，Started，Performed與Canceled階段各有與之關聯的callback函數

1
2
3
4
5

var action = new InputAction();

action.started += context => {/* Action已經開始 */};
action.performed += context => {/* Action已經執行 */};
action.canceled += context => {/* Action已經取消 */};

每個callback都會接收一個InputAction.CallbackContext結構，該結構包含上下文信息，您可以利用它來查詢Action的當前狀態，以及讀取觸發該動作的裝置控制的值。

• 注意：此結構的內容只在callback期間中有效，請勿把它暫存並在callback之外使用。

callback函數的觸發時機和方式取決於綁定中存在的交互 (Interactions)。如果綁定沒有適用的交互，則會應用預設的交互(Default Interaction)。

除了監聽個別Action，你也可以使用InputActionMap.actionTriggered監聽該Map中的全部Action，使用這種方式，該單一個callback會收到started，performed與canceled，且其InputAction.CallbackContext結構與使用個別started，performed與canceled的結構相同。

1
2
3
4
5
6

var actionMap = new InputActionMap();
actionMap.AddAction("action1", "<Gamepad>/buttonSouth");
actionMap.AddAction("action2", "<Gamepad>/buttonNorth");

actionMap.actionTriggered +=
    context => { ... };

InputSystem.onActionChange與InputSystem.onDeviceChange類似，讓你可以全域(globally)監聽任何與Action相關的變更

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

InputSystem.onActionChange +=
    (obj, change) =>
    {
        // obj可能是InputAction或是InputMap，需要依靠change去判斷
        switch (change)
        {
            case InputActionChange.ActionStarted:
            case InputActionChange.ActionPerformed:
            case InputActionChange.ActionCanceled:
                Debug.Log($"{((InputAction)obj).name} {change}");
                break;
        }
    }

InputActionTrace

，你可以使用InputActionTrace為某些特定Action集合建立日誌(log)，讓你可以追蹤它們。

• 注意：InputActionTrace會使用不受管理的記憶體，因此在使用後要去處理(disposed)它，避免造成記憶體洩漏(memory leak)

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

// 實體化一個 InputActionTrace
var trace = new InputActionTrace();

// 為這個Action訂閱trace。
// 取消訂閱的話，使用UnsubscribeFrom方法
trace.SubscribeTo(myAction);

// 為整個Action Map訂閱trace
// 取消訂閱的話，使用UnsubscribeFrom方法
trace.SubscribeTo(myActionMap);

// 為所有在系統中的Action訂閱trace
trace.SubscribeToAll();

// 為這個Action紀錄一個觸發
myAction.performed +=
    ctx =>
    {
        if (ctx.ReadValue<float>() > 0.5f)
            trace.RecordAction(ctx);
    };

// 輸出這個trace
Debug.Log(string.Join(",\n", trace));

// 拜訪所有Action的trace紀錄，之後清除trace。
foreach (var record in trace)
{
    Debug.Log($"{record.action} was {record.phase} by control {record.control}");

    // 讀取這個紀錄的值，你需要知道它的類型是什麼，否則你可以把它讀為一般的Byte。此處假設他是float
    Debug.Log("Value: " + record.ReadValue<float>());

    // 如果願意接受GC負擔，也可以將值讀取為物件(object)。
    // 此時，你可以不需要知道它的類型
    Debug.Log("Value: " + record.ReadValueAsObject());
}
trace.Clear();

// 取消所有追蹤的訂閱。
trace.UnsubscribeFromAll();

// 釋放trace使用的記憶體
trace.Dispose();

一旦紀錄完成，只要不同時進行寫入操作，並且主線程上不會同時變更Action設置，則trace可以安全地從多個線程讀取。

Action types

Action有三種類型，這些類型會影響Input System如何處理操作Action的狀態。

使用Input Debugger，可以觀察目前啟用的Action以及與他們綁定的Control。
也可以使用InputActionVisualizer在螢幕上即時可視化動作的值和交互狀態。

上一篇：Actions概念

Reference: https://docs.unity3d.com/Packages/com.unity.inputsystem@1.8/manual/RespondingToActions.html

Action是將裝置控制(device control)與輸入(input)分開的一個重要概念。舉例來說，某個遊戲中某些輸入(input)的目的是讓遊戲角色移動，而與該動作(Action)相關的裝置控制(device control)可能是左搖桿。將動作(action)與執行這個輸入的裝置控制(左搖桿)關聯起來的稱作綁定(Binding)。你可以在Action Editor中建立這種綁定，當在程式碼中使用Actons時，你不需要去指定特定的裝置，因為Binding定義了哪些裝置可以執行這個Action。

透過Action Editor你可以為Action建立多個設備的對應，例如下圖，

Move對應了鍵盤與遊戲搖桿，之後你就可以在程式碼中取得這個Action的參考，並可以檢查它的值，或是為它附加callback方法

1
2

// 透過InputSystem API可以找到Move，注意不要在Update loop中使用，因為它是基於字串搜尋，因此會影響效能
InputAction moveAction = InputSystem.actions.FindAction("Move");

注意：

• Action只可在runtime使用，不可以在Edit Window code中使用。
• 也可以不使用Action和Binding來直接取得裝置控制的值var gamepad = Gamepad.current;，但是彈性會比較差。
• Action Editor 中顯示的動作順序僅供視覺參考，並不代表實際程式碼執行的順序。多個動作可能在同一幀中執行，Input system的動作順序是不確定的。為了避免潛在問題，請勿在程式碼中假設動作會按特定順序執行。

當您在InputSystem中使用Action進行Script編寫時，可以利用以下一些重要的API，

• Action：每個Action都有一個名稱(InputAction.name)，在一個Action Map中，這個Action的名稱必須是獨一無二的，每個Action也會有一個獨一無二的ID(InputAction.id)，可以用它們來找到這個Action的引用。當ID產生之後，就算名稱改變ID也不會變。
• Action Map：每個Action Map都有一個名稱(InputActionMap.name)，這個Action Map的名稱必須是獨一無二的，每個Action Map也會有一個獨一無二的ID(InputActionMap.id)，可以用它們來找到這個Action Map的引用。當ID產生之後，就算名稱改變ID也不會變。

建立Action

建立Action有好幾種方式

• 方法一：使用Action Editor建立Action：最簡單的方式是使用Action Editor建立
• 方法二：在MonoBehaviours中宣告Action，此方法與方法一類似，差異在於它將Actions定義在GameObject的屬性中，並儲存為Scene或是Prefab。並且它不是project-wide action，因此在使用時需要手動的啟用，停用這些Action。

  1 2 3 4 5 6 7 8

  using UnityEngine; using UnityEngine.InputSystem; public class ExampleScript : MonoBehaviour { public InputAction move; public InputAction jump; }

• 方法三：在JSON中載入

  1 2 3 4 5

  // Load a set of action maps from JSON. var maps = InputActionMap.FromJson(json); // Load an entire InputActionAsset from JSON. var asset = InputActionAsset.FromJson(json);

• 方法四：使用程式碼

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

  // Create free-standing Actions. var lookAction = new InputAction("look", binding: "<Gamepad>/leftStick"); var moveAction = new InputAction("move", binding: "<Gamepad>/rightStick"); lookAction.AddBinding("<Mouse>/delta"); moveAction.AddCompositeBinding("Dpad") .With("Up", "<Keyboard>/w") .With("Down", "<Keyboard>/s") .With("Left", "<Keyboard>/a") .With("Right", "<Keyboard>/d"); // Create an Action Map with Actions. var map = new InputActionMap("Gameplay"); var lookAction = map.AddAction("look"); lookAction.AddBinding("<Gamepad>/leftStick"); // Create an Action Asset. var asset = ScriptableObject.CreateInstance<InputActionAsset>(); var gameplayMap = new InputActionMap("gameplay"); asset.AddActionMap(gameplayMap); var lookAction = gameplayMap.AddAction("look", "<Gamepad>/leftStick");

對於非專案範圍(project-wide)的Actions，在使用前需要先啟用(Enable)

1
2
3
4
5

// 啟用單一action
lookAction.Enable();

// 啟用整個action map.
gameplayActions.Enable();

當您啟用一個「動作」(Action)時，InputSystem會解析其綁定(bindings)。啟用後，「動作」會積極監控其綁定的「控件」(Control(s))。如果綁定的「控件」狀態改變，「動作」就會處理該變化。如果「控件」的變化代表「交互」(Interaction) 變化，則「動作」會創建一個響應。所有這些都發生在輸入系統的更新邏輯中。取決於輸入設置中選擇的「更新模式」，這可能每幀發生一次，每固定更新一次，或者如果更新設置為手動，則手動發生一次。

在「動作」啟用的情況下，有些配置無法更改，例如「動作綁定」。要停止Action或Action Map響應輸入，可以使用「停用」(Disable)方法。

上一篇：使用Action Editor編輯Action

下一篇：使用Action

Reference: https://docs.unity3d.com/Packages/com.unity.inputsystem@1.8/manual/Actions.html

1. 在Project-Wide Actions中可以建立一個整個專案可用的Action Asset，此外你也可以自己再額外建立更多的Action Asset，在編輯器中，選擇Create > Input Actions 便可建立一個Action Asset。
   

2. 滑鼠左鍵點擊兩次剛剛建立的Action檔案，便可以打開編輯畫面(Actions Editor)
   

   Name	描述
   Action Maps	顯示目前定義的Action Maps
   Actions	顯示目前選中的Action Map擁有的Action以及Binding
   Properties	顯示目前選中Action或是Binding的屬性(properties)

3. 設定Action Maps：在Action Maps旁邊的+可以添加Action Map，對新增的Action Map按下兩次滑鼠左鍵可以對它命名，

   • 注意Action Map的名稱不可以包含 / (slashes)，

4. 設定Action：在Action旁邊的+可以添加Action，對新增的Action按下兩次滑鼠左鍵可以對它命名

   • Action的屬性
     • Action Type：可以選擇Button，Value或是PassThrough
       • 若你的Action為鍵盤按鈕，滑鼠點擊或是搖桿按鈕控制的話，選擇Button，如果有多個裝置接上，那麼只會選擇一個最活躍的輸入裝置的輸入(稱為Conflicting inputs)
       • 若是滑鼠移動或是搖桿移動這種屬於連續不斷改變的輸入的話，選擇Value
       • PassThrough和Value相同，差別在於不處理衝突，即會發送所有綁定此Action裝置的輸入。
     • Control Type：讓你選擇此Action期望的控制類型，這可以限制哪些控制設備可以顯示在UI上，例如選擇了2D axis，那麼在選擇綁定時只有那些支援2D vector的控制設備會顯示在選項上。
     • Binding：在添加的自訂Action旁邊的+可以為這個Action新增Binding。可以在一個Action上添加多個Binding以支援多個類型的輸入裝置。
     • Composite Bindings：為多個Binding組成，
       • 例如Up/Down/Left/Right Composite就是在模擬2D搖桿(2D stick input)的輸入
         
       • 可以透過Duplicate添加不同的 Binding
         

5. 在Action Editor左上角可以找到Control Schemes，讓你可以根據不同的裝置啟用或是停用Action的Bindings
   

上一篇：將Action設為整個專案可用(Project-Wide Actions)

下一篇：Actions概念

Input System是Unity較新的輸入系統，目前版本為1.8

官方文件：https://docs.unity3d.com/Packages/com.unity.inputsystem@1.8/manual/

1. Input System基本概念
2. 安裝Input System
3. 將Action設為整個專案可用(Project-Wide Actions)
4. 使用Action Editor編輯Action
5. Actions概念
6. 使用Action

Input System的project-wide actions功能讓你可以設定一個能夠在整個專案中使用的Action Asset，當Action Asset設為project-wide actions之後，那這個action就是個preloaded asset，也就是說當你的App啟動後就會載入，並且一直保持可用直到App關閉為止。

建立Project-Wide Actions Asset

1. 找到 Edit > Project Settings > Input System Package 並按下 Create a new project-wide Action Asset
   
2. 在專案中會建立一個名為InputSystem_Actions的Action Asset。
   
3. 這個InputSystem_Actions中已經有一些預設的Action，像是Move，Jump等，符合大部分遊戲，並預設綁定大部分裝置如鍵盤，滑鼠，遊戲搖桿，觸控螢幕，XR等
4. 在程式碼中使用InputSystem.actions去找到Action

   1	InputSystem.actions.FindAction("Move");

上一篇：安裝Input System

下一篇：使用Action Editor編輯Action

Reference: https://docs.unity3d.com/Packages/com.unity.inputsystem@1.8/manual/ProjectWideActions.html