Ir al contenido
Descargar
Curso de Grost

Señales

Módulo 3 · Grost en el juegoLección 13 de 209 min de lectura4 retos
main.groPaso 1 de 4
signal golpeado(danio: int)1 · Declarar una señalUna señal es un aviso que un script lanza cuando pasa algo. Esta se llama golpeado y lleva un dato: cuánto daño.
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
signal golpeado(danio: int)

fn _ready() void {
  emit golpeado(1)2 · Emitirlaemit lanza la señal con su dato. Todavía no pasa nada visible: nadie está escuchando.}
Output

Este código todavía no imprime nada.

main.groPaso 3 de 4
signal golpeado(danio: int)

on self.golpeado(danio: int) {
  print($"¡Ay! {danio} de daño")
}3 · Reaccionar con onon self.golpeado conecta un bloque a la señal. Se ejecuta cada vez que alguien la emite, y recibe el mismo dato.
fn _ready() void {
  emit golpeado(1)
}
Output
¡Ay! 1 de daño
main.groPaso 4 de 4
use actor::Mecha as mecha : Timer

on mecha.timeout() {4 · La señal de otro actorLos actores de la escena también tienen señales. Mecha es un Timer: cuando acaba su cuenta emite timeout, y este bloque reacciona.  print("¡Boom!")
}
Output
¡Boom!
También con las flechas ← →

Gobi recibe un golpe. La barra de vida tiene que bajar, la pantalla parpadear y sonar un quejido. ¿Tiene que saber el código de Gobi todo eso? Mejor que no: Gobi solo avisa “me han golpeado”, y cada parte del juego que esté interesada reacciona a su manera.

Ese aviso es una señal. Quien la envía no necesita saber quién la escucha.

Declarar y emitir

main.gro
module Gobi
signal golpeado(danio: int)
signal derrotado
fn recibir_golpe(danio: int) void {
emit golpeado(danio)
}
fn _ready() void {
recibir_golpe(1)
derrotado.emit()
}
  • signal golpeado(danio: int) declara una señal que lleva un dato. signal derrotado declara una sin datos.
  • emit golpeado(danio) la emite: la lanza para que la oiga quien escuche.
  • derrotado.emit() hace lo mismo, escrito de otra forma.

Este código no imprime nada. Emitir una señal que nadie escucha no es un error: simplemente no pasa nada.

Reaccionar con on

Para hacer algo cuando llega una señal, escribe un bloque on:

main.gro
module Gobi
signal golpeado(danio: int)
signal derrotado
mut vidas : int = 3
on self.golpeado(danio: int) {
vidas -= danio
print($"¡Ay! Vidas: {vidas}")
if vidas <= 0 {
emit derrotado()
}
}
on self.derrotado() {
print("Fin de la partida")
}
fn _ready() void {
emit golpeado(1)
emit golpeado(2)
}
Output¡Ay! Vidas: 2 ¡Ay! Vidas: 0 Fin de la partida
ParteQué es
onConecta un bloque a una señal
selfDe quién es la señal: self es este mismo script
.golpeadoQué señal
(danio: int)Los datos que trae, con los mismos tipos que en signal
{ ... }Lo que se hace cada vez que llega

El bloque se ejecuta en el mismo momento del emit. Por eso un on puede emitir otra señal, como aquí derrotado, y la cadena sigue.

Solo la primera vez: once

A veces un bloque solo debe ejecutarse la primera vez que llega una señal: el primer golpe, una moneda que se recoge. Escribe once en vez de on:

main.gro
module Gobi
signal hit(damage: int)
on self.hit(damage: int) {
print("Hit: ", damage)
}
once self.hit(_damage: int) {
print("First blood!")
}
fn _ready() void {
emit hit(1)
emit hit(2)
}
OutputHit: 1 First blood! Hit: 2

El bloque on se ejecuta con cada emit; el once, solo con el primero. Aunque la señal se emita dos veces en el mismo frame (dos cuerpos que tocan una moneda a la vez), once se ejecuta una sola vez.

Señales de los actores de la escena

Los actores del motor ya traen sus propias señales. En esta escena hay un actor Mecha de tipo Timer, preparado para contar un segundo. Cuando termina, emite timeout:

main.gro
module Nivel
use actor::Mecha as mecha : Timer
fn _ready() void {
print("Mecha encendida...")
}
on mecha.timeout() {
print("¡Boom!")
}
OutputMecha encendida... ¡Boom!

Se escribe igual que con self, pero delante del punto va el alias que trajiste con use actor::. Algunas señales que usarás a menudo:

ActorSeñalCuándo se emite
Timertimeout()Al terminar su cuenta
Buttonpressed()Al pulsarlo
Area2Dbody_entered(body)Cuando un cuerpo entra en su zona, por ejemplo Gobi en una moneda
¿Puedo poner una variable delante del punto?

No. Si escribes on enemigo.murio() con mut enemigo : Spatial2D, Grost da un error antes de ejecutar. El objetivo de un on tiene que ser self, un alias de use actor:: o un objeto global del motor, como GameMode.

Señales de tus prefabs

Tus prefabs también pueden emitir sus propias señales. Este es el código de Bomba.prefab: una cuenta atrás de dos segundos, como las de la lección “Cada frame”, que al terminar emite exploto y quita la bomba de la escena.

Bomba.prefab
module Bomba
use actor::Bomba as bomba : Spatial2D
signal exploto(danio: int)
mut cuenta_atras : float = 2.0
fn _ready() void {
print("Bomba: tic, tac...")
}
fn _process(delta: float) void {
cuenta_atras -= delta
if cuenta_atras <= 0.0 {
emit exploto(25)
bomba.destroy()
}
}
OutputBomba: tic, tac...

bomba.destroy() quita la bomba de la escena al final del frame. Ahora, un nivel que tiene una bomba como hija la escucha igual que al Timer:

main.gro
module Nivel
use actor::Bomba as bomba : Spatial2D
fn _ready() void {
print("Nivel listo")
}
on bomba.exploto(danio: int) {
print($"¡Boom! La bomba hace {danio} de daño")
}
OutputBomba: tic, tac... Nivel listo ¡Boom! La bomba hace 25 de daño

La bomba no sabe que el nivel la escucha: solo emite. Fíjate también en el orden: el _ready de la bomba, que es hija del nivel, va antes que el del nivel.

¿Y si la bomba la crea el código con instantiate()?

Entonces no está en la escena al empezar y no puedes traerla con use actor::. Para eso existe on await bomba.exploto(danio: int) { }: aquí bomba es la etiqueta del prefab (el nombre de su module), y la conexión se hace en cuanto aparece una en el juego.

Esperar una señal

A veces no quieres reaccionar cada vez, sino quedarte esperando en un punto de una función hasta que llegue la señal. Eso es await:

main.gro
module Nivel
use actor::Mecha as mecha : Timer
async fn cuenta_atras() void {
print("Mecha encendida...")
await mecha.timeout
print("¡Boom!")
}
fn _ready() void {
spawn cuenta_atras()
}
OutputMecha encendida... ¡Boom!
  • await mecha.timeout detiene la función ahí hasta que la mecha emite timeout. Mientras tanto, el resto del juego sigue.
  • Una función que usa await se declara async fn.
  • spawn la arranca y sigue adelante sin esperarla.
¿Y connect()?

El connect() del motor también funciona, pero on es más corto y Grost lo comprueba antes de ejecutar.

Hora de practicar

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

¿Qué imprime este código?

main.gro
signal sumar(n: int)

mut total : int = 0

on self.sumar(n: int) {
  total += n
}

fn _ready() void {
  emit sumar(2)
  emit sumar(3)
  print(total)
}
Cada emit ejecuta el bloque on en ese mismo momento: primero suma 2 y luego 3. Cuando llega el print, total vale 5.
El bloque on se ejecuta una vez por cada emit, en el momento en que se emite.
Reto 2 de 4sin resolver

Completa el código: declara la señal, reacciona a ella y emítela.

Salida esperada
¡La puerta se abre!
main.gro
 abierta

 self.abierta() {
  print("¡La puerta se abre!")
}

fn _ready() void {
   abierta()
}
Son tres palabras: la que declara la señal, la que conecta un bloque y la que la lanza.
Solución:
main.gro
signal abierta

on self.abierta() {
  print("¡La puerta se abre!")
}

fn _ready() void {
  emit abierta()
}
Reto 3 de 4sin resolver

Quieres reaccionar a la señal timeout de un actor Reloj de tu escena. ¿Qué línea necesitas antes de escribir on reloj.timeout() { ... }?

El objetivo de un on tiene que ser self, un alias de use actor:: o un objeto global del motor, como GameMode. Con una variable como mut reloj, Grost da un error.
Primero tienes que traer el actor a tu código.
Reto 4 de 4sin resolver

¿Qué necesita una función para poder usar await dentro?

Una función que espera con await se declara async fn, y se arranca con spawn.
Hay una palabra que va delante de fn.