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.
async fn y await
Sección titulada «async fn y await»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ónssegundos de tiempo de juego; el resto del juego sigue corriendo.await next_frame()pausa hasta el siguiente frame.awaittambién espera una señal (capítulo 7) u otra corrutina.- Una función que usa
awaittiene que declararseasync fn.
async fn wait_two_frames() void { await next_frame() await next_frame() print("two frames later")}spawn y tareas
Sección titulada «spawn y tareas»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:
| Miembro | Qué 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 |
canceled | señ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.
Corrutinas infinitas con loop
Sección titulada «Corrutinas infinitas con loop»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 xse toma antes de que se ejecuten losdefer. - Dentro de un
deferno puede haberreturn,await, ni unbreak/continueque 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.
race y sync
Sección titulada «race y sync»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 conas(race { ... } as intes unOption[int]).sync { }da unArray.
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)}Los ejemplos completos
Sección titulada «Los ejemplos completos»| Escribes | Qué 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_arrivedsignal 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()}