Spelgegevens opslaan en laden in Arcade

Het toevoegen van een opslag- en laadsysteem aan je game kan de spelerservaring aanzienlijk verbeteren. Hiermee kunnen spelers hun voortgang voortzetten, gameplay-sessies hervatten en experimenteren met verschillende strategieën zonder zuurverdiende prestaties te verliezen.

Je zult aangenaam verrast zijn hoe eenvoudig het is om deze functie aan je game toe te voegen met behulp van de Arcade-bibliotheek van Python.

Maak een eenvoudig spel

Begin met creëren een eenvoudig spel waarbij de speler kan bewegen links en rechts.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Maak een nieuw bestand met de naam simpel-spel.py en voeg onderstaande code toe:

importeren arcade
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
SPELER_SPEED = 5
blauw = arcade.kleur. BLAUW
klasGameWindow(arcade. Raam):





instagram viewer

def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 2

defon_draw(zelf):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, blauw)
defupdate(zelf, delta_tijd):
doorgang
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.player_x -= PLAYER_SPEED
elif sleutel == arcade.sleutel. RECHTS:
 self.player_x += PLAYER_SPEED
defvoornaamst():
 venster = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()
als __naam__ == '__voornaamst__':
 voornaamst()

De code creëert een venster met een blauwe rechthoek die de speler voorstelt. De speler kan naar links en rechts bewegen met de linker en rechter pijltjestoetsen.

Spelstatussen beheren

Om een ​​opslag- en laadsysteem te implementeren, moet je verschillende spelstatussen beheren. Een spelstatus vertegenwoordigt de huidige status van het spel, inclusief de posities van objecten, scores en andere relevante gegevens. Focus voor dit voorbeeld alleen op de x-coördinaat van de speler.

Om spelstatussen te beheren, introduceert u een GameState klasse die de gegevens van het spel inkapselt en methoden biedt om deze op te slaan en te laden. Hier is de code:

klasGameState:
def__in het__(zelf):
 zelf.speler_x = 0

De spelgegevens opslaan

Om de spelgegevens op te slaan, verlengt u het GameWindow class en voeg een methode toe om de spelstatus op te slaan wanneer dat nodig is. Gebruik het JSON-formaat voor eenvoud. Hier is de code:

In de spel opslaan methode, maak een Python-woordenboek met de relevante spelgegevens. Serialiseer het vervolgens in een JSON-bestand met de naam opslaan.json.

importeren json
klasGameWindow(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.game_state = GameState()
defspel opslaan(zelf):
 gegevens = {
'speler_x': self.game_state.player_x
 }
met open('opslaan.json', 'w') als bestand:
 json.dump (gegevens, bestand)
 afdrukken (gegevens)
defon_draw(zelf):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, blauw)
defupdate(zelf, delta_tijd):
doorgang
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.game_state.player_x -= PLAYER_SPEED
elif sleutel == arcade.sleutel. RECHTS:
 self.game_state.player_x += PLAYER_SPEED
elif sleutel == arcade.sleutel. S:
 zelf.save_game()

De spelgegevens laden

Om de spelgegevens te laden, verlengt u het GameWindow klasse verder en voeg een methode toe om de spelstatus te laden. Maak een nieuw bestand met de naam load-game.py en voeg de code toe met de onderstaande updates:

klasGameWindow(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.game_state = GameState()
 zelf.load_game()
defspel laden(zelf):
poging:
met open('opslaan.json', 'R') als bestand:
 data = json.load (bestand)
 self.game_state.player_x = gegevens['speler_x']
behalve FileNotFoundError:
doorgang
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. L:
 zelf.load_game()

De spel laden methode probeert het opslaan.json bestand en haal de spelgegevens op. Vervolgens wordt de spelstatus bijgewerkt met de geladen gegevens. Als het bestand niet bestaat, kun je de uitzondering gewoon negeren en de standaard spelstatus behouden.

Inclusief extra functies

Je kunt meer functies toevoegen om het opslag- en laadsysteem van de game te verbeteren.

Hoge scores opslaan

Het opslaan van hoge scores naast de spelstatus is een veelvoorkomend kenmerk in veel spellen. Jij kan de scores beheren en sla de hoogste score op met behulp van dit systeem. Maak een nieuw bestand met de naam hoge score.py en voeg de code toe met de onderstaande updates:

klasGameWindow(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 zelf.high_score = 0
defspel laden(zelf):
poging:
met open('opslaan.json', 'R') als bestand:
 data = json.load (bestand)
 afdrukken (gegevens)
 self.player_x = data.get('speler_x', zelf.speler_x)
 zelf.hoge_score = data.get('hoogste score', zelf.hoge_score)
behalve FileNotFoundError:
doorgang
defspel opslaan(zelf):
 gegevens = {
'speler_x': zelf.speler_x,
'hoogste score': zelf.hoge_score
 }
met open('opslaan.json', 'w') als bestand:
 json.dump (gegevens, bestand)
 afdrukken (gegevens)
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.player_x -= PLAYER_SPEED
elif sleutel == arcade.sleutel. RECHTS:
 self.player_x += PLAYER_SPEED
 zelf.hoge_score += 1

Autosave-functie

Om spelers gemoedsrust te bieden en verlies van voortgang te voorkomen, kun je de spelstatus automatisch met regelmatige tussenpozen opslaan. Maak een nieuw bestand met de naam automatisch opslaan.py en voeg de code toe met de onderstaande updates:

importeren tijd
klasGameWindow(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.game_state = GameState()
# Sla elke 6 seconden op
 self.autosave_interval = 6
 self.last_save_time = tijd.tijd()
defupdate(zelf, delta_tijd):
 huidige_tijd = tijd.tijd()
 time_diff = huidige_tijd - self.last_save_time
als time_diff >= self.autosave_interval:
 zelf.save_game()
 afdrukken("Opgeslagen")
 self.last_save_time = huidige_tijd

In dit codefragment wordt de update methode controleert of het opgegeven tijdsinterval is verstreken sinds de laatste opslag. Als dat zo is, activeert het de spel opslaan methode van de GameWindow class om de spelstatus automatisch op te slaan. Pas de... aan autosave_interval waarde volgens de eisen van uw spel.

Spelgegevens valideren

Het valideren van de geladen spelgegevens is essentieel om de integriteit en consistentie ervan te waarborgen. U kunt gegevensvalidatie eenvoudig integreren in ons opslag- en laadsysteem:

klasGameState:
def__in het__(zelf):
 zelf.speler_x = 0
defsave_state(zelf):
als zelf.is_valid_state():
 gegevens = {
'speler_x': zelf.speler_x
 }
met open('opslaan.json', 'w') als bestand:
 json.dump (gegevens, bestand)
defload_state(zelf):
met open('opslaan.json', 'R') als bestand:
 data = json.load (bestand)
als self.validate_loaded_data (gegevens):
 self.player_x = gegevens['speler_x']
anders:
 afdrukken("Fout!")
defis_valid_state(zelf):
# Voer hier validatielogica uit
# Geef True terug als de status geldig is, anders False
doorgang
defvalideren_geladen_gegevens(zelf, gegevens):
# Voer validatie uit op de geladen gegevens
# Geef True terug als de gegevens geldig zijn, anders False
doorgang

Door deze extra functies in het opslag- en laadsysteem op te nemen, kun je een veelzijdigere en robuustere gameplay creëren ervaring, waardoor spelers de mogelijkheid hebben om meerdere spelstatussen op te slaan, hoge scores bij te houden, automatisch opslaan in te schakelen en gegevens te waarborgen integriteit.

Best Practices voor het Save and Load-systeem

Het implementeren van een opslag- en laadsysteem is een belangrijk aspect van de ontwikkeling van games. Om een ​​robuust en betrouwbaar systeem te garanderen, is het essentieel om best practices te volgen. Hier zijn enkele belangrijke praktijken om te overwegen:

Versleutel gevoelige gegevens

Als uw game gevoelige informatie bevat, zoals wachtwoorden, persoonlijke gegevens of in-app-aankopen, is het van cruciaal belang om de status van de opgeslagen game te versleutelen. Versleuteling voegt een extra beveiligingslaag toe, beschermt de privacy van de speler en voorkomt ongeoorloofde toegang tot zijn gegevens. Gebruik versleutelingsalgoritmen en bibliotheken om gevoelige informatie te beschermen.

Valideer geladen gegevens

Voordat u de gamegegevens laadt, is het essentieel om deze te valideren om de integriteit en consistentie te waarborgen. Controleer of de geladen gegevens voldoen aan de verwachte indeling, structuur en beperkingen van uw game.

Voer validatiecontroles uit op kritieke gegevensvelden om crashes of valsspelen te voorkomen. Implementeer robuuste mechanismen voor gegevensvalidatie om mogelijke fouten of onverwachte gegevens te verwerken.

Ga netjes om met fouten

Bij bestands-I/O-bewerkingen kunnen fouten optreden. Het is van cruciaal belang om netjes met deze fouten om te gaan en informatieve foutmeldingen aan de speler te geven. Uitzonderingen opvangen en afhandelen, zoals FileNotFoundError of Toestemmingsfout, tijdens opslag- en laadbewerkingen.

Geef gebruiksvriendelijke foutmeldingen weer om spelers te begeleiden en frustratie te voorkomen. Overweeg daarnaast om foutregistratie te implementeren om problemen te diagnosticeren en op te lossen.

Test de opslag- en laadfunctionaliteit

Test de opslag- en laadfunctionaliteit van uw game grondig om de betrouwbaarheid en correctheid ervan te garanderen. Maak testgevallen die verschillende scenario's dekken, zoals opslaan in verschillende spelstatussen, laden van geldige en ongeldige opslagbestanden en het testen van randgevallen.

Valideer dat de spelstatus correct is opgeslagen en geladen en dat het verwachte gedrag optreedt. Geautomatiseerde testframeworks kunnen helpen bij het creëren van uitgebreide testsuites.

Maak games leuker met het systeem voor opslaan en laden

Het toevoegen van een opslag- en laadsysteem kan games aantrekkelijker maken door spelers een gevoel van continuïteit en vooruitgang te bieden. Spelers kunnen vrijuit experimenteren, verschillende benaderingen uitproberen en later terugkeren naar het spel zonder hun prestaties te verliezen.

Deze functie stelt spelers ook in staat om te concurreren met vrienden of zichzelf uit te dagen om hun eerdere hoge scores te verbeteren, waardoor herspeelbaarheid en betrokkenheid op de lange termijn aan je game worden toegevoegd.