Ir al contenido
Descargar
Curso de Grost

Guardar partida

Módulo 4 · Herramientas de juegoLección 18 de 2010 min de lectura4 retos
main.groPaso 1 de 4
@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)
}
Output
es
main.groPaso 2 de 4
@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")
  }
}
Output

Este código todavía no imprime nada.

main.groPaso 3 de 4
@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.}
Output
0.5
main.groPaso 4 de 4
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")
  }
}
Output

Este código todavía no imprime nada.

También con las flechas ← →

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:

main.gro
module Opciones
@persistent
Ajustes :: 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)
}
Outputtrue es
  • @persistent encima del struct le añade dos funciones: load y save.
  • "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, load da un Ajustes con los valores por defecto. Siempre da un Ajustes, nunca un error.

Guardar con save

main.gro
module Volumen
@persistent
Ajustes :: 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)
}
Output0.5
  • load se llama sobre el tipo (Ajustes.load(...)) y save sobre el valor (a.save(...)).
  • save devuelve un bool: false si no pudo escribir el archivo. Si no lo usas, el editor te avisa. Compruébalo con if 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:

progreso.iface.gro
@persistent
interface 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:

main.gro
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)
}
}
Output0 10
  • reset() devuelve la interfaz a sus valores iniciales. Aquí hace de “cerrar el juego”.
  • Las dos funciones devuelven un bool. load da false cuando todavía no hay partida guardada: es una partida nueva.
  • Después de load, los campos live avisan del cambio y sus watch se ejecutan: el marcador muestra las monedas cargadas sin código extra.
  • Solo una interfaz global puede ser @persistent. Los campos sin mut, los static y 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 guardaNo se guarda (Grost da un error)
int, float, bool, StringActores
Vectores, ColorRecursos, como una textura
Arrays y diccionariosCallable
Otros structs @persistent

Un actor o una textura no son datos. Si lo intentas, Grost te lo dice antes de ejecutar:

main.gro
module Malo
@persistent
Partida :: struct {
jugador : Actor = null
}
fn _ready() void {
print("hola")
}
OutputParse Error: Field "jugador" of the persistent struct "Partida" has type "Actor", which cannot be saved. Use plain data (numbers, text, vectors, arrays, dictionaries) or a "@persistent" struct.

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:

main.gro
module Version
@persistent
Ajustes :: 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)
}
Output0.3 es

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:

main.gro
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"))
}
Outputtrue partida2 borrada false
FunciónQué 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

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

¿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.
Piensa en la primera vez que alguien abre tu juego.
Reto 2 de 4sin resolver

Completa el código para guardar el récord y volver a leerlo.

Salida esperada
120
main.gro

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)
}
Primero, la anotación que da load y save. Después, cargar desde el tipo y guardar desde el valor.
Solución:
main.gro
@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)
}
Reto 3 de 4sin resolver

¿Qué campo no puede ir en un struct @persistent?

Un actor no son datos, y Grost da un error antes de ejecutar. Guarda lo que lo identifica, como su nombre.
Solo se guardan datos: números, texto, vectores, colores, listas...
Reto 4 de 4sin resolver

Tu juego ya tiene partidas guardadas y añades el campo nivel : int = 1 al struct. ¿Qué pasa al cargar una partida vieja?

Un campo que falta en la partida conserva su valor por defecto. Por eso puedes añadir campos sin miedo.
La partida vieja no tiene ese campo. ¿Qué valor le queda?