Ja vien jūsu spēle nav ļoti īsa, tas palīdz saglabāt progresu. Pat īsas spēles var gūt labumu no labāko rezultātu saglabāšanas.

Saglabāšanas un ielādes sistēmas pievienošana spēlei var ievērojami uzlabot spēlētāja pieredzi. Tas ļauj spēlētājiem turpināt progresu, atsākt spēļu sesijas un eksperimentēt ar dažādām stratēģijām, nezaudējot grūti nopelnītos sasniegumus.

Jūs būsiet patīkami pārsteigts par to, cik vienkārši ir pievienot šo funkciju savai spēlei, izmantojot Python Arcade bibliotēku.

Izveidojiet vienkāršu spēli

Sāciet ar izveidi vienkārša spēle, kurā spēlētājs var pārvietoties pa kreisi un pa labi.

Šajā rakstā izmantotais kods ir pieejams šajā GitHub repozitorijs un to varat izmantot bez maksas saskaņā ar MIT licenci.

Izveidojiet jaunu failu ar nosaukumu simple-game.py un pievienojiet zemāk esošo kodu:

imports arkāde
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
zils = arkāde.krāsa. ZILS


klasēGameWindow(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 self.player_x = platums // 2







instagram viewer



defon_draw(pats):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, zils)


defAtjaunināt(self, delta_time):
caurlaide


defon_key_press(pašs, atslēga, modifikatori):
ja taustiņš == arcade.key. PA kreisi:
 self.player_x -= PLAYER_SPEED
elifs taustiņš == arcade.key. PA LABI:
 self.player_x += PLAYER_SPEED


defgalvenais():
 logs = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
ja __nosaukums__ == '__galvenais__':
 galvenais ()

Kods izveido logu ar zilu taisnstūri, kas attēlo atskaņotāju. Spēlētājs var pārvietoties pa kreisi un pa labi, izmantojot kreiso un labo bulttaustiņu.

Spēļu stāvokļu pārvaldība

Lai ieviestu saglabāšanas un ielādes sistēmu, jums jāpārvalda dažādi spēles stāvokļi. Spēles stāvoklis atspoguļo pašreizējo spēles stāvokli, tostarp objektu pozīcijas, rezultātus un citus būtiskus datus. Šajā piemērā koncentrējieties tikai uz spēlētāja x-koordinātu.

Lai pārvaldītu spēles stāvokļus, ievadiet a GameState klase, kas iekapsulē spēles datus un nodrošina metodes to saglabāšanai un ielādei. Lūk, kods:

klasēGameState:
def__tajā__(pats):
 self.player_x = 0

Spēles datu saglabāšana

Lai saglabātu spēles datus, pagariniet GameWindow klasē un pievienojiet metodi spēles stāvokļa saglabāšanai, kad vien nepieciešams. Vienkāršības labad izmantojiet JSON formātu. Lūk, kods:

Iekš saglabā spēli metode, izveidot Python vārdnīcu kas satur attiecīgos spēles datus. Pēc tam serializējiet to JSON failā ar nosaukumu save.json.

imports json
klasēGameWindow(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 self.game_state = GameState()


defsaglabā spēli(pats):
 dati = {
'player_x': self.game_state.player_x
 }
ar atvērt ("save.json", "w") kā fails:
 json.dump (dati, fails)
 drukāt (dati)


defon_draw(pats):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, zils)


defAtjaunināt(self, delta_time):
caurlaide
defon_key_press(pašs, atslēga, modifikatori):
ja taustiņš == arcade.key. PA kreisi:
 self.game_state.player_x -= SPĒLĒTĀJA_ĀTRUMS
elifs taustiņš == arcade.key. PA LABI:
 self.game_state.player_x += PLAYER_SPEED
elifs taustiņš == arcade.key. S:
 self.save_game()

Notiek spēles datu ielāde

Lai ielādētu spēles datus, pagariniet GameWindow klasi tālāk un pievienojiet metodi spēles stāvokļa ielādei. Izveidojiet jaunu failu ar nosaukumu load-game.py un pievienojiet kodu ar tālāk norādītajiem atjauninājumiem:

klasēGameWindow(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 self.game_state = GameState()
 self.load_game()
defielādēt spēli(pats):
mēģināt:
ar atvērt ("save.json", "r") kā fails:
 dati = json.load (fails)
 self.game_state.player_x = dati['player_x']
izņemot FileNotFoundError:
caurlaide
defon_key_press(pašs, atslēga, modifikatori):
ja taustiņš == arcade.key. L:
 self.load_game()

The ielādēt spēli metode mēģina atvērt save.json failu un izgūt spēles datus. Pēc tam tas atjaunina spēles stāvokli ar ielādētajiem datiem. Ja fails neeksistē, varat vienkārši ignorēt izņēmumu, atstājot noklusējuma spēles stāvokli.

Ieskaitot papildu funkcijas

Varat pievienot citas funkcijas, lai uzlabotu spēles saglabāšanas un ielādes sistēmu.

Augstāko rezultātu saglabāšana

Augstāko rezultātu saglabāšana līdztekus spēles stāvoklim ir izplatīta iezīme daudzās spēlēs. Jūs varat pārvaldīt punktu skaitu un saglabājiet labāko rezultātu, izmantojot šo sistēmu. Izveidojiet jaunu failu ar nosaukumu augsts rādītājs.py un pievienojiet kodu ar tālāk norādītajiem atjauninājumiem:

klasēGameWindow(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 self.high_score = 0
defielādēt spēli(pats):
mēģināt:
ar atvērt ("save.json", "r") kā fails:
 dati = json.load (fails)
 drukāt (dati)
 self.player_x = data.get('player_x', self.player_x)
 self.high_score = data.get('augsts_rezultāts', self.high_score)
izņemot FileNotFoundError:
caurlaide


defsaglabā spēli(pats):
 dati = {
'player_x': self.player_x,
'augsts_rezultāts': self.high_score
 }
ar atvērt ("save.json", "w") kā fails:
 json.dump (dati, fails)
 drukāt (dati)
defon_key_press(pašs, atslēga, modifikatori):
ja taustiņš == arcade.key. PA kreisi:
 self.player_x -= PLAYER_SPEED
elifs taustiņš == arcade.key. PA LABI:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Automātiskās saglabāšanas funkcija

Lai nodrošinātu spēlētājiem sirdsmieru un novērstu progresa zudumu, varat automātiski saglabāt spēles stāvokli ar regulāriem intervāliem. Izveidojiet jaunu failu ar nosaukumu auto-save.py un pievienojiet kodu ar tālāk norādītajiem atjauninājumiem:

imports laiks
klasēGameWindow(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 self.game_state = GameState()


# Saglabājiet ik pēc 6 sekundēm
 self.autosave_interval = 6
 self.last_save_time = laiks.laiks()


defAtjaunināt(self, delta_time):
 pašreizējais_laiks = laiks.laiks()
 time_diff = pašreizējais_laiks — self.last_save_time
ja time_diff >= self.autosave_interval:
 self.save_game()
 drukāt ("Saglabāts")
 self.last_save_time = pašreizējais_laiks

Šajā koda fragmentā Atjaunināt metode pārbauda, ​​vai norādītais laika intervāls ir pagājis kopš pēdējās saglabāšanas. Ja tā, tas aktivizē saglabā spēli metode GameWindow klasē, lai automātiski saglabātu spēles stāvokli. Pielāgojiet autosave_interval vērtība atbilstoši jūsu spēles prasībām.

Spēļu datu apstiprināšana

Ielādēto spēles datu apstiprināšana ir būtiska, lai nodrošinātu to integritāti un konsekvenci. Jūs varat viegli iekļaut datu validāciju mūsu saglabāšanas un ielādes sistēmā:

klasēGameState:
def__tajā__(pats):
 self.player_x = 0
defsaglabāšanas_stāvoklis(pats):
ja self.is_valid_state():
 dati = {
'player_x': self.player_x
 }


ar atvērt ("save.json", "w") kā fails:
 json.dump (dati, fails)


defload_state(pats):
ar atvērt ("save.json", "r") kā fails:
 dati = json.load (fails)


ja self.validate_loaded_data (dati):
 self.player_x = dati['player_x']
cits:
 drukāt ("Kļūda!")


defir_derīgs_stāvoklis(pats):
# Šeit veiciet validācijas loģiku
# Atgriezt True, ja statuss ir derīgs, False pretējā gadījumā
caurlaide
defvalide_loaded_data(sevis, dati):
# Veiciet ielādēto datu validāciju
# Atgriezt True, ja dati ir derīgi, False pretējā gadījumā
caurlaide

Iekļaujot šīs papildu funkcijas saglabāšanas un ielādes sistēmā, varat izveidot daudzpusīgāku un izturīgāku spēli pieredzi, piedāvājot spēlētājiem iespēju saglabāt vairākus spēļu stāvokļus, izsekot labākos rezultātus, iespējot automātisko saglabāšanu un nodrošināt datus integritāte.

Saglabāšanas un ielādes sistēmas labākā prakse

Saglabāšanas un ielādes sistēmas ieviešana ir svarīgs spēļu izstrādes aspekts. Lai nodrošinātu stabilu un uzticamu sistēmu, ir svarīgi ievērot labāko praksi. Šeit ir dažas galvenās prakses, kas jāņem vērā:

Šifrēt sensitīvus datus

Ja jūsu spēlē ir ietverta sensitīva informācija, piemēram, paroles, personas dati vai pirkumi lietotnē, ir ļoti svarīgi šifrēt saglabāto spēles stāvokli. Šifrēšana pievieno papildu drošības līmeni, aizsargājot spēlētāja privātumu un novēršot nesankcionētu piekļuvi viņu datiem. Izmantojiet šifrēšanas algoritmus un bibliotēkas, lai aizsargātu sensitīvu informāciju.

Apstipriniet ielādētos datus

Pirms spēles datu ielādes ir svarīgi tos apstiprināt, lai nodrošinātu to integritāti un konsekvenci. Pārbaudiet, vai ielādētie dati atbilst paredzētajam spēles formātam, struktūrai un ierobežojumiem.

Veiciet kritisko datu lauku validācijas pārbaudes, lai izvairītos no avārijām vai krāpšanās. Ieviesiet stabilus datu validācijas mehānismus, lai apstrādātu iespējamās kļūdas vai negaidītus datus.

Graciozi rīkojieties ar kļūdām

Strādājot ar failu I/O operācijām, var rasties kļūdas. Ir ļoti svarīgi graciozi apstrādāt šīs kļūdas un sniegt atskaņotājam informatīvus kļūdu ziņojumus. Noķert un apstrādājiet izņēmumus, piemēram, FileNotFoundError vai Atļaujas kļūda, saglabāšanas un ielādes darbību laikā.

Parādiet lietotājam draudzīgus kļūdu ziņojumus, lai palīdzētu spēlētājiem un novērstu neapmierinātību. Turklāt apsveriet iespēju ieviest kļūdu reģistrēšanu, lai palīdzētu diagnosticēt un novērst problēmas.

Pārbaudiet saglabāšanas un ielādes funkcionalitāti

Rūpīgi pārbaudiet savas spēles saglabāšanas un ielādes funkcionalitāti, lai nodrošinātu tās uzticamību un pareizību. Izveidojiet testa gadījumus, kas aptver dažādus scenārijus, piemēram, saglabāšanu dažādos spēles stāvokļos, ielādi no derīgiem un nederīgiem saglabāšanas failiem un testēšanas iespējas.

Pārbaudiet, vai spēles stāvoklis ir pareizi saglabāts un ielādēts un vai notiek paredzētā darbība. Automatizētās testēšanas sistēmas var palīdzēt izveidot visaptverošus testu komplektus.

Padariet spēles jautrākas, izmantojot saglabāšanas un ielādes sistēmu

Saglabāšanas un ielādes sistēmas pievienošana var padarīt spēles saistošākas, nodrošinot spēlētājiem nepārtrauktības un progresa sajūtu. Spēlētāji var brīvi eksperimentēt, izmēģināt dažādas pieejas un atgriezties spēlē vēlāk, nezaudējot savus sasniegumus.

Šī funkcija arī ļauj spēlētājiem sacensties ar draugiem vai izaicināt sevi, lai pārspētu savus iepriekšējos labākos rezultātus, pievienojot spēlei atkārtojamību un ilgtermiņa iesaistīšanos.