Hur man sparar och laddar speldata i Arcade

Att lägga till ett spara och ladda system till ditt spel kan avsevärt förbättra spelarupplevelsen. Det låter spelare fortsätta sina framsteg, återuppta spelsessioner och experimentera med olika strategier utan att förlora surt förvärvade prestationer.

Du kommer att bli glatt överraskad över hur enkelt det är att lägga till den här funktionen i ditt spel med Pythons Arcade-bibliotek.

Skapa ett enkelt spel

Börja med att skapa ett enkelt spel där spelaren kan röra sig vänster och höger.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Skapa en ny fil med namnet simple-game.py och lägg till koden nedan:

importera arkad
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
blå = arkad.färg. BLÅ
klassGameWindow(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd)
 self.player_x = bredd // 2





instagram viewer

defon_draw(själv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, blå)
defuppdatering(själv, delta_tid):
passera
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.player_x -= PLAYER_SPEED
elif nyckel == arkad.nyckel. HÖGER:
 self.player_x += PLAYER_SPEED
defhuvud():
 fönster = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
om __namn__ == '__main__':
 main()

Koden skapar ett fönster med en blå rektangel som representerar spelaren. Spelaren kan flytta åt vänster och höger med hjälp av vänster och höger piltangenter.

Hantera spelstater

För att implementera ett spara och ladda system måste du hantera olika speltillstånd. Ett spelläge representerar det aktuella tillståndet i spelet, inklusive positionerna för objekt, poäng och annan relevant data. I det här exemplet fokuserar du bara på spelarens x-koordinat.

För att hantera speltillstånd, introducera en GameState klass som kapslar in spelets data och tillhandahåller metoder för att spara och ladda den. Här är koden:

klassGameState:
def__i det__(själv):
 self.player_x = 0

Spara speldata

För att spara speldata, utöka GameWindow klass och lägg till en metod för att spara speltillståndet när det behövs. Använd JSON-formatet för enkelhetens skull. Här är koden:

I den spara spelet metod, skapa en Python-ordbok som innehåller relevant speldata. Serialisera den sedan till en JSON-fil som heter save.json.

importera json
klassGameWindow(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd)
 self.game_state = GameState()
defspara spelet(själv):
 data = {
'player_x': self.game_state.player_x
 }
med öppen("save.json", 'w') som fil:
 json.dump (data, fil)
 skriva ut (data)
defon_draw(själv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, blå)
defuppdatering(själv, delta_tid):
passera
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.game_state.player_x -= PLAYER_SPEED
elif nyckel == arkad.nyckel. HÖGER:
 self.game_state.player_x += PLAYER_SPEED
elif nyckel == arkad.nyckel. S:
 self.save_game()

Laddar speldata

För att ladda speldata, utöka GameWindow klass vidare och lägg till en metod för att ladda speltillståndet. Skapa en ny fil med namnet load-game.py och lägg till koden med följande uppdateringar:

klassGameWindow(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd)
 self.game_state = GameState()
 self.load_game()
defbelastnings spel(själv):
Prova:
med öppen("save.json", 'r') som fil:
 data = json.load (fil)
 self.game_state.player_x = data['player_x']
bortsett från FileNotFoundError:
passera
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. L:
 self.load_game()

De belastnings spel metoden försöker öppna save.json fil och hämta speldata. Den uppdaterar sedan speltillståndet med inlästa data. Om filen inte finns kan du bara ignorera undantaget och lämna standardspeltillståndet.

Inklusive ytterligare funktioner

Du kan lägga till fler funktioner för att förbättra spelets spara och ladda system.

Sparar höga poäng

Att spara höga poäng tillsammans med spelstatusen är en vanlig funktion i många spel. Du kan hantera poängen och spara den höga poängen med detta system. Skapa en ny fil med namnet high-score.py och lägg till koden med följande uppdateringar:

klassGameWindow(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd)
 self.high_score = 0
defbelastnings spel(själv):
Prova:
med öppen("save.json", 'r') som fil:
 data = json.load (fil)
 skriva ut (data)
 self.player_x = data.get('player_x', self.player_x)
 self.high_score = data.get('rekord', self.high_score)
bortsett från FileNotFoundError:
passera
defspara spelet(själv):
 data = {
'player_x': self.player_x,
'rekord': self.high_score
 }
med öppen("save.json", 'w') som fil:
 json.dump (data, fil)
 skriva ut (data)
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.player_x -= PLAYER_SPEED
elif nyckel == arkad.nyckel. HÖGER:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Autospara funktion

