So speichern und laden Sie Spieldaten in Arcade

Das Hinzufügen eines Speicher- und Ladesystems zu Ihrem Spiel kann das Spielerlebnis erheblich verbessern. Es ermöglicht den Spielern, ihren Fortschritt fortzusetzen, Spielsitzungen fortzusetzen und mit verschiedenen Strategien zu experimentieren, ohne hart erkämpfte Erfolge zu verlieren.

Sie werden angenehm überrascht sein, wie einfach es ist, diese Funktion mithilfe der Arcade-Bibliothek von Python zu Ihrem Spiel hinzuzufügen.

Erstellen Sie ein einfaches Spiel

Beginnen Sie mit dem Erstellen ein einfaches Spiel, bei dem der Spieler sich bewegen kann links und rechts.

Der in diesem Artikel verwendete Code ist hier verfügbar GitHub-Repository Die Nutzung steht Ihnen unter der MIT-Lizenz kostenlos zur Verfügung.

Erstellen Sie eine neue Datei mit dem Namen simple-game.py und fügen Sie den folgenden Code hinzu:

importieren Arkade





instagram viewer

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
blau = arcade.color. BLAU
KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 self.player_x = Breite // 2
defon_draw(selbst):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, Blau)
defaktualisieren(self, delta_time):
passieren
defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player_x -= PLAYER_SPEED
elif Schlüssel == arcade.key. RECHTS:
 self.player_x += PLAYER_SPEED
defhauptsächlich():
 window = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Wenn __name__ == '__hauptsächlich__':
 hauptsächlich()

Der Code erstellt ein Fenster mit einem blauen Rechteck, das den Player darstellt. Der Spieler kann sich mit der linken und rechten Pfeiltaste nach links und rechts bewegen.

Spielstatus verwalten

Um ein Speicher- und Ladesystem zu implementieren, müssen Sie verschiedene Spielzustände verwalten. Ein Spielstatus stellt den aktuellen Stand des Spiels dar, einschließlich der Positionen von Objekten, Spielständen und anderen relevanten Daten. Konzentrieren Sie sich in diesem Beispiel nur auf die x-Koordinate des Spielers.

Um Spielzustände zu verwalten, führen Sie a ein GameState Klasse, die die Spieldaten kapselt und Methoden zum Speichern und Laden bereitstellt. Hier ist der Code:

KlasseGameState:
def__drin__(selbst):
 self.player_x = 0

Speichern der Spieldaten

Um die Spieldaten zu speichern, erweitern Sie die GameWindow Klasse und fügen Sie eine Methode hinzu, um den Spielstatus bei Bedarf zu speichern. Verwenden Sie der Einfachheit halber das JSON-Format. Hier ist der Code:

Im Spiel speichern Methode, Erstellen Sie ein Python-Wörterbuch mit den relevanten Spieldaten. Serialisieren Sie es dann in eine JSON-Datei mit dem Namen save.json.

importieren json
KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 self.game_state = GameState()
defSpiel speichern(selbst):
 Daten = {
'player_x': self.game_state.player_x
 }
mit offen('save.json', 'w') als Datei:
 json.dump (Daten, Datei)
 drucken (Daten)
defon_draw(selbst):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, Blau)
defaktualisieren(self, delta_time):
passieren
defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.game_state.player_x -= PLAYER_SPEED
elif Schlüssel == arcade.key. RECHTS:
 self.game_state.player_x += PLAYER_SPEED
elif Schlüssel == arcade.key. S:
 self.save_game()

Laden der Spieldaten

Um die Spieldaten zu laden, erweitern Sie die GameWindow Klasse weiter und fügen Sie eine Methode zum Laden des Spielstatus hinzu. Erstellen Sie eine neue Datei mit dem Namen laden-game.py und fügen Sie den Code mit den folgenden Updates hinzu:

KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 self.game_state = GameState()
 self.load_game()
defSpiel laden(selbst):
versuchen:
mit offen('save.json', 'R') als Datei:
 data = json.load (Datei)
 self.game_state.player_x = Daten['player_x']
außer FileNotFoundError:
passieren
defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. L:
 self.load_game()

Der Spiel laden Methode versucht, die zu öffnen save.json Datei und rufen Sie die Spieldaten ab. Anschließend wird der Spielstatus mit den geladenen Daten aktualisiert. Wenn die Datei nicht vorhanden ist, können Sie die Ausnahme einfach ignorieren und den Standardspielstatus beibehalten.

Inklusive zusätzlicher Funktionen

Sie können weitere Funktionen hinzufügen, um das Speicher- und Ladesystem des Spiels zu verbessern.

Highscores speichern

Das Speichern von Highscores neben dem Spielstatus ist in vielen Spielen üblich. Du kannst die Punkte verwalten und speichern Sie den Highscore mit diesem System. Erstellen Sie eine neue Datei mit dem Namen high-score.py und fügen Sie den Code mit den folgenden Updates hinzu:

KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 self.high_score = 0
defSpiel laden(selbst):
versuchen:
mit offen('save.json', 'R') als Datei:
 data = json.load (Datei)
 drucken (Daten)
 self.player_x = data.get('player_x', self.player_x)
 self.high_score = data.get('Highscore', self.high_score)
außer FileNotFoundError:
passieren
defSpiel speichern(selbst):
 Daten = {
'player_x': self.player_x,
'Highscore': self.high_score
 }
mit offen('save.json', 'w') als Datei:
 json.dump (Daten, Datei)
 drucken (Daten)
defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player_x -= PLAYER_SPEED
elif Schlüssel == arcade.key. RECHTS:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Automatische Speicherfunktion

Um den Spielern Sicherheit zu geben und Fortschrittsverluste zu vermeiden, können Sie den Spielstatus in regelmäßigen Abständen automatisch speichern. Erstellen Sie eine neue Datei mit dem Namen auto-save.py und fügen Sie den Code mit den folgenden Updates hinzu:

importieren Zeit
KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 self.game_state = GameState()
# Alle 6 Sekunden speichern
 self.autosave_interval = 6
 self.last_save_time = time.time()
defaktualisieren(self, delta_time):
 current_time = time.time()
 time_diff = current_time – self.last_save_time
Wenn time_diff >= self.autosave_interval:
 self.save_game()
 drucken("Gerettet")
 self.last_save_time = current_time

In diesem Codeausschnitt ist die aktualisieren Die Methode prüft, ob seit dem letzten Speichern das angegebene Zeitintervall vergangen ist. Wenn ja, löst es das aus Spiel speichern Methode der GameWindow Klasse, um den Spielstatus automatisch zu speichern. Verstelle die autosave_interval Wert entsprechend den Anforderungen Ihres Spiels.

Spieldaten validieren

Die Validierung der geladenen Spieldaten ist wichtig, um deren Integrität und Konsistenz sicherzustellen. Sie können die Datenvalidierung ganz einfach in unser Speicher- und Ladesystem integrieren:

KlasseGameState:
def__drin__(selbst):
 self.player_x = 0
defsicherer Staat(selbst):
Wenn self.is_valid_state():
 Daten = {
'player_x': self.player_x
 }
mit offen('save.json', 'w') als Datei:
 json.dump (Daten, Datei)
defLadezustand(selbst):
mit offen('save.json', 'R') als Datei:
 data = json.load (Datei)
Wenn self.validate_loaded_data (Daten):
 self.player_x = Daten['player_x']
anders:
 drucken("Fehler!")
defis_valid_state(selbst):
# Führen Sie hier eine Validierungslogik aus
# Gibt „True“ zurück, wenn der Status gültig ist, andernfalls „False“.
passieren
defvalidieren_geladene_Daten(Selbst, Daten):
# Führen Sie eine Validierung der geladenen Daten durch
# Gibt „True“ zurück, wenn die Daten gültig sind, andernfalls „False“.
passieren

Durch die Integration dieser zusätzlichen Funktionen in das Speicher- und Ladesystem können Sie ein vielseitigeres und robusteres Gameplay erstellen Erfahrung und bietet Spielern die Möglichkeit, mehrere Spielstände zu speichern, Highscores zu verfolgen, die automatische Speicherung zu aktivieren und Daten sicherzustellen Integrität.

Best Practices für das Speicher- und Ladesystem

Die Implementierung eines Speicher- und Ladesystems ist ein wichtiger Aspekt der Spieleentwicklung. Um ein robustes und zuverlässiges System zu gewährleisten, ist es wichtig, Best Practices zu befolgen. Hier sind einige wichtige Praktiken, die Sie berücksichtigen sollten:

Sensible Daten verschlüsseln

Wenn Ihr Spiel vertrauliche Informationen wie Passwörter, persönliche Daten oder In-App-Käufe enthält, ist es wichtig, den gespeicherten Spielstatus zu verschlüsseln. Die Verschlüsselung bietet eine zusätzliche Sicherheitsebene, schützt die Privatsphäre des Spielers und verhindert unbefugten Zugriff auf seine Daten. Nutzen Sie Verschlüsselungsalgorithmen und -bibliotheken, um vertrauliche Informationen zu schützen.

Geladene Daten validieren

Vor dem Laden der Spieldaten ist es wichtig, diese zu validieren, um ihre Integrität und Konsistenz sicherzustellen. Stellen Sie sicher, dass die geladenen Daten dem erwarteten Format, der Struktur und den Einschränkungen Ihres Spiels entsprechen.

Führen Sie Validierungsprüfungen für kritische Datenfelder durch, um Abstürze oder Betrug zu vermeiden. Implementieren Sie robuste Datenvalidierungsmechanismen, um potenzielle Fehler oder unerwartete Daten zu verarbeiten.

Gehen Sie ordnungsgemäß mit Fehlern um

Beim Umgang mit Datei-E/A-Vorgängen können Fehler auftreten. Es ist von entscheidender Bedeutung, diese Fehler ordnungsgemäß zu behandeln und dem Player informative Fehlermeldungen bereitzustellen. Ausnahmen abfangen und behandeln, z FileNotFoundError oder Berechtigungsfehler, während Speicher- und Ladevorgängen.

Zeigen Sie benutzerfreundliche Fehlermeldungen an, um den Spielern Orientierung zu geben und Frustrationen vorzubeugen. Erwägen Sie außerdem die Implementierung einer Fehlerprotokollierung, um die Diagnose und Behebung von Problemen zu erleichtern.

Testen Sie die Speicher- und Ladefunktion

Testen Sie die Speicher- und Ladefunktion Ihres Spiels gründlich, um dessen Zuverlässigkeit und Korrektheit sicherzustellen. Erstellen Sie Testfälle, die verschiedene Szenarien abdecken, z. B. das Speichern in verschiedenen Spielzuständen, das Laden aus gültigen und ungültigen Speicherdateien und das Testen von Randfällen.

Überprüfen Sie, ob der Spielstatus ordnungsgemäß gespeichert und geladen wurde und das erwartete Verhalten auftritt. Automatisierte Test-Frameworks können bei der Erstellung umfassender Testsuiten helfen.

Machen Sie Spiele mit dem Speicher- und Ladesystem noch unterhaltsamer

Das Hinzufügen eines Speicher- und Ladesystems kann Spiele spannender machen, indem es den Spielern ein Gefühl von Kontinuität und Fortschritt vermittelt. Spieler können frei experimentieren, verschiedene Ansätze ausprobieren und später zum Spiel zurückkehren, ohne ihre Erfolge zu verlieren.

Diese Funktion ermöglicht es den Spielern auch, mit Freunden zu konkurrieren oder sich selbst herauszufordern, ihre vorherigen Highscores zu übertreffen, was Ihrem Spiel Wiederspielbarkeit und langfristiges Engagement verleiht.