Configurer dynamiquement une carte d’action

Page mise à jour : jeudi 29 juin 2023

Date de création de la page : jeudi 24 mars 2022

Environnement de vérification

Windows

Fenêtres 11

Éditeur Unity

2020.3.25f1

Package système d’entrée

1.2.0

Conditions préalables à cette astuce

Les paramètres suivants ont été définis à l’avance comme prémisse pour la description de cette astuce.

Vous devez également connaître les conseils suivants :

Utiliser des cartes d’action pour attribuer des boutons aux comportements de jeu

À propos de la configuration dynamique de la carte d’action

Il est courant d’ajouter et de définir des cartes d’action au projet à l’avance, Dans ce cas, les affectations des boutons de la manette sont fixes pendant l’exécution du jeu et ne peuvent pas être modifiées librement par l’utilisateur pendant le jeu. Ceci est principalement attendu pour les jeux qui nécessitent une configuration de clé.

Cette astuce décrit comment modifier arbitrairement les affectations de clés d’une carte d’action dans un script.

Gestion dynamique des modifications de carte d’action

Cette fois, la carte d’action initiale est également définie par le script, et le changement de carte d’action au milieu est également effectué dans le script. Je pense que cette méthode est utilisée lors du chargement et de la définition de la configuration de clé enregistrée au démarrage du jeu.

Le contenu de l’exemple consiste à modifier l’affectation des clés de la carte d’action lorsque vous appuyez sur le bouton et à afficher le contenu exploité sous forme de texte. Le placement des boutons et le texte d’affichage sont disposés comme indiqué dans la figure, mais ils ne sont pas très importants, veuillez donc les placer librement.

Processus de configuration initiale de la carte d’action

Créez un script. Le nom est arbitraire, mais dans ce cas InputActionMap , il est . Cette fois, tous les processus seront décrits ici, mais dans la production réelle, veuillez les diviser en fonction de la création du projet.

Le script ressemble à ceci : Tout d’abord, créez une carte d’action par défaut au démarrage.

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

Tout d’abord, définissez autant d’actions dans la classe que vous InputAction souhaitez implémenter sur le terrain. Ici, nous allons préparer les champs pour « Déplacer » et « Attaquer », qui ont également été utilisés dans l’explication précédente de la carte d’action. Si le nombre d’actions augmente, vous devez déclarer ce nombre, mais s’il y en a List Dictionary plusieurs, vous pouvez les gérer avec , , etc. Il n’est pas utilisé ici, mais si vous avez votre propre InputActionMap classe, vous pouvez la gérer là-bas.

L’instanciation et l’affectation AddBinding de clé dans la méthode appelée Awake lors de l’initialisation InputAction sont effectuées. Vous pouvez considérer ce que vous faites comme un programme qui ajoute une liaison sur l’écran de configuration de la carte d’action. AddBinding La chaîne spécifiée pour Méthode, etc. est identique à la chaîne affichée dans Chemin sur l’écran de configuration de la carte d’action. Pour afficher une chaîne de caractères, appuyez sur le bouton « T » à droite.

La gestion des événements appelée lorsqu’un bouton est actionné est identique au traitement de la version scriptée d’une carte d’action normale. Le processus de rappel est également détourné tel quel.

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

Activer, désactiver est InputAction une unité, alors décrivez autant d’actions que vous le souhaitez. Si c’est gênant, vous pouvez le List gérer avec, etc.

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

Après EventSystem avoir enregistré le script, attachez-le à un objet texte et configurez-le pour l’affichage.

Lancez le jeu et voyez si les informations d’entrée apparaissent. Le résultat doit être identique à la version scriptée du processus statique de la carte d’action.

Carte d’action Traitement dynamique des modifications

Étant donné que le changement dynamique de la carte d’action se fait lorsque vous appuyez sur le bouton, définissez la méthode qui sera appelée lorsque vous appuyez sur le bouton. OnClickButton Pour l’instant, nous allons le laisser comme .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

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

Définit l’événement click pour le bouton.

Le processus de réécriture de la carte d’action est le suivant :

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

Étant donné qu’une méthode est fournie pour ApplyBindingOverride chaque action, le path chemin de la clé ou du bouton initialisé à , overridePath Écrivez le chemin de la touche ou du bouton que vous souhaitez remplacer.

Soit dit en passant, il s’agit simplement de définir le chemin d’écrasement, de sorte que le chemin d’origine reste tel quel. Par exemple, dans une action Attaque, remplacez la touche z par la barre d’espace. De plus, si vous souhaitez passer de la touche espace à la touche x, la description sera écrasée pour la touche z au lieu d’être basée sur l’espace, comme suit.

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

Une fois enregistré, lancez le jeu et cliquez sur le bouton pour voir si les touches ou les boutons avec lesquels vous interagissez changent.

InputAction Cette fois, nous modifions la carte d’action pour celle qui a créé une instance de , Il existe également InputAction un script généré par le paramètre de carte d’action de l’interface graphique, veuillez donc l’implémenter dans celui qui est facile à faire.

Utiliser des cartes d’action pour attribuer des boutons aux comportements de jeu

Utiliser des commandes d’entrée optimisées pour les écrans tactiles avec contrôle à l’écran