Esperar y repetir
async fn cuenta_atras() void {
print("3")
await sleep(1.0)1 · Una función que esperaawait sleep(1.0) pausa la función durante un segundo de juego. Una función que usa await se declara con async fn. print("2")
await sleep(1.0)
print("1")
}Este código todavía no imprime nada.
async fn cuenta_atras() void {
print("3")
await sleep(1.0)
print("2")
await sleep(1.0)
print("1")
}
fn _ready() void {
spawn cuenta_atras()2 · Arrancarla con spawnspawn arranca la función y sigue adelante sin esperarla. Los números salen con un segundo de diferencia.}3 2 1
async fn patrullar() void {
loop {
print("izquierda")
await sleep(1.0)
print("derecha")
await sleep(1.0)3 · Repetir para siempreUn loop con await dentro no congela el juego: mientras espera, todo lo demás sigue. Esta patrulla va y viene sin fin. }
}Este código todavía no imprime nada.
async fn patrullar() void {
loop {
print("izquierda")
await sleep(1.0)
print("derecha")
await sleep(1.0)
}
}
async fn _ready() void {
tarea : GrostFunctionState = spawn patrullar()
await sleep(2.5)
tarea.cancel()4 · Pararla con cancelspawn te da la **tarea** que acaba de arrancar. Con cancel() la paras justo donde está esperando.}izquierda derecha izquierda
async fn patrullar() void {
defer { print("fin de la patrulla") }5 · Recoger al salir: deferdefer guarda un bloque para cuando la función termine, también si la cancelan. Es el sitio para recoger lo que deja a medias. loop {
print("izquierda")
await sleep(1.0)
print("derecha")
await sleep(1.0)
}
}
async fn _ready() void {
tarea : GrostFunctionState = spawn patrullar()
await sleep(2.5)
tarea.cancel()
}izquierda derecha izquierda fin de la patrulla
Mucho de lo que pasa en un juego dura un rato: una cuenta atrás antes de la carrera, un guardia
que va y viene, un escudo que dura dos segundos. Con lo que sabes hasta ahora, tendrías que llevar
la cuenta del tiempo en _process, frame a frame.
En Grost hay una forma más sencilla: escribir una función que se pausa donde haga falta y luego sigue. Se llama corrutina, y en esta lección aprendes a crearlas, a repetirlas y a pararlas.
Una función que espera
module CuentaAtras
async fn cuenta_atras() void { print("3...") await sleep(1.0) print("2...") await sleep(1.0) print("1...") await sleep(1.0) print("¡Ya!")}
fn _ready() void { spawn cuenta_atras()}Cada línea sale un segundo después de la anterior:
await sleep(1.0)pausa la función durante 1 segundo de tiempo de juego. Mientras tanto, el resto del juego sigue: los personajes se mueven y la música suena.- Una función que usa
awaites una corrutina, y se declara conasync fnen vez defn. Si se te olvida elasync, Grost te avisa antes de ejecutar nada. spawnarranca la corrutina. Lo ves con más detalle en la sección siguiente.
| Escribes | Espera |
|---|---|
await sleep(1.5) | Un segundo y medio |
await next_frame() | Hasta el siguiente frame |
spawn o await: arrancar o esperar
Una corrutina no se llama como una función normal. Si lo intentas, Grost te para:
module SinSpawn
async fn esperar() void { await sleep(1.0)}
fn _ready() void { esperar()}Tienes dos formas de llamarla:
spawn cuenta_atras()la arranca y sigue con la línea siguiente, sin esperar a que termine.await cuenta_atras()espera a que termine. Como espera, solo se puede usar dentro de otraasync fn.
Fíjate en el orden en que sale todo con spawn:
module Orden
async fn cuenta_atras() void { print("3...") await sleep(1.0) print("2...") await sleep(1.0) print("1...")}
fn _ready() void { spawn cuenta_atras() print("la música ya suena")}spawn ejecuta la corrutina hasta su primer await. Ahí se pausa, y _ready sigue con su
siguiente línea. Un segundo después, la cuenta atrás continúa donde se quedó.
Con await, en cambio, _ready espera a que acabe la cuenta. Para eso _ready también tiene
que ser async fn, y puede serlo:
module Esperar
async fn cuenta_atras() void { print("3...") await sleep(1.0) print("2...") await sleep(1.0) print("1...")}
async fn _ready() void { await cuenta_atras() print("¡Ya!")}Repetir para siempre: una patrulla
Un guardia que va de un lado a otro no termina nunca. Para eso está loop, el bucle sin fin que
viste en el módulo 1:
module Patrulla
async fn patrullar() void { loop { print("hacia la izquierda") await sleep(1.5) print("hacia la derecha") await sleep(1.5) }}
fn _ready() void { spawn patrullar()}En el juego, la patrulla sigue mientras el actor exista; aquí ves sus primeros segundos.
Parar una tarea
spawn te da algo a cambio: la tarea que acaba de arrancar, de tipo GrostFunctionState.
Guárdala en una variable y podrás pararla más tarde. Aquí el guardia deja de patrullar cuando
ve al jugador:
module Guardia
mut patrulla : GrostFunctionState = null
async fn patrullar() void { loop { print("izquierda") await sleep(1.0) print("derecha") await sleep(1.0) }}
async fn _ready() void { patrulla = spawn patrullar() await sleep(2.5) ver_al_jugador()}
fn ver_al_jugador() void { patrulla.cancel() print("¡Alto ahí!") print(patrulla.is_running())}null quiere decir “nada todavía”: al empezar no hay ninguna tarea guardada.
| En una tarea | Qué hace |
|---|---|
cancel() | La para justo donde está esperando |
is_running() | true mientras no ha terminado |
is_canceled() | true si la cancelaron |
Recoger al salir: defer
A veces una corrutina deja algo a medias que hay que deshacer: un escudo que hay que quitar, un
icono que hay que esconder. defer { } guarda un bloque que se ejecuta al salir del bloque
donde está, salga como salga:
module Escudo
mut escudo : bool = false
async fn escudo_temporal() void { escudo = true print("escudo puesto") defer { escudo = false print("escudo quitado") } await sleep(2.0) print("se acabó el tiempo")}
fn _ready() void { spawn escudo_temporal()}- El
deferno se ejecuta donde está escrito, sino al final: después dese acabó el tiempo. - Se ejecuta igual si la función sale con
returno si cancelan la tarea. Si un golpe cancela el escudo a mitad,escudovuelve afalsede todas formas. - Ponlo justo después de lo que deshace. Así, al leer el código, ves juntas las dos mitades.
¿Y si escribo varios defer?
Se ejecutan todos, del último que escribiste al primero.
Al final del frame: later
later f() llama a f al final del frame, en vez de ahora mismo:
module Despues
fn decir(texto: String) void { print(texto)}
fn _ready() void { later decir("b") print("a")}Sirve para cambios que el motor no permite en mitad de algo. Por ejemplo, un área no puede dejar
de vigilar dentro de su propia señal body_entered: con later el cambio se hace justo después.
Para borrar un actor no lo necesitas: destroy() ya espera al final del frame.
Hora de practicar
¿Qué imprime este código?
async fn avisar() void {
print("a")
await sleep(1.0)
print("b")
}
fn _ready() void {
spawn avisar()
print("c")
}a. En el await la función se pausa y _ready sigue con c. Un segundo después sale b.spawn ejecuta la función hasta su primer await y entonces vuelve a _ready.Completa el código para que salude medio segundo después de empezar.
¡Hola!
fn saludar_luego() void {
sleep(0.5)
print("¡Hola!")
}
fn _ready() void {
saludar_luego()
}fn. Dentro, otra palabra pausa. En _ready, una tercera la arranca sin esperarla.async fn saludar_luego() void {
await sleep(0.5)
print("¡Hola!")
}
fn _ready() void {
spawn saludar_luego()
}¿Qué imprime este código?
async fn luz() void {
defer { print("apagada") }
loop {
print("encendida")
await sleep(1.0)
}
}
async fn _ready() void {
tarea : GrostFunctionState = spawn luz()
await sleep(1.5)
tarea.cancel()
}cancel() la para, y su defer imprime apagada.defer cuando cancelas.¿Cuándo se ejecuta un bloque defer { }?
defer se ejecuta al salir de su bloque, también con return o si cancelan la tarea. later es otra cosa: llama a una función al final del frame.