Hur man implementerar funktionen Spara och ladda i PyGame

I modern spelutveckling är möjligheten att spara och ladda spelframsteg en avgörande funktion som förbättrar användarupplevelsen och engagemanget. PyGame, ett populärt bibliotek för att skapa 2D-spel i Python, tillhandahåller de nödvändiga verktygen för att implementera spara och ladda funktionen utan ansträngning.

Skapa ett enkelt spel

Innan du börjar, se till att du har pip installerad på din enhet. När du har installerat pip, kör kommandot nedan för att installera pygame modul:

pip installera pygame

För att illustrera implementeringen av ett spara och ladda system i PyGame, börja med att skapa ett enkelt spel.

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.

I det här spelet kommer spelaren att ha möjlighet att röra sig åt vänster och höger. Här är ett exempel på ett kodavsnitt som visar den grundläggande spelstrukturen:

importera pygame
# Initiera Pygame
pygame.init()
# Ställ in spelfönstret
fönsterbredd = 800
fönsterhöjd = 600
fönster = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Spara och ladda systemhandledning")
# Spelvariabler
player_x = 400
player_y = 500
player_speed = 5
# Spelslinga
springer = Sann
medan löpning:
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk
 keys = pygame.key.get_pressed()
om nycklar[pygame. K_LEFT]:
 player_x -= player_speed
om nycklar[pygame. K_RIGHT]:
 player_x += player_speed
# Rensa skärmen
 window.fill((0, 0, 0))
# Rita spelaren
 pygame.draw.rect (fönster, (255, 255, 255), (spelare_x, spelare_y, 50, 50))
# Uppdatera displayen
 pygame.display.flip()
# Avsluta spelet
pygame.quit()

Hantera speltillstånd och databeständighet

Innan du implementerar funktionen för att spara och ladda, måste du etablera ett sätt att hantera speltillståndet och bevara data. Ett vanligt tillvägagångssätt är att använd en Python-ordbok för att lagra relevant speldata. Här är ett exempel på hur du kan ändra den tidigare koden för att inkludera spelstatushantering:

# Spelvariabler
game_state = {
'player_x': 400,
'player_y': 500
}
# Spelslinga
springer = Sann
medan löpning:
# ...
 keys = pygame.key.get_pressed()
om nycklar[pygame. K_LEFT]:
 game_state['player_x'] -= player_speed
om nycklar[pygame. K_RIGHT]:
 game_state['player_x'] += player_speed
# ...
 pygame.display.flip()

Implementera spara och ladda funktionalitet

För att möjliggöra att spara och ladda spelframsteg kan du utnyttja Pythons inbyggda ättikslag modul, som låter oss serialisera och deserialisera Python-objekt. Skapa en ny fil med namnet save-game.py och lägg till koden med följande uppdateringar:

game_state = {
'player_x': player_x,
'player_y': player_y
}
# Spara spelstatus
defsave_game_state(game_state, file_name):
Prova:
med öppna (filnamn, 'wb') som fil:
 pickle.dump (game_state, fil)
 skriva ut("Speltillståndet har sparats framgångsrikt!")
bortsett från IOE-fel:
 skriva ut("Fel: Det gick inte att spara spelstatus.")
# Ladda speltillstånd
defload_game_state(filnamn):
Prova:
med öppna (filnamn, 'rb') som fil:
 game_state = pickle.load (fil)
 skriva ut("Speltillståndet har laddats!")
lämna tillbaka game_state
bortsett från (IOError, pickle. UnpicklingError):
 skriva ut("Fel: Det gick inte att ladda spelstatus.")
# Spelslinga
springer = Sann
medan löpning:
# ...
 keys = pygame.key.get_pressed()
om nycklar[pygame. K_LEFT]:
 player_x -= player_speed
 game_state['player_x'] = player_x
om nycklar[pygame. K_RIGHT]:
 player_x += player_speed
 game_state['player_x'] = player_x
om nycklar[pygame. K_s]:
 save_game_state (game_state, "save_game.pickle")
om nycklar[pygame. K_l]:
 game_state = load_game_state("save_game.pickle")
 player_x = game_state['player_x']

# ...
# ...

Nedan är utgången:

Utformning av ett användargränssnitt för Save Slots

För att tillhandahålla ett gränssnitt för att spara och ladda kan du visa sparplatser som låter spelaren välja vilken plats som ska sparas eller laddas. För det här exemplet visas alternativen i konsolen, men du kan använda Pythons GUI-ramverk för att skapa ett mer användarvänligt gränssnitt.

Skapa en spara_slots lista som representerar de tillgängliga sparplatserna. Lägg också till en vald_slot variabel för att hålla reda på den plats som spelaren valt.

Visa de tillgängliga sparplatserna när spelaren trycker på sparaknappen (K_s). Spelaren kan välja en plats genom att trycka på motsvarande sifferknapp (K_1, K_2, eller K_3). Om en plats väljs sparas speltillståndet i en fil med namnet efter den valda luckan.

På samma sätt, när spelaren trycker på laddningsknappen (K_l), visa sparplatserna. Spelaren kan välja en plats genom att trycka på tangenterna K_a, K_b, eller K_c för att ladda spelläget. Alternativt kan du använd pekingångar istället för tangentbordsingångar för val av plats. Om en slot väljs laddas speltillståndet från motsvarande fil.

Skapa en ny fil med namnet interface.py och lägg till koden med följande uppdateringar:

# Spelvariabler
save_slots = ["plats 1", "plats 2", "plats 3"]
select_slot = Ingen
# Spelslinga
springer = Sann
medan löpning:
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk
om event.type == pygame. NYCKEL NER:
om event.key == pygame. K_s:
# Visa sparplatser
 select_slot = Ingen
för jag, slot i räkna upp (save_slots):
 skriva ut(f"Spara plats {i+1}: {spår}")
 skriva ut("Välj en slot för att spara spelet.")
om event.key == pygame. K_l:
 skriva ut("Välj plats:- a - plats 1, b - plats 3, c - plats 3")
# Visa sparplatser
 select_slot = Ingen
för jag, slot i räkna upp (save_slots):
 skriva ut(f"Spara plats {i+1}: {spår}")
 skriva ut("Välj en slot för att ladda spelet.")
om händelse.nyckel i [pygame. K_1, pygame. K_2, pygame. K_3]:
# Spara eller ladda spel baserat på vald slot
 slot_index = event.key - pygame. K_1
 select_slot = save_slots[slot_index]

 save_game_state (game_state, f"{selected_slot}.ättikslag")
 skriva ut(f"Spelet sparat in {selected_slot}!")
om händelse.nyckel i [pygame. K_a, pygame. K_b, pygame. K_c]:

 slot_index = event.key - pygame. K_a
 select_slot = save_slots[slot_index]
 game_state = load_game_state(f"{selected_slot}.ättikslag")
 player_x = game_state['player_x']
 skriva ut(f"Spelet laddat från {selected_slot}!")
# ...
 pygame.display.flip()
# ...

Nedan är utgången:

Hantera överskrivningsalternativ

För att tillhandahålla alternativ för att skriva över befintliga lagringar kan du implementera ett varningsmeddelande som ber spelaren om bekräftelse innan du skriver över en sparad fil. Skapa en ny fil med namnet overwriting-save.py och ändra koden med följande uppdateringar:

# Spara spelstatus
defsave_game_state(game_state, file_name):
om os.path.exists (filnamn):
# Fråga om bekräftelse för att skriva över befintlig sparafil
 skriva över = input("Spara fil finns redan. Vill du skriva över? (å/n): ")
om overwrite.lower() != 'y':
 skriva ut("Spara avbröts.")
lämna tillbaka
Prova:
med öppna (filnamn, 'wb') som fil:
 pickle.dump (game_state, fil)
 skriva ut("Speltillståndet har sparats framgångsrikt!")
bortsett från IOE-fel:
 skriva ut("Fel: Det gick inte att spara spelstatus.")
# ...
# Ladda speltillstånd
defload_game_state(filnamn):
ominte os.path.exists (filnamn):
 skriva ut("Fel: Spara filen finns inte.")
lämna tillbakaIngen
Prova:
med öppna (filnamn, 'rb') som fil:
 game_state = pickle.load (fil)
 skriva ut("Speltillståndet har laddats!")
lämna tillbaka game_state
bortsett från (IOError, pickle. UnpicklingError):
 skriva ut("Fel: Det gick inte att ladda spelstatus.")
lämna tillbakaIngen
# ...

I koden ovan, innan du sparar ett speltillstånd, kontrollerar du om sparafilen redan finns med os.path.exists(). Om den gör det, ber du spelaren om bekräftelse att skriva över den befintliga sparade filen. Om spelaren väljer att inte skriva över avbryts lagringen.

På samma sätt, innan du laddar ett spelläge, kontrollerar du om sparafilen finns med os.path.exists(). Om det inte gör det, informerar du spelaren med ett felmeddelande.

Bästa metoder för att spara och ladda system

När du implementerar ett spara och ladda system i PyGame eller något spelutvecklingsprojekt, överväg följande bästa praxis:

• Använd en väldefinierad datastruktur för att representera speltillståndet och serialisera det med ett serialiseringsbibliotek som ättikslag. Detta gör att du enkelt kan spara och ladda hela spelläget.
• Skapa en dedikerad katalog eller mapp för att lagra sparade filer. Detta hjälper till att organisera de sparade filerna och förhindrar att spelkatalogen blir rörig.
• Implementera felhantering och tillhandahåll informativa felmeddelanden för att hjälpa till med felsökning och felsökning. Detta hjälper spelare att förstå alla problem som kan uppstå under lagring och laddning.
• Överväg att implementera flera sparplatser för att tillåta spelare att spara flera spel. Detta ger spelarna flexibiliteten att utforska olika vägar eller spela om specifika delar av spelet utan att skriva över deras framsteg.

Gör spel mer engagerande med systemet för att spara och ladda

Tillägget av spara och ladda funktionen kan avsevärt förbättra engagemanget och njutningen av ett spel. Det låter spelare spara sina framsteg och återgå till spelet när det passar dem. Vidare öppnar det för möjligheter att skapa komplexa spelvärldar, där spelarens val och handlingar får bestående konsekvenser.

Genom att implementera ett spara och ladda system kan du ge dina spelare en mer uppslukande och tillfredsställande spelupplevelse.