Hvordan implementere Lagre og Last-funksjonen i PyGame

I moderne spillutvikling er muligheten til å lagre og laste spillfremdrift en avgjørende funksjon som forbedrer brukeropplevelsen og engasjementet. PyGame, et populært bibliotek for å lage 2D-spill i Python, gir de nødvendige verktøyene for å implementere lagre og laste funksjonen uten problemer.

Opprette et enkelt spill

Før du starter, sørg for at du har pip installert på enheten din. Etter å ha installert pip, kjør kommandoen nedenfor for å installere pygame modul:

pip installer pygame

For å illustrere implementeringen av et lagrings- og lastsystem i PyGame, start med å lage et enkelt spill.

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

I dette spillet vil spilleren ha muligheten til å bevege seg til venstre og høyre. Her er en eksempelkodebit som demonstrerer den grunnleggende spillstrukturen:

import pygame
# Initialiser Pygame
pygame.init()





instagram viewer

# Sett opp spillvinduet
window_width = 800
vindu_høyde = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Lagre og last systemveiledning")
# Spillvariabler
player_x = 400
player_y = 500
player_speed = 5
# Spillløkke
kjører = ekte
samtidig som løping:
til begivenhet i pygame.event.get():
hvis event.type == pygame. SLUTTE:
 kjører = Falsk
 keys = pygame.key.get_pressed()
hvis keys[pygame. K_LEFT]:
 player_x -= player_speed
hvis keys[pygame. K_RIGHT]:
 player_x += player_speed
# Tøm skjermen
 window.fill((0, 0, 0))
# Tegn spilleren
 pygame.draw.rect (vindu, (255, 255, 255), (spiller_x, spiller_y, 50, 50))
# Oppdater skjermen
 pygame.display.flip()
# Avslutt spillet
pygame.quit()

Administrere spilltilstand og datapersistens

Før du implementerer lagrings- og lastfunksjonaliteten, må du etablere en måte å administrere spilltilstanden på og opprettholde dataene. En vanlig tilnærming er å bruk en Python-ordbok for å lagre relevante spilldata. Her er et eksempel på hvordan du kan endre den forrige koden for å inkludere spillstatusadministrasjon:

# Spillvariabler
game_state = {
'player_x': 400,
'player_y': 500
}
# Spillløkke
kjører = ekte
samtidig som løping:
# ...
 keys = pygame.key.get_pressed()
hvis keys[pygame. K_LEFT]:
 game_state['player_x'] -= player_speed
hvis keys[pygame. K_RIGHT]:
 game_state['player_x'] += player_speed
# ...
 pygame.display.flip()

Implementering av Lagre og Last-funksjonalitet

For å aktivere lagring og lasting av spillfremgang, kan du utnytte Pythons innebygde sylteagurk modul, som lar oss serialisere og deserialisere Python-objekter. Opprett en ny fil med navnet save-game.py og legg til koden med oppdateringene nedenfor:

game_state = {
'player_x': player_x,
'player_y': player_y
}
# Lagre spilltilstand
defsave_game_state(spilltilstand, filnavn):
prøve:
med åpen (filnavn, 'wb') som fil:
 pickle.dump (game_state, fil)
 skrive ut("Spillstatus lagret vellykket!")
unntatt IOE-feil:
 skrive ut("Feil: Kan ikke lagre spillstatus.")
# Last inn spilltilstand
defload_game_state(filnavn):
prøve:
med åpen (filnavn, 'rb') som fil:
 game_state = pickle.load (fil)
 skrive ut("Spillstatus ble lastet inn!")
komme tilbake game_state
unntatt (IOError, sylteagurk. UnpicklingError):
 skrive ut("Feil: Kan ikke laste inn spillstatus.")
# Spillløkke
kjører = ekte
samtidig som løping:
# ...
 keys = pygame.key.get_pressed()
hvis keys[pygame. K_LEFT]:
 player_x -= player_speed
 game_state['player_x'] = spiller_x
hvis keys[pygame. K_RIGHT]:
 player_x += player_speed
 game_state['player_x'] = spiller_x
hvis keys[pygame. K_s]:
 save_game_state (game_state, 'save_game.pickle')
hvis keys[pygame. K_l]:
 game_state = load_game_state('save_game.pickle')
 player_x = game_state['player_x']

# ...
# ...

Nedenfor er utgangen:

Utforme et brukergrensesnitt for Save Slots

For å gi et grensesnitt for lagring og lasting, kan du vise lagringsspor som lar spilleren velge hvilket spor som skal lagres eller lastes. For dette eksemplet vises alternativene i konsollen, men du kan bruke Pythons GUI-rammeverk for å skape et mer brukervennlig grensesnitt.

Lage en spare_slots liste som representerer tilgjengelige lagringsplasser. Legg også til en valgt_spor variabel for å holde styr på sporet valgt av spilleren.

Vis de tilgjengelige lagringsplassene når spilleren trykker på lagringsknappen (K_s). Spilleren kan velge et spor ved å trykke på den tilsvarende talltasten (K_1, K_2, eller K_3). Hvis et spor er valgt, lagres spilltilstanden i en fil oppkalt etter det valgte sporet.

På samme måte, når spilleren trykker på load-knappen (K_l), viser lagringssporene. Spilleren kan velge et spor ved å trykke på tastene K_a, K_b, eller K_c for å laste inn spilltilstanden. Alternativt kan du bruk berøringsinnganger i stedet for tastaturinnganger for sporvalg. Hvis et spor er valgt, lastes spilltilstanden fra den tilsvarende filen.

