Guardar partida
@persistent
Ajustes :: struct {
volumen : float = 0.8
idioma : String = "es"
}
fn _ready() void {
a : Ajustes = Ajustes.load("opciones")1 · Marcar el struct@persistent le da al struct load para cargar y save para guardar. La primera vez no hay nada guardado, y load da los valores por defecto. print(a.idioma)
}es
@persistent
Ajustes :: struct {
volumen : float = 0.8
idioma : String = "es"
}
fn _ready() void {
mut a : Ajustes = Ajustes.load("opciones")
a.volumen = 0.5
if not a.save("opciones") {2 · Cambiar y guardarCambias lo que quieras y lo guardas con save. Devuelve true si pudo escribir la partida y false si no. print("no se pudo guardar")
}
}Este código todavía no imprime nada.
@persistent
Ajustes :: struct {
volumen : float = 0.8
idioma : String = "es"
}
fn _ready() void {
mut a : Ajustes = Ajustes.load("opciones")
a.volumen = 0.5
if not a.save("opciones") {
print("no se pudo guardar")
}
luego : Ajustes = Ajustes.load("opciones")
print(luego.volumen)3 · La próxima vezCuando el jugador vuelva a jugar, load le devuelve lo que guardó. Aquí cargamos justo después para verlo.}0.5
use interface::progreso as progreso
fn _ready() void {
progreso.monedas = 10
if not progreso.save("partida") {4 · El progreso de todo el juegoLo que comparte todo el juego vive en una interfaz global. Con @persistent en su archivo, la interfaz también tiene save y load. print("no se pudo guardar")
}
}Este código todavía no imprime nada.
Monedas recogidas, niveles desbloqueados, el volumen de la música: el jugador espera encontrarlos la próxima vez que juegue. Para eso hay que guardar esos datos en un archivo y cargarlos al volver.
En Grost no escribes archivos a mano. Marcas los datos con @persistent y aprenden a guardarse
y cargarse solos.
Un struct que se guarda
Las opciones del juego son un buen ejemplo. Pon @persistent encima de su struct:
module Opciones
@persistentAjustes :: struct { volumen : float = 0.8 pantalla_completa : bool = true idioma : String = "es"}
fn _ready() void { a : Ajustes = Ajustes.load("opciones") print(a.pantalla_completa) print(a.idioma)}@persistentencima del struct le añade dos funciones:loadysave."opciones"es la ranura: el nombre de una partida guardada. Puedes tener varias, como"partida1"y"partida2".- Si la ranura no tiene nada guardado, por ejemplo la primera vez que alguien juega,
loadda unAjustescon los valores por defecto. Siempre da unAjustes, nunca un error.
Guardar con save
module Volumen
@persistentAjustes :: struct { volumen : float = 0.8 pantalla_completa : bool = true idioma : String = "es"}
fn cambiar_volumen(nuevo: float) void { mut a : Ajustes = Ajustes.load("opciones") a.volumen = nuevo if not a.save("opciones") { print("no se pudo guardar") }}
fn _ready() void { cambiar_volumen(0.5) # Lo que vería el jugador al volver a abrir el juego: luego : Ajustes = Ajustes.load("opciones") print(luego.volumen)}loadse llama sobre el tipo (Ajustes.load(...)) ysavesobre el valor (a.save(...)).savedevuelve unbool:falsesi no pudo escribir el archivo. Si no lo usas, el editor te avisa. Compruébalo conif not, como aquí.- Primero cargas, luego cambias y luego guardas. Así no pierdes los demás ajustes que ya estaban guardados.
El progreso de todo el juego
Las monedas o los niveles desbloqueados los comparte todo el juego, así que suelen vivir en una
interfaz global: un bloque de datos compartido, en su propio archivo .iface.gro. Pon
@persistent encima:
@persistentinterface progreso global { live monedas : int = 0 mut mejor_puntuacion : int = 0 mut niveles : []int = [1]}La interfaz gana también save(ranura) y load(ranura), y cualquier script que la use puede
llamarlas:
module Nivel
use interface::progreso as progreso
fn nivel_superado() void { progreso.monedas += 10 if not progreso.save("partida") { print("no se pudo guardar") }}
fn _ready() void { nivel_superado() progreso.reset() # como si el jugador cerrara el juego print(progreso.monedas) if progreso.load("partida") { print(progreso.monedas) }}reset()devuelve la interfaz a sus valores iniciales. Aquí hace de “cerrar el juego”.- Las dos funciones devuelven un
bool.loaddafalsecuando todavía no hay partida guardada: es una partida nueva. - Después de
load, los camposliveavisan del cambio y suswatchse ejecutan: el marcador muestra las monedas cargadas sin código extra. - Solo una interfaz global puede ser
@persistent. Los campos sinmut, losstaticy los derivados (=>) no se guardan: no son datos que cambien.
¿Dónde va el load en un juego de verdad?
Al empezar, normalmente en el _ready del nivel o del menú principal:
if not progreso.load("partida") { print("partida nueva") }. Y el save, cada vez que pasa
algo que el jugador no querría perder, como superar un nivel.
Qué se puede guardar
| Se guarda | No se guarda (Grost da un error) |
|---|---|
int, float, bool, String | Actores |
Vectores, Color | Recursos, como una textura |
| Arrays y diccionarios | Callable |
Otros structs @persistent |
Un actor o una textura no son datos. Si lo intentas, Grost te lo dice antes de ejecutar:
module Malo
@persistentPartida :: struct { jugador : Actor = null}
fn _ready() void { print("hola")}Guarda lo que lo identifica: un nombre, un número de nivel.
Cambiar tus datos más adelante
Tu juego cambiará cuando ya haya gente con partidas guardadas. Las reglas lo hacen seguro:
- Un campo que falta en la partida conserva su valor por defecto. Puedes añadir campos sin miedo.
- Un campo de la partida que el struct ya no tiene se ignora. Puedes quitar campos sin miedo.
- Lo que no funciona es renombrar: para la partida, un campo renombrado es uno quitado y uno nuevo, que vuelve a su valor por defecto.
Puedes verlo con from_dict, que crea un struct a partir de un diccionario con las mismas
reglas que load:
module Version
@persistentAjustes :: struct { volumen : float = 0.8 idioma : String = "es"}
fn _ready() void { # Una partida guardada con una versión vieja del juego vieja : Dictionary = { "volumen": 0.3, "brillo": 5 } a : Ajustes = Ajustes.from_dict(vieja) print(a.volumen) print(a.idioma)}brillo ya no existe y se ignora; idioma no estaba guardado y empieza en "es".
Ver y borrar partidas: Persist
Debajo de todo está Persist, que guarda un diccionario en una ranura con nombre. Te sirve para
un menú que lista o borra partidas:
module Menu
use interface::progreso as progreso
fn borrar_partida(ranura: String) void { if Persist.remove(ranura) { print($"{ranura} borrada") }}
fn _ready() void { if not progreso.save("partida2") { print("no se pudo guardar") } print(Persist.has("partida2")) borrar_partida("partida2") print(Persist.has("partida2"))}| Función | Qué hace |
|---|---|
Persist.has(ranura) | Si la ranura tiene una partida guardada |
Persist.remove(ranura) | La borra; da true si había algo que borrar |
Persist.save(ranura, datos) | Guarda un diccionario; da un bool |
Persist.load(ranura) | El diccionario guardado, o uno vacío si no hay |
Cada ranura es un archivo user://saves/<ranura>.save, así que una ranura es un nombre simple
("partida1"), no una ruta. Para los datos en sí, mejor @persistent.
Hora de practicar
¿Qué da Ajustes.load("opciones") si todavía no hay nada guardado en esa ranura?
load de un struct siempre da un valor de ese struct: el guardado o, si no hay, uno con los valores por defecto.Completa el código para guardar el récord y volver a leerlo.
120
Record :: struct {
puntos : int = 0
}
fn _ready() void {
mut r : Record = Record.("records")
r.puntos = 120
if not r.("records") {
print("no se pudo guardar")
}
otro : Record = Record.load("records")
print(otro.puntos)
}load y save. Después, cargar desde el tipo y guardar desde el valor.@persistent
Record :: struct {
puntos : int = 0
}
fn _ready() void {
mut r : Record = Record.load("records")
r.puntos = 120
if not r.save("records") {
print("no se pudo guardar")
}
otro : Record = Record.load("records")
print(otro.puntos)
}¿Qué campo no puede ir en un struct @persistent?
Tu juego ya tiene partidas guardadas y añades el campo nivel : int = 1 al struct. ¿Qué pasa al cargar una partida vieja?