Sådan gemmer og indlæses spildata i Arcade

Tilføjelse af et gemme- og indlæsningssystem til dit spil kan i høj grad forbedre spilleroplevelsen. Det giver spillerne mulighed for at fortsætte deres fremskridt, genoptage gameplay-sessioner og eksperimentere med forskellige strategier uden at miste hårdt tjente præstationer.

Du vil blive glædeligt overrasket over, hvor ligetil det er at tilføje denne funktion til dit spil ved hjælp af Pythons Arcade-bibliotek.

Opret et simpelt spil

Start med at skabe et simpelt spil, hvor spilleren kan bevæge sig venstre og højre.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Opret en ny fil med navnet simple-game.py og tilføj nedenstående kode:

importere arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
blå = arkade.farve. BLÅ
klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 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å)
defopdatering(selv, delta_tid):
passere
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= PLAYER_SPEED
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += PLAYER_SPEED
defvigtigste():
 vindue = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
hvis __navn__ == '__main__':
 hoved()

Koden opretter et vindue med et blåt rektangel, der repræsenterer spilleren. Spilleren kan flytte til venstre og højre ved at bruge venstre og højre piletasterne.

Håndtering af spilstater

For at implementere et gem og indlæst system skal du administrere forskellige spiltilstande. En spiltilstand repræsenterer den aktuelle tilstand af spillet, inklusive positionerne af objekter, scoringer og andre relevante data. I dette eksempel skal du kun fokusere på spillerens x-koordinat.

For at administrere spiltilstande skal du introducere en GameState klasse, der indkapsler spillets data og giver metoder til at gemme og indlæse dem. Her er koden:

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

Lagring af spildata

For at gemme spildataene skal du forlænge GameWindow klasse og tilføje en metode til at gemme spiltilstanden, når det er nødvendigt. Brug JSON-formatet for enkelhedens skyld. Her er koden:

I den Gem spil metode, oprette en Python-ordbog indeholdende de relevante spildata. Serialiser det derefter til en JSON-fil kaldet save.json.

importere json
klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 self.game_state = GameState()
defGem spil(selv):
 data = {
'player_x': self.game_state.player_x
 }