Opprett en ny fil med navnet interface.py og legg til koden med oppdateringene nedenfor:

# Spillvariabler
spare_slots = ["Slot 1", "Slot 2", "Slot 3"]
valgt_spor = Ingen
# Spillløkke
kjører = ekte
samtidig som løping:
til begivenhet i pygame.event.get():
hvis event.type == pygame. SLUTTE:
 kjører = Falsk
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_s:
# Vis lagringsplasser
 valgt_spor = Ingen
til jeg, spor i oppregne (lagre_spor):
 skrive ut(f"Lagre spor {i+1}: {slot}")
 skrive ut("Velg en spilleautomat for å lagre spillet.")
hvis event.key == pygame. K_l:
 skrive ut("Velg spor:- a - spor 1, b - spor 3, c - spor 3")
# Vis lagringsplasser
 valgt_spor = Ingen
til jeg, spor i oppregne (lagre_spor):
 skrive ut(f"Lagre spor {i+1}: {slot}")
 skrive ut("Velg en spilleautomat for å laste spillet.")
hvis event.key i [pygame. K_1, pygame. K_2, pygame. K_3]:
# Lagre eller last inn spillet basert på valgt spor
 slot_index = event.key - pygame. K_1
 valgt_slot = spare_slots[slot_index]

 save_game_state (game_state, f"{selected_slot}.pickle")
 skrive ut(f"Spillet er lagret {selected_slot}!")
hvis event.key i [pygame. K_a, pygame. K_b, pygame. K_c]:

 slot_index = event.key - pygame. K_a
 valgt_slot = spare_slots[slot_index]
 game_state = load_game_state(f"{selected_slot}.pickle")
 player_x = game_state['player_x']
 skrive ut(f"Spill lastet fra {selected_slot}!")
# ...
 pygame.display.flip()
# ...

Nedenfor er utgangen:

Håndtere overskrivingsalternativer

For å gi alternativer for å overskrive eksisterende lagringer, kan du implementere en advarselsmelding som ber spilleren om bekreftelse før en lagringsfil overskrives. Opprett en ny fil med navnet overwriting-save.py og endre koden med oppdateringene nedenfor:

# Lagre spilltilstand
defsave_game_state(spilltilstand, filnavn):
hvis os.path.exists (filnavn):
# Spør om bekreftelse for å overskrive eksisterende lagringsfil
 overskriv = input("Lagre fil eksisterer allerede. Vil du overskrive? (y/n): ")
hvis overwrite.lower() != 'y':
 skrive ut("Lagre avbrutt.")
komme tilbake
prøve:
med åpen (filnavn, 'wb') som fil:
 pickle.dump (game_state, fil)
 skrive ut("Spillstatus lagret vellykket!")
unntatt IOE-feil:
 skrive ut("Feil: Kan ikke lagre spillstatus.")
# ...
# Last inn spilltilstand
defload_game_state(filnavn):
hvisikke os.path.exists (filnavn):
 skrive ut("Feil: Lagringsfilen eksisterer ikke.")
komme tilbakeIngen
prøve:
med åpen (filnavn, 'rb') som fil:
 game_state = pickle.load (fil)
 skrive ut("Spillstatus ble lastet inn!")
komme tilbake game_state
unntatt (IOError, sylteagurk. UnpicklingError):
 skrive ut("Feil: Kan ikke laste inn spillstatus.")
komme tilbakeIngen
# ...

I koden ovenfor, før du lagrer en spilltilstand, sjekker du om lagringsfilen allerede eksisterer med os.path.exists(). Hvis den gjør det, ber du spilleren om bekreftelse for å overskrive den eksisterende lagringsfilen. Hvis spilleren velger å ikke overskrive, avbrytes lagringsoperasjonen.

På samme måte, før du laster inn en spilltilstand, sjekker du om lagringsfilen eksisterer med os.path.exists(). Hvis den ikke gjør det, informerer du spilleren med en feilmelding.

Beste praksis for lagring og lastingssystem

Når du implementerer et lagrings- og lastsystem i PyGame eller et hvilket som helst spillutviklingsprosjekt, bør du vurdere følgende beste praksis:

• Bruk en veldefinert datastruktur for å representere spilltilstanden og serialiser den ved å bruke et serialiseringsbibliotek som sylteagurk. Dette lar deg lagre og laste hele spillstatusen enkelt.
• Opprett en dedikert katalog eller mappe for å lagre lagrede filer. Dette hjelper til med å organisere de lagrede filene og forhindrer rot i hovedspillkatalogen.
• Implementer feilhåndtering og gi informative feilmeldinger for å hjelpe til med feilsøking og feilsøking. Dette hjelper spillere med å forstå eventuelle problemer som kan oppstå under lagring og innlasting.
• Vurder å implementere flere lagringsautomater for å tillate spillere å lagre flere spill. Dette gir spillerne fleksibiliteten til å utforske forskjellige baner eller spille spesifikke deler av spillet på nytt uten å overskrive fremgangen deres.

Gjør spill mer engasjerende med Lagre og Last-systemet

Tillegget av funksjonen for å lagre og laste kan i stor grad forbedre engasjementet og nytelsen av et spill. Det lar spillere lagre fremgangen og gå tilbake til spillet når det passer det. Videre åpner det for muligheter for å skape komplekse spillverdener, der spillervalg og handlinger får varige konsekvenser.

Ved å implementere et lagrings- og lastsystem kan du gi spillerne dine en mer oppslukende og tilfredsstillende spillopplevelse.