Ir al contenido
Descargar
Curso de Grost

Controles: acciones, no teclas

Módulo 4 · Herramientas de juegoLección 19 de 2010 min de lectura4 retos
main.groPaso 1 de 5
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.
Output

Este código todavía no imprime nada.

main.groPaso 2 de 5
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.}
Output

Este código todavía no imprime nada.

main.groPaso 3 de 5
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.
Output

Este código todavía no imprime nada.

main.groPaso 4 de 5
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)
  }
}
Output

Este código todavía no imprime nada.

main.groPaso 5 de 5
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!")
}
Output
¡salto!
También con las flechas ← →

“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)ValorEjemplo
    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 con saltar, las teclas A y D con mover. 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:

DisparadorSe dispara
Ninguno (es como InputTriggerDown)Mientras se mantiene la tecla: en cada frame
InputTriggerPressedUna vez, al pulsar
InputTriggerReleasedUna vez, al soltar
InputTriggerHoldTras 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::

main.gro
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")
}
OutputPulsa [Space] para saltar
  • use input::a_pie as pie trae el contexto del archivo a_pie.inputcontext.
  • Sus acciones son miembros suyos, con el nombre de su archivo: saltar.inputaction es pie.saltar.
  • use solo no activa el contexto: lo activa enable. 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:

main.gro
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.

EventoCuándo llega
startedLa tecla empieza a pulsarse
ongoingEl disparador todavía decide (un Hold que aún no dura bastante)
triggeredLa acción se dispara
completedLa acción deja de dispararse
canceledTerminó 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:

main.gro
module Jugador
use actor::Main as yo : Spatial2D
use 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ónDa
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:

main.gro
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()
}
Outputtrue false
En un contextoHace
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:

main.gro
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")
}
Output¡salto! empiezo a moverme 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 a stop_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

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

Con use input::a_pie as pie, ¿cómo llegas a la acción del archivo saltar.inputaction?

Las acciones de un contexto se usan como miembros suyos, por el nombre de su archivo: saltar.inputaction es pie.saltar.
Las acciones son miembros del contexto, con el nombre de su archivo.
Reto 2 de 4sin resolver

Completa el código: activa el contexto y reacciona cuando se dispara saltar.

main.gro
use input::a_pie as pie

fn _ready() void {
  pie.(0)
}

 pie.saltar.triggered() {
  print("¡salto!")
}
El primer hueco activa el contexto con una prioridad. El segundo conecta un bloque a un evento, como con las señales.
Solución:
main.gro
use input::a_pie as pie

fn _ready() void {
  pie.enable(0)
}

on pie.saltar.triggered() {
  print("¡salto!")
}
Reto 3 de 4sin resolver

¿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.
En la lección hacía falta una línea más en _ready.
Reto 4 de 4sin resolver

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.
Busca el evento que llega cuando la acción deja de dispararse.