Controles: acciones, no teclas
use input::a_pie as pie1 · Traer el contextoUn **contexto** une teclas con acciones. use input::a_pie trae el del archivo a_pie.inputcontext, y pie es el nombre con el que lo usas.Este código todavía no imprime nada.
use input::a_pie as pie
fn _ready() void {
pie.enable(0)2 · Activarlouse solo no activa el contexto: lo activa enable. El número es su prioridad.}Este código todavía no imprime nada.
use input::a_pie as pie
fn _ready() void {
pie.enable(0)
}
on pie.saltar.triggered() {
print("¡salto!")
}3 · Reaccionar a una acciónCon on reaccionas cuando la acción se dispara, la dispare una tecla o un mando. Tu código habla de **saltar**, nunca de la barra espaciadora.Este código todavía no imprime nada.
use input::a_pie as pie
fn _ready() void {
pie.enable(0)
}
fn _process(_delta: float) void {
direccion : float = pie.mover.value()4 · Preguntar en cada framevalue() lee el valor de la acción en este momento: 1 con D, -1 con A y 0 si no pulsas nada. if direccion != 0.0 {
print(direccion)
}
}Este código todavía no imprime nada.
use input::a_pie as pie
fn _ready() void {
pie.enable(0)
EnhancedInput.inject_input_for_action(pie.saltar, true)5 · Pulsar desde el códigoinject_input_for_action pulsa la acción como si fuera el jugador. Sirve para probar el código sin teclado, para demos y para una IA.}
on pie.saltar.triggered() {
print("¡salto!")
}¡salto!
“Saltar” no es “la barra espaciadora”. Es la barra, o el botón A del mando, o un toque en la pantalla, y el jugador puede querer cambiarlo. Si tu código pregunta por teclas, cada uno de esos cambios es un cambio en el código.
Por eso, en Gobu tu código no habla de teclas: habla de acciones, lo que el jugador quiere hacer. Qué tecla hace cada acción se decide aparte. El sistema que lo hace se llama Enhanced Input, y sigue el mismo modelo que el de Unreal Engine.
Acciones y contextos
Se trabaja con dos tipos de archivo, que creas en el editor dentro de resources/:
-
Una acción (
.inputaction) es algo que hace el jugador: saltar, moverse, mirar. Tiene un tipo de valor:Tipo ( value_type)Valor Ejemplo VALUE_TYPE_BOOLboolSaltar, interactuar VALUE_TYPE_AXIS_1DfloatMoverse a izquierda y derecha, acelerar VALUE_TYPE_AXIS_2DVector2Moverse en un plano, mirar VALUE_TYPE_AXIS_3DVector3Volar -
Un contexto de mapeo (
.inputcontext) une teclas con acciones: la barra consaltar, las teclas A y D conmover. Un juego puede tener varios: a pie, conduciendo, en un menú.
Cada tecla del contexto puede llevar modificadores, que cambian su valor. Por ejemplo,
InputModifierNegate le cambia el signo: así, en la misma acción mover, D da 1 y A da -1.
Y una acción puede llevar disparadores (triggers), que deciden cuándo se dispara:
| Disparador | Se dispara |
|---|---|
Ninguno (es como InputTriggerDown) | Mientras se mantiene la tecla: en cada frame |
InputTriggerPressed | Una vez, al pulsar |
InputTriggerReleased | Una vez, al soltar |
InputTriggerHold | Tras mantenerla un rato |
En esta lección, el contexto a_pie.inputcontext tiene dos acciones: saltar (la barra, con
InputTriggerPressed) y mover (D, y A con InputModifierNegate), de tipo VALUE_TYPE_AXIS_1D.
Usar un contexto: use input::
module Jugador
use input::a_pie as pie
fn _ready() void { pie.enable(0) teclas : []String = pie.saltar.get_key_texts() print($"Pulsa [{teclas[0]}] para saltar")}use input::a_pie as pietrae el contexto del archivoa_pie.inputcontext.- Sus acciones son miembros suyos, con el nombre de su archivo:
saltar.inputactionespie.saltar. usesolo no activa el contexto: lo activaenable. El número es su prioridad.get_key_texts()da las teclas de una acción como texto. Si el jugador cambia la tecla, el aviso cambia solo.
Si escribes mal el nombre de una acción, Grost te avisa antes de ejecutar, con la lista de las
que hay: The mapping context has no action "brincar". Its actions: mover, saltar.
Reaccionar con on
Los eventos de una acción se conectan con on:
module Jugador
use input::a_pie as pie
fn _ready() void { pie.enable(0)}
on pie.saltar.triggered() { print("¡salto!")}
on pie.mover.triggered(valor: float) { print("me muevo ", valor)}
on pie.mover.completed() { print("me paro")}Este código no imprime nada hasta que pulsas algo. Al pulsar la barra sale ¡salto! una vez,
porque saltar tiene InputTriggerPressed. Mientras mantienes D sale me muevo 1.0 en cada
frame, porque mover no tiene disparadores. Y al soltar, me paro.
| Evento | Cuándo llega |
|---|---|
started | La tecla empieza a pulsarse |
ongoing | El disparador todavía decide (un Hold que aún no dura bastante) |
triggered | La acción se dispara |
completed | La acción deja de dispararse |
canceled | Terminó sin llegar a dispararse (un Hold soltado demasiado pronto) |
El bloque puede recibir hasta tres datos, en este orden: el valor (bool, float,
Vector2 o Vector3, según el tipo de la acción), los segundos desde started y los segundos
que lleva disparada. Pon solo los que uses.
Preguntar en cada frame
A veces es más sencillo preguntar que reaccionar. Para mover un personaje, por ejemplo, lees la
acción en _process:
module Jugador
use actor::Main as yo : Spatial2Duse input::a_pie as pie
VELOCIDAD :: 200.0
fn _ready() void { pie.enable(0)}
fn _process(delta: float) void { yo.position.x += pie.mover.value() * VELOCIDAD * delta if pie.saltar.is_triggered() { print("¡salto!") }}Main es el actor raíz de la escena. Con D pulsada, value() da 1 y el actor avanza 200 por
segundo hacia la derecha; con A, -1 y va hacia la izquierda; sin tocar nada, 0 y se queda quieto.
| En una acción | Da |
|---|---|
value() | Su valor ahora mismo |
is_triggered() | Si se dispara en este frame |
get_key_texts() | Sus teclas, como texto |
Cambiar de contexto
Cuando el juego se pausa o el jugador se sube a un coche, las teclas de andar tienen que dejar de funcionar. Para eso desactivas su contexto:
module Pausa
use input::a_pie as pie
fn pausar() void { pie.disable() print(pie.is_enabled())}
fn _ready() void { pie.enable(0) print(pie.is_enabled()) pausar()}| En un contexto | Hace |
|---|---|
enable(prioridad) | Lo activa |
disable() | Lo desactiva |
is_enabled() | Si está activo |
Con varios contextos activos a la vez, gana el de mayor prioridad: una tecla que usa para una de sus acciones no llega a los de prioridad menor.
¿Y los botones de los menús?
Los menús (Button, LineEdit…) siguen usando las acciones ui_* del motor, que no necesitas
tocar. Enhanced Input es para el juego.
Probar sin teclado
EnhancedInput puede pulsar una acción como si fuera el jugador. A esto se le llama
inyectar entrada:
module Demo
use input::a_pie as pie
async fn _ready() void { pie.enable(0) EnhancedInput.inject_input_for_action(pie.saltar, true) await sleep(1.0) EnhancedInput.start_continuous_input_injection_for_action(pie.mover, 1.0) await sleep(0.5) EnhancedInput.stop_continuous_input_injection_for_action(pie.mover)}
on pie.saltar.triggered() { print("¡salto!")}
on pie.mover.started() { print("empiezo a moverme")}
on pie.mover.completed() { print("me paro")}inject_input_for_action(accion, valor)la pulsa durante un frame.start_continuous_input_injection_for_action(accion, valor)la mantiene pulsada hasta que llamas astop_continuous_input_injection_for_action(accion).
Sirve para probar tu código sin tocar el teclado, para una demo que se juega sola o para una IA que maneja el mismo prefab que el jugador.
Hora de practicar
Con use input::a_pie as pie, ¿cómo llegas a la acción del archivo saltar.inputaction?
saltar.inputaction es pie.saltar.Completa el código: activa el contexto y reacciona cuando se dispara saltar.
use input::a_pie as pie
fn _ready() void {
pie.(0)
}
pie.saltar.triggered() {
print("¡salto!")
}use input::a_pie as pie
fn _ready() void {
pie.enable(0)
}
on pie.saltar.triggered() {
print("¡salto!")
}¿Qué hace use input::a_pie as pie por sí solo?
use solo trae el contexto para usarlo en el código. Hasta que llamas a enable, sus teclas no hacen nada._ready.Quieres que algo pase justo cuando el jugador **deja** de moverse. ¿Qué evento de la acción usas?
completed llega cuando la acción deja de dispararse. started es al empezar a pulsar, y triggered, mientras se dispara.