Ir al contenido
Descargar
Curso de Grost

Estado reactivo

Módulo 3 · Grost en el juegoLección 14 de 208 min de lectura4 retos
main.groPaso 1 de 4
live vidas : int = 31 · Una variable livelive declara una variable que avisa cuando cambia. Por lo demás, es una variable como cualquier otra.
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
live vidas : int = 3

fn _ready() void {
  set vidas -= 12 · Cambiarla con setPara que avise, cámbiala con set delante. set vidas -= 1 le resta uno y anuncia el cambio.  print(vidas)
}
Output
2
main.groPaso 3 de 4
live vidas : int = 3

watch vidas(valor: int) {
  print($"Vidas: {valor}")
}3 · Reaccionar con watchwatch ejecuta su bloque cada vez que vidas cambia, con el valor nuevo. Nadie tiene que llamarlo.
fn _ready() void {
  set vidas -= 1
  set vidas -= 1
}
Output
Vidas: 2
Vidas: 1
main.groPaso 4 de 4
live vidas : int = 1
live vivo : bool => vidas > 0

upon not vivo {4 · Un valor derivadovivo se calcula a partir de vidas y se recalcula solo. upon ejecuta su bloque una vez: la primera vez que su condición se cumple.  print("Fin de la partida")
}

fn _ready() void {
  set vidas -= 1
}
Output
Fin de la partida
También con las flechas ← →

En un juego, mucho código existe solo para darse cuenta de que algo cambió: actualizar el contador cuando coges una moneda, mostrar “Fin de la partida” cuando las vidas llegan a cero.

Podrías comprobarlo en cada frame con _process, pero es trabajo repetido y es fácil olvidarse de algún caso. En Grost, el propio valor puede avisar cuando cambia, y tú solo dices qué hacer entonces. A eso se le llama estado reactivo.

Variables que avisan: live y set

main.gro
module Vidas
live vidas : int = 3
watch vidas(valor: int) {
print($"Vidas: {valor}")
}
fn _ready() void {
set vidas -= 1
vidas = 0
print(vidas)
set vidas = 5
}
OutputVidas: 2 0 Vidas: 5
  • live vidas : int = 3 es una variable normal que además anuncia sus cambios.
  • set vidas -= 1 la cambia y avisa: el watch imprime Vidas: 2.
  • vidas = 0, sin set, también la cambia (el print muestra 0), pero sin avisar a nadie: el watch no se entera.
  • set vidas = 5 vuelve a avisar.

watch: reaccionar a un cambio

watch va fuera de las funciones, como un on, y recibe el valor nuevo cada vez que la variable cambia. Una variable puede tener varios:

main.gro
module Marcador
live monedas : int = 0
@onready watch monedas(valor: int) {
print($"Monedas: {valor}")
}
watch monedas(_valor: int) {
print("¡Tintín!")
}
fn _ready() void {
print("Listo")
set monedas += 1
}
OutputMonedas: 0 Listo Monedas: 1 ¡Tintín!
  • Al cambiar monedas, se ejecutan los dos bloques, en el orden en que están escritos.
  • @onready delante hace que ese watch se ejecute además una vez al empezar, con el valor inicial. Es justo lo que quieres para un marcador, que tiene que mostrar el 0 desde el principio.
  • El segundo watch no usa el valor, así que su parámetro empieza por _.
¿Y si quiero reaccionar a una variable sin live?

No se puede: Grost da un error si haces watch sobre una variable normal. El mensaje lo dice: only "live" variables can be observed. Cámbiala de mut a live.

Valores derivados

A veces un valor sale de otros: la defensa total es las vidas más el escudo. Un valor derivado se escribe con => en lugar de =, y se recalcula solo cuando cambian los valores live que usa:

main.gro
module Defensa
live vidas : int = 3
live escudo : int = 2
live total : int => vidas + escudo
fn _ready() void {
print(total)
set escudo = 0
print(total)
}
Output5 3

Lo que no puedes es asignarlo: su valor sale siempre de la expresión.

main.gro
module Derivado
live vidas : int = 3
live vivo : bool => vidas > 0
fn _ready() void {
set vivo = false
}
OutputParse Error: Cannot assign to "vivo": it is derived ("=>") and recomputes when the live values it uses change.

upon: una sola vez

watch reacciona a cada cambio. upon es para lo que tiene que pasar una sola vez: ejecuta su bloque la primera vez que su condición se cumple, y nunca más.

main.gro
module Fin
live vidas : int = 2
live vivo : bool => vidas > 0
upon not vivo {
print("Fin de la partida")
}
fn _ready() void {
set vidas -= 1
set vidas -= 1
set vidas = 3
set vidas = 0
}
OutputFin de la partida

vidas llega a 0 dos veces, pero el mensaje sale una sola. Grost vuelve a mirar la condición solo cuando cambian los valores live que lee: aquí, vivo.

Todo junto: un reloj de partida

Con _process de la lección “Cada frame” y estas piezas, un reloj que avisa cada segundo y termina la partida a los tres:

main.gro
module Reloj
live segundos : int = 0
mut tiempo : float = 0.0
watch segundos(valor: int) {
print($"Segundo {valor}")
}
upon segundos >= 3 {
print("¡Se acabó el tiempo!")
}
fn _ready() void {
print("¡Ya!")
}
fn _process(delta: float) void {
tiempo += delta
if tiempo >= 1.0 and segundos < 3 {
tiempo -= 1.0
set segundos += 1
}
}
Output¡Ya! Segundo 1 Segundo 2 Segundo 3 ¡Se acabó el tiempo!

_process solo cuenta el tiempo y cambia segundos. Lo que pasa después (el mensaje de cada segundo, el final) está en sus propios bloques, y puedes añadir más sin tocar _process.

Hora de practicar

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

¿Qué imprime este código?

main.gro
live monedas : int = 0

watch monedas(valor: int) {
  print(valor)
}

fn _ready() void {
  set monedas += 1
  monedas += 1
  set monedas += 1
}
La línea sin set cambia el valor a 2 sin avisar a nadie. El último set lo deja en 3 y avisa: el watch solo ve el 1 y el 3.
Fíjate en qué líneas llevan set y cuál no.
Reto 2 de 4sin resolver

Completa el código para que el mensaje salga cada vez que cambian las vidas.

Salida esperada
Vidas: 2
main.gro
 vidas : int = 3

 vidas(valor: int) {
  print($"Vidas: {valor}")
}

fn _ready() void {
   vidas -= 1
}
La variable tiene que avisar, alguien tiene que mirarla, y el cambio tiene que anunciarse.
Solución:
main.gro
live vidas : int = 3

watch vidas(valor: int) {
  print($"Vidas: {valor}")
}

fn _ready() void {
  set vidas -= 1
}
Reto 3 de 4sin resolver

Con live vivo : bool => vidas > 0, ¿qué pasa si escribes set vivo = false?

Un valor derivado sale siempre de su expresión. Asignarlo es un error que Grost detecta antes de ejecutar.
Mira el =>: ¿de dónde sale el valor de vivo?
Reto 4 de 4sin resolver

¿Qué imprime este código?

main.gro
live vidas : int = 1

upon vidas == 0 {
  print("¡Fuera!")
}

fn _ready() void {
  set vidas = 0
  set vidas = 1
  set vidas = 0
}
upon se ejecuta una sola vez, la primera vez que la condición se cumple. Aunque vidas vuelva a 0, no se repite.
upon no es lo mismo que watch.