Unité

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

Page mise à jour :
Date de création de la page :

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 :

À propos du contrôle à l’écran pour le tactile

J’utilise souvent un clavier ou une manette de jeu pour jouer à des jeux. Sur les appareils qui ne peuvent être utilisés que par le toucher, tels que les smartphones, vous jouerez au jeu au toucher.

Le système d’entrée de Unity utilise le contrôle à l’écran pour simuler les interactions tactiles comme si elles étaient contrôlées par un contrôleur.

Avant le contrôle à l’écran

Cet article est un peu long, mais ce sujet n’est pas directement lié au contrôle à l’écran. Si vous pouvez utiliser le package système d’entrée dans d’autres étapes pour vérifier l’entrée, comme une manette de jeu, c’est très bien.

Dans cette astuce, nous allons créer une carte d’action. Décrit comment simuler le toucher d’une manette de jeu comme si vous interagissiez avec elle.

Soit dit en passant, il prend également en charge la méthode d’utilisation des classes et Gamepad des classes dans Keyboard les scripts au lieu des cartes d’action. Je ne vais pas l’expliquer cette fois, mais si vous voulez l’essayer avec ces classes, vous pouvez préparer le code décrit sur la page suivante à la place.

Tout d’abord, placez un objet texte sur le canevas pour afficher vos entrées. Plus tard, nous placerons l’objet tactile en bas, alors laissez un peu d’espace.

Tout d’abord, créez une carte d’action comme suit : Vous créez la même action que lorsque vous avez décrit la carte d’actions.

Puisque l’explication de la carte d’action n’est pas la chose principale, la liaison est simple. Veuillez vous référer à la page suivante pour plus de détails sur les cartes d’action.

Cette fois, l’acquisition des entrées est effectuée par script au lieu de « Envoyer des messages » ou « Appeler des événements Unity ». Ceci n’est pas non plus limité aux scripts, et cela fonctionne correctement même si vous utilisez « Envoyer des messages », etc.

Assurez-vous d’avoir généré le code à partir de la carte d’action.

Le script ressemble à ceci : C’est presque la même chose que lors de l’explication de la carte d’action.

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

public class InputActionScript : MonoBehaviour
{
  /// <summary>情報を表示させるテキストオブジェクト。</summary>
  [SerializeField] private Text TextObject;

  /// <summary>アクションマップから自動生成されたクラス。</summary>
  private InputActionSample _actionMap;

  private void Awake()
  {
    // 各操作を行ったときに呼ばれるイベントを設定する
    _actionMap = new InputActionSample();
    _actionMap.Action2D.Move.performed += context => OnMove(context);
    _actionMap.Action2D.Attack.performed += context => OnAttack(context);
    _actionMap.Action2D.Move.canceled += context => OnMove(context);
    _actionMap.Action2D.Attack.canceled += context => OnAttack(context);
  }

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

  private void OnDisable()
  {
    // このオブジェクトが無効になったときにアクションマップが余計な動作を起こさないように無効にする
    _actionMap.Disable();
  }

  /// <summary>
  /// Move 操作をした時に呼ばれるメソッドです。
  /// </summary>
  /// <param name="context">コールバックパラメータ。</param>
  public void OnMove(InputAction.CallbackContext context)
  {
    // Move の入力量を取得
    var vec = context.ReadValue<Vector2>();
    TextObject.text = $"Move:({vec.x:f2}, {vec.y:f2})\n{TextObject.text}";
  }

  /// <summary>
  /// Attack 操作をした時に呼ばれるメソッドです。
  /// </summary>
  /// <param name="context">コールバックパラメータ。</param>
  public void OnAttack(InputAction.CallbackContext context)
  {
    // Attack ボタンの状態を取得
    var value = context.ReadValueAsButton();
    TextObject.text = $"Attack:{value}\n{TextObject.text}";
  }
}

Le EventSystem script est attaché à .

Exécutez le jeu pour voir s’il fonctionne comme une carte d’action.

Bouton à l’écran

Le bouton à l’écran simule le fait d’appuyer sur les boutons d’une manette de jeu, tels que A et B, et sur les touches du clavier lorsque vous touchez un objet à l’écran. Au fait, il dit tactile, mais cela fonctionne aussi avec des clics de souris.

Placez d’abord le bouton sur l’écran. Puisque vous attachez simplement un composant, il fonctionne avec des objets autres que des boutons.

Ajoutez un bouton d’entrée > à l’écran à partir du composant.

Placez le bouton de la manette à l’est du chemin de contrôle. Cela donne l’impression que le bouton Est de la manette de jeu a été enfoncé lorsqu’il a été touché.

Assurez-vous que Attack apparaît lorsque vous lancez le jeu et cliquez sur le bouton. S’il s’agit d’un appareil tactile, vous pouvez confirmer qu’il fonctionne avec le tactile.

Stick à l’écran

Le bâton à l’écran vous permet de déplacer des objets comme des bâtons avec votre toucher. Lorsque vous déplacez un bâton, il est possible de le simuler comme si vous aviez déplacé un bâton de manette. En plus du toucher, il est également possible de le déplacer avec la souris.

Place un objet bouton sur l’écran qui sera un bâton tactile. Nous utilisons un bouton ici, mais il fonctionne également avec des objets autres que des boutons.

Sous Ajouter un composant, sélectionnez Entrée > Stick à l’écran.

Dans Chemin de contrôle, sélectionnez le LeftStick de la manette de jeu défini dans la carte d’action.

Lancez le jeu et essayez de faire glisser le bouton Stick. Les boutons se déplacent en cercle, comme s’ils déplaçaient un bâton. Bien sûr, vous pouvez également vérifier que le contenu d’entrée est récupéré pendant son exécution.

Dans ce cas, nous avons placé un bouton, mais il est également possible de le faire ressembler à un bâton virtuel en plaçant un cadre circulaire et un objet bâton rond.

À propos, cette plage mobile peut être modifiée dans la « plage de mouvement » du stick à l’écran.

Configurer dynamiquement une carte d’action
Personnaliser le contrôle à l’écran pour implémenter le pavé directionnel