Játékadatok mentése és betöltése az Arcade-ban

Mentés és betöltés rendszer hozzáadása a játékhoz nagyban javíthatja a játékos élményét. Lehetővé teszi a játékosok számára, hogy kitartsák fejlődésüket, folytassák a játékmeneteket, és kísérletezzenek különböző stratégiákkal anélkül, hogy elveszítenék a nehezen megszerzett eredményeket.

Kellemesen meg fog lepődni, hogy milyen egyszerű ezt a funkciót a Python Arcade könyvtárával hozzáadni a játékhoz.

Hozzon létre egy egyszerű játékot

Kezdje a létrehozással egy egyszerű játék, ahol a játékos mozoghat bal és jobb.

A cikkben használt kód itt érhető el GitHub adattár és az MIT licence alapján ingyenesen használható.

Hozzon létre egy új nevű fájlt simple-game.py és add hozzá az alábbi kódot:

import árkád
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
kék = arcade.color. KÉK
osztályGameWindow(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 self.player_x = szélesség // 2





instagram viewer

defon_draw(maga):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, kék)
deffrissítés(self, delta_time):
pass
defon_key_press(én, kulcs, módosítók):
ha kulcs == arcade.key. BAL:
 self.player_x -= PLAYER_SPEED
elif kulcs == arcade.key. JOBB:
 self.player_x += PLAYER_SPEED
deffő-():
 ablak = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
ha __név__ == '__fő__':
 fő()

A kód létrehoz egy ablakot egy kék téglalappal, amely a játékost jelképezi. A játékos balra és jobbra mozoghat a bal és jobb nyílbillentyűkkel.

Játékállapotok kezelése

A mentési és betöltési rendszer megvalósításához különböző játékállapotokat kell kezelnie. A játék állapota a játék aktuális állapotát jelzi, beleértve az objektumok helyzetét, pontszámait és egyéb releváns adatokat. Ebben a példában csak a játékos x-koordinátájára összpontosítson.

A játékállapotok kezeléséhez vezessen be a GameState osztály, amely magába foglalja a játék adatait, és módszereket biztosít a mentéshez és betöltéshez. Íme a kód:

osztályGameState:
def__benne__(maga):
 self.player_x = 0

A játékadatok mentése

A játék adatainak mentéséhez hosszabbítsa meg a GameWindow osztályt, és adjon hozzá egy metódust a játék állapotának mentéséhez, amikor csak szükséges. Az egyszerűség kedvéért használja a JSON formátumot. Íme a kód:

Ban,-ben játék mentése módszer, hozzon létre egy Python szótárt tartalmazza a vonatkozó játékadatokat. Ezután szerializálja egy JSON-fájlba save.json.

import json
osztályGameWindow(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 self.game_state = GameState()
defjáték mentése(maga):
 adat = {
'player_x': self.game_state.player_x
 }
val vel nyisd ki("save.json", "w") mint fájl:
 json.dump (adat, fájl)
 nyomtatás (adat)
defon_draw(maga):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, kék)
deffrissítés(self, delta_time):
pass
defon_key_press(én, kulcs, módosítók):
ha kulcs == arcade.key. BAL:
 self.game_state.player_x -= PLAYER_SPEED
elif kulcs == arcade.key. JOBB:
 self.game_state.player_x += PLAYER_SPEED
elif kulcs == arcade.key. S:
 self.save_game()

A játék adatainak betöltése

A játékadatok betöltéséhez hosszabbítsa meg a GameWindow osztályt tovább, és adjunk hozzá egy metódust a játék állapotának betöltéséhez. Hozzon létre egy új nevű fájlt load-game.py és adja hozzá a kódot az alábbi frissítésekkel:

