À moins que votre jeu ne soit très court, il est utile de pouvoir enregistrer la progression. Même les jeux courts peuvent bénéficier de la sauvegarde des scores élevés.
L'ajout d'un système de sauvegarde et de chargement à votre jeu peut grandement améliorer l'expérience du joueur. Il permet aux joueurs de poursuivre leur progression, de reprendre les sessions de jeu et d'expérimenter différentes stratégies sans perdre les réalisations durement gagnées.
Vous serez agréablement surpris de voir à quel point il est simple d'ajouter cette fonctionnalité à votre jeu à l'aide de la bibliothèque Python's Arcade.
Créer un jeu simple
Commencez par créer un jeu simple où le joueur peut se déplacer gauche et droite.
Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.
Créer un nouveau fichier nommé jeu-simple.py et ajoutez le code ci-dessous :
importer arcadeSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
bleu = arcade.color. BLEUclasseFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
super().__init__(largeur, hauteur)
self.player_x = largeur // 2définitivementon_draw(soi):
arcade.start_render()
arcade.draw_rectangle_filled (self.game_state.player_x,
50, 50, 50, bleu)définitivementmise à jour(soi, delta_time):
passerdéfinitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
self.player_x -= PLAYER_SPEED
elif clé == arcade.clé. DROITE:
self.player_x += PLAYER_SPEEDdéfinitivementprincipal():
window = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
si __nom__ == '__principal__':
principal()
Le code crée une fenêtre avec un rectangle bleu représentant le joueur. Le joueur peut se déplacer à gauche et à droite en utilisant les touches fléchées gauche et droite.
Gérer les états du jeu
Pour implémenter un système de sauvegarde et de chargement, vous devez gérer différents états de jeu. Un état de jeu représente l'état actuel du jeu, y compris les positions des objets, les scores et d'autres données pertinentes. Pour cet exemple, concentrez-vous uniquement sur la coordonnée x du joueur.
Pour gérer les états du jeu, introduisez un État du jeu classe qui encapsule les données du jeu et fournit des méthodes pour les enregistrer et les charger. Voici le code :
classeÉtat du jeu:
définitivement__init__(soi):
self.player_x = 0Sauvegarde des données de jeu
Pour sauvegarder les données du jeu, étendez le Fenêtre de jeu classe et ajoutez une méthode pour enregistrer l'état du jeu chaque fois que nécessaire. Utilisez le format JSON pour plus de simplicité. Voici le code :
Dans le sauvegarder la partie méthode, créer un dictionnaire Python contenant les données de jeu pertinentes. Ensuite, sérialisez-le dans un fichier JSON appelé save.json.
importer jsonclasseFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
super().__init__(largeur, hauteur)
self.game_state = GameState()définitivementsauvegarder la partie(soi):
données = {
'joueur_x': self.game_state.player_x
}
avec ouvrir('sauvegarder.json', 'w') comme déposer:
json.dump (données, fichier)
imprimer (données)définitivementon_draw(soi):
arcade.start_render()
arcade.draw_rectangle_filled (self.game_state.player_x,
50, 50, 50, bleu)définitivementmise à jour(soi, delta_time):
passer
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
self.game_state.player_x -= PLAYER_SPEED
elif clé == arcade.clé. DROITE:
self.game_state.player_x += PLAYER_SPEED
elif clé == arcade.clé. S :
self.save_game()
Chargement des données de jeu
Pour charger les données du jeu, étendez le Fenêtre de jeu classez plus loin et ajoutez une méthode pour charger l'état du jeu. Créer un nouveau fichier nommé load-game.py et ajoutez le code avec les mises à jour ci-dessous :
classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
super().__init__(largeur, hauteur)
self.game_state = GameState()
self.load_game()définitivementchargement du jeu(soi):
essayer:
avec ouvrir('sauvegarder.json', 'r') comme déposer:
data = json.load (fichier)
self.game_state.player_x = données['joueur_x']
sauf FileNotFoundError :
passer
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. L :
self.load_game()
Le chargement du jeu méthode tente d'ouvrir le save.json fichier et récupérer les données du jeu. Il met ensuite à jour l'état du jeu avec les données chargées. Si le fichier n'existe pas, vous pouvez simplement ignorer l'exception, en laissant l'état du jeu par défaut.
Inclure des fonctionnalités supplémentaires
Vous pouvez ajouter plus de fonctionnalités pour améliorer le système de sauvegarde et de chargement du jeu.
Enregistrement des meilleurs scores
La sauvegarde des meilleurs scores parallèlement à l'état du jeu est une caractéristique commune à de nombreux jeux. Tu peux gérer les pointages et enregistrez le meilleur score en utilisant ce système. Créer un nouveau fichier nommé high-score.py et ajoutez le code avec les mises à jour ci-dessous :
classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
super().__init__(largeur, hauteur)
self.high_score = 0définitivementchargement du jeu(soi):
essayer:
avec ouvrir('sauvegarder.json', 'r') comme déposer:
data = json.load (fichier)
imprimer (données)
self.player_x = data.get('joueur_x', self.player_x)
self.high_score = data.get('score élevé', self.high_score)
sauf FileNotFoundError :
passerdéfinitivementsauvegarder la partie(soi):
données = {
'joueur_x': self.player_x,
'score élevé': self.high_score
}
avec ouvrir('sauvegarder.json', 'w') comme déposer:
json.dump (données, fichier)
imprimer (données)
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
self.player_x -= PLAYER_SPEED
elif clé == arcade.clé. DROITE:
self.player_x += PLAYER_SPEED
self.high_score += 1
Fonction d'enregistrement automatique
Pour offrir aux joueurs la tranquillité d'esprit et éviter la perte de progression, vous pouvez enregistrer automatiquement l'état du jeu à intervalles réguliers. Créer un nouveau fichier nommé auto-save.py et ajoutez le code avec les mises à jour ci-dessous :
importer tempsclasseFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
super().__init__(largeur, hauteur)
self.game_state = GameState()# Enregistrer toutes les 6 secondes
self.autosave_interval = 6
self.last_save_time = time.time()définitivementmise à jour(soi, delta_time):
heure_actuelle = heure.heure()
time_diff = current_time - self.last_save_time
si time_diff >= self.autosave_interval :
self.save_game()
imprimer("Enregistré")
self.last_save_time = heure_actuelle
Dans cet extrait de code, le mise à jour La méthode vérifie si l'intervalle de temps spécifié s'est écoulé depuis le dernier enregistrement. Si c'est le cas, cela déclenche le sauvegarder la partie méthode de la Fenêtre de jeu classe pour enregistrer automatiquement l'état du jeu. Ajuste le intervalle de sauvegarde automatique valeur selon les exigences de votre jeu.
Validation des données de jeu
La validation des données de jeu chargées est essentielle pour garantir leur intégrité et leur cohérence. Vous pouvez facilement intégrer la validation des données dans notre système de sauvegarde et de chargement :
classeÉtat du jeu:
définitivement__init__(soi):
self.player_x = 0définitivementsave_state(soi):
si self.is_valid_state() :
données = {
'joueur_x': self.player_x
}avec ouvrir('sauvegarder.json', 'w') comme déposer:
json.dump (données, fichier)définitivementÉtat de chargement(soi):
avec ouvrir('sauvegarder.json', 'r') comme déposer:
data = json.load (fichier)si self.validate_loaded_data (données) :
self.player_x = données['joueur_x']
autre:
imprimer("Erreur!")définitivementest_état_valide(soi):
# Effectuez la logique de validation ici
# Renvoie True si l'état est valide, False sinon
passer
définitivementvalider_loaded_data(soi, données):
# Effectuer la validation sur les données chargées
# Renvoie True si la donnée est valide, False sinon
passer
En incorporant ces fonctionnalités supplémentaires dans le système de sauvegarde et de chargement, vous pouvez créer un gameplay plus polyvalent et robuste expérience, offrant aux joueurs la possibilité de sauvegarder plusieurs états de jeu, de suivre les meilleurs scores, d'activer la sauvegarde automatique et de garantir les données intégrité.
Meilleures pratiques pour le système de sauvegarde et de chargement
La mise en œuvre d'un système de sauvegarde et de chargement est un aspect important du développement d'un jeu. Pour assurer un système robuste et fiable, il est essentiel de suivre les meilleures pratiques. Voici quelques pratiques clés à considérer :
Crypter les données sensibles
Si votre jeu contient des informations sensibles telles que des mots de passe, des données personnelles ou des achats intégrés, il est crucial de chiffrer l'état du jeu enregistré. Le cryptage ajoute une couche de sécurité supplémentaire, protégeant la vie privée du joueur et empêchant l'accès non autorisé à ses données. Utilisez des algorithmes de chiffrement et des bibliothèques pour protéger les informations sensibles.
Valider les données chargées
Avant de charger les données du jeu, il est essentiel de les valider pour s'assurer de leur intégrité et de leur cohérence. Vérifiez que les données chargées respectent le format, la structure et les contraintes attendus de votre jeu.
Effectuez des contrôles de validation sur les champs de données critiques pour éviter les plantages ou la triche. Mettez en œuvre des mécanismes de validation des données robustes pour gérer les erreurs potentielles ou les données inattendues.
Gérer les erreurs avec grâce
Lorsque vous traitez des opérations d'E/S de fichiers, des erreurs peuvent se produire. Il est crucial de gérer ces erreurs avec élégance et de fournir des messages d'erreur informatifs au joueur. Intercepter et gérer les exceptions, telles que FileNotFoundError ou PermissionError, pendant les opérations de sauvegarde et de chargement.
Affichez des messages d'erreur conviviaux pour guider les joueurs et éviter les frustrations. En outre, envisagez d'implémenter la journalisation des erreurs pour aider à diagnostiquer et à résoudre les problèmes.
Tester la fonctionnalité de sauvegarde et de chargement
Testez soigneusement la fonctionnalité de sauvegarde et de chargement de votre jeu pour vous assurer de sa fiabilité et de son exactitude. Créez des cas de test qui couvrent divers scénarios, tels que la sauvegarde dans différents états de jeu, le chargement à partir de fichiers de sauvegarde valides et non valides et le test de cas extrêmes.
Vérifiez que l'état du jeu est correctement enregistré et chargé et que le comportement attendu se produit. Les cadres de test automatisés peuvent aider à créer des suites de tests complètes.
Rendez les jeux plus amusants avec le système de sauvegarde et de chargement
L'ajout d'un système de sauvegarde et de chargement peut rendre les jeux plus attrayants en offrant aux joueurs un sentiment de continuité et de progression. Les joueurs peuvent expérimenter librement, essayer différentes approches et revenir au jeu plus tard sans perdre leurs réalisations.
Cette fonctionnalité permet également aux joueurs de rivaliser avec des amis ou de se mettre au défi de battre leurs meilleurs scores précédents, ajoutant ainsi une rejouabilité et un engagement à long terme à votre jeu.