Sådan implementerer du funktionen Gem og indlæs i PyGame

I moderne spiludvikling er muligheden for at gemme og indlæse spilfremskridt en afgørende funktion, der forbedrer brugeroplevelsen og engagementet. PyGame, et populært bibliotek til at skabe 2D-spil i Python, giver de nødvendige værktøjer til at implementere funktionen Gem og indlæs ubesværet.

Oprettelse af et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på din enhed. Efter installation af pip skal du køre nedenstående kommando for at installere pygame modul:

pip installer pygame

For at illustrere implementeringen af ​​et gem og indlæs system i PyGame, start med at lave et simpelt spil.

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

I dette spil vil spilleren have mulighed for at bevæge sig til venstre og højre. Her er et eksempel på et kodestykke, der demonstrerer den grundlæggende spilstruktur:

importere pygame
# Initialiser Pygame
pygame.init()
# Indstil spilvinduet
vinduesbredde = 800
vindueshøjde = 600
vindue = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Gem og indlæs system selvstudie")
# Spilvariabler
player_x = 400
player_y = 500
player_speed = 5
# Spilløkke
kører = Rigtigt
mens kører:
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 kører = Falsk
 keys = pygame.key.get_pressed()
hvis nøgler[pygame. K_LEFT]:
 player_x -= player_speed
hvis nøgler[pygame. K_RIGHT]:
 player_x += player_speed
# Ryd skærmen
 window.fill((0, 0, 0))
# Tegn afspilleren
 pygame.draw.rect (vindue, (255, 255, 255), (player_x, player_y, 50, 50))
# Opdater displayet
 pygame.display.flip()
# Afslut spillet
pygame.quit()

Håndtering af spiltilstand og datapersistens

Før du implementerer funktionen til at gemme og indlæse, skal du etablere en måde at administrere spiltilstanden og bevare dataene på. En almindelig tilgang er at bruge en Python-ordbog at gemme de relevante spildata. Her er et eksempel på, hvordan du kan ændre den tidligere kode til at inkludere spiltilstandsstyring:

# Spilvariabler
game_state = {
'player_x': 400,
'player_y': 500
}
# Spilløkke
kører = Rigtigt
mens kører:
# ...
 keys = pygame.key.get_pressed()
hvis nøgler[pygame. K_LEFT]:
 game_state['player_x'] -= player_speed
hvis nøgler[pygame. K_RIGHT]:
 game_state['player_x'] += player_speed
# ...
 pygame.display.flip()

Implementering af Save and Load funktionalitet

For at aktivere lagring og indlæsning af spilfremskridt kan du udnytte Pythons indbyggede pickle modul, som giver os mulighed for at serialisere og deserialisere Python-objekter. Opret en ny fil med navnet save-game.py og tilføj koden med nedenstående opdateringer:

game_state = {
'player_x': player_x,
'player_y': player_y
}
# Gem spiltilstand
defsave_game_state(spiltilstand, filnavn):
prøve:
med åben (filnavn, 'wb') som fil:
 pickle.dump (game_state, fil)
 Print("Spiltilstand blev gemt med succes!")
undtagen IOEfejl:
 Print("Fejl: Kan ikke gemme spiltilstand.")
# Indlæs spiltilstand
defload_game_state(filnavn):
prøve:
med åben (filnavn, 'rb') som fil:
 game_state = pickle.load (fil)
 Print("Spiltilstand blev indlæst!")
Vend tilbage game_state
undtagen (IOError, pickle. UnpicklingError):
 Print("Fejl: Kan ikke indlæse spiltilstand.")
# Spilløkke
kører = Rigtigt
mens kører:
# ...
 keys = pygame.key.get_pressed()
hvis nøgler[pygame. K_LEFT]:
 player_x -= player_speed
 game_state['player_x'] = player_x
hvis nøgler[pygame. K_RIGHT]:
 player_x += player_speed
 game_state['player_x'] = player_x
hvis nøgler[pygame. K_s]:
 save_game_state (game_state, 'save_game.pickle')
hvis nøgler[pygame. K_l]:
 game_state = load_game_state('save_game.pickle')
 player_x = game_state['player_x']

# ...
# ...

Nedenfor er output:

Design af en brugergrænseflade til Save Slots

For at give en gemme- og indlæsningsgrænseflade kan du vise gemmepladser, der giver spilleren mulighed for at vælge, hvilken slot der skal gemmes eller indlæses. For dette eksempel vises mulighederne i konsollen, men du kan bruge Pythons GUI-rammer for at skabe en mere brugervenlig grænseflade.

Lave en save_slots liste, der repræsenterer de tilgængelige gemmepladser. Tilføj også en valgt_slot variabel for at holde styr på den slot valgt af spilleren.

Vis de tilgængelige gemmepladser, når spilleren trykker på gem-knappen (K_s). Spilleren kan vælge et slot ved at trykke på den tilsvarende taltast (K_1, K_2, eller K_3). Hvis en slot er valgt, gemmes spiltilstanden i en fil, der er opkaldt efter den valgte slot.

På samme måde, når afspilleren trykker på indlæsningsknappen (K_l), få ​​vist gemmepladserne. Spilleren kan vælge en slot ved at trykke på tasterne K_a, K_b, eller K_c for at indlæse spiltilstanden. Alternativt kan du bruge berøringsindgange i stedet for tastaturindgange til valg af slot. Hvis en slot er valgt, indlæses spiltilstanden fra den tilsvarende fil.

