Een actiekaart dynamisch instellen

Pagina bijgewerkt : donderdag 29 juni 2023

Aanmaakdatum van pagina : donderdag 24 maart 2022

Verificatieomgeving

Ramen

Voor Windows 11

Unity Editor

2020.3.25f1

Input systeem pakket

1.2.0

Vereisten voor deze tip

De volgende instellingen zijn vooraf gemaakt als uitgangspunt voor de beschrijving van deze tip.

U moet ook bekend zijn met de volgende tips:

Actiekaarten gebruiken om knoppen toe te wijzen aan gamegedrag

Informatie over de configuratie van dynamische actiekaarten

Het is gebruikelijk om van tevoren actiekaarten aan het project toe te voegen en in te stellen, In dit geval worden de toewijzingen van de controllerknoppen vastgesteld tijdens de uitvoering van het spel en kunnen ze niet vrijelijk door de gebruiker worden gewijzigd tijdens het spel. Dit wordt vooral verwacht voor games die sleutelconfiguratie vereisen.

In deze tip wordt beschreven hoe u willekeurig de belangrijkste toewijzingen van een actiemap in een script kunt wijzigen.

Dynamische verwerking van actiekaartwijzigingen

Deze keer wordt de initiële actiemap ook ingesteld door het script en wordt de actiekaartwijziging in het midden ook in het script gedaan. Ik denk dat deze methode wordt gebruikt bij het laden en instellen van de sleutelconfiguratie die is opgeslagen bij het opstarten van het spel.

De inhoud van het voorbeeld is om de sleuteltoewijzing van de actiekaart te wijzigen wanneer u op de knop drukt en om de bediende inhoud als tekst weer te geven. De plaatsing van de knop en de weergavetekst zijn gerangschikt zoals weergegeven in de afbeelding, maar ze zijn niet erg belangrijk, dus plaats ze vrij.

Initiële configuratieprocedure voor actiekaart

Maak een script. De naam is arbitrair, maar in dit geval InputActionMap is het . Deze keer worden alle processen hier beschreven, maar in de daadwerkelijke productie, verdeel ze volgens de creatie van het project.

Het script ziet er als volgt uit: Maak eerst een standaardactiekaart bij het opstarten.

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

Definieer eerst zoveel acties in de klasse als u InputAction in het veld wilt implementeren. Hier bereiden we de velden voor "Move" en "Attack" voor, die ook werden gebruikt in de vorige uitleg van de actiekaart. Als het aantal acties toeneemt, moet u dat aantal declareren, maar als er veel zijn List Dictionary , kunt u ze beheren met , , enz. Het wordt hier niet gebruikt, maar als je je eigen InputActionMap klas hebt, kun je het daar beheren.

Instantiatie en sleuteltoewijzing AddBinding in de InputAction methode die bij initialisatie wordt aangeroepenAwake, worden uitgevoerd. U kunt zien wat u doet als een programma dat een binding toevoegt aan het instellingenscherm van de actiekaart. AddBinding De tekenreeks die is opgegeven voor Methode, enzovoort, is dezelfde als de tekenreeks die wordt weergegeven in Pad op het instellingenscherm van de actiekaart. Om een tekenreeks weer te geven, drukt u op de knop "T" aan de rechterkant.

De gebeurtenisafhandeling die wordt aangeroepen wanneer een knop wordt bediend, is hetzelfde als de verwerking van de scriptversie van een normale actiekaart. Het terugbelproces wordt ook omgeleid zoals het is.

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

Inschakelen, Uitschakelen is InputAction een eenheid, dus beschrijf zoveel acties als u wilt. Als het lastig is, kun je het List beheren met etc.

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

Nadat EventSystem u het script hebt opgeslagen, koppelt u het aan en configureert u een tekstobject voor weergave.

Voer het spel uit en kijk of de invoerinformatie wordt weergegeven. Het resultaat moet hetzelfde zijn als de scriptversie van het statische proces van de actiekaart.

Actiekaart Dynamische wijzigingsverwerking

Aangezien de dynamische wijziging van de actiekaart wordt uitgevoerd wanneer de knop wordt ingedrukt, definieert u de methode die wordt aangeroepen wanneer de knop wordt ingedrukt. OnClickButton Voor nu laten we het als .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

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

Hiermee stelt u de klikgebeurtenis voor de knop in.

Het herschrijfproces van de actiekaart is als volgt:

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

Aangezien voor elke actie een methode is opgegeven ApplyBindingOverride , wordt het path pad van de toets of knop die is geïnitialiseerd naar , overridePath Schrijf het pad van de toets of knop die u wilt overschrijven.

Overigens is dit gewoon het instellen van het overschrijfpad, dus het oorspronkelijke pad blijft zoals het is. Wijzig bijvoorbeeld in een aanvalsactie de z-toets in de spatiebalk. Bovendien, als u van spatie naar x-toets wilt veranderen, wordt de beschrijving als volgt overschreven voor de z-toets in plaats van op basis van spatie.

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

Eenmaal opgeslagen, voer je het spel uit en klik je op de knop om te zien of de toetsen of knoppen waarmee je communiceert, veranderen.

InputAction Deze keer wijzigen we de actiekaart voor degene die een instantie van , Er is ook InputAction een script gegenereerd door de actiekaartinstelling van de GUI, dus implementeer het in degene die gemakkelijk te doen is.

Actiekaarten gebruiken om knoppen toe te wijzen aan gamegedrag

Gebruik voor aanraking geoptimaliseerde invoerbesturingselementen met On-Screen Control