Introduction
Dans de nombreux jeux vidéo, il est crucial de permettre aux joueurs de sauvegarder leur progression et de la charger ultérieurement. Cela peut inclure des données comme les niveaux atteints, les scores, ou l'état du personnage. En Python, grâce à des outils comme fichiers, JSON, et pickle, il est facile d'implémenter des systèmes de sauvegarde robustes.
Dans cet article, nous allons explorer :
- Comment utiliser des fichiers pour sauvegarder et charger la progression des joueurs.
- La sérialisation des données avec pickle et JSON.
- La création d'un système de scores et de classements.
1. Utiliser des fichiers pour sauvegarder la progression des joueurs
L'un des moyens les plus simples de sauvegarder la progression d'un joueur dans un jeu est d'écrire les données dans un fichier. Ces données peuvent inclure des informations telles que le niveau atteint, les points de vie restants, ou les scores. Lorsqu'un joueur charge le jeu, ces informations sont lues à partir du fichier et restaurées.
Sauvegarder les données dans un fichier texte
Voici un exemple de comment sauvegarder les données de progression d'un joueur dans un fichier texte, puis les charger plus tard.
def sauvegarder_progression(niveau, score, vie):
with open('sauvegarde.txt', 'w') as fichier:
fichier.write(f'{niveau}\n')
fichier.write(f'{score}\n')
fichier.write(f'{vie}\n')
print("Progression sauvegardée.")
def charger_progression():
try:
with open('sauvegarde.txt', 'r') as fichier:
niveau = int(fichier.readline().strip())
score = int(fichier.readline().strip())
vie = int(fichier.readline().strip())
print("Progression chargée.")
return niveau, score, vie
except FileNotFoundError:
print("Aucune sauvegarde trouvée.")
return None, None, None
# Exemple d'utilisation
sauvegarder_progression(3, 1200, 5)
niveau, score, vie = charger_progression()
print(f"Niveau: {niveau}, Score: {score}, Vie: {vie}")
Explication :
open('sauvegarde.txt', 'w'): Ouvre un fichier en mode écriture. Si le fichier n'existe pas, il est créé.fichier.write(): Écrit les données (le niveau, le score et les vies) dans le fichier.open('sauvegarde.txt', 'r'): Ouvre le fichier en mode lecture pour récupérer les données.FileNotFoundError: Vérifie si le fichier existe, et évite une erreur si aucun fichier de sauvegarde n'a été trouvé.
Gestion des erreurs lors de la sauvegarde
Il est important de gérer les erreurs lors de l'enregistrement des fichiers, par exemple si l'application est arrêtée brusquement ou si le fichier est corrompu. Vous pouvez utiliser des exceptions pour gérer ces cas.
2. Sérialisation avec pickle ou JSON
Pour des données plus complexes (par exemple des objets ou des structures de données), vous pouvez utiliser la sérialisation. La sérialisation permet de convertir des objets Python en un format qui peut être stocké dans un fichier, puis restauré plus tard. Deux méthodes courantes de sérialisation en Python sont pickle et JSON.
Sérialisation avec pickle
pickle est une bibliothèque Python qui permet de sérialiser des objets complexes en un format binaire. C'est très utile pour sauvegarder des objets comme des classes, des listes ou des dictionnaires.
Voici comment utiliser pickle pour sauvegarder et charger des objets Python :
import pickle
# Sérialiser les données avec pickle
def sauvegarder_objet(objet, nom_fichier):
with open(nom_fichier, 'wb') as fichier:
pickle.dump(objet, fichier)
print("Objet sauvegardé avec pickle.")
# Charger des données sérialisées avec pickle
def charger_objet(nom_fichier):
try:
with open(nom_fichier, 'rb') as fichier:
objet = pickle.load(fichier)
print("Objet chargé avec pickle.")
return objet
except FileNotFoundError:
print("Aucune sauvegarde trouvée.")
return None
# Exemple d'utilisation
progression = {'niveau': 3, 'score': 1200, 'vie': 5}
sauvegarder_objet(progression, 'progression.pkl')
# Charger les données
progression_chargee = charger_objet('progression.pkl')
print(progression_chargee)
Explication :
pickle.dump(objet, fichier): Sauvegarde un objet Python dans un fichier binaire.pickle.load(fichier): Charge l'objet sérialisé à partir du fichier.
L'avantage de pickle est sa capacité à sérialiser presque n'importe quel objet Python. Cependant, comme pickle utilise un format binaire, les fichiers ne sont pas facilement lisibles par l'homme.
Sérialisation avec JSON
JSON (JavaScript Object Notation) est un format de données léger et lisible par l'homme, largement utilisé pour échanger des données. Contrairement à pickle, JSON ne supporte que des types de données simples comme les dictionnaires, les listes, les chaînes, et les nombres. C'est idéal pour les sauvegardes lisibles ou lorsque vous voulez échanger des données entre différentes applications.
Voici comment utiliser JSON pour sauvegarder et charger des données :
import json
# Sauvegarder les données avec JSON
def sauvegarder_json(donnees, nom_fichier):
with open(nom_fichier, 'w') as fichier:
json.dump(donnees, fichier)
print("Données sauvegardées avec JSON.")
# Charger des données à partir d'un fichier JSON
def charger_json(nom_fichier):
try:
with open(nom_fichier, 'r') as fichier:
donnees = json.load(fichier)
print("Données chargées avec JSON.")
return donnees
except FileNotFoundError:
print("Aucune sauvegarde trouvée.")
return None
# Exemple d'utilisation
progression = {'niveau': 3, 'score': 1200, 'vie': 5}
sauvegarder_json(progression, 'progression.json')
# Charger les données JSON
progression_chargee = charger_json('progression.json')
print(progression_chargee)
Avantages de JSON :
- Lisibilité : Les fichiers JSON peuvent être ouverts et lus dans un éditeur de texte.
- Compatibilité : JSON est largement utilisé et peut être lu par de nombreux langages.
3. Créer un système de scores et de classements
Dans les jeux vidéo, un système de scores permet de mesurer les performances des joueurs. Un système de classements peut également être mis en place pour comparer les scores de plusieurs joueurs.
Sauvegarder les scores dans un fichier JSON
Voici un exemple simple de système de scores où les scores des joueurs sont sauvegardés dans un fichier JSON.
import json
def ajouter_score(nom, score):
scores = charger_scores('scores.json')
scores.append({'nom': nom, 'score': score})
sauvegarder_json(scores, 'scores.json')
def sauvegarder_json(donnees, nom_fichier):
with open(nom_fichier, 'w') as fichier:
json.dump(donnees, fichier)
def charger_scores(nom_fichier):
try:
with open(nom_fichier, 'r') as fichier:
return json.load(fichier)
except FileNotFoundError:
return []
def afficher_classement(nom_fichier):
scores = charger_scores(nom_fichier)
scores_tries = sorted(scores, key=lambda x: x['score'], reverse=True)
print("Classement :")
for i, score in enumerate(scores_tries, 1):
print(f"{i}. {score['nom']} - {score['score']}")
# Exemple d'utilisation
ajouter_score('Alice', 1500)
ajouter_score('Bob', 3000)
afficher_classement('scores.json')
Explication :
ajouter_score(): Ajoute un score pour un joueur et le sauvegarde dans un fichier JSON.afficher_classement(): Trie les scores dans l'ordre décroissant et affiche le classement.
Avec ce système, les scores des joueurs sont sauvegardés et peuvent être consultés ou classés. Vous pouvez utiliser cette méthode pour créer des tableaux de scores en fin de partie.
Conclusion
Sauvegarder et charger des données de jeu est une fonctionnalité essentielle pour tout jeu vidéo. Que ce soit pour sauvegarder la progression des joueurs, sérialiser des objets complexes avec pickle ou JSON, ou encore pour créer un système de scores et de classements, Python et Pygame offrent des outils puissants et flexibles pour gérer ces fonctionnalités.
En maîtrisant ces techniques, vous pourrez offrir aux joueurs une expérience plus fluide et engageante, avec la possibilité de reprendre leur partie là où ils l'ont laissée.