osztályGameWindow(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 self.game_state = GameState()
 self.load_game()
defjáték betöltése(maga):
próbáld ki:
val vel nyisd ki("save.json", "r") mint fájl:
 adatok = json.load (fájl)
 self.game_state.player_x = adatok['player_x']
kivéve FileNotFoundError:
pass
defon_key_press(én, kulcs, módosítók):
ha kulcs == arcade.key. L:
 self.load_game()

A játék betöltése módszer megpróbálja megnyitni a save.json fájlt és lekérni a játék adatait. Ezután frissíti a játék állapotát a betöltött adatokkal. Ha a fájl nem létezik, figyelmen kívül hagyhatja a kivételt, és hagyja az alapértelmezett játékállapotot.

Kiegészítő funkciókkal együtt

További funkciókat is hozzáadhat a játék mentési és betöltési rendszerének javításához.

Magas pontszámok mentése

A magas pontszámok mentése a játékállapot mellett sok játékban általános jellemző. tudsz kezelni a pontszámokat és mentse el a magas pontszámot ezzel a rendszerrel. Hozzon létre egy új nevű fájlt magas pontszámú.py és adja hozzá a kódot az alábbi frissítésekkel:

osztályGameWindow(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 self.high_score = 0
defjáték betöltése(maga):
próbáld ki:
val vel nyisd ki("save.json", "r") mint fájl:
 adatok = json.load (fájl)
 nyomtatás (adat)
 self.player_x = data.get('player_x', self.player_x)
 self.high_score = data.get('magas pontszám', self.high_score)
kivéve FileNotFoundError:
pass
defjáték mentése(maga):
 adat = {
'player_x': self.player_x,
'magas pontszám': self.high_score
 }
val vel nyisd ki("save.json", "w") mint fájl:
 json.dump (adat, fájl)
 nyomtatás (adat)
defon_key_press(én, kulcs, módosítók):
ha kulcs == arcade.key. BAL:
 self.player_x -= PLAYER_SPEED
elif kulcs == arcade.key. JOBB:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Automatikus mentés funkció

A játékosok nyugalmának és a haladás elvesztésének megelőzése érdekében rendszeres időközönként automatikusan mentheti a játék állapotát. Hozzon létre egy új nevű fájlt auto-save.py és adja hozzá a kódot az alábbi frissítésekkel:

import idő
osztályGameWindow(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 self.game_state = GameState()
# Mentse 6 másodpercenként
 self.autosave_interval = 6
 self.last_save_time = time.time()
deffrissítés(self, delta_time):
 jelenlegi_idő = idő.idő()
 time_diff = aktuális_idő – self.utolsó_megtakarítási_idő
ha time_diff >= self.autosave_interval:
 self.save_game()
 nyomtatás("Mentett")
 self.last_save_time = jelenlegi_idő

Ebben a kódrészletben a frissítés metódus ellenőrzi, hogy a megadott időintervallum eltelt-e az utolsó mentés óta. Ha igen, akkor kiváltja a játék mentése módszere a GameWindow osztályt, hogy automatikusan mentse a játék állapotát. Állítsa be a autosave_interval érték a játék követelményei szerint.

Játékadatok érvényesítése

A betöltött játékadatok ellenőrzése elengedhetetlen azok integritásának és konzisztenciájának biztosításához. Az adatellenőrzést egyszerűen beépítheti mentési és betöltési rendszerünkbe:

osztályGameState:
def__benne__(maga):
 self.player_x = 0
defmentés_állapot(maga):
ha self.is_valid_state():
 adat = {
'player_x': self.player_x
 }
val vel nyisd ki("save.json", "w") mint fájl:
 json.dump (adat, fájl)
defload_state(maga):
val vel nyisd ki("save.json", "r") mint fájl:
 adatok = json.load (fájl)
ha self.validate_loaded_data (adatok):
 self.player_x = adat['player_x']
más:
 nyomtatás("Hiba!")
defvan_valid_state(maga):
# Itt hajtsa végre az érvényesítési logikát
# Igaz, ha az állapot érvényes, hamis, ellenkező esetben False
pass
defvalidate_loaded_data(én, adatok):
# Végezze el a betöltött adatok érvényesítését
# Igazat ad vissza, ha az adat érvényes, hamis ellenkező esetben
pass

Ha ezeket a kiegészítő funkciókat beépíti a mentési és betöltési rendszerbe, sokoldalúbb és robusztusabb játékmenetet hozhat létre tapasztalat, amely lehetőséget kínál a játékosoknak több játékállapot mentésére, a magas pontszámok nyomon követésére, az automatikus mentés engedélyezésére és az adatok biztosítására sértetlenség.

Mentés és betöltés rendszer legjobb gyakorlatai

A mentési és betöltési rendszer megvalósítása fontos szempont a játékfejlesztésben. A robusztus és megbízható rendszer biztosítása érdekében elengedhetetlen a bevált gyakorlatok követése. Íme néhány kulcsfontosságú gyakorlat, amelyet figyelembe kell venni:

Érzékeny adatok titkosítása

Ha a játék érzékeny információkat, például jelszavakat, személyes adatokat vagy alkalmazáson belüli vásárlásokat tartalmaz, kulcsfontosságú a mentett játékállapot titkosítása. A titkosítás egy extra biztonsági réteget ad, védi a játékos magánéletét, és megakadályozza az adatokhoz való jogosulatlan hozzáférést. Használjon titkosítási algoritmusokat és könyvtárakat az érzékeny információk védelmére.

Érvényesítse a betöltött adatokat

A játékadatok betöltése előtt feltétlenül ellenőrizni kell azokat, hogy biztosítsák azok integritását és konzisztenciáját. Ellenőrizze, hogy a betöltött adatok megfelelnek-e a játék elvárt formátumának, szerkezetének és megszorításainak.

Végezzen érvényesítési ellenőrzéseket a kritikus adatmezőkön az összeomlások és csalások elkerülése érdekében. Robusztus adatellenőrzési mechanizmusok alkalmazása a lehetséges hibák vagy váratlan adatok kezelésére.

Kezelje a hibákat kecsesen

A fájl I/O műveletei során hibák léphetnek fel. Kulcsfontosságú, hogy ezeket a hibákat kecsesen kezeljük, és informatív hibaüzeneteket küldjünk a lejátszónak. Fogd meg és kezeld a kivételeket, mint pl FileNotFoundError vagy PermissionError, mentési és betöltési műveletek során.

Felhasználóbarát hibaüzenetek megjelenítése a játékosok irányítása és a frusztráció elkerülése érdekében. Ezenkívül fontolja meg a hibanaplózás megvalósítását a problémák diagnosztizálása és kijavítása érdekében.

Tesztelje a mentési és betöltési funkciót

Alaposan tesztelje játéka mentési és betöltési funkcióját, hogy megbizonyosodjon annak megbízhatóságáról és helyességéről. Hozzon létre teszteseteket, amelyek különféle forgatókönyveket fednek le, például mentést különböző játékállapotokban, betöltést érvényes és érvénytelen mentési fájlokból, valamint éles esetek tesztelését.

Ellenőrizze, hogy a játék állapota megfelelően van-e mentve és betöltve, és hogy a várt viselkedés megtörténik. Az automatizált tesztelési keretrendszerek segíthetnek átfogó tesztcsomagok létrehozásában.

Tedd szórakoztatóbbá a játékokat a mentés és betöltés rendszerrel

A mentési és betöltési rendszer hozzáadása vonzóbbá teheti a játékokat azáltal, hogy a játékosok számára a folyamatosság és a fejlődés érzését biztosítja. A játékosok szabadon kísérletezhetnek, kipróbálhatnak különböző megközelítéseket, és később visszatérhetnek a játékhoz anélkül, hogy elveszítenék teljesítményeiket.

Ez a funkció azt is lehetővé teszi a játékosoknak, hogy versenyezzenek a barátaikkal, vagy kihívást jelentsenek maguknak, hogy legyőzzék korábbi csúcspontjaikat, ami újrajátszhatóságot és hosszú távú elkötelezettséget ad a játékhoz.