Ir al contenido
Descargar
Curso de Grost

Esperar y repetir

Módulo 4 · Herramientas de juegoLección 16 de 209 min de lectura4 retos
main.groPaso 1 de 5
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")
}
Output

Este código todavía no imprime nada.

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

Este código todavía no imprime nada.

main.groPaso 4 de 5
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.}
Output
izquierda
derecha
izquierda
main.groPaso 5 de 5
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()
}
Output
izquierda
derecha
izquierda
fin de la patrulla
También con las flechas ← →

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

main.gro
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()
}
Output3... 2... 1... ¡Ya!

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 await es una corrutina, y se declara con async fn en vez de fn. Si se te olvida el async, Grost te avisa antes de ejecutar nada.
  • spawn arranca la corrutina. Lo ves con más detalle en la sección siguiente.
EscribesEspera
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:

main.gro
module SinSpawn
async fn esperar() void {
await sleep(1.0)
}
fn _ready() void {
esperar()
}
OutputParse Error: Function "esperar()" is a coroutine, so it must be called with "await" or "spawn".

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 otra async fn.

Fíjate en el orden en que sale todo con spawn:

main.gro
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")
}
Output3... la música ya suena 2... 1...

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:

main.gro
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!")
}
Output3... 2... 1... ¡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:

main.gro
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()
}
Outputhacia la izquierda hacia la derecha hacia la izquierda

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:

main.gro
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())
}
Outputizquierda derecha izquierda ¡Alto ahí! false

null quiere decir “nada todavía”: al empezar no hay ninguna tarea guardada.

En una tareaQué 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:

main.gro
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()
}
Outputescudo puesto se acabó el tiempo escudo quitado
  • El defer no se ejecuta donde está escrito, sino al final: después de se acabó el tiempo.
  • Se ejecuta igual si la función sale con return o si cancelan la tarea. Si un golpe cancela el escudo a mitad, escudo vuelve a false de 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:

main.gro
module Despues
fn decir(texto: String) void {
print(texto)
}
fn _ready() void {
later decir("b")
print("a")
}
Outputa b

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

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

¿Qué imprime este código?

main.gro
async fn avisar() void {
  print("a")
  await sleep(1.0)
  print("b")
}

fn _ready() void {
  spawn avisar()
  print("c")
}
Primero sale 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.
Reto 2 de 4sin resolver

Completa el código para que salude medio segundo después de empezar.

Salida esperada
¡Hola!
main.gro
 fn saludar_luego() void {
   sleep(0.5)
  print("¡Hola!")
}

fn _ready() void {
   saludar_luego()
}
La función espera, así que necesita una palabra delante de fn. Dentro, otra palabra pausa. En _ready, una tercera la arranca sin esperarla.
Solución:
main.gro
async fn saludar_luego() void {
  await sleep(0.5)
  print("¡Hola!")
}

fn _ready() void {
  spawn saludar_luego()
}
Reto 3 de 4sin resolver

¿Qué imprime este código?

main.gro
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()
}
Se enciende al empezar y otra vez al cabo de un segundo. A los 1,5 segundos cancel() la para, y su defer imprime apagada.
Cuenta cuántas veces da tiempo a encenderse antes del segundo y medio. Y recuerda qué hace defer cuando cancelas.
Reto 4 de 4sin resolver

¿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.
Piensa en el escudo de la lección: tenía que quitarse siempre.