Configurar un mapa d'accions dinàmicament

Pàgina actualitzada : dijous, 29 de juny de 2023

Data de creació de la pàgina : dijous, 24 de març de 2022

Entorn de verificació

Windows

Finestres 11

Editor d'unitat

25.3.2020

Paquet del sistema d'entrada

1.2.0

Requisits previs per a aquest consell

La configuració següent s'ha fet amb antelació com a premissa per a la descripció d'aquest consell.

També hauríeu de conèixer els consells següents:

Utilitzar mapes d'accions per assignar botons als comportaments del joc

Quant a la configuració del mapa d'accions dinàmiques

És habitual afegir i establir mapes d'accions al projecte amb antelació, En aquest cas, les assignacions dels botons del controlador es fixen durant l'execució del joc i l'usuari no pot canviar-les lliurement durant el joc. Això s'espera principalment per als jocs que requereixen configuració de tecles.

Aquest consell descriu com canviar arbitràriament les assignacions clau d'un mapa d'accions en un script.

Gestió dinàmica de canvis en el mapa d'accions

Aquesta vegada, el mapa d'acció inicial també està establert pel guió, i el canvi de mapa d'acció al mig també es fa al guió. Crec que aquest mètode s'utilitza a l'hora de carregar i configurar la configuració de la clau guardada a l'inici del joc.

El contingut de la mostra és canviar l'assignació de claus del mapa d'accions en prémer el botó, i mostrar el contingut operat com a text. La col·locació del botó i el text de visualització estan disposats com es mostra a la figura, però no són molt importants, així que si us plau, col·loqueu-los lliurement.

Mapa d'accions Procés de configuració inicial

Creeu un script. El nom és arbitrari, però en aquest cas InputActionMap és . Aquesta vegada, tots els processos es descriuran aquí, però en la producció real, dividiu-los segons la creació del projecte.

El guió té aquest aspecte: En primer lloc, creeu un mapa d'accions predeterminat a l'inici.

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

En primer lloc, definiu tantes accions a la classe com vulgueu InputAction implementar al camp. Aquí prepararem els camps "Mou" i "Ataca", que també es van utilitzar en l'explicació anterior del mapa d'accions. Si el nombre d'accions augmenta, cal declarar aquest nombre, però si són List Dictionary moltes, es poden gestionar amb , , etc. Aquí no s'utilitza, però si tens classe pròpia InputActionMap , pots gestionar-la allà.

Es realitza la instanciació i l'assignació de AddBinding claus en el mètode anomenat Awake a la InputAction inicialització. Podeu pensar en el que esteu fent com un programa que afegeix una vinculació a la pantalla de configuració del mapa d'accions. AddBinding La cadena especificada per a Mètode, etc. és la mateixa que la cadena que es mostra a Camí a la pantalla de configuració del mapa d'accions. Per mostrar una cadena de caràcters, premeu el botó "T" de la dreta.

La gestió d'esdeveniments anomenada quan s'opera un botó és la mateixa que el processament de la versió amb script d'un mapa d'accions normal. El procés de devolució de trucada també es desvia tal com està.

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

Habilitar, Desactivar és InputAction una unitat, així que descriviu tantes accions com vulgueu. Si és problemàtic, podeu gestionar-lo List amb etc.

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

Després EventSystem de desar l'script, adjunteu-lo i configureu un objecte de text per mostrar-lo.

Executeu el joc i comproveu si apareix la informació d'entrada. El resultat ha de ser el mateix que la versió amb script del procés estàtic del mapa d'accions.

Mapa d'Acció Processament Dinàmic del Canvi

Com que el canvi dinàmic del mapa d'accions es realitza quan es prem el botó, definiu el mètode que es cridarà quan premeu el botó. OnClickButton De moment, ho deixarem com .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

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

Defineix l'esdeveniment de clic per al botó.

El procés de reescriptura del mapa d'acció és el següent:

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

Com que es proporciona un mètode per a ApplyBindingOverride cada acció, la ruta de la path tecla o botó que es va inicialitzar a , overridePath Escriviu el camí de la tecla o el botó que voleu substituir.

Per cert, això només estableix el camí de sobreescriptura, de manera que el camí original es manté tal com és. Per exemple, en una acció d'atac, canvieu la tecla z de la barra espaiadora. A més, si voleu canviar d'espai a clau x, la descripció se sobreescriurà per a la tecla z en lloc de basar-se en l'espai, de la següent manera.

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

Un cop desat, executeu el joc i feu clic al botó per veure si les tecles o botons amb què interactueu canvien.

InputAction Aquesta vegada, estem canviant el mapa d'accions per aquell que va crear una instància de , També InputAction hi ha un script generat per la configuració del mapa d'accions de la interfície gràfica, així que si us plau, implementeu-lo en el que sigui fàcil de fer.

Utilitzar mapes d'accions per assignar botons als comportaments del joc

Utilitzar controls d'entrada tàctils optimitzats amb el control en pantalla