Ir al contenido
Descargar
El libro de Grost

Concurrencia

Mucha lógica de juego pasa a lo largo del tiempo: una cuenta atrás, un enemigo que patrulla, una luz que parpadea.

Podrías escribirla en _process, la función que el motor llama en cada frame, pero entonces necesitas variables de más para recordar por dónde vas (“¿estoy esperando? ¿cuánto? ¿qué paso toca ahora?”). Eso se llama una máquina de estados, y se vuelve tedioso enseguida.

En Grost la escribes como una función normal que se pausa y sigue más tarde: una corrutina. Este capítulo trata de las corrutinas y las herramientas que las rodean. Tener varias corriendo a la vez se llama concurrencia.

En un juego: una cuenta atrás de “3, 2, 1, ¡ya!” antes de empezar la carrera.

async fn intro() void {
print("3...")
await sleep(1.0)
print("2...")
await sleep(1.0)
print("go!")
}
  • await sleep(s) pausa la función s segundos de tiempo de juego; el resto del juego sigue corriendo.
  • await next_frame() pausa hasta el siguiente frame.
  • await también espera una señal (capítulo 7) u otra corrutina.
  • Una función que usa await tiene que declararse async fn.
async fn wait_two_frames() void {
await next_frame()
await next_frame()
print("two frames later")
}

En un juego: una luz empieza a parpadear cuando salta la alarma, y para cuando el jugador la apaga.

Llamar a una async fn sin await es un error. Para arrancarla y seguir adelante, usa spawn. Su valor es la tarea, de tipo GrostFunctionState: un asa para manejar la corrutina que está corriendo.

mut blink_task : GrostFunctionState = null
fn start_blinking() void {
blink_task = spawn blink()
}
fn stop_blinking() void {
if blink_task != null and blink_task.is_running() {
blink_task.cancel()
print(blink_task.is_canceled()) # true
}
}

Una tarea tiene:

MiembroQué hace
cancel()detiene la corrutina donde esté esperando
is_running()true mientras no ha terminado
is_canceled()true si se canceló
completed(result)señal: terminó, con su valor de retorno
canceledseñal: se canceló

await task espera su resultado (null si se canceló).

Cancelar una corrutina cancela primero las corrutinas que está esperando. Y cuando se libera un actor, se cancelan todas sus corrutinas: un enemigo que muere no deja su patrulla en marcha.

En un juego: una patrulla o una luz que parpadea, que siguen hasta que algo las detiene.

loop { } (capítulo 4) es la forma natural para algo que corre hasta que lo cancelan:

async fn blink() void {
defer { print("blink stopped") }
loop {
print("on")
await sleep(0.5)
print("off")
await sleep(0.5)
}
}

Cada await dentro del bucle es un punto donde cancel() puede detenerlo. También es lo que deja seguir al juego: un loop sin await y sin break lo congelaría.

En un juego: un icono de “alerta” aparece mientras el enemigo patrulla, y tiene que desaparecer termine como termine la patrulla.

defer { } ejecuta un bloque al salir del bloque que lo contiene, salga como salga:

mut log_text : String = ""
fn note(text: String) void {
log_text += text + " "
}
fn work() void {
defer { note("first defer") }
defer { note("second defer") }
note("body")
}

work() deja "body second defer first defer": varios defer se ejecutan del más interno (el último escrito) al primero. La salida puede ser el final del bloque, return, break, continue o una cancelación:

fn find(value: int) int {
defer { note("leaving find") }
if value > 0 {
return value * 10
}
return -1
}
  • El valor de return x se toma antes de que se ejecuten los defer.
  • Dentro de un defer no puede haber return, await, ni un break/continue que salga de él.

Por eso brilla en las corrutinas: en blink(), más arriba, el mensaje se imprime cuando se cancela la tarea o se libera su actor. La limpieza (ocultar un icono, soltar un bloqueo) va en un defer justo después de lo que deshace.

En un juego: un área que deja de vigilar en cuanto entra el primer cuerpo.

