Unidade

Configurar um mapa de ação dinamicamente

Página atualizada :
Data de criação de página :

Ambiente de verificação

Windows
  • Janelas 11
Unity Editor
  • 25.3.2020F1
Pacote do sistema de entrada
  • 1.2.0

Pré-requisitos para esta dica

As configurações a seguir foram feitas com antecedência como premissa para a descrição desta dica.

Você também deve estar familiarizado com as seguintes dicas:

Sobre a configuração do mapa de ação dinâmico

É comum adicionar e definir mapas de ação para o projeto com antecedência, Neste caso, as atribuições do botão do controle são fixas durante a execução do jogo e não podem ser alteradas livremente pelo usuário durante o jogo. Isso é esperado principalmente para jogos que exigem configuração de chave.

Esta dica descreve como alterar arbitrariamente as principais atribuições de um mapa de ação em um script.

Tratamento de alterações no mapa de ação dinâmico

Desta vez, o mapa de ação inicial também é definido pelo script, e a mudança do mapa de ação no meio também é feita no script. Acho que esse método é usado ao carregar e definir a configuração de chave salva na inicialização do jogo.

O conteúdo do exemplo deve alterar a atribuição de chave do mapa de ação quando você pressiona o botão e exibir o conteúdo operado como texto. O posicionamento do botão e o texto de exibição são organizados como mostrado na figura, mas não são muito importantes, então coloque-os livremente.

Processo de Configuração Inicial do Mapa de Ação

Crie um script. O nome é arbitrário, mas neste caso InputActionMap é . Desta vez, todos os processos serão descritos aqui, mas na produção real, divida-os de acordo com a criação do projeto.

O script tem a seguinte aparência: Primeiro, crie um mapa de ação padrão na inicialização.

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

Primeiro, defina quantas ações na classe você InputAction deseja implementar no campo. Aqui, vamos preparar os campos para "Mover" e "Atacar", que também foram usados na explicação do mapa de ação anterior. Se o número de ações aumentar, você precisará declarar esse número, mas se houver List Dictionary muitas, você pode gerenciá-las com , , etc. Ele não é usado aqui, mas se você tem sua própria InputActionMap classe, você pode gerenciá-lo lá.

A instanciação e a InputAction atribuição AddBinding de chave no método chamado Awake na inicialização são executadas. Você pode pensar no que está fazendo como um programa que adiciona uma ligação na tela de configuração do mapa de ação. AddBinding A cadeia de caracteres especificada para Método, etc. é a mesma que a cadeia de caracteres exibida em Caminho na tela de configuração do mapa de ação. Para exibir uma cadeia de caracteres, pressione o botão "T" à direita.

A manipulação de eventos chamada quando um botão é operado é o mesmo que o processamento da versão com script de um mapa de ação normal. O processo de retorno de chamada também é desviado como 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, Desabilitar é InputAction uma unidade, então descreva quantas ações quiser. Se for problemático, você pode gerenciá-lo List com etc.

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

Depois de salvar o script, anexe-o e configure um objeto de EventSystem texto para exibição.

Execute o jogo e veja se as informações de entrada aparecem. O resultado deve ser o mesmo que a versão com script do processo estático do mapa de ação.

Mapa de Ação Processamento Dinâmico de Alterações

Como a mudança dinâmica do mapa de ação é feita quando o botão é pressionado, defina o método que será chamado quando o botão for pressionado. OnClickButton Por enquanto, vamos deixar como .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

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

Define o evento click para o botão.

O processo de regravação do mapa de ação é o seguinte:

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

Como um método é fornecido para cada ação, o path caminho da chave ou botão que foi inicializado para ApplyBindingOverride , overridePath Escreva o caminho da chave ou botão que você deseja substituir.

A propósito, isso é apenas definir o caminho de substituição, para que o caminho original permaneça como está. Por exemplo, em uma ação Ataque, altere a tecla z para a barra de espaço. Além disso, se você quiser mudar de espaço para tecla x, a descrição será substituída para a tecla z em vez de com base no espaço, como a seguir.

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

Uma vez salvo, execute o jogo e clique no botão para ver se as teclas ou botões com os quais você interage mudam.

InputAction Desta vez, estamos alterando o mapa de ação para aquele que criou uma instância de , Há também InputAction um script gerado pela configuração do mapa de ação da GUI, então implemente-o no que é fácil de fazer.

Usar mapas de ação para atribuir botões a comportamentos de jogo
Use controles de entrada otimizados para toque com o Controle na tela