För att ge spelare sinnesfrid och förhindra förlust av framsteg kan du automatiskt spara speltillståndet med jämna mellanrum. Skapa en ny fil med namnet auto-save.py och lägg till koden med följande uppdateringar:

importera tid
klassGameWindow(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd)
 self.game_state = GameState()
# Spara var 6:e ​​sekund
 self.autosave_interval = 6
 self.last_save_time = time.time()
defuppdatering(själv, delta_tid):
 aktuell_tid = tid.tid()
 time_diff = aktuell_tid - self.last_save_time
om time_diff >= self.autosave_interval:
 self.save_game()
 skriva ut("Sparad")
 self.last_save_time = aktuell_tid

I det här kodavsnittet visas uppdatering metod kontrollerar om det angivna tidsintervallet har passerat sedan den senaste lagringen. Om så är fallet utlöser det spara spelet metod för GameWindow klass för att automatiskt spara speltillståndet. Justera autosave_interval värde enligt ditt spels krav.

Validerar speldata

Validering av laddad speldata är viktigt för att säkerställa dess integritet och konsistens. Du kan enkelt integrera datavalidering i vårt spara och ladda system:

klassGameState:
def__i det__(själv):
 self.player_x = 0
defspara_tillstånd(själv):
om self.is_valid_state():
 data = {
'player_x': self.player_x
 }
med öppen("save.json", 'w') som fil:
 json.dump (data, fil)
defload_state(själv):
med öppen("save.json", 'r') som fil:
 data = json.load (fil)
om self.validate_loaded_data (data):
 self.player_x = data['player_x']
annan:
 skriva ut("Fel!")
defär_giltigt_tillstånd(själv):
# Utför valideringslogik här
# Returnera True om tillståndet är giltigt, False annars
passera
defvalidate_loaded_data(själv, data):
# Utför validering av laddade data
# Returnera True om uppgifterna är giltiga, annars False
passera

Genom att införliva dessa ytterligare funktioner i spara och ladda systemet kan du skapa ett mer mångsidigt och robust spel erfarenhet, erbjuder spelare möjligheten att spara flera spellägen, spåra höga poäng, aktivera autospara och säkerställa data integritet.

Bästa tillvägagångssätt för systemet för att spara och ladda

Att implementera ett spara och ladda system är en viktig aspekt av spelutveckling. För att säkerställa ett robust och pålitligt system är det viktigt att följa bästa praxis. Här är några viktiga metoder att tänka på:

Kryptera känsliga data

Om ditt spel innehåller känslig information som lösenord, personlig data eller köp i appar är det avgörande att kryptera det sparade spelläget. Kryptering lägger till ett extra lager av säkerhet, skyddar spelarens integritet och förhindrar obehörig åtkomst till deras data. Använd krypteringsalgoritmer och bibliotek för att skydda känslig information.

Validera laddade data

Innan du laddar speldata är det viktigt att validera det för att säkerställa dess integritet och konsistens. Verifiera att den laddade datan följer det förväntade formatet, strukturen och begränsningarna för ditt spel.

Utför valideringskontroller av kritiska datafält för att undvika krascher eller fusk. Implementera robusta datavalideringsmekanismer för att hantera potentiella fel eller oväntade data.

Hantera fel graciöst

Vid hantering av fil I/O-operationer kan fel uppstå. Det är viktigt att hantera dessa fel på ett elegant sätt och ge informativa felmeddelanden till spelaren. Fånga och hantera undantag, som t.ex FileNotFoundError eller PermissionError, under lagring och laddning.

Visa användarvänliga felmeddelanden för att vägleda spelare och förhindra frustration. Överväg dessutom att implementera felloggning för att diagnostisera och åtgärda problem.

Testa spara och ladda funktionalitet

Testa noggrant funktionen för att spara och ladda ditt spel för att säkerställa dess tillförlitlighet och korrekthet. Skapa testfall som täcker olika scenarier, som att spara i olika spellägen, ladda från giltiga och ogiltiga sparafiler och testa edge-fall.

Verifiera att speltillståndet är korrekt sparat och laddat och att det förväntade beteendet inträffar. Automatiserade testramar kan hjälpa till att skapa omfattande testsviter.

Gör spel roligare med systemet för att spara och ladda

Att lägga till ett spara och ladda system kan göra spel mer engagerande genom att ge spelarna en känsla av kontinuitet och framsteg. Spelare kan experimentera fritt, prova olika metoder och återgå till spelet senare utan att förlora sina prestationer.

Den här funktionen tillåter också spelare att tävla med vänner eller utmana sig själva att slå sina tidigare höga poäng, vilket ger omspelbarhet och långsiktigt engagemang i ditt spel.