Impostare dinamicamente una mappa delle azioni

Ambiente di verifica

Finestre

• Windows 11

Unity Editor

• 2020.3.25F1

Pacchetto del sistema di input

• 1.2.0

Prerequisiti per questo suggerimento

Le seguenti impostazioni sono state effettuate in anticipo come premessa per la descrizione di questo suggerimento.

• Introduzione al pacchetto del sistema di input
• Allineare la fotocamera (2D) con l'area di lavoro

Dovresti anche avere familiarità con i seguenti suggerimenti:

• Utilizzare le mappe di azione per assegnare pulsanti ai comportamenti di gioco

Informazioni sulla configurazione della mappa di azione dinamica

È comune aggiungere e impostare mappe d'azione al progetto in anticipo, In questo caso, le assegnazioni dei pulsanti del controller sono fisse durante l'esecuzione del gioco e non possono essere modificate liberamente dall'utente durante il gioco. Questo è previsto principalmente per i giochi che richiedono una configurazione chiave.

In questo suggerimento viene descritto come modificare arbitrariamente le assegnazioni dei tasti di una mappa azioni in uno script.

Gestione dinamica delle modifiche della mappa delle azioni

Questa volta, anche la mappa delle azioni iniziale viene impostata dallo script e la modifica della mappa delle azioni nel mezzo viene eseguita anche nello script. Penso che questo metodo venga utilizzato durante il caricamento e l'impostazione della configurazione della chiave salvata all'avvio del gioco.

Il contenuto dell'esempio consiste nel modificare l'assegnazione dei tasti della mappa azioni quando si preme il pulsante e nel visualizzare il contenuto utilizzato come testo. Il posizionamento dei pulsanti e il testo visualizzato sono disposti come mostrato nella figura, ma non sono molto importanti, quindi si prega di posizionarli liberamente.

Processo di configurazione iniziale della mappa delle azioni

Creare uno script. Il nome è arbitrario, ma in questo caso InputActionMap è . Questa volta, tutti i processi saranno descritti qui, ma nella produzione effettiva, si prega di dividerli in base alla creazione del progetto.

Lo script è simile al seguente: Innanzitutto, crea una mappa delle azioni predefinita all'avvio.

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}";
  }
}

Innanzitutto, definire tutte le azioni nella classe che si InputAction desidera implementare sul campo. Qui, prepareremo i campi per "Sposta" e "Attacco", che sono stati utilizzati anche nella precedente spiegazione della mappa d'azione. Se il numero di azioni aumenta, è necessario dichiarare quel numero, ma se ce ne sono List Dictionary molte, è possibile gestirle con , , ecc. Non è usato qui, ma se hai la tua InputActionMap classe, puoi gestirlo lì.

Vengono eseguite l'istanza e l'assegnazione AddBinding delle chiavi nel metodo chiamato Awake all'inizializzazioneInputAction. Puoi pensare a ciò che stai facendo come a un programma che aggiunge un'associazione nella schermata di impostazione della mappa delle azioni. AddBinding La stringa specificata per Metodo e così via è uguale alla stringa visualizzata in Percorso nella schermata di impostazione della mappa delle azioni. Per visualizzare una stringa di caratteri, premere il pulsante "T" a destra.

La gestione degli eventi chiamata quando viene azionato un pulsante è uguale all'elaborazione della versione di script di una normale mappa delle azioni. Anche il processo di callback viene deviato così com'è.

// 操作時のイベントを設定
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}";
}

Enable, Disable è InputAction un'unità, quindi descrivi tutte le azioni che desideri. Se è problematico, puoi gestirlo List con ecc.

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

Dopo EventSystem aver salvato lo script, collegarlo e configurare un oggetto di testo per la visualizzazione.

Esegui il gioco e verifica se vengono visualizzate le informazioni di input. Il risultato deve essere uguale alla versione di script del processo statico della mappa delle azioni.

Action Map Elaborazione dinamica delle modifiche

Poiché la modifica dinamica della mappa delle azioni viene eseguita quando si preme il pulsante, definire il metodo che verrà chiamato quando viene premuto il pulsante. OnClickButton Per ora, lo lasceremo come .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

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

Imposta l'evento click per il pulsante.

Il processo di riscrittura della mappa delle azioni è il seguente:

/// <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" });
}

Poiché viene fornito un metodo per ApplyBindingOverride ogni azione, il path percorso del tasto o del pulsante inizializzato su , overridePath Scrivi il percorso della chiave o del pulsante che desideri sostituire.

A proposito, questo è solo l'impostazione del percorso di sovrascrittura, quindi il percorso originale rimane così com'è. Ad esempio, in un'azione Attacco, modificare il tasto z sulla barra spaziatrice. Inoltre, se si desidera passare dallo spazio al tasto x, la descrizione verrà sovrascritta per il tasto z anziché in base allo spazio, come segue.

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

Una volta salvato, esegui il gioco e fai clic sul pulsante per vedere se i tasti o i pulsanti con cui interagisci cambiano.

InputAction Questa volta, stiamo cambiando la mappa delle azioni per quella che ha creato un'istanza di , C'è anche InputAction uno script generato dall'impostazione della mappa delle azioni della GUI, quindi per favore implementalo in quello che è facile da fare.