Dynamisches Einrichten einer Aktionskarte

Diese Seite wurde aktualisiert : Donnerstag, 29. Juni 2023

Erstellungsdatum der Seite : Donnerstag, 24. März 2022

Verifizierungsumgebung

Fenster

Windows 11

Unity-Editor

2020.3.25f1

Eingabesystem-Paket

1.2.0

Voraussetzungen für diesen Tipp

Die folgenden Einstellungen wurden im Vorfeld als Prämisse für die Beschreibung dieses Tipps vorgenommen.

Sie sollten auch mit den folgenden Tipps vertraut sein:

Verwenden von Aktionskarten zum Zuweisen von Schaltflächen zu Spielverhalten

Informationen zur Konfiguration dynamischer Aktionszuordnungen

Es ist üblich, dem Projekt im Voraus Aktionskarten hinzuzufügen und festzulegen. In diesem Fall sind die Tastenbelegungen des Controllers während der Spielausführung festgelegt und können vom Benutzer während des Spiels nicht frei geändert werden. Dies ist vor allem bei Spielen zu erwarten, die eine Tastenkonfiguration erfordern.

Dieser Tipp beschreibt, wie Sie die Tastenbelegung einer Aktionszuordnung in einem Skript willkürlich ändern können.

Dynamische Behandlung von Action-Map-Änderungen

Dieses Mal wird auch die anfängliche Aktionskarte vom Skript festgelegt, und die Änderung der Aktionskarte in der Mitte wird ebenfalls im Skript vorgenommen. Ich denke, diese Methode wird beim Laden und Festlegen der beim Start des Spiels gespeicherten Schlüsselkonfiguration verwendet.

Der Inhalt des Beispiels besteht darin, die Tastenbelegung der Aktionskarte zu ändern, wenn Sie die Taste drücken, und den bedienten Inhalt als Text anzuzeigen. Die Platzierung der Schaltflächen und der Anzeigetext sind wie in der Abbildung gezeigt angeordnet, aber sie sind nicht sehr wichtig, also platzieren Sie sie bitte frei.

Action Map Erstkonfigurationsprozess

Erstellen Sie ein Skript. Der Name ist willkürlich, aber in diesem Fall InputActionMap ist es . Diesmal werden hier alle Prozesse beschrieben, aber in der eigentlichen Produktion teilen Sie sie bitte entsprechend der Erstellung des Projekts auf.

Das Skript sieht wie folgt aus: Erstellen Sie zunächst beim Start eine Standardaktionszuordnung.

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

public class InputActionMap : MonoBehaviour
{
  /// <summary>情報を表示させるテキストオブジェクト。</summary>
  [SerializeField] private Text TextObject;

  /// <summary>Move アクション用の定義。</summary>
  public InputAction MoveAction { get; set; }

  /// <summary>Attack アクション用の定義。</summary>
  public InputAction AttackAction { get; set; }

  private void Awake()
  {
    // Move アクションの作成
    MoveAction = new InputAction("Move");

    // バインド(キー割り当て)の追加
    // 設定する文字列の形式はアクションマップ設定画面の Path に表示される文字列となる
    MoveAction.AddBinding("<Gamepad>/leftStick");

    // キーボードに上下左右を割り当てるにはコンポジットの 2DVector を設定する
    MoveAction.AddCompositeBinding("2DVector")
        .With("Up", "<Keyboard>/upArrow")
        .With("Down", "<Keyboard>/downArrow")
        .With("Left", "<Keyboard>/leftArrow")
        .With("Right", "<Keyboard>/rightArrow");

    // Attack アクションの作成
    AttackAction = new InputAction("Attack");

    // バインド(キー割り当て)の追加
    AttackAction.AddBinding("<Gamepad>/buttonSouth");
    AttackAction.AddBinding("<Keyboard>/z");

    // 操作時のイベントを設定
    MoveAction.performed += context => OnMove(context);
    MoveAction.canceled += context => OnMove(context);
    AttackAction.performed += context => OnAttack(context);
    AttackAction.canceled += context => OnAttack(context);
  }

  private void OnEnable()
  {
    // オブジェクトが有効になったときにアクションマップを有効にする
    MoveAction.Enable();
    AttackAction.Enable();
  }

  private void OnDisable()
  {
    // アクションマップが誤動作しないようにオブジェクト終了時に無効にする
    MoveAction.Disable();
    AttackAction.Disable();
  }

  /// <summary>
  /// Move 操作を行ったときに呼ばれる。
  /// </summary>
  /// <param name="context">コールバック内容。</param>
  public void OnMove(InputAction.CallbackContext context)
  {
    var vec = context.ReadValue<Vector2>();
    TextObject.text = $"Move:({vec.x:f2}, {vec.y:f2})\n{TextObject.text}";
  }

  /// <summary>
  /// Move 操作を行ったときに呼ばれる。
  /// </summary>
  /// <param name="context">コールバック内容。</param>
  public void OnAttack(InputAction.CallbackContext context)
  {
    var value = context.ReadValueAsButton();
    TextObject.text = $"Attack:{value}\n{TextObject.text}";
  }
}

Definieren Sie zunächst so viele Aktionen in der Klasse, wie Sie InputAction im Feld implementieren möchten. Hier bereiten wir die Felder für "Move" und "Attack" vor, die auch in der vorherigen Action-Map-Erklärung verwendet wurden. Wenn die Anzahl der Aktionen zunimmt, müssen Sie diese Anzahl deklarieren, aber wenn es viele sind List Dictionary , können Sie sie mit , usw. verwalten. Es wird hier nicht verwendet, aber wenn Sie eine eigene InputActionMap Klasse haben, können Sie es dort verwalten.

