Ir al contenido
Descargar
El libro de Grost

Estado reactivo

En un juego, mucho código existe solo para darse cuenta de que un valor cambió. Cuando baja el hp (los puntos de vida) del jugador, la barra de vida tiene que encogerse. Cuando llega a cero, tiene que aparecer “game over”.

Podrías comprobar el valor en cada frame. Funciona, pero es un desperdicio y es fácil equivocarse: te olvidas de una comprobación y la barra muestra un número viejo. Grost deja que el propio valor avise cuando cambia, y tu código reacciona. Eso es el estado reactivo.

En un juego: la vida, las monedas o la puntuación son valores que otras partes del juego (el HUD, las reglas) tienen que seguir.

live hp : int = 100
live shield : int = 50

Una variable live es una variable normal que además avisa de sus cambios. Por debajo emite una señal (capítulo 7) llamada <nombre>_changed: para hp, es hp_changed.

El aviso solo ocurre cuando escribes con set:

fn take_damage(amount: int) void {
set hp -= amount
}
fn heal() void {
set hp = 100
}
  • set hp -= amount y set hp = 100 cambian el valor y avisan.
  • Un hp = 100 a secas cambia el valor sin decírselo a nadie.

Como es una señal de verdad, también puedes conectarte a ella con on, como en el capítulo 7:

live hp : int = 100
on self.hp_changed(value: int) {
print($"ahora hp vale {value}")
}
fn _ready() void {
set hp = 40
}

Esto imprime ahora hp vale 40. Aun así, casi siempre watch es más corto.

En un juego: redibujar la barra de vida cada vez que cambia hp, o hacer parpadear la pantalla cuando golpean al jugador.

watch ejecuta un bloque cada vez que cambia una variable live, y le da el valor nuevo:

watch hp(value: int) {
print($"hp: {value}")
}
watch hp(_value: int) {
print("flash the health bar")
}
@onready
watch shield(value: int) {
print($"shield: {value}")
}
  • Puedes tener varios bloques watch para la misma variable; se ejecutan todos.
  • @onready watch además se ejecuta una vez al empezar (en _ready) con el valor inicial. Es lo que conviene para una interfaz que tiene que mostrar el valor desde el primer frame.
  • Un parámetro que no usas empieza por _, como _value.

Así funciona @onready:

live monedas : int = 0
@onready
watch monedas(value: int) {
print($"monedas: {value}")
}
fn _ready() void {
set monedas += 5
}

Imprime monedas: 0 al empezar el script, antes del código de _ready, y monedas: 5 después del set. Sin @onready, solo saldría monedas: 5.

En un juego: la protección total es la vida más el escudo, y el jugador sigue vivo mientras la vida sea mayor que cero. No quieres actualizar eso a mano.

Un valor derivado se calcula a partir de otros valores live y se recalcula solo cuando cambian:

live total : int => hp + shield
live alive : bool => hp > 0
watch total(value: int) {
print($"total: {value}")
}

live total : int => hp + shield usa => en lugar de =. Léelo como “total siempre vale hp + shield”.

  • Se puede observar con watch como cualquier variable live.
  • No se puede asignar: su valor sale siempre de la expresión. set total = 5 es un error.

En un juego: mostrar “game over” la primera vez que la vida llega a cero, o desbloquear un logro una sola vez.

upon ejecuta un bloque una vez, la primera vez que una condición se cumple:

upon not alive {
print("game over")
}
upon total >= 200 {
print("overcharged!")
}
  • La condición se vuelve a comprobar solo cuando cambian los valores live que lee.
  • Después de ejecutarse, el bloque no vuelve a correr, aunque la condición deje de cumplirse y se cumpla otra vez.
  • Si la condición ya se cumple cuando empieza el script, el bloque se ejecuta enseguida.

En un juego: cuando el jugador reaparece, la vida y el escudo se rellenan a la vez. El HUD no debería ver un estado a medias, con la vida llena pero el escudo viejo.

A veces cambias varios valores a la vez y solo te importa el resultado final. Dentro de batch { }, cada variable live avisa una sola vez, al final:

fn respawn() void {
batch {
set hp = 100
set shield = 50
}
}

Sin batch, total se recalcularía (y sus watch se ejecutarían) después de cada set: primero con el hp nuevo y el shield viejo, y luego con los dos. Con batch, los watch solo ven los valores finales.

Todo lo del capítulo, de un vistazo:

EscribesQué hace
live hp : int = 100Una variable que avisa de sus cambios
set hp -= 10La cambia y avisa
watch hp(value: int) { }Ejecuta un bloque en cada cambio
@onready watch ...Además se ejecuta una vez al empezar, con el valor inicial
live total : int => hp + shieldUn valor derivado, siempre al día
upon hp <= 0 { }Ejecuta un bloque una vez, la primera vez que se cumple
batch { }Cada variable avisa una sola vez, al final

Y el ejemplo, entero:

module Stats
live hp : int = 100
live shield : int = 50
watch hp(value: int) {
print($"hp: {value}")
}
watch hp(_value: int) {
print("flash the health bar")
}
@onready
watch shield(value: int) {
print($"shield: {value}")
}
live total : int => hp + shield
live alive : bool => hp > 0
watch total(value: int) {
print($"total: {value}")
}
upon not alive {
print("game over")
}
upon total >= 200 {
print("overcharged!")
}
fn take_damage(amount: int) void {
set hp -= amount
}
fn heal() void {
set hp = 100
}
fn respawn() void {
batch {
set hp = 100
set shield = 50
}
}
fn _ready() void {
take_damage(30)
heal()
respawn()
}