Señales
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.Este código todavía no imprime nada.
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.}Este código todavía no imprime nada.
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)
}¡Ay! 1 de daño
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!")
}¡Boom!
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
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 derrotadodeclara 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:
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)}| Parte | Qué es |
|---|---|
on | Conecta un bloque a una señal |
self | De quién es la señal: self es este mismo script |
.golpeado | Qué 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:
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)}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:
module Nivel
use actor::Mecha as mecha : Timer
fn _ready() void { print("Mecha encendida...")}
on mecha.timeout() { print("¡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:
| Actor | Señal | Cuándo se emite |
|---|---|---|
Timer | timeout() | Al terminar su cuenta |
Button | pressed() | Al pulsarlo |
Area2D | body_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.
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() }}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:
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")}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:
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()}await mecha.timeoutdetiene la función ahí hasta que la mecha emitetimeout. Mientras tanto, el resto del juego sigue.- Una función que usa
awaitse declaraasync fn. spawnla 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
¿Qué imprime este código?
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)
}emit ejecuta el bloque on en ese mismo momento: primero suma 2 y luego 3. Cuando llega el print, total vale 5.on se ejecuta una vez por cada emit, en el momento en que se emite.Completa el código: declara la señal, reacciona a ella y emítela.
¡La puerta se abre!
abierta
self.abierta() {
print("¡La puerta se abre!")
}
fn _ready() void {
abierta()
}signal abierta
on self.abierta() {
print("¡La puerta se abre!")
}
fn _ready() void {
emit abierta()
}Quieres reaccionar a la señal timeout de un actor Reloj de tu escena. ¿Qué línea necesitas antes de escribir on reloj.timeout() { ... }?
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.¿Qué necesita una función para poder usar await dentro?
await se declara async fn, y se arranca con spawn.fn.