Die Instanziierung und Schlüsselzuweisung AddBinding in der bei der InputAction Initialisierung aufgerufenen Awake Methode wird durchgeführt. Sie können sich das, was Sie tun, als ein Programm vorstellen, das dem Einstellungsbildschirm der Aktionskarte eine Bindung hinzufügt. AddBinding Die Zeichenfolge, die für Methode usw. angegeben ist, ist identisch mit der Zeichenfolge, die unter Pfad auf dem Einstellungsbildschirm der Aktionskarte angezeigt wird. Um eine Zeichenfolge anzuzeigen, drücken Sie die Taste "T" auf der rechten Seite.

Die Ereignisbehandlung, die beim Betätigen einer Schaltfläche aufgerufen wird, entspricht der Verarbeitung der Skriptversion einer normalen Aktionszuordnung. Der Rückrufvorgang wird ebenfalls umgeleitet, so wie er ist.

// 操作時のイベントを設定
MoveAction.performed += context => OnMove(context);
MoveAction.canceled += context => OnMove(context);
AttackAction.performed += context => OnAttack(context);
AttackAction.canceled += context => OnAttack(context);

/// <summary>
/// Move 操作を行ったときに呼ばれる。
/// </summary>
/// <param name="context">コールバック内容。</param>
public void OnMove(InputAction.CallbackContext context)
{
  var vec = context.ReadValue<Vector2>();
  TextObject.text = $"Move:({vec.x:f2}, {vec.y:f2})\n{TextObject.text}";
}

Aktivieren, Deaktivieren ist InputAction eine Einheit, also beschreiben Sie so viele Aktionen, wie Sie möchten. Wenn es mühsam ist, können Sie es List mit etc.

private void OnEnable()
{
  // オブジェクトが有効になったときにアクションマップを有効にする
  MoveAction.Enable();
  AttackAction.Enable();
}

Nachdem EventSystem Sie das Skript gespeichert haben, fügen Sie es an ein Textobjekt für die Anzeige an, und konfigurieren Sie es.

Führen Sie das Spiel aus und prüfen Sie, ob die Eingabeinformationen angezeigt werden. Das Ergebnis sollte mit der Skriptversion des statischen Action-Map-Prozesses identisch sein.

Action Map Dynamische Änderungsverarbeitung

Da die dynamische Änderung der Aktionszuordnung erfolgt, wenn die Schaltfläche gedrückt wird, definieren Sie die Methode, die aufgerufen wird, wenn die Schaltfläche gedrückt wird. OnClickButton Im Moment belassen wir es bei .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

  /// <summary>
  /// ボタンをクリックしたときに呼ばれる。
  /// </summary>
  public void OnClickButton()
  {
  }
}

Legt das Click-Ereignis für die Schaltfläche fest.

Der Prozess des Umschreibens der Aktionszuordnung läuft wie folgt ab:

/// <summary>
/// ボタンをクリックしたときに呼ばれる。
/// </summary>
public void OnClickButton()
{
  TextObject.text = "アクションマップを変更しました。";

  // Move アクションのキーを置き換える
  MoveAction.ApplyBindingOverride(new InputBinding { path = "<Gamepad>/leftStick", overridePath = "<Gamepad>/dpad" } );
  MoveAction.ApplyBindingOverride(new InputBinding { path = "<Keyboard>/upArrow", overridePath = "<Keyboard>/w" });
  MoveAction.ApplyBindingOverride(new InputBinding { path = "<Keyboard>/downArrow", overridePath = "<Keyboard>/s" });
  MoveAction.ApplyBindingOverride(new InputBinding { path = "<Keyboard>/leftArrow", overridePath = "<Keyboard>/a" });
  MoveAction.ApplyBindingOverride(new InputBinding { path = "<Keyboard>/rightArrow", overridePath = "<Keyboard>/d" });

  // Attack アクションのキーを置き換える
  AttackAction.ApplyBindingOverride(new InputBinding { path = "<Gamepad>/buttonSouth", overridePath = "<Gamepad>/buttonEast" });
  AttackAction.ApplyBindingOverride(new InputBinding { path = "<Keyboard>/z", overridePath = "<Keyboard>/space" });
}

Da für ApplyBindingOverride jede Aktion eine Methode bereitgestellt wird, ist der path Pfad der Taste oder Schaltfläche, die mit initialisiert wurde, overridePath Schreiben Sie den Pfad des Schlüssels oder der Schaltfläche, die Sie überschreiben möchten.

Übrigens wird damit nur der Überschreibpfad festgelegt, sodass der ursprüngliche Pfad so bleibt, wie er ist. Ändern Sie z. B. in einer Angriffsaktion die Z-Taste in die Leertaste. Wenn Sie außerdem von Leerzeichen zu x-Taste wechseln möchten, wird die Beschreibung für die z-Taste überschrieben, anstatt auf Leerzeichen zu basieren, wie folgt.

AttackAction.ApplyBindingOverride(new InputBinding { path = "<Keyboard>/z", overridePath = "<Keyboard>/x" });

Starten Sie nach dem Speichern das Spiel und klicken Sie auf die Schaltfläche, um zu sehen, ob sich die Tasten oder Schaltflächen, mit denen Sie interagieren, ändern.

InputAction Dieses Mal ändern wir die Aktionskarte für diejenige, die eine Instanz von erstellt hat, Es gibt auch InputAction ein Skript, das von der Action-Map-Einstellung der GUI generiert wird, also implementieren Sie es bitte in das Skript, das einfach zu erstellen ist.

Verwenden von Aktionskarten zum Zuweisen von Schaltflächen zu Spielverhalten

Touch-optimierte Eingabesteuerung mit On-Screen-Steuerung verwenden