Cómo guardar y cargar datos de juegos en Arcade

Agregar un sistema de guardar y cargar a su juego puede mejorar en gran medida la experiencia del jugador. Permite a los jugadores continuar con su progreso, reanudar las sesiones de juego y experimentar con diferentes estrategias sin perder los logros obtenidos con tanto esfuerzo.

Te sorprenderá gratamente lo sencillo que es agregar esta función a tu juego usando la biblioteca Arcade de Python.

Crea un juego simple

Empiece por crear un juego simple donde el jugador puede moverse izquierda y derecha.

El código utilizado en este artículo está disponible en este repositorio GitHub y es gratis para su uso bajo la licencia MIT.

Crear un nuevo archivo llamado juego-simple.py y agregue el siguiente código:

importar arcada
ANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600
VELOCIDAD DEL JUGADOR = 5
azul = arcada.color. AZUL
claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):





instagram viewer

 super().__init__(ancho, alto)
 self.jugador_x = ancho // 2

definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, azul)
definitivamenteactualizar(uno mismo, delta_time):
aprobar
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.player_x -= PLAYER_SPEED
elif clave == arcade.clave. BIEN:
 self.player_x += PLAYER_SPEED
definitivamenteprincipal():
 ventana = GameWindow (PANTALLA_ANCHO, PANTALLA_ALTO)
 arcade.ejecutar()
si __nombre__ == '__principal__':
 principal()

El código crea una ventana con un rectángulo azul que representa al jugador. El jugador puede moverse hacia la izquierda y hacia la derecha usando las teclas de flecha izquierda y derecha.

Gestión de estados del juego

Para implementar un sistema de guardar y cargar, debe administrar diferentes estados del juego. Un estado del juego representa el estado actual del juego, incluidas las posiciones de los objetos, las puntuaciones y otros datos relevantes. Para este ejemplo, enfócate solo en la coordenada x del jugador.

Para administrar los estados del juego, introduzca un estado del juego clase que encapsula los datos del juego y proporciona métodos para guardarlos y cargarlos. Aquí está el código:

claseestado del juego:
definitivamente__en eso__(ser):
 self.jugador_x = 0

Guardar los datos del juego

Para guardar los datos del juego, extienda el ventana de juego class y agregue un método para guardar el estado del juego cuando sea necesario. Utilice el formato JSON para simplificar. Aquí está el código:

En el guardar partida método, crear un diccionario Python que contiene los datos relevantes del juego. Luego serialízalo en un archivo JSON llamado guardar.json.

importar json
claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 self.game_state = GameState()
definitivamenteguardar partida(ser):
 datos = {
'jugador_x': self.game_state.player_x
 }
con abierto('guardar.json', 'w') como archivo:
 json.dump (datos, archivo)
 imprimir (datos)
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, azul)
definitivamenteactualizar(uno mismo, delta_time):
aprobar
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.game_state.player_x -= PLAYER_SPEED
elif clave == arcade.clave. BIEN:
 self.game_state.player_x += PLAYER_SPEED
elif clave == arcade.clave. S:
 self.save_game()

Cargando los datos del juego

Para cargar los datos del juego, extienda el ventana de juego clase más y agregue un método para cargar el estado del juego. Crear un nuevo archivo llamado cargar-juego.py y agregue el código con las siguientes actualizaciones:

claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 self.game_state = GameState()
 self.load_game()
definitivamentecargar_juego(ser):
intentar:
con abierto('guardar.json', 'r') como archivo:
 datos = json.load (archivo)
 self.game_state.player_x = datos['jugador_x']
excepto Error de archivo no encontrado:
aprobar
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. L:
 self.load_game()

El cargar_juego método intenta abrir el guardar.json archivo y recuperar los datos del juego. Luego actualiza el estado del juego con los datos cargados. Si el archivo no existe, puede ignorar la excepción y dejar el estado predeterminado del juego.

Incluyendo funciones adicionales

Puede agregar más funciones para mejorar el sistema de guardado y carga del juego.

Guardar puntajes altos

Guardar puntajes altos junto con el estado del juego es una característica común en muchos juegos. Puede gestionar las puntuaciones y guarde la puntuación más alta usando este sistema. Crear un nuevo archivo llamado alta-puntuacion.py y agregue el código con las siguientes actualizaciones:

claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 self.high_score = 0
definitivamentecargar_juego(ser):
intentar:
con abierto('guardar.json', 'r') como archivo:
 datos = json.load (archivo)
 imprimir (datos)
 self.jugador_x = datos.get('jugador_x', self.jugador_x)
 self.high_score = data.get('puntuación más alta', self.puntaje_alto)
excepto Error de archivo no encontrado:
aprobar
definitivamenteguardar partida(ser):
 datos = {
'jugador_x': self.jugador_x,
'puntuación más alta': self.puntaje_alto
 }
con abierto('guardar.json', 'w') como archivo:
 json.dump (datos, archivo)
 imprimir (datos)
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.player_x -= PLAYER_SPEED
elif clave == arcade.clave. BIEN:
 self.player_x += PLAYER_SPEED
 self.puntaje_alto += 1

Función de guardado automático

Para brindar tranquilidad a los jugadores y evitar la pérdida de progreso, puede guardar automáticamente el estado del juego a intervalos regulares. Crear un nuevo archivo llamado auto-save.py y agregue el código con las siguientes actualizaciones:

importar tiempo
claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 self.game_state = GameState()
# Guardar cada 6 segundos
 self.autosave_interval = 6
 self.last_save_time = tiempo.tiempo()
definitivamenteactualizar(uno mismo, delta_time):
 hora_actual = hora.hora()
 time_diff = hora_actual - self.last_save_time
si time_diff >= self.autosave_interval:
 self.save_game()
 imprimir("Salvado")
 self.last_save_time = hora_actual

En este fragmento de código, el actualizar El método comprueba si el intervalo de tiempo especificado ha pasado desde la última vez que se guardó. Si es así, desencadena el guardar partida metodo de la ventana de juego clase para guardar automáticamente el estado del juego. Ajustar el intervalo_de_autoguardado valor de acuerdo con los requisitos de su juego.

Validación de datos del juego

La validación de los datos del juego cargados es esencial para garantizar su integridad y consistencia. Puede incorporar fácilmente la validación de datos en nuestro sistema de guardar y cargar:

claseestado del juego:
definitivamente__en eso__(ser):
 self.jugador_x = 0
definitivamenteguardar Estado(ser):
si self.es_estado_válido():
 datos = {
'jugador_x': self.jugador_x
 }
con abierto('guardar.json', 'w') como archivo:
 json.dump (datos, archivo)
definitivamenteestado de carga(ser):
con abierto('guardar.json', 'r') como archivo:
 datos = json.load (archivo)
si self.validate_loaded_data (datos):
 self.jugador_x = datos['jugador_x']
demás:
 imprimir("¡Error!")
definitivamentees_estado_válido(ser):
# Realizar lógica de validación aquí
# Devuelve True si el estado es válido, False en caso contrario
aprobar
definitivamentevalidar_datos_cargados(uno mismo, datos):
# Realizar la validación de los datos cargados
# Devuelve True si los datos son válidos, False en caso contrario
aprobar

Al incorporar estas características adicionales en el sistema de guardar y cargar, puede crear un juego más versátil y robusto. experiencia, que ofrece a los jugadores la capacidad de guardar múltiples estados del juego, rastrear puntajes altos, habilitar el guardado automático y garantizar datos integridad.

Mejores prácticas para el sistema Guardar y cargar

La implementación de un sistema de guardar y cargar es un aspecto importante del desarrollo del juego. Para garantizar un sistema robusto y confiable, es esencial seguir las mejores prácticas. Estas son algunas prácticas clave a tener en cuenta:

Cifrar datos confidenciales

Si su juego incluye información confidencial, como contraseñas, datos personales o compras dentro de la aplicación, es fundamental cifrar el estado del juego guardado. El cifrado agrega una capa adicional de seguridad, protege la privacidad del jugador y evita el acceso no autorizado a sus datos. Utilice bibliotecas y algoritmos de cifrado para proteger la información confidencial.

Validar datos cargados

Antes de cargar los datos del juego, es fundamental validarlos para garantizar su integridad y consistencia. Verifique que los datos cargados cumplan con el formato, la estructura y las restricciones esperados de su juego.

Realice verificaciones de validación en campos de datos críticos para evitar bloqueos o trampas. Implemente mecanismos robustos de validación de datos para manejar posibles errores o datos inesperados.

Manejar errores con gracia

Cuando se trata de operaciones de E/S de archivos, pueden ocurrir errores. Es crucial manejar estos errores correctamente y proporcionar mensajes de error informativos al jugador. Detectar y manejar excepciones, como Error de archivo no encontrado o Error de permiso, durante las operaciones de guardar y cargar.

Muestre mensajes de error fáciles de usar para guiar a los jugadores y evitar la frustración. Además, considere implementar el registro de errores para ayudar a diagnosticar y solucionar problemas.

Probar la funcionalidad de guardar y cargar

Pruebe exhaustivamente la funcionalidad de guardar y cargar de su juego para garantizar su confiabilidad y corrección. Cree casos de prueba que cubran varios escenarios, como guardar en diferentes estados del juego, cargar desde archivos guardados válidos y no válidos y probar casos extremos.

Valide que el estado del juego se guarde y cargue correctamente y que se produzca el comportamiento esperado. Los marcos de prueba automatizados pueden ayudar a crear suites de prueba integrales.

Haz que los juegos sean más divertidos con el sistema de guardar y cargar

Agregar un sistema de guardar y cargar puede hacer que los juegos sean más atractivos al brindarles a los jugadores una sensación de continuidad y progreso. Los jugadores pueden experimentar libremente, probar diferentes enfoques y volver al juego más tarde sin perder sus logros.

Esta función también permite a los jugadores competir con amigos o desafiarse a sí mismos para superar sus puntajes anteriores, lo que agrega capacidad de reproducción y compromiso a largo plazo a su juego.