Hvordan lagre og laste inn spilldata i Arcade

Å legge til et lagrings- og lastsystem i spillet ditt kan forbedre spilleropplevelsen betraktelig. Det lar spillere fortsette fremgangen, gjenoppta spilløkter og eksperimentere med forskjellige strategier uten å miste hardt opptjente prestasjoner.

Du vil bli positivt overrasket over hvor enkelt det er å legge til denne funksjonen i spillet ditt ved å bruke Pythons Arcade-bibliotek.

Lag et enkelt spill

Start med å lage et enkelt spill hvor spilleren kan bevege seg venstre og høyre.

Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

Opprett en ny fil med navnet simple-game.py og legg til koden nedenfor:

import arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
blå = arkade.farge. BLÅ
klasseGameWindow(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.player_x = bredde // 2





instagram viewer

defon_draw(selv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, blå)
defOppdater(selv, delta_tid):
sende
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= PLAYER_SPEED
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += PLAYER_SPEED
defhoved-():
 vindu = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
hvis __navn__ == '__hoved__':
 hoved()

Koden lager et vindu med et blått rektangel som representerer spilleren. Spilleren kan bevege seg til venstre og høyre ved å bruke venstre og høyre piltaster.

Administrere spillstater

For å implementere et lagrings- og lastsystem må du administrere forskjellige spilltilstander. En spilltilstand representerer spillets gjeldende tilstand, inkludert posisjonene til objekter, poengsum og andre relevante data. For dette eksemplet, fokuser kun på spillerens x-koordinat.

For å administrere spilltilstander, introduser en GameState klasse som innkapsler spillets data og gir metoder for å lagre og laste dem. Her er koden:

klasseGameState:
def__i det__(selv):
 self.player_x = 0

Lagre spilldataene

For å lagre spilldataene, utvider du GameWindow klasse og legg til en metode for å lagre spilltilstanden når det er nødvendig. Bruk JSON-formatet for enkelhets skyld. Her er koden:

I lagre spillet metode, lage en Python-ordbok som inneholder relevante spilldata. Serialiser den deretter til en JSON-fil kalt save.json.

import json
klasseGameWindow(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.game_state = GameState()
deflagre spillet(selv):
 data = {
'player_x': self.game_state.player_x
 }
med åpen('save.json', 'w') som fil:
 json.dump (data, fil)
 print (data)
defon_draw(selv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, blå)
defOppdater(selv, delta_tid):
sende
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.game_state.player_x -= PLAYER_SPEED
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.game_state.player_x += PLAYER_SPEED
elif nøkkel == arkade.nøkkel. S:
 self.save_game()

Laster inn spilldata

For å laste inn spilldataene, utvider du GameWindow klasse videre og legg til en metode for å laste spilltilstanden. Opprett en ny fil med navnet load-game.py og legg til koden med oppdateringene nedenfor:

klasseGameWindow(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.game_state = GameState()
 self.load_game()
defLast Spill(selv):
prøve:
med åpen('save.json', 'r') som fil:
 data = json.load (fil)
 self.game_state.player_x = data['player_x']
unntatt FileNotFoundError:
sende
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. L:
 self.load_game()

De Last Spill metoden prøver å åpne save.json fil og hente spilldataene. Den oppdaterer deretter spilltilstanden med de innlastede dataene. Hvis filen ikke eksisterer, kan du bare ignorere unntaket og forlate standard spilltilstand.

Inkludert tilleggsfunksjoner

Du kan legge til flere funksjoner for å forbedre spillets lagrings- og lastesystem.

Lagre toppscore

Lagring av høye poengsum ved siden av spilltilstanden er en vanlig funksjon i mange spill. Du kan administrere poengsummene og lagre den høyeste poengsummen ved å bruke dette systemet. Opprett en ny fil med navnet high-score.py og legg til koden med oppdateringene nedenfor:

klasseGameWindow(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.high_score = 0
defLast Spill(selv):
prøve:
med åpen('save.json', 'r') som fil:
 data = json.load (fil)
 print (data)
 self.player_x = data.get('player_x', self.player_x)
 self.high_score = data.get('høy poengsum', self.high_score)
unntatt FileNotFoundError:
sende
deflagre spillet(selv):
 data = {
'player_x': self.player_x,
'høy poengsum': self.high_score
 }
med åpen('save.json', 'w') som fil:
 json.dump (data, fil)
 print (data)
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= PLAYER_SPEED
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Autolagringsfunksjon

For å gi spillerne trygghet og forhindre tap av fremgang, kan du automatisk lagre spillstatusen med jevne mellomrom. Opprett en ny fil med navnet auto-save.py og legg til koden med oppdateringene nedenfor:

import tid
klasseGameWindow(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.game_state = GameState()
# Lagre hvert 6. sekund
 self.autosave_interval = 6
 self.last_save_time = time.time()
defOppdater(selv, delta_tid):
 gjeldende_tid = tid.tid()
 time_diff = gjeldende_tid - self.last_save_time
hvis time_diff >= self.autosave_interval:
 self.save_game()
 skrive ut("Lagret")
 self.last_save_time = gjeldende_tid

I denne kodebiten er Oppdater metoden sjekker om det angitte tidsintervallet har gått siden siste lagring. I så fall utløser det lagre spillet metoden for GameWindow klasse for å automatisk lagre spilltilstanden. Juster autolagringsintervall verdi i henhold til spillets krav.

Validerer spilldata

Validering av de innlastede spilldataene er avgjørende for å sikre integriteten og konsistensen. Du kan enkelt integrere datavalidering i vårt lagrings- og lastesystem:

klasseGameState:
def__i det__(selv):
 self.player_x = 0
deflagre_tilstand(selv):
hvis self.is_valid_state():
 data = {
'player_x': self.player_x
 }
med åpen('save.json', 'w') som fil:
 json.dump (data, fil)
defload_state(selv):
med åpen('save.json', 'r') som fil:
 data = json.load (fil)
hvis self.validate_loaded_data (data):
 self.player_x = data['player_x']
ellers:
 skrive ut("Feil!")
defis_valid_state(selv):
# Utfør valideringslogikk her
# Returner True hvis tilstanden er gyldig, False ellers
sende
defvalidate_loaded_data(selv, data):
# Utfør validering på de innlastede dataene
# Returner True hvis dataene er gyldige, False ellers
sende

Ved å inkorporere disse tilleggsfunksjonene i lagrings- og lastesystemet, kan du skape et mer allsidig og robust spill erfaring, og gir spillere muligheten til å lagre flere spilltilstander, spore høye poengsummer, aktivere automatisk lagring og sikre data integritet.

Beste praksis for Lagre og Last-systemet

Implementering av et lagrings- og lastsystem er et viktig aspekt ved spillutvikling. For å sikre et robust og pålitelig system, er det viktig å følge beste praksis. Her er noen viktige fremgangsmåter du bør vurdere:

Krypter sensitive data

Hvis spillet ditt inneholder sensitiv informasjon som passord, personlige data eller kjøp i apper, er det avgjørende å kryptere den lagrede spilltilstanden. Kryptering legger til et ekstra lag med sikkerhet, beskytter spillerens personvern og forhindrer uautorisert tilgang til dataene deres. Bruk krypteringsalgoritmer og biblioteker for å beskytte sensitiv informasjon.

Valider innlastede data

Før du laster inn spilldataene, er det viktig å validere dem for å sikre integriteten og konsistensen. Kontroller at de innlastede dataene overholder det forventede formatet, strukturen og begrensningene for spillet ditt.

Utfør valideringssjekker på kritiske datafelt for å unngå krasj eller juks. Implementer robuste datavalideringsmekanismer for å håndtere potensielle feil eller uventede data.

Håndter feil grasiøst

Når du arbeider med fil-I/O-operasjoner, kan det oppstå feil. Det er avgjørende å håndtere disse feilene på en elegant måte og gi informative feilmeldinger til spilleren. Fang og håndtere unntak, som f.eks FileNotFoundError eller PermissionError, under lagring og lasting.

Vis brukervennlige feilmeldinger for å veilede spillere og forhindre frustrasjon. I tillegg bør du vurdere å implementere feillogging for å hjelpe deg med å diagnostisere og fikse problemer.

Test Lagre og Last inn funksjonalitet

Test lagrings- og lastfunksjonaliteten til spillet ditt grundig for å sikre påliteligheten og korrektheten. Lag testsaker som dekker ulike scenarier, for eksempel lagring i forskjellige spilltilstander, lasting fra gyldige og ugyldige lagringsfiler og testing av edge-tilfeller.

Bekreft at spilltilstanden er riktig lagret og lastet inn, og at forventet oppførsel oppstår. Automatiserte testrammeverk kan hjelpe til med å lage omfattende testsuiter.

Gjør spill morsommere med Lagre og Last-system

Å legge til et lagrings- og lastsystem kan gjøre spill mer engasjerende ved å gi spillerne en følelse av kontinuitet og fremgang. Spillere kan eksperimentere fritt, prøve forskjellige tilnærminger og gå tilbake til spillet senere uten å miste prestasjonene.

Denne funksjonen lar også spillere konkurrere med venner eller utfordre seg selv til å slå sine tidligere høye poeng, noe som gir gjenspillbarhet og langsiktig engasjement til spillet ditt.