Configurarea dinamică a unei hărți de acțiuni

Pagina actualizată : joi, 29 iunie 2023

Data creării paginii : joi, 24 martie 2022

Mediul de verificare

Windows

Ferestre 11

Unity Editor

2020.3.25F1

Pachet sistem de intrare

1.2.0

Cerințe preliminare pentru acest sfat

Următoarele setări au fost făcute în avans ca premisă pentru descrierea acestui sfat.

De asemenea, trebuie să cunoașteți următoarele sfaturi:

Utilizați hărți de acțiune pentru a atribui butoane comportamentelor de joc

Despre configurarea hărții de acțiuni dinamice

Este obișnuit să adăugați și să setați hărți de acțiune la proiect în avans, În acest caz, alocările butoanelor controlerului sunt fixate în timpul executării jocului și nu pot fi modificate în mod liber de către utilizator în timpul jocului. Acest lucru este de așteptat în principal pentru jocurile care necesită configurare cheie.

Acest sfat descrie modul de modificare arbitrară a atribuirilor cheie ale unei hărți de acțiuni într-un script.

Gestionarea modificărilor hărții dinamice de acțiune

De data aceasta, harta de acțiune inițială este, de asemenea, setată de script, iar modificarea hărții de acțiune din mijloc se face și în script. Cred că această metodă este utilizată la încărcarea și setarea configurației cheii salvate la pornirea jocului.

Conținutul eșantionului trebuie să modifice atribuirea tastelor hărții de acțiuni atunci când apăsați butonul și să afișeze conținutul operat ca text. Plasarea butoanelor și textul afișat sunt aranjate așa cum se arată în figură, dar nu sunt foarte importante, așa că vă rugăm să le plasați liber.

Procesul inițial de configurare a hărții de acțiune

Creați un script. Numele este arbitrar, dar în acest caz InputActionMap este . De data aceasta, toate procesele vor fi descrise aici, dar în producția efectivă, vă rugăm să le împărțiți în funcție de crearea proiectului.

Scenariul arată astfel: Mai întâi, creați o hartă de acțiune implicită la pornire.

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

În primul rând, definiți câte acțiuni din clasă doriți să implementați InputAction pe teren. Aici, vom pregăti câmpurile pentru "Mutare" și "Atac", care au fost folosite și în explicația anterioară a hărții de acțiune. Dacă numărul de acțiuni crește, trebuie să declarați acel număr, dar dacă sunt List Dictionary multe, le puteți gestiona cu , , etc. Nu este folosit aici, dar dacă aveți propria InputActionMap clasă, o puteți gestiona acolo.

Se efectuează instanțierea și atribuirea AddBinding cheilor în InputAction metoda numită Awake inițializare. Vă puteți gândi la ceea ce faceți ca la un program care adaugă o legătură pe ecranul de setare a hărții de acțiuni. AddBinding Șirul specificat pentru Metodă etc. este același cu șirul afișat în Cale pe ecranul de setare a hărții de acțiune. Pentru a afișa un șir de caractere, apăsați butonul "T" din dreapta.

Gestionarea evenimentelor apelată atunci când este operat un buton este aceeași cu procesarea versiunii scriptate a unei hărți de acțiune normale. Procesul de apelare inversă este, de asemenea, deviat așa cum este.

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

Activare, Dezactivare este InputAction o unitate, deci descrieți câte acțiuni doriți. Dacă este supărător, îl List puteți gestiona cu etc.

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

După ce EventSystem salvați scriptul, atașați-l și configurați un obiect text pentru afișare.

Rulați jocul și vedeți dacă apar informațiile de intrare. Rezultatul ar trebui să fie același cu versiunea scriptată a procesului static al hărții de acțiune.

Harta de acțiune Procesarea dinamică a schimbărilor

Deoarece modificarea dinamică a hărții de acțiune se face atunci când este apăsat butonul, definiți metoda care va fi apelată la apăsarea butonului. OnClickButton Deocamdată, o vom lăsa ca .

// 省略

public class InputActionMap : MonoBehaviour
{
  // 省略

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

Setează evenimentul de clic pentru buton.

Procesul de rescriere a hărții de acțiune este următorul:

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

Deoarece este prevăzută o metodă pentru ApplyBindingOverride fiecare acțiune, calea tastei sau a butonului care a fost inițializată în , path overridePath Scrieți calea tastei sau a butonului pe care doriți să îl înlocuiți.

Apropo, aceasta este doar setarea căii de suprascriere, astfel încât calea originală rămâne așa cum este. De exemplu, într-o acțiune Atac, schimbați tasta z pe bara de spațiu. În plus, dacă doriți să treceți de la tasta spațiu la tasta x, descrierea va fi suprascrisă pentru tasta z în loc să se bazeze pe spațiu, după cum urmează.

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

Odată salvat, rulați jocul și faceți clic pe buton pentru a vedea dacă tastele sau butoanele cu care interacționați se schimbă.

InputAction De data aceasta, schimbăm harta de acțiune pentru cea care a creat o instanță de , Există, de asemenea, InputAction un script generat de setarea hărții de acțiune a interfeței grafice, așa că vă rugăm să îl implementați într-unul ușor de făcut.

Utilizați hărți de acțiune pentru a atribui butoane comportamentelor de joc

Utilizarea comenzilor de intrare optimizate pentru atingere cu Control pe ecran