Ir al contenido
Descargar
Curso de Grost

Interfaces

Módulo 3 · Grost en el juegoLección 15 de 208 min de lectura4 retos
main.groPaso 1 de 4
interface tesoro global {
  live gemas : int = 01 · Un archivo para lo compartidoUna interfaz guarda datos que comparten varios scripts. Va en su propio archivo, tesoro.iface.gro. global quiere decir que hay una sola para todo el juego.}
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
use interface::tesoro as tesoro

fn _ready() void {
  tesoro.gemas += 12 · Usarla desde un scriptuse interface:: la trae, igual que un actor o un prefab. Después lees y cambias sus campos con un punto: tesoro.gemas.  print(tesoro.gemas)
}
Output
1
main.groPaso 3 de 4
use interface::tesoro as tesoro

@onready watch tesoro.gemas(valor: int) {
  print($"Contador: {valor} gemas")
}3 · Mirarla desde otro scriptEste es el código del contador de gemas. Con watch reacciona cada vez que cambian, como si fueran una variable live suya.
Output
Contador: 0 gemas
main.groPaso 4 de 4
use interface::tesoro as tesoro

fn _ready() void {
  tesoro.gemas += 1
  tesoro.gemas += 14 · Los dos a la vezEn esta escena, el contador del paso anterior es un actor más. El nivel suma gemas y el contador las muestra, sin que ninguno sepa que el otro existe.}
Output
Contador: 0 gemas
Contador: 1 gemas
Contador: 2 gemas
También con las flechas ← →

Gobi recoge una gema y el contador de la pantalla tiene que subir. Son dos scripts distintos: el del nivel y el del contador. Podrían buscarse el uno al otro para pasarse el número, pero entonces cada uno dependería del otro: cambias uno y se rompe el otro.

Una interfaz es un bloque de datos (y funciones) compartido, que los dos usan sin saber nada el uno del otro.

Declarar una interfaz

Cada interfaz va en su propio archivo, llamado <nombre>.iface.gro. Este es tesoro.iface.gro:

tesoro.iface.gro
interface tesoro global {
live gemas : int = 0
fn recoger(n: int) void {
set gemas += n
}
}
  • interface tesoro le pone nombre. El que cuenta es el escrito dentro del archivo.
  • global significa que hay una sola para todo el juego: todos los scripts que la usan ven los mismos datos.
  • Los campos se declaran como variables. Con live, otros scripts pueden observarlos con watch.
  • Las funciones, como cualquier función. Dentro, los cambios a un campo live llevan set, como en la lección anterior.

Usarla

Un script la trae con use interface::, por el nombre de dentro:

main.gro
module Nivel
use interface::tesoro as tesoro
fn _ready() void {
tesoro.gemas += 1
tesoro.recoger(2)
print(tesoro.gemas)
}
Output3
  • tesoro.gemas += 1 cambia el campo directamente. Desde otro script no hace falta set: el cambio avisa igual.
  • tesoro.recoger(2) llama a la función de la interfaz, que suma 2 más.

Dos scripts, un mismo dato

Ahora el contador. Su código no sabe nada del nivel: solo observa el campo gemas.

ContadorGemas.prefab
module ContadorGemas
use interface::tesoro as tesoro
@onready watch tesoro.gemas(valor: int) {
print($"Contador: {valor} gemas")
}
OutputContador: 0 gemas

Pon el contador en la escena del nivel, y el nivel solo tiene que sumar gemas:

main.gro
module Nivel
use interface::tesoro as tesoro
fn _ready() void {
print("Nivel listo")
tesoro.gemas += 1
tesoro.recoger(2)
}
OutputContador: 0 gemas Nivel listo Contador: 1 gemas Contador: 3 gemas
  • El contador muestra el 0 al empezar, gracias al @onready.
  • Cada cambio del nivel le llega al contador, que lo muestra.
  • Ninguno conoce al otro. Podrías cambiar el contador por una barra o un sonido, y el nivel no cambiaría ni una línea.
¿Y sin global?

Sin global, hay una instancia por actor: cada uno que la usa con use interface:: tiene la suya. Sirve para datos que cada enemigo lleva por su cuenta, como su propia salud: interface salud { live puntos : int = 10 }.

Empezar de nuevo: reset()

Todas las interfaces tienen la función reset(): devuelve sus campos a los valores con los que se declararon. Es lo que usas para empezar de nuevo un nivel o una partida.

main.gro
module Nivel
use interface::tesoro as tesoro
fn _ready() void {
tesoro.recoger(5)
print(tesoro.gemas)
tesoro.reset()
print(tesoro.gemas)
}
Output5 0

Quien observa la interfaz con watch también ve el cambio, así que un contador volvería a mostrar 0.

Hora de practicar

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

¿Dónde se escribe una interfaz?

Cada interfaz va en su propio archivo <nombre>.iface.gro, y los scripts la traen con use interface::.
Es la única de estas cosas que no puede ir dentro de un script normal.
Reto 2 de 4sin resolver

Completa el código del contador para que muestre las gemas desde el principio y cada vez que cambien.

Salida esperada
Gemas: 0
main.gro
use ::tesoro as tesoro

@onready  tesoro.gemas(valor: int) {
  print($"Gemas: {valor}")
}
El primer hueco es el namespace de las interfaces. El segundo, la palabra que reacciona a un cambio.
Solución:
main.gro
use interface::tesoro as tesoro

@onready watch tesoro.gemas(valor: int) {
  print($"Gemas: {valor}")
}
Reto 3 de 4sin resolver

¿Qué quiere decir global en interface tesoro global { ... }?

Con global hay una única instancia compartida: lo que escribe un script lo ve cualquier otro. Sin global, hay una por actor.
Piensa en el contador y el nivel: ¿ven el mismo número?
Reto 4 de 4sin resolver

La interfaz tesoro tiene fn recoger(n: int), que suma n gemas. ¿Qué imprime este código?

main.gro
use interface::tesoro as tesoro

fn _ready() void {
  tesoro.recoger(2)
  tesoro.recoger(3)
  tesoro.reset()
  tesoro.recoger(1)
  print(tesoro.gemas)
}
Suma 2 y 3, reset() deja gemas otra vez en 0, y luego suma 1.
reset() devuelve los campos al valor con el que se declararon.