later f() llama a f al final del frame en lugar de ahora:

fn later_demo() void {
later note("b")
note("a")
}

log_text recibe primero "a" y "b" al final del frame. Así se cambia lo que la física no permite en mitad de una de sus señales, por ejemplo un área que deja de vigilar dentro de su propio body_entered:

use actor::Zone as area : Area2D
on area.body_entered(_body: Spatial2D) {
later area.set_monitoring(false) # no se permite dentro de la señal: después
}

destroy() no lo necesita: ya espera al final del frame, así que area.destroy() puede ir directamente en la señal.

En un juego: esperar a que llegue el jugador o a que pasen diez segundos, lo que ocurra antes; o cargar el mapa, los enemigos y la música, y seguir cuando estén todos.

race { } ejecuta cada línea como una rama, todas a la vez. La primera en terminar gana y las demás se cancelan:

async fn wait_for_player() void {
winner : String = race {
await arrive()
await countdown(10.0)
}
print($"first: {winner}")
}

sync { } espera a todas y da un Array con sus valores, en orden:

async fn load_level() void {
parts : Array = sync {
await load_part("map")
await load_part("enemies")
"music"
}
print(parts)
}
  • Cada línea es una rama. Lee las variables de alrededor, pero lo que asigna se queda dentro de la rama, y no puede declarar variables.
  • race { } da el valor de la ganadora, sin un tipo fijo: tómalo con as (race { ... } as int es un Option[int]). sync { } da un Array.

Las dos existen también como funciones que reciben una lista de tareas, callables o señales:

async fn load_with_functions() void {
# A list of callables can give anything: "as" checks what came.
first : String = (await race([load_part.bind("a"), countdown.bind(2.0)]) as String) ?? "nothing"
print(first)
all : Array = await sync([load_part.bind("b"), load_part.bind("c")])
print(all)
}
EscribesQué hace
async fn f() { await ... }Una función que puede pausarse
await sleep(1.0), await next_frame()Pausar un tiempo, o un frame
spawn f()Arrancar una corrutina sin esperarla; da su tarea
tarea.cancel()Detenerla donde espera
defer { }Ejecutar un bloque al salir del bloque actual
later f()Llamar a f al final del frame
race { } / sync { }La primera en terminar / todas
module Patrol
async fn intro() void {
print("3...")
await sleep(1.0)
print("2...")
await sleep(1.0)
print("go!")
}
async fn blink() void {
defer { print("blink stopped") }
loop {
print("on")
await sleep(0.5)
print("off")
await sleep(0.5)
}
}
mut blink_task : GrostFunctionState = null
fn start_blinking() void {
blink_task = spawn blink()
}
fn stop_blinking() void {
if blink_task != null and blink_task.is_running() {
blink_task.cancel()
print(blink_task.is_canceled()) # true
}
}
async fn wait_two_frames() void {
await next_frame()
await next_frame()
print("two frames later")
}
fn _ready() void {
spawn intro()
spawn wait_two_frames()
start_blinking()
stop_blinking()
}
module RaceDemo
signal player_arrived
signal tick
async fn arrive() String {
await player_arrived
return "player"
}
async fn countdown(seconds: float) String {
await sleep(seconds)
return "timeout"
}
async fn load_part(part: String) String {
await tick
return part
}
async fn wait_for_player() void {
winner : String = race {
await arrive()
await countdown(10.0)
}
print($"first: {winner}")
}
async fn load_level() void {
parts : Array = sync {
await load_part("map")
await load_part("enemies")
"music"
}
print(parts)
}
async fn load_with_functions() void {
# A list of callables can give anything: "as" checks what came.
first : String = (await race([load_part.bind("a"), countdown.bind(2.0)]) as String) ?? "nothing"
print(first)
all : Array = await sync([load_part.bind("b"), load_part.bind("c")])
print(all)
}
fn _ready() void {
spawn wait_for_player()
spawn load_level()
spawn load_with_functions()
emit player_arrived()
emit tick()
}