Ir al contenido
Descargar
El libro de Grost

Input

“Saltar” no es “la barra espaciadora”. Es la barra, o el botón A, o un toque en la pantalla, y el jugador puede quererlo en otra tecla. El sistema de entrada de Gobu, Enhanced Input (el mismo modelo que el de Unreal), separa lo que el jugador quiere hacer de qué tecla lo hace. Tu código solo habla de lo primero.

Así puedes cambiar las teclas, añadir un mando o dejar que el jugador elija sus controles sin tocar el código.

En el editor creas dos tipos de recurso (archivos de datos), dentro de resources/.

Una acción (.inputaction) es algo que hace el jugador: Saltar, Moverse, Mirar. Tiene un tipo de valor, el tipo de valor que da:

value_typeValorEjemplo
VALUE_TYPE_BOOLboolSaltar, Interactuar
VALUE_TYPE_AXIS_1DfloatAcelerador, Zoom
VALUE_TYPE_AXIS_2DVector2Moverse, Mirar
VALUE_TYPE_AXIS_3DVector3Volar

Un contexto de mapeo (.inputcontext) une teclas con acciones: la barra y el botón A con jump, WASD y el stick izquierdo con move. Un juego suele tener varios, uno por situación: a pie, conduciendo, en un menú.

Cada tecla del contexto puede llevar dos tipos de extras:

  • Los modificadores cambian el valor. Por ejemplo, convierten el “1” de la tecla A en “-1” (izquierda).
  • Los disparadores (triggers) deciden cuándo se dispara la acción: al pulsar, tras mantener, con un toque rápido…

Una acción también puede llevarlos: entonces valen para todas sus teclas.

Modificadores
InputModifierNegateCambia el signo
InputModifierSwizzleIntercambia ejes (una tecla en X pasa a Y)
InputModifierDeadZoneIgnora movimientos pequeños del stick
InputModifierScalarMultiplica
InputModifierScaleByDeltaTimeMultiplica por el tiempo del frame
InputModifierResponseCurveExponentialCurva la respuesta
InputModifierSmoothSuaviza a lo largo de varios frames
DisparadoresSe dispara
InputTriggerDown (el de por defecto, sin disparadores)Mientras se mantiene
InputTriggerPressed / InputTriggerReleasedAl pulsar / al soltar
InputTriggerHold / InputTriggerHoldAndReleaseTras mantener / al soltar tras mantener
InputTriggerTapCon una pulsación rápida
InputTriggerPulseRepetidamente mientras se mantiene
InputTriggerChordedActionSolo mientras otra acción está activa (Shift + tecla)
InputTriggerChordBlockerNo mientras otra acción está activa
InputTriggerComboTras una secuencia de pasos (InputComboStep)

Por ejemplo, WASD en una acción move de tipo Axis 2D:

  • D tal cual.
  • A con Negate.
  • W con Swizzle.
  • S con Swizzle y Negate.

W da entonces (0, 1). Si “arriba” tiene que ser -Y en pantalla, añade un Negate en Y.

El ajuste de proyecto input_devices/enhanced_input/default_mapping_contexts lista los contextos activos desde el principio.

Un script importa un contexto de mapeo con use input:: y el nombre de archivo del contexto. Las acciones son miembros del contexto, por su nombre de archivo: jump.inputaction es foot.jump.

module Player
use input::on_foot as foot
use input::driving as car
fn _ready() void {
foot.enable(0)
}
  • use solo no activa el contexto; lo activa enable. El número es su prioridad (la verás más abajo).
  • Un nombre de acción equivocado es un error de validación: lo ves mientras escribes el código, no como una sorpresa mientras juegas.

Casi siempre quieres reaccionar: cuando el jugador salta, saltar. Los eventos de una acción se conectan con on, como las señales del capítulo 7:

use input::on_foot as foot
on foot.jump.triggered() {
print("jump")
}
on foot.move.triggered(value: Vector2) {
print("move ", value)
}
on foot.move.completed(_value: Vector2, elapsed: float, _triggered: float) {
print("moved for ", elapsed)
}

Una acción pasa por estos eventos, en este orden:

EventoCuándo
startedLa tecla empieza a pulsarse
ongoingEl disparador todavía decide (un Hold que aún no dura bastante)
triggeredLa acción se dispara
completedDeja de dispararse
canceledTerminó sin dispararse (un Hold soltado demasiado pronto)

El manejador recibe de 0 a 3 parámetros, en este orden:

  1. value: bool, float, Vector2 o Vector3, según el tipo de la acción.
  2. elapsed_time: segundos desde started.
  3. triggered_time: segundos que lleva disparada.

El valor es cero salvo que la acción esté disparada: un Hold que sigue ongoing lee cero.

A veces es más sencillo preguntar que reaccionar, por ejemplo en _process, que corre una vez por frame:

use input::driving as car
fn _process(_delta: float) void {
if car.honk.is_triggered() {
print("honk")
}
}
En una acciónDa
value()El valor actual
is_triggered()Si se dispara en este frame
get_state()InputTrigger.STATE_NONE, STATE_ONGOING o STATE_TRIGGERED
get_elapsed_time(), get_triggered_time()Los mismos tiempos que los eventos
get_key_texts()Sus teclas, como texto (["E"]), para avisos tipo “Pulsa [E]”

Cuando el jugador se sube a un coche, tiene que dejar de andar y empezar a conducir. En lugar de preguntar “¿estoy en el coche?” en cada acción, cambias de contexto:

use input::on_foot as foot
use input::driving as car
fn enter_car() void {
foot.disable()
car.enable(10)
}
En un contextoHace
enable(priority = 0, ignore_pressed_keys = true)Lo activa
disable(ignore_pressed_keys = true)Lo desactiva
is_enabled()Si está activo
set_priority(p), get_priority()Cambia o lee su prioridad
  • Con varios contextos activos gana el de mayor prioridad. Una tecla que usa para una acción con consume_input (activado por defecto) no llega a los contextos de menor prioridad, salvo que esa acción tenga reserve_all_mappings.
  • Con ignore_pressed_keys, las teclas pulsadas en el momento del cambio leen cero hasta que se sueltan. Así la tecla de saltar que tenías pulsada no hace sonar el claxon.

EnhancedInput es un singleton: un objeto que el motor crea una sola vez y al que cualquier script llega por su nombre. Hace lo mismo que los contextos desde código, y algunas cosas más:

use input::on_foot as foot
use input::driving as car
mut jump : InputAction = foot.jump
mut move : InputAction = foot.move
EnhancedInput.add_mapping_context(car, 10)
EnhancedInput.remove_mapping_context(car)
EnhancedInput.inject_input_for_action(jump, true)
EnhancedInput.start_continuous_input_injection_for_action(move, Vector2(1, 0))
EnhancedInput.stop_continuous_input_injection_for_action(move)

Inyectar entrada pulsa una acción como si lo hubiera hecho el jugador: durante un frame, o hasta que la pares. Sirve para una IA que maneja el mismo prefab del jugador, para demos y para tests.

Muchos jugadores quieren sus propios controles. En el contexto, marca una tecla como player_mappable y dale un mapping_name. Un menú de controles puede entonces listarlas:

fn list_keys() void {
keys : Array = EnhancedInput.get_player_mappable_keys()
for key in keys {
entry : Dictionary = (key as Dictionary) ?? {}
print(entry["display_name"], ": ", entry["key_text"])
}
}

Cada entrada es un diccionario con mapping_name, display_name, key_text y más. Para cambiar una, pasa la tecla nueva como un InputEvent (el que el jugador acaba de pulsar):

fn rebind(mapping_name: String, event: InputEvent) void {
EnhancedInput.set_player_mapped_key(mapping_name, event)
err : Error = EnhancedInput.save_player_mapped_keys()
if err != OK {
print("could not save the controls")
}
}
fn reset(mapping_name: String) void {
EnhancedInput.reset_player_mapped_key(mapping_name)
}

save_player_mapped_keys() escribe user://input_mappings.cfg, que se carga solo al arrancar: el jugador encuentra sus teclas la próxima vez.