Estado reactivo
live vidas : int = 31 · Una variable livelive declara una variable que avisa cuando cambia. Por lo demás, es una variable como cualquier otra.Este código todavía no imprime nada.
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)
}2
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
}Vidas: 2 Vidas: 1
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
}Fin de la partida
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
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}live vidas : int = 3es una variable normal que además anuncia sus cambios.set vidas -= 1la cambia y avisa: elwatchimprimeVidas: 2.vidas = 0, sinset, también la cambia (elprintmuestra 0), pero sin avisar a nadie: elwatchno se entera.set vidas = 5vuelve 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:
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}- Al cambiar
monedas, se ejecutan los dos bloques, en el orden en que están escritos. @onreadydelante hace que esewatchse 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
watchno 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:
module Defensa
live vidas : int = 3live escudo : int = 2live total : int => vidas + escudo
fn _ready() void { print(total) set escudo = 0 print(total)}Lo que no puedes es asignarlo: su valor sale siempre de la expresión.
module Derivado
live vidas : int = 3live vivo : bool => vidas > 0
fn _ready() void { set vivo = false}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.
module Fin
live vidas : int = 2live 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}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:
module Reloj
live segundos : int = 0mut 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 }}_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
¿Qué imprime este código?
live monedas : int = 0
watch monedas(valor: int) {
print(valor)
}
fn _ready() void {
set monedas += 1
monedas += 1
set monedas += 1
}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.set y cuál no.Completa el código para que el mensaje salga cada vez que cambian las vidas.
Vidas: 2
vidas : int = 3
vidas(valor: int) {
print($"Vidas: {valor}")
}
fn _ready() void {
vidas -= 1
}live vidas : int = 3
watch vidas(valor: int) {
print($"Vidas: {valor}")
}
fn _ready() void {
set vidas -= 1
}Con live vivo : bool => vidas > 0, ¿qué pasa si escribes set vivo = false?
=>: ¿de dónde sale el valor de vivo?¿Qué imprime este código?
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.