Ejemplo de como guardar un juego

Vamos a ver un ejemplo de como guardar datos en Game Maker Studio. Los datos que podemos guardar son variados, podemos guardar el score, es una variable global, podemos guardar variables, de un objeto en particular, o podemos guardar una partida. Veamos éste último caso.

Ya vimos en su momento como gestionar ficheros ini, que nos es muy útil para guardar configuraciones, texto en diferentes idiomas, o variables globales. Pero para guardar una partida entera es mejor ficheros de texto.

Comentamos que los ficheros de texto se guardan y leen secuencialmente, es decir, vamos grabando los datos que nos interesa en cada línea del fichero, y luego los vamos a leer de la misma manera y del mismo orden.

Como guardar una partida de tu juego

Para guardar una partida entera deberíamos coger todas las instancias que existen en ese momento y almacenar todas sus variables: posición X/Y, sprite asociado, otra variables que podemos necesitar, y además las variables propias que hemos creado.

Es posible que también necesitemos el nivel o room que estamos en ese momento y algunas variables globales (score, health, o las que hayamos creado).

Si usamos ficheros de texto, podemos grabar primero todo lo global, que ocupará siempre las mismas líneas y posiciones, y luego grabar todas las instancias que nos interesa.

En el ejemplo, creo varias instancias del mismo objeto, pero con los valores de las variables diferentes (lo hago con un botón). Tengo además un botón que graba en un fichero todas estas instancias de ese objeto, y otro botón que recupera los datos guardados.

Veamos el ejemplo

Ejemplo de guardar datos de un juego

Creo un proyecto nuevo que he llamado Save Instance. Voy a pillar los sprites del proyecto Cyber City de OpenGameArt, como suelo hacer.

Creo un nuevo sprite, que llamo spr_people, y le doy al botón Load Sprite. Desde allí accedo al menú  File – Add from Strip, y elijo el fichero streetPeople.png. Utilizo estos parámetros para crear las subimágenes.

Hago lo mismo con el fichero streetPeople2.png, solamente para tener más imágenes.

Crear los botones

De manera muy sencilla, creo tres sprites más, spr_create, spr_save y spr_read, con un tamaño fijo y un texto que he hecho desde el editor de imágenes de Game Maker Studio.

Así podemos probar el ejemplo tantas veces como queramos.

Crear objeto people

Este será muy sencillo, creamos un objeto nuevo obj_people. Asociamos el sprite spr_people.

En su evento Create, añado dos Set Variable: una acción dónde image_speed = 0, para que no tenga movimiento el sprite, y creamos la variable name="".
En el evento Draw vamos a mostrar la variable name. Primero, añadimos la acción Draw Self (para que se vea el sprite). Luego añadimos la acción Set Color, para darle a las letras un color rojo. Como última acción, tenemos un Draw Text, en text habrá "Name:" + string(name), en x será 0, en y será -15 y marcamos el check Relative.

Crear objeto que genera instancias

Ahora creamos el objeto que genera varias instancias de obj_people. Hacemos un objeto nuevo llamado obj_create_people, con su sprite spr_create.

Como nos interesa que funcione como un botón, le añadiremos el evento Left Released, y añadimos la acción Execute Code. El código es el siguiente:

///CREATE PEOPLE

//Eliminamos las posibles instancias
with (obj_people) {
    instance_destroy();
}

for (i = 0; i < sprite_get_number(spr_people); i++) {
    xx = irandom_range(50, room_width - 50);
    yy = irandom_range(50, room_height - 50);
    //buscamos una posición libre
    while (position_meeting(xx, yy, obj_people) == true) {
        xx = irandom_range(50, room_width - 50);
        yy = irandom_range(50, room_height - 50);    
    }
    //crear instancia y le damos algunos valores    
    with (instance_create(xx, yy, obj_people)) {
        image_index = other.i;
        name = "P " + string(other.i + 1)
    }
}

Si tenéis dudas con el código, preguntad en los comentarios.
Añadimos una room nueva, añadimos el objeto último que hemos creado y probamos el botón.

Crear objeto que guarda datos

Ahora creamos un objeto nuevo llamado obj_save_people. Al ser un botón, le añadimos el evento Left Released, y la acción Execute Code. Guardamos todas las instancias de obj_people.

///SAVE ALL INSTANCES

file = file_text_open_write("players.txt");
with (obj_people) {
    file_text_write_real(other.file, x);
    file_text_write_real(other.file, y);
    file_text_write_real(other.file, image_index);
    file_text_write_string(other.file, name);
    file_text_writeln(other.file);
}

file_text_close(file);
show_message("FILE SAVED!");

Abrimos/creamos el fichero, y guardamos su referencia en la variable file. Luego cogemos todas las instancias con with (obj_people). Recordemos que con la instrucción with podemos usar all, y así tendríamos todas las instancias de la room.

Dentro de with tenemos las funciones que graba los datos que nos interese, diferenciando de si es un número o texto: posición X/Y, image_index y variable name. Luego hago un salto de línea para diferenciarcada objeto (se podría hacer en cada variable si queremos).

Al final, cierro el fichero y muestro un mensaje para saber que ha finalizado el proceso correctamente.

Añadimos el botón a la room. Si queremos ver el fichero, hay que recordar que los ficheros se graban en el sandbox o área de guardado que utiliza YoYoGames.

Crear objeto para leer la partida

Ahora creamos el botón para leer del fichero de texto. Llamamos al objeto nuevo obj_read_people, con su sprite spr_read. Le añadimos el mismo evento del ratón, con el siguiente código:

///OPEN PEOPLE

//eliminar posibles instancias
with (obj_people) {
    instance_destroy();
}

file = file_text_open_read("players.txt")

while (!file_text_eof(file)) {
    xx = file_text_read_real(file);
    yy = file_text_read_real(file);
    index = file_text_read_real(file);
    name =  file_text_read_string(file);
    file_text_readln(file);
    with(instance_create(xx, yy, obj_people)) {
        image_index = other.index;
        name = other.name;
    }
}
file_text_close(file);

Como véis, es un bucle que lee hasta el final del fichero. Dentro del bucle ponemos en el MISMO ORDEN las variables que nos interesa y el salto de línea. Luego creamos la instancia con los valores que hemos leído. Al final, cerramos el fichero.

Para finalizar

Os dejo el enlace de este ejemplo para que podáis descargar el proyecto de Game Maker: Studio. Ya comentaréis si os gusta o le falta algo.
Proyecto Save Instances