Opret en ny fil med navnet interface.py og tilføj koden med nedenstående opdateringer:

# Spilvariabler
save_slots = ['Slot 1', 'Slot 2', 'Slot 3']
valgt_slot = Ingen
# Spilløkke
kører = Rigtigt
mens kører:
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 kører = Falsk
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_s:
# Vis gemmepladser
 valgt_slot = Ingen
til i, slot i opregn (save_slots):
 Print(f"Gem slot {i+1}: {slot}")
 Print("Vælg en slot for at gemme spillet.")
hvis event.key == pygame. K_l:
 Print("Vælg Slot:- a - Slot 1, b - Slot 3, c - Slot 3")
# Vis gemmepladser
 valgt_slot = Ingen
til i, slot i opregn (save_slots):
 Print(f"Gem slot {i+1}: {slot}")
 Print("Vælg en slot for at indlæse spillet.")
hvis begivenhed.nøgle i [pygame. K_1, pygame. K_2, pygame. K_3]:
# Gem eller indlæs spil baseret på den valgte slot
 slot_index = event.key - pygame. K_1
 select_slot = save_slots[slot_index]

 save_game_state (game_state, f"{selected_slot}.pickle")
 Print(f"Spil gemt i {selected_slot}!")
hvis begivenhed.nøgle 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}.pickle")
 player_x = game_state['player_x']
 Print(f"Spil indlæst fra {selected_slot}!")
# ...
 pygame.display.flip()
# ...

Nedenfor er output:

Håndtering af overskrivningsmuligheder

For at give muligheder for at overskrive eksisterende lagringer kan du implementere en advarselsmeddelelse, der beder afspilleren om bekræftelse, før du overskriver en lagringsfil. Opret en ny fil med navnet overskrivning-save.py og rediger koden med nedenstående opdateringer:

# Gem spiltilstand
defsave_game_state(spiltilstand, filnavn):
hvis os.path.exists (filnavn):
# Bed om bekræftelse for at overskrive eksisterende gemt fil
 overskriv = input("Gem fil eksisterer allerede. Vil du overskrive? (å/n): ")
hvis overwrite.lower() != 'y':
 Print("Gem annulleret.")
Vend tilbage
prøve:
med åben (filnavn, 'wb') som fil:
 pickle.dump (game_state, fil)
 Print("Spiltilstand blev gemt med succes!")
undtagen IOEfejl:
 Print("Fejl: Kan ikke gemme spiltilstand.")
# ...
# Indlæs spiltilstand
defload_game_state(filnavn):
hvisikke os.path.exists (filnavn):
 Print("Fejl: Gem fil findes ikke.")
Vend tilbageIngen
prøve:
med åben (filnavn, 'rb') som fil:
 game_state = pickle.load (fil)
 Print("Spiltilstand blev indlæst!")
Vend tilbage game_state
undtagen (IOError, pickle. UnpicklingError):
 Print("Fejl: Kan ikke indlæse spiltilstand.")
Vend tilbageIngen
# ...

I ovenstående kode, før du gemmer en spiltilstand, kontrollerer du, om gemmefilen allerede eksisterer vha os.path.exists(). Hvis det gør det, beder du afspilleren om bekræftelse for at overskrive den eksisterende gemte fil. Hvis afspilleren vælger ikke at overskrive, annulleres lagringen.

På samme måde, før du indlæser en spiltilstand, kontrollerer du, om gemmefilen findes ved hjælp af os.path.exists(). Hvis den ikke gør det, informerer du afspilleren med en fejlmeddelelse.

Bedste fremgangsmåder for Save and Load System

Når du implementerer et gem og indlæst system i PyGame eller et hvilket som helst spiludviklingsprojekt, skal du overveje følgende bedste praksis:

• Brug en veldefineret datastruktur til at repræsentere spiltilstanden og serialiser den ved hjælp af et serialiseringsbibliotek som pickle. Dette giver dig mulighed for nemt at gemme og indlæse hele spiltilstanden.
• Opret en dedikeret mappe eller mappe til at gemme gemte filer. Dette hjælper med at organisere de gemte filer og forhindrer rod i spilbiblioteket.
• Implementer fejlhåndtering og giv informative fejlmeddelelser for at hjælpe med fejlfinding og fejlfinding. Dette hjælper spillere med at forstå eventuelle problemer, der kan opstå under lagring og indlæsning.
• Overvej at implementere flere lagringspladser for at give spillere mulighed for at gemme flere spil. Dette giver spillerne fleksibiliteten til at udforske forskellige stier eller afspille specifikke sektioner af spillet uden at overskrive deres fremskridt.

Gør spil mere engagerende med Save and Load System

Tilføjelsen af ​​funktionen Gem og indlæs kan i høj grad øge engagementet og nydelsen af ​​et spil. Det giver spillerne mulighed for at gemme deres fremskridt og vende tilbage til spillet, når det passer dem. Ydermere åbner det op for muligheder for at skabe komplekse spilverdener, hvor spillervalg og handlinger har varige konsekvenser.

Ved at implementere et gemme og indlæse system kan du give dine spillere en mere fordybende og tilfredsstillende spiloplevelse.