Unidad

Usar controles de entrada táctiles optimizados con el control en pantalla

Actualización de la página :
Fecha de creación de la página :

Entorno de verificación

Windows
  • Ventanas 11
Unity Editor
  • 2020.3.25f1
Paquete del sistema de entrada
  • 1.2.0

Requisitos previos para esta sugerencia

Los siguientes ajustes se han realizado de antemano como premisa para la descripción de este consejo.

También debe estar familiarizado con los siguientes consejos:

Acerca del control en pantalla táctil

A menudo uso un teclado o gamepad para jugar. En dispositivos que solo se pueden operar con el tacto, como los teléfonos inteligentes, jugará el juego con el tacto.

El paquete del sistema de entrada de Unity utiliza el control en pantalla para simular las interacciones táctiles como si estuvieran controladas por un controlador.

Antes del control en pantalla

Este artículo es un poco largo, pero este tema no está directamente relacionado con el control en pantalla. Si puede usar el paquete del sistema de entrada en otros pasos para verificar la entrada, como un gamepad, está bien.

En este consejo, crearemos un mapa de acción. Describe cómo simular tocar un gamepad como si estuviera interactuando con él.

Por cierto, también admite el método de usar clases y Gamepad clases en scripts en Keyboard lugar de mapas de acción. No lo explicaré esta vez, pero si quieres probarlo con esas clases, puedes preparar el código descrito en la siguiente página.

Primero, coloque un objeto de texto en el lienzo para mostrar sus entradas. Más tarde, colocaremos el objeto táctil en la parte inferior, así que dejaremos algo de espacio.

Primero, cree un mapa de acción de la siguiente manera: Está creando la misma acción que cuando describió el mapa de acción.

Dado que la explicación del mapa de acción no es lo principal, el enlace es simple. Consulte la siguiente página para obtener detalles sobre los mapas de acción.

Esta vez, la adquisición de entradas se realiza mediante script en lugar de "Enviar mensajes" o "Invocar eventos de Unity". Esto tampoco se limita a los scripts, y funciona correctamente incluso si usa "Enviar mensajes", etc.

Asegúrese de haber generado el código desde el mapa de acción.

El script tiene este aspecto: Es casi lo mismo que cuando se explica el mapa de acción.

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

El EventSystem script se adjunta a .

Ejecuta el juego para ver si funciona como un mapa de acción.

Botón en pantalla

El botón en pantalla simula presionar botones en un gamepad, como A y B, y las teclas del teclado cuando toca algún objeto en la pantalla. Por cierto, dice tacto, pero también funciona con clics del mouse.

Primero coloque el botón en la pantalla. Como solo adjunta un componente, funciona con objetos que no sean botones.

Agregue un botón de entrada > en pantalla desde el componente.

Establezca el botón del Gamepad en este desde Ruta de control. Esto hace que parezca que el botón Este en el Gamepad se presionó cuando se tocó.

Asegúrate de que Ataque aparece cuando ejecutas el juego y haz clic en el botón. Si se trata de un dispositivo táctil, puede confirmar que funciona con tacto.

Stick en pantalla

On-Screen Stick te permite mover objetos como sticks con tu toque. Cuando mueves un palo, es posible simularlo como si hubieras movido un palo de gamepad. Además del tacto, también es posible moverlo con el ratón.

Coloca un objeto de botón en la pantalla que será un stick táctil. Estamos usando un botón aquí, pero también funciona con objetos que no sean botones.

En Agregar componente, seleccione Entrada > dispositivo en pantalla.

En Ruta de control, seleccione el Gamepad LeftStick definido en el mapa de acción.

Ejecuta el juego e intenta arrastrar el botón Stick. Los botones se mueven en círculo, como si movieran un palo. Por supuesto, también puede verificar que el contenido de entrada se obtenga mientras se está ejecutando.

En este caso, hemos colocado un botón, pero también es posible hacer que parezca un palo virtual colocando un marco circular y un objeto de palo redondo.

Por cierto, este rango móvil se puede cambiar en el "Rango de movimiento" del On-Screen Stick.

Configurar un mapa de acción dinámicamente
Personalizar el control en pantalla para implementar el cruceta