med åben('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å)
defopdatering(selv, delta_tid):
passere
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.game_state.player_x -= PLAYER_SPEED
elif nøgle == arkade.nøgle. HØJRE:
 self.game_state.player_x += PLAYER_SPEED
elif nøgle == arkade.nøgle. S:
 self.save_game()

Indlæsning af spildata

For at indlæse spildata skal du forlænge GameWindow klasse videre og tilføje en metode til at indlæse spiltilstanden. Opret en ny fil med navnet load-game.py og tilføj koden med nedenstående opdateringer:

klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 self.game_state = GameState()
 self.load_game()
defIndlæs spil(selv):
prøve:
med åben('save.json', 'r') som fil:
 data = json.load (fil)
 self.game_state.player_x = data['player_x']
undtagen FileNotFoundError:
passere
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. L:
 self.load_game()

Det Indlæs spil metoden forsøger at åbne save.json fil og hent spildataene. Den opdaterer derefter spiltilstanden med de indlæste data. Hvis filen ikke eksisterer, kan du bare ignorere undtagelsen og forlade standardspiltilstanden.

Inklusiv yderligere funktioner

Du kan tilføje flere funktioner for at forbedre spillets gemme- og indlæsningssystem.

Gemmer Highscores

At gemme høje scores sammen med spiltilstanden er en fælles funktion i mange spil. Du kan styre scoringerne og gem den højeste score ved hjælp af dette system. Opret en ny fil med navnet high-score.py og tilføj koden med nedenstående opdateringer:

klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 self.high_score = 0
defIndlæs spil(selv):
prøve:
med åben('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øjeste score', self.high_score)
undtagen FileNotFoundError:
passere
defGem spil(selv):
 data = {
'player_x': self.player_x,
'højeste score': self.high_score
 }
med åben('save.json', 'w') som fil:
 json.dump (data, fil)
 print (data)
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= PLAYER_SPEED
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Autosave funktion

For at give spillerne ro i sindet og forhindre tab af fremskridt, kan du automatisk gemme spiltilstanden med jævne mellemrum. Opret en ny fil med navnet auto-save.py og tilføj koden med nedenstående opdateringer:

importere tid
klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 self.game_state = GameState()
# Gem hvert 6. sekund
 self.autosave_interval = 6
 self.last_save_time = time.time()
defopdatering(selv, delta_tid):
 aktuel_tid = tid.tid()
 time_diff = nuværende_tid - selv.sidste_sparetid
hvis time_diff >= self.autosave_interval:
 self.save_game()
 Print("gemt")
 self.last_save_time = nuværende_tid

I dette kodestykke er opdatering metoden kontrollerer, om det angivne tidsinterval er gået siden sidste lagring. Hvis det er tilfældet, udløser det Gem spil metoden til GameWindow klasse for automatisk at gemme spiltilstanden. Juster autosave_interval værdi i henhold til dit spils krav.

Validering af spildata

Validering af de indlæste spildata er afgørende for at sikre dets integritet og konsistens. Du kan nemt integrere datavalidering i vores gemme og indlæse system:

klasseGameState:
def__i det__(selv):
 self.player_x = 0
defsave_state(selv):
hvis self.is_valid_state():
 data = {
'player_x': self.player_x
 }
med åben('save.json', 'w') som fil:
 json.dump (data, fil)
defload_state(selv):
med åben('save.json', 'r') som fil:
 data = json.load (fil)
hvis self.validate_loaded_data (data):
 self.player_x = data['player_x']
andet:
 Print("Fejl!")
defer_gyldig_tilstand(selv):
# Udfør valideringslogik her
# Returner True, hvis tilstanden er gyldig, ellers False
passere
defvalidate_loaded_data(selv, data):
# Udfør validering af de indlæste data
# Returner True, hvis dataene er gyldige, ellers False
passere

Ved at inkorporere disse ekstra funktioner i save and load-systemet kan du skabe et mere alsidigt og robust gameplay oplevelse, der giver spillerne muligheden for at gemme flere spiltilstande, spore højeste score, aktivere automatisk lagring og sikre data integritet.

Bedste praksis for Save and Load-systemet

Implementering af et gemme og indlæse system er et vigtigt aspekt af spiludvikling. For at sikre et robust og pålideligt system er det vigtigt at følge bedste praksis. Her er nogle vigtige praksisser at overveje:

Krypter følsomme data

Hvis dit spil indeholder følsomme oplysninger såsom adgangskoder, personlige data eller køb i appen, er det afgørende at kryptere den gemte spiltilstand. Kryptering tilføjer et ekstra lag af sikkerhed, beskytter spillerens privatliv og forhindrer uautoriseret adgang til deres data. Brug krypteringsalgoritmer og biblioteker til at beskytte følsomme oplysninger.

Valider indlæste data

Før du indlæser spildataene, er det vigtigt at validere det for at sikre dets integritet og konsistens. Bekræft, at de indlæste data overholder det forventede format, struktur og begrænsninger for dit spil.

Udfør valideringstjek på kritiske datafelter for at undgå nedbrud eller snyd. Implementer robuste datavalideringsmekanismer til at håndtere potentielle fejl eller uventede data.

Håndter fejl med ynde

Når man håndterer fil I/O-operationer, kan der opstå fejl. Det er afgørende at håndtere disse fejl elegant og give informative fejlmeddelelser til spilleren. Fang og håndtere undtagelser, som f.eks FileNotFoundError eller PermissionError, under lagring og indlæsning.

Vis brugervenlige fejlmeddelelser for at vejlede spillere og forhindre frustration. Overvej desuden at implementere fejllogning for at hjælpe med at diagnosticere og løse problemer.

Test gemme og indlæse funktionalitet

Test gemme- og indlæsningsfunktionaliteten af ​​dit spil grundigt for at sikre dets pålidelighed og korrekthed. Opret testcases, der dækker forskellige scenarier, såsom lagring i forskellige spiltilstande, indlæsning fra gyldige og ugyldige gemte filer, og test edge cases.

Bekræft, at spiltilstanden er korrekt gemt og indlæst, og at den forventede adfærd forekommer. Automatiserede testrammer kan hjælpe med at skabe omfattende testpakker.

Gør spil sjovere med Save and Load System

Tilføjelse af et gemme- og indlæsningssystem kan gøre spil mere engagerende ved at give spillerne en følelse af kontinuitet og fremskridt. Spillere kan eksperimentere frit, prøve forskellige tilgange og vende tilbage til spillet senere uden at miste deres præstationer.

Denne funktion giver også spillere mulighed for at konkurrere med venner eller udfordre sig selv til at slå deres tidligere highscores, hvilket tilføjer genspilbarhed og langsigtet engagement til dit spil.