Comment implémenter la fonctionnalité de sauvegarde et de chargement dans PyGame

Dans le développement de jeux modernes, la possibilité de sauvegarder et de charger la progression du jeu est une fonctionnalité cruciale qui améliore l'expérience et l'engagement de l'utilisateur. PyGame, une bibliothèque populaire pour la création de jeux 2D en Python, fournit les outils nécessaires pour implémenter la fonction de sauvegarde et de chargement sans effort.

Créer un jeu simple

Avant de commencer, assurez-vous d'avoir pip installé sur votre appareil. Après avoir installé pip, exécutez la commande ci-dessous pour installer le pygame module:

pip installer pygame

Pour illustrer l'implémentation d'un système de sauvegarde et de chargement dans PyGame, commencez par créer un jeu simple.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

Dans ce jeu, le joueur aura la possibilité de se déplacer à gauche et à droite. Voici un exemple d'extrait de code qui illustre la structure de base du jeu :

importer pygame
# Initialiser Pygame
pygame.init()
# Configurer la fenêtre de jeu
largeur_fenêtre = 800
hauteur_fenêtre = 600
fenêtre = pygame.display.set_mode((largeur_fenêtre, hauteur_fenêtre))
pygame.display.set_caption("Didacticiel d'enregistrement et de chargement du système")
#Variables de jeu
joueur_x = 400
joueur_y = 500
player_speed = 5
# Boucle de jeu
courir = Vrai
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX
 clés = pygame.key.get_pressed()
si clés[pygame. K_LEFT] :
 joueur_x -= vitesse_joueur
si clés[pygame. K_RIGHT] :
 player_x += player_speed
# Effacer l'écran
 fenêtre.fill((0, 0, 0))
# Dessinez le joueur
 pygame.draw.rect (fenêtre, (255, 255, 255), (joueur_x, joueur_y, 50, 50))
# Mettre à jour l'affichage
 pygame.display.flip()
# Quitter le jeu
pygame.quit()

Gestion de l'état du jeu et de la persistance des données

Avant d'implémenter la fonctionnalité de sauvegarde et de chargement, vous devez établir un moyen de gérer l'état du jeu et de conserver les données. Une approche courante consiste à utiliser un dictionnaire Python pour stocker les données de jeu pertinentes. Voici un exemple de la façon dont vous pouvez modifier le code précédent pour inclure la gestion de l'état du jeu :

#Variables de jeu
état_jeu = {
'joueur_x': 400,
'joueur_y': 500
}
# Boucle de jeu
courir = Vrai
alors que en cours d'exécution:
# ...
 clés = pygame.key.get_pressed()
si clés[pygame. K_LEFT] :
 état_jeu['joueur_x'] -= vitesse_joueur
si clés[pygame. K_RIGHT] :
 état_jeu['joueur_x'] += vitesse_joueur
# ...
 pygame.display.flip()

Implémentation de la fonctionnalité de sauvegarde et de chargement

Pour activer l'enregistrement et le chargement de la progression du jeu, vous pouvez tirer parti de la fonction intégrée de Python cornichon module, qui nous permet de sérialiser et de désérialiser des objets Python. Créer un nouveau fichier nommé save-game.py et ajoutez le code avec les mises à jour ci-dessous :

état_jeu = {
'joueur_x': joueur_x,
'joueur_y': joueur_y
}
# Enregistrer l'état du jeu
définitivementsave_game_state(état_jeu, nom_fichier):
essayer:
avec ouvrir (nom_fichier, 'wb') comme déposer:
 pickle.dump (état_jeu, fichier)
 imprimer("État du jeu enregistré avec succès !")
sauf Erreur IO :
 imprimer("Erreur: Impossible d'enregistrer l'état du jeu.")
# Charger l'état du jeu
définitivementload_game_state(nom de fichier):
essayer:
avec ouvrir (nom_fichier, 'rb') comme déposer:
 game_state = pickle.load (fichier)
 imprimer("État du jeu chargé avec succès !")
retour game_state
sauf (IOErreur, cornichon. Erreur de décapage):
 imprimer("Erreur: Impossible de charger l'état du jeu.")
# Boucle de jeu
courir = Vrai
alors que en cours d'exécution:
# ...
 clés = pygame.key.get_pressed()
si clés[pygame. K_LEFT] :
 joueur_x -= vitesse_joueur
 état_jeu['joueur_x'] = joueur_x
si clés[pygame. K_RIGHT] :
 player_x += player_speed
 état_jeu['joueur_x'] = joueur_x
si clés[pygame. K_s] :
 save_game_state (état_jeu, 'save_game.pickle')
si clés[pygame. K_l] :
 game_state = load_game_state('save_game.pickle')
 player_x = game_state['joueur_x']

# ...
# ...

Ci-dessous la sortie :

Conception d'une interface utilisateur pour les emplacements de sauvegarde

Pour fournir une interface de sauvegarde et de chargement, vous pouvez afficher des emplacements de sauvegarde qui permettent au joueur de choisir quel emplacement enregistrer ou charger. Pour cet exemple, les options sont affichées dans la console, mais vous pouvez utiliser Les frameworks GUI de Python pour créer une interface plus conviviale.

Créer un save_slots liste qui représente les emplacements de sauvegarde disponibles. Aussi, ajoutez un slot_sélectionné variable pour garder une trace de l'emplacement choisi par le joueur.

Afficher les emplacements de sauvegarde disponibles lorsque le joueur appuie sur le bouton de sauvegarde (K_s). Le joueur peut choisir un emplacement en appuyant sur la touche numérique correspondante (K_1, K_2, ou K_3). Si un emplacement est sélectionné, l'état du jeu est enregistré dans un fichier nommé d'après l'emplacement sélectionné.

De même, lorsque le joueur appuie sur le bouton de chargement (K_l), affichez les emplacements de sauvegarde. Le joueur peut choisir un emplacement en appuyant sur les touches K_a, K_b, ou K_c pour charger l'état du jeu. Alternativement, vous pouvez utiliser les entrées tactiles au lieu d'entrées clavier pour la sélection de slot. Si un emplacement est sélectionné, l'état du jeu est chargé à partir du fichier correspondant.

Créer un nouveau fichier nommé interface.py et ajoutez le code avec les mises à jour ci-dessous :

#Variables de jeu
save_slots = ['Emplacement 1', 'Emplacement 2', 'Emplacement 3']
slot_sélectionné = Aucun
# Boucle de jeu
courir = Vrai
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX
si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_s :
# Afficher les emplacements de sauvegarde
 slot_sélectionné = Aucun
pour je, fente dans énumérer (save_slots):
 imprimer(f"Enregistrer l'emplacement {je+1}: {fente}")
 imprimer("Choisissez un emplacement pour sauvegarder la partie.")
si event.key == pygame. K_l :
 imprimer("Sélectionnez l'emplacement :- a - Emplacement 1, b - Emplacement 3, c - Emplacement 3")
# Afficher les emplacements de sauvegarde
 slot_sélectionné = Aucun
pour je, fente dans énumérer (save_slots):
 imprimer(f"Enregistrer l'emplacement {je+1}: {fente}")
 imprimer("Choisissez un emplacement pour charger le jeu.")
si event.key dans [pygame. K_1, pygame. K_2, pygame. K_3] :
# Enregistrer ou charger le jeu en fonction de l'emplacement sélectionné
 slot_index = event.key - pygame. K_1
 slot_sélectionné = save_slots[slot_index]

 save_game_state (état_jeu, F"{selected_slot}.cornichon")
 imprimer(f"Jeu enregistré dans {selected_slot}!")
si event.key dans [pygame. K_a, pygame. K_b, pygame. K_c] :

 slot_index = event.key - pygame. K_a
 slot_sélectionné = save_slots[slot_index]
 game_state = load_game_state(F"{selected_slot}.cornichon")
 player_x = game_state['joueur_x']
 imprimer(f"Jeu chargé depuis {selected_slot}!")
# ...
 pygame.display.flip()
# ...

Ci-dessous la sortie:

Gestion des options d'écrasement

Pour fournir des options d'écrasement des sauvegardes existantes, vous pouvez implémenter un message d'avertissement qui invite le lecteur à confirmer avant d'écraser un fichier de sauvegarde. Créer un nouveau fichier nommé écraser-enregistrer.py et modifiez le code avec les mises à jour ci-dessous :

# Enregistrer l'état du jeu
définitivementsave_game_state(état_jeu, nom_fichier):
si os.path.exists (nom_fichier) :
# Demande de confirmation pour écraser le fichier de sauvegarde existant
 écraser = entrée("Le fichier de sauvegarde existe déjà. Voulez-vous écraser? (o/n): ")
si overwrite.lower() != 'y':
 imprimer("Enregistrement annulé.")
retour
essayer:
avec ouvrir (nom_fichier, 'wb') comme déposer:
 pickle.dump (état_jeu, fichier)
 imprimer("État du jeu enregistré avec succès !")
sauf Erreur IO :
 imprimer("Erreur: Impossible d'enregistrer l'état du jeu.")
# ...
# Charger l'état du jeu
définitivementload_game_state(nom de fichier):
sipas os.path.exists (nom_fichier) :
 imprimer("Erreur: le fichier de sauvegarde n'existe pas.")
retourAucun
essayer:
avec ouvrir (nom_fichier, 'rb') comme déposer:
 game_state = pickle.load (fichier)
 imprimer("État du jeu chargé avec succès !")
retour game_state
sauf (IOErreur, cornichon. Erreur de décapage):
 imprimer("Erreur: Impossible de charger l'état du jeu.")
retourAucun
# ...

Dans le code ci-dessus, avant de sauvegarder un état de jeu, vous vérifiez si le fichier de sauvegarde existe déjà en utilisant os.path.exists(). Si c'est le cas, vous demandez au lecteur de confirmer qu'il doit écraser le fichier de sauvegarde existant. Si le lecteur choisit de ne pas écraser, l'opération de sauvegarde est annulée.

De même, avant de charger un état de jeu, vous vérifiez si le fichier de sauvegarde existe en utilisant os.path.exists(). Si ce n'est pas le cas, vous informez le joueur avec un message d'erreur.

Meilleures pratiques pour le système de sauvegarde et de chargement

Lors de la mise en œuvre d'un système de sauvegarde et de chargement dans PyGame ou dans tout projet de développement de jeu, tenez compte des bonnes pratiques suivantes :

• Utilisez une structure de données bien définie pour représenter l'état du jeu et sérialisez-le à l'aide d'une bibliothèque de sérialisation comme cornichon. Cela vous permet de sauvegarder et de charger facilement tout l'état du jeu.
• Créez un répertoire ou un dossier dédié pour stocker les fichiers enregistrés. Cela aide à organiser les fichiers enregistrés et évite d'encombrer le répertoire principal du jeu.
• Implémentez la gestion des erreurs et fournissez des messages d'erreur informatifs pour faciliter le débogage et le dépannage. Cela aide les joueurs à comprendre les problèmes qui peuvent survenir lors des opérations de sauvegarde et de chargement.
• Envisagez de mettre en place plusieurs emplacements de sauvegarde pour permettre aux joueurs d'avoir plusieurs sauvegardes de jeu. Cela donne aux joueurs la possibilité d'explorer différents chemins ou de rejouer des sections spécifiques du jeu sans écraser leur progression.

Rendez les jeux plus attrayants avec le système de sauvegarde et de chargement

L'ajout de la fonction de sauvegarde et de chargement peut grandement améliorer l'engagement et le plaisir d'un jeu. Il permet aux joueurs de sauvegarder leur progression et de revenir au jeu à leur convenance. De plus, cela ouvre des possibilités pour créer des mondes de jeu complexes, où les choix et les actions des joueurs ont des conséquences durables.

En mettant en œuvre un système de sauvegarde et de chargement, vous pouvez permettre à vos joueurs d'avoir une expérience de jeu plus immersive et satisfaisante.