So implementieren Sie die Funktion zum Speichern und Laden in PyGame

In der modernen Spieleentwicklung ist die Möglichkeit, Spielfortschritte zu speichern und zu laden, eine entscheidende Funktion, die das Benutzererlebnis und das Engagement verbessert. PyGame, eine beliebte Bibliothek zum Erstellen von 2D-Spielen in Python, bietet die notwendigen Tools, um die Funktion zum Speichern und Laden mühelos zu implementieren.

Ein einfaches Spiel erstellen

Bevor Sie beginnen, stellen Sie sicher, dass Sie dies getan haben pip auf Ihrem Gerät installiert. Führen Sie nach der Installation von pip den folgenden Befehl aus, um das zu installieren Pygame Modul:

Pip Pygame installieren

Um die Implementierung eines Speicher- und Ladesystems in PyGame zu veranschaulichen, erstellen Sie zunächst ein einfaches Spiel.

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

In diesem Spiel hat der Spieler die Möglichkeit, sich nach links und rechts zu bewegen. Hier ist ein Beispiel-Codeausschnitt, der die grundlegende Spielstruktur demonstriert:

importieren Pygame
# Pygame initialisieren
pygame.init()
# Richten Sie das Spielfenster ein
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption(„Tutorial zum Speichern und Laden des Systems“)
# Spielvariablen
Spieler_x = 400
player_y = 500
player_speed = 5
# Spielschleife
laufen = WAHR
während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == pygame. AUFHÖREN:
 laufen = FALSCH
 Schlüssel = pygame.key.get_pressed()
Wenn Schlüssel[pygame. K_LEFT]:
 Spieler_x -= Spielergeschwindigkeit
Wenn Schlüssel[pygame. K_RIGHT]:
 Spieler_x += Spielergeschwindigkeit
# Löschen Sie den Bildschirm
 window.fill((0, 0, 0))
# Zeichne den Spieler
 pygame.draw.rect (Fenster, (255, 255, 255), (Spieler_x, Spieler_y, 50, 50))
# Aktualisieren Sie die Anzeige
 pygame.display.flip()
# Das Spiel verlassen
pygame.quit()

Verwalten des Spielstatus und der Datenpersistenz

Bevor Sie die Speicher- und Ladefunktion implementieren, müssen Sie eine Möglichkeit einrichten, den Spielstatus zu verwalten und die Daten beizubehalten. Ein gängiger Ansatz ist Verwenden Sie ein Python-Wörterbuch um die relevanten Spieldaten zu speichern. Hier ist ein Beispiel dafür, wie Sie den vorherigen Code ändern können, um die Spielstatusverwaltung einzubeziehen:

# Spielvariablen
game_state = {
'player_x': 400,
'player_y': 500
}
# Spielschleife
laufen = WAHR
während Betrieb:
# ...
 Schlüssel = pygame.key.get_pressed()
Wenn Schlüssel[pygame. K_LEFT]:
 game_state['player_x'] -= Spielergeschwindigkeit
Wenn Schlüssel[pygame. K_RIGHT]:
 game_state['player_x'] += Spielergeschwindigkeit
# ...
 pygame.display.flip()

Implementierung der Speicher- und Ladefunktion

Um das Speichern und Laden des Spielfortschritts zu ermöglichen, können Sie die integrierte Funktion von Python nutzen Essiggurke Modul, mit dem wir Python-Objekte serialisieren und deserialisieren können. Erstellen Sie eine neue Datei mit dem Namen save-game.py und fügen Sie den Code mit den folgenden Updates hinzu:

game_state = {
'player_x': Spieler_x,
'player_y': Spieler_y
}
# Spielstatus speichern
defsave_game_state(game_state, file_name):
versuchen:
mit öffnen (Dateiname, 'wb') als Datei:
 pickle.dump (game_state, Datei)
 drucken(„Spielstatus erfolgreich gespeichert!“)
außer IOError:
 drucken(„Fehler: Spielstatus konnte nicht gespeichert werden.“)
# Spielstatus laden
defLoad_Game_State(Dateinamen):
versuchen:
mit öffnen (Dateiname, 'rb') als Datei:
 game_state = pickle.load (Datei)
 drucken(„Spielstatus erfolgreich geladen!“)
zurückkehren game_state
außer (IOError, pickle. UnpicklingError):
 drucken(„Fehler: Spielstatus konnte nicht geladen werden.“)
# Spielschleife
laufen = WAHR
während Betrieb:
# ...
 Schlüssel = pygame.key.get_pressed()
Wenn Schlüssel[pygame. K_LEFT]:
 Spieler_x -= Spielergeschwindigkeit
 game_state['player_x'] = Spieler_x
Wenn Schlüssel[pygame. K_RIGHT]:
 Spieler_x += Spielergeschwindigkeit
 game_state['player_x'] = Spieler_x
Wenn Schlüssel[pygame. K_s]:
 save_game_state (game_state, 'save_game.pickle')
Wenn Schlüssel[pygame. K_l]:
 game_state = load_game_state('save_game.pickle')
 player_x = game_state['player_x']

# ...
# ...

Unten ist die Ausgabe:

Entwerfen einer Benutzeroberfläche für Speicherplätze

Um eine Schnittstelle zum Speichern und Laden bereitzustellen, können Sie Speicherslots anzeigen, die es dem Spieler ermöglichen, auszuwählen, welcher Slot gespeichert oder geladen werden soll. In diesem Beispiel werden die Optionen in der Konsole angezeigt, Sie können sie aber verwenden Pythons GUI-Frameworks zur Schaffung einer benutzerfreundlicheren Oberfläche.

Ein... kreieren save_slots Liste, die die verfügbaren Speicherplätze darstellt. Fügen Sie außerdem a hinzu ausgewählter_Steckplatz Variable, um den vom Spieler gewählten Slot zu verfolgen.

Zeigt die verfügbaren Speicherplätze an, wenn der Spieler die Speichertaste drückt (K_s). Der Spieler kann einen Slot auswählen, indem er die entsprechende Zifferntaste drückt (K_1, K_2, oder K_3). Wenn ein Slot ausgewählt ist, wird der Spielstatus in einer Datei gespeichert, die nach dem ausgewählten Slot benannt ist.

Ähnlich verhält es sich, wenn der Spieler die Ladetaste drückt (K_l), zeigen Sie die Speicherplätze an. Der Spieler kann durch Drücken der Tasten einen Slot auswählen K_a, K_b, oder K_c um den Spielstand zu laden. Alternativ können Sie Verwenden Sie Touch-Eingaben anstelle von Tastatureingaben zur Steckplatzauswahl. Wird ein Slot ausgewählt, wird der Spielstand aus der entsprechenden Datei geladen.

Erstellen Sie eine neue Datei mit dem Namen interface.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Spielvariablen
save_slots = ['Schlitz 1', 'Steckplatz 2', 'Slot 3']
selected_slot = Keiner
# Spielschleife
laufen = WAHR
während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == pygame. AUFHÖREN:
 laufen = FALSCH
Wenn event.type == pygame. TASTE NACH UNTEN:
Wenn event.key == pygame. K_s:
# Speicherplätze anzeigen
 selected_slot = Keiner
für ich, Schlitz In aufzählen (save_slots):
 drucken(f"Slot speichern {i+1}: {Slot}")
 drucken(„Wählen Sie einen Slot, um das Spiel zu speichern.“)
Wenn event.key == pygame. K_l:
 drucken(„Steckplatz auswählen: a – Steckplatz 1, b – Steckplatz 3, c – Steckplatz 3“)
# Speicherplätze anzeigen
 selected_slot = Keiner
für ich, Schlitz In aufzählen (save_slots):
 drucken(f"Slot speichern {i+1}: {Slot}")
 drucken(„Wählen Sie einen Slot, um das Spiel zu laden.“)
Wenn event.key In [pygame. K_1, Pygame. K_2, Pygame. K_3]:
# Spiel basierend auf dem ausgewählten Slot speichern oder laden
 Slot_index = event.key – Pygame. K_1
 selected_slot = save_slots[slot_index]

 save_game_state (game_state, F"{selected_slot}.Essiggurke")
 drucken(f"Spiel gespeichert in {selected_slot}!")
Wenn event.key In [pygame. K_a, Pygame. K_b, Pygame. K_c]:

 Slot_index = event.key – Pygame. K_a
 selected_slot = save_slots[slot_index]
 game_state = load_game_state(F"{selected_slot}.Essiggurke")
 player_x = game_state['player_x']
 drucken(f"Spiel geladen von {selected_slot}!")
# ...
 pygame.display.flip()
# ...

Unten ist die Ausgabe:

Umgang mit Überschreiboptionen

Um Optionen zum Überschreiben vorhandener Speicherstände bereitzustellen, können Sie eine Warnmeldung implementieren, die den Player vor dem Überschreiben einer Sicherungsdatei zur Bestätigung auffordert. Erstellen Sie eine neue Datei mit dem Namen overwriting-save.py und ändern Sie den Code mit den folgenden Updates:

# Spielstatus speichern
defsave_game_state(game_state, file_name):
Wenn os.path.exists (Dateiname):
# Zur Bestätigung auffordern, die vorhandene Sicherungsdatei zu überschreiben
 überschreiben = Eingabe(„Speicherdatei existiert bereits. Möchtest du überschreiben? (j/n): „)
Wenn overwrite.lower() != 'y':
 drucken(„Speichern abgebrochen.“)
zurückkehren
versuchen:
mit öffnen (Dateiname, 'wb') als Datei:
 pickle.dump (game_state, Datei)
 drucken(„Spielstatus erfolgreich gespeichert!“)
außer IOError:
 drucken(„Fehler: Spielstatus konnte nicht gespeichert werden.“)
# ...
# Spielstatus laden
defLoad_Game_State(Dateinamen):
Wennnicht os.path.exists (Dateiname):
 drucken(„Fehler: Speicherdatei existiert nicht.“)
zurückkehrenKeiner
versuchen:
mit öffnen (Dateiname, 'rb') als Datei:
 game_state = pickle.load (Datei)
 drucken(„Spielstatus erfolgreich geladen!“)
zurückkehren game_state
außer (IOError, pickle. UnpicklingError):
 drucken(„Fehler: Spielstatus konnte nicht geladen werden.“)
zurückkehrenKeiner
# ...

Im obigen Code überprüfen Sie vor dem Speichern eines Spielstatus, ob die Speicherdatei bereits vorhanden ist os.path.exists(). Wenn dies der Fall ist, fordern Sie den Player zur Bestätigung auf, dass die vorhandene Sicherungsdatei überschrieben werden soll. Wenn der Spieler sich dafür entscheidet, nicht zu überschreiben, wird der Speichervorgang abgebrochen.

Ebenso überprüfen Sie vor dem Laden eines Spielstatus, ob die Sicherungsdatei vorhanden ist os.path.exists(). Ist dies nicht der Fall, informieren Sie den Spieler mit einer Fehlermeldung.

Best Practices für das Speichern und Laden des Systems

Berücksichtigen Sie bei der Implementierung eines Speicher- und Ladesystems in PyGame oder einem anderen Spieleentwicklungsprojekt die folgenden Best Practices:

• Verwenden Sie eine wohldefinierte Datenstruktur, um den Spielstatus darzustellen, und serialisieren Sie ihn mithilfe einer Serialisierungsbibliothek wie z Essiggurke. Dadurch können Sie den gesamten Spielstand einfach speichern und laden.
• Erstellen Sie ein spezielles Verzeichnis oder einen Ordner zum Speichern gespeicherter Dateien. Dies hilft bei der Organisation der gespeicherten Dateien und verhindert ein Überladen des Hauptspielverzeichnisses.
• Implementieren Sie die Fehlerbehandlung und stellen Sie informative Fehlermeldungen zur Verfügung, um das Debuggen und die Fehlerbehebung zu unterstützen. Dies hilft den Spielern, alle Probleme zu verstehen, die während der Speicher- und Ladevorgänge auftreten können.
• Erwägen Sie die Implementierung mehrerer Speicherplätze, um den Spielern die Möglichkeit zu geben, mehrere Spielstände zu speichern. Dies gibt Spielern die Flexibilität, verschiedene Pfade zu erkunden oder bestimmte Abschnitte des Spiels noch einmal zu spielen, ohne ihren Fortschritt zu überschreiben.

Machen Sie Spiele mit dem Speicher- und Ladesystem ansprechender

Das Hinzufügen der Funktion zum Speichern und Laden kann das Engagement und den Spaß an einem Spiel erheblich steigern. Es ermöglicht den Spielern, ihren Fortschritt zu speichern und nach Belieben zum Spiel zurückzukehren. Darüber hinaus eröffnet es Möglichkeiten zur Schaffung komplexer Spielwelten, in denen Entscheidungen und Aktionen der Spieler nachhaltige Konsequenzen haben.

Durch die Implementierung eines Speicher- und Ladesystems können Sie Ihren Spielern ein noch intensiveres und zufriedenstellenderes Spielerlebnis ermöglichen.