Ir al contenido
Descargar
El libro de Grost

Interfaces

El jugador recoge una moneda y el HUD muestra la cuenta. Son dos documentos (los archivos de tu juego que tienen su propio código, como un .prefab o un .uip) compartiendo un valor.

Podrían buscarse el uno al otro y pasarse el número, pero entonces el HUD depende del jugador y el jugador del HUD: cambias uno y se rompe el otro. Una interfaz es un bloque de datos (y funciones) compartido que ambos usan sin saber nada el uno del otro.

Una interfaz vive en su propio archivo, así que los ejemplos de este capítulo están escritos aquí mismo.

En un juego: un solo sitio para lo que necesitan varios documentos, como las monedas, los corazones o la puntuación.

Cada interfaz va en su propio archivo llamado <nombre>.iface.gro. El nombre escrito dentro del archivo es el que cuenta.

interface coins global {
live coins : int = 0
}

global significa que hay una única instancia (una copia de los datos) compartida para todo el juego.

Sin global, hay una instancia por actor dueño, el actor cuyo código la usa. Cada enemigo tiene sus propios datos:

interface enemy_stats {
live health : int = 50
mut score : int = 0
fn add_score(points: int) void { score += points }
}

Los campos se declaran como cualquier variable, las funciones como cualquier función, y los setters funcionan igual que siempre (el código que se ejecuta cuando un valor se escribe con set, capítulo 3):

interface player_stats global {
live health : int = 100 { set(value): field = clamp(value, 0, 100) }
fn apply_damage(value: int) void { set health -= value }
}

Aquí el setter mantiene health entre 0 y 100, la cambie quien la cambie:

use interface::player_stats as stats
fn _ready() void {
stats.apply_damage(300)
print(stats.health) # 0, no -200
}

Con player, hay una instancia por jugador de la partida (el PlayerState de Unreal): el código del personaje recibe la de su jugador, y cualquier otro script (el HUD) la del jugador local. Dura lo que dura el jugador, no su personaje, así que se conserva cuando el personaje muere y reaparece:

interface marcador player {
live puntos : int = 0
mut equipo : int = 0
}

InterfacesManager.marcador.get_all() devuelve { id del jugador : instancia }, la de cada jugador, para una tabla de resultados. En una partida online sus campos @replicated los decide el servidor y los recibe cada jugador, como los de una interfaz global (el GameState de Unreal); ver Juegos online.

En un juego: el jugador suma monedas, el HUD las muestra, y ninguno tiene que buscar al otro.

Un script la importa con use interface:: (capítulo 6):

use interface::coins as icoins
use actor::Coins as coins_label : Label
@onready watch icoins.coins(value: int) { # también se ejecuta una vez al empezar
coins_label.text = str(value)
}
fn collect_coin() void {
icoins.coins += 1
}
  • use interface::x as a enlaza el alias solo: a la instancia global, a la instancia propia de este actor si la interfaz es por instancia, o a la de su jugador si es una interfaz de jugador.
  • watch funciona sobre los campos de una interfaz igual que en el capítulo 8, y necesita que el campo sea live.
  • Desde otro script, un icoins.coins += 1 a secas ya avisa a quien observa. Dentro de las funciones de la propia interfaz, escribe set, como en el capítulo 8.

Así el jugador solo escribe icoins.coins += 1 y el HUD solo observa icoins.coins. Ninguno sabe que el otro existe.

En un juego: una pantalla de resultados que lista a todos los enemigos, o un botón de “partida nueva” que lo limpia todo.

Desde código sin use, a las interfaces se llega con InterfacesManager. Para una interfaz por instancia te da un manejador (un GrostInterfaceHandle) que llega a la instancia de cada actor:

inst : Shared = InterfacesManager.coins # instancia global
enemies : GrostInterfaceHandle = InterfacesManager.enemy_stats # una interfaz por instancia
stats : Shared = enemies.create(self) # por instancia: mismo dueño, misma instancia
all : Dictionary = enemies.get_all() # todas las instancias
InterfacesManager.clear() # las descarta todas

Para empezar de nuevo un nivel o una partida, llama a reset() en la interfaz: todas lo tienen, y sus variables vuelven a los valores con los que se declararon. Los observadores (watch, live) ven el cambio y cada script que usa la interfaz sigue con la misma instancia:

use interface::game_state as game
fn restart() void {
game.reset() # selected = 0, score = 0, lost = false...
SceneManager.restart()
}

Si la interfaz declara su propio fn reset(), se usa ese. En una interfaz por instancia, reset() reinicia solo la instancia de ese actor. Para reiniciar varias a la vez (las dos devuelven cuántas reiniciaron; _ = dice que no necesitas el número):

enemies : GrostInterfaceHandle = InterfacesManager.enemy_stats
_ = InterfacesManager.reset_all() # todas: las globales y las de cada actor
_ = enemies.reset_all() # las de cada actor de una interfaz

InterfacesManager.clear() descarta todas las instancias; se crean otras nuevas la próxima vez que se usan, pero los alias tomados antes siguen con las viejas. Mejor reset().