כיצד לשמור ולטעון נתוני משחק בארקייד

הוספת מערכת שמירה וטעינה למשחק שלך יכולה לשפר מאוד את חווית השחקן. זה מאפשר לשחקנים להתמיד בהתקדמות שלהם, לחדש הפעלות משחק ולהתנסות באסטרטגיות שונות מבלי לאבד הישגים שהרווחתם קשה.

תופתעו לטובה מכמה פשוט להוסיף תכונה זו למשחק שלכם באמצעות ספריית Arcade של Python.

צור משחק פשוט

התחל ביצירה משחק פשוט שבו השחקן יכול לזוז שמאל וימין.

הקוד המשמש במאמר זה זמין כאן מאגר GitHub והוא בחינם עבורך לשימוש תחת רישיון MIT.

צור קובץ חדש בשם simple-game.py והוסיפו את הקוד הבא:

יְבוּא מִקמֶרֶת
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
כחול = arcade.color. כְּחוֹל
מעמדGameWindow(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 self.player_x = רוחב // 2
defon_draw(עצמי):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, כחול)
defעדכון(עצמי, זמן_דלתא):
לַעֲבוֹר
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= PLAYER_SPEED
אליף key == arcade.key. ימין:
 self.player_x += PLAYER_SPEED





instagram viewer

defרָאשִׁי():
 window = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
אם __שם__ == '__רָאשִׁי__':
 רָאשִׁי()

הקוד יוצר חלון עם מלבן כחול המייצג את השחקן. השחקן יכול לנוע ימינה ושמאלה באמצעות מקשי החצים שמאלה וימינה.

ניהול מדינות משחק

כדי ליישם מערכת שמירה וטעינה, עליך לנהל מצבי משחק שונים. מצב משחק מייצג את המצב הנוכחי של המשחק, כולל מיקומי החפצים, התוצאות ונתונים רלוונטיים אחרים. עבור דוגמה זו, התמקד רק בקואורדינטת ה-x של השחקן.

כדי לנהל מצבי משחק, הצג את א GameState מחלקה המקופלת את נתוני המשחק ומספקת שיטות לשמור ולטעון אותם. הנה הקוד:

מעמדGameState:
def__init__(עצמי):
 self.player_x = 0

שמירת נתוני המשחק

כדי לשמור את נתוני המשחק, הארך את GameWindow class והוסיפו שיטה לשמירת מצב המשחק בכל פעם שצריך. השתמש בפורמט JSON לפשטות. הנה הקוד:

בתוך ה שמור משחק שיטה, ליצור מילון Python המכיל את נתוני המשחק הרלוונטיים. לאחר מכן עשה אותו בסידרה לקובץ JSON בשם save.json.

יְבוּא json
מעמדGameWindow(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 self.game_state = GameState()
defשמור משחק(עצמי):
 נתונים = {
'player_x': self.game_state.player_x
 }
עם לִפְתוֹחַ('save.json', 'וו') כפי ש קוֹבֶץ:
 json.dump (נתונים, קובץ)
 הדפס (נתונים)
defon_draw(עצמי):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, כחול)
defעדכון(עצמי, זמן_דלתא):
לַעֲבוֹר
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.game_state.player_x -= PLAYER_SPEED
אליף key == arcade.key. ימין:
 self.game_state.player_x += PLAYER_SPEED
אליף key == arcade.key. S:
 self.save_game()

טעינת נתוני המשחק

כדי לטעון את נתוני המשחק, הארך את GameWindow שיעור נוסף והוסף שיטה לטעינת מצב המשחק. צור קובץ חדש בשם load-game.py והוסיפו את הקוד עם העדכונים הבאים:

מעמדGameWindow(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 self.game_state = GameState()
 self.load_game()
defטוען משחק(עצמי):
לְנַסוֹת:
עם לִפְתוֹחַ('save.json', 'ר') כפי ש קוֹבֶץ:
 data = json.load (קובץ)
 self.game_state.player_x = נתונים['player_x']
מלבד FileNotFoundError:
לַעֲבוֹר
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. L:
 self.load_game()

ה טוען משחק השיטה מנסה לפתוח את save.json קובץ ואחזר את נתוני המשחק. לאחר מכן הוא מעדכן את מצב המשחק עם הנתונים הטעונים. אם הקובץ לא קיים, אתה יכול פשוט להתעלם מהחריג ולהשאיר את מצב ברירת המחדל של המשחק.

כולל תכונות נוספות

אתה יכול להוסיף תכונות נוספות כדי לשפר את מערכת השמירה והטעינה של המשחק.

שמירת ציונים גבוהים

שמירת ציונים גבוהים לצד מצב המשחק היא תכונה נפוצה במשחקים רבים. אתה יכול לנהל את הציונים ולשמור את הציון הגבוה באמצעות מערכת זו. צור קובץ חדש בשם high-score.py והוסיפו את הקוד עם העדכונים הבאים:

מעמדGameWindow(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 self.high_score = 0
defטוען משחק(עצמי):
לְנַסוֹת:
עם לִפְתוֹחַ('save.json', 'ר') כפי ש קוֹבֶץ:
 data = json.load (קובץ)
 הדפס (נתונים)
 self.player_x = data.get('player_x', self.player_x)
 self.high_score = data.get('ניקוד גבוה', self.high_score)
מלבד FileNotFoundError:
לַעֲבוֹר
defשמור משחק(עצמי):
 נתונים = {
'player_x': self.player_x,
'ניקוד גבוה': self.high_score
 }
עם לִפְתוֹחַ('save.json', 'וו') כפי ש קוֹבֶץ:
 json.dump (נתונים, קובץ)
 הדפס (נתונים)
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= PLAYER_SPEED
אליף key == arcade.key. ימין:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

תכונת שמירה אוטומטית

כדי לספק לשחקנים שקט נפשי ולמנוע אובדן התקדמות, אתה יכול לשמור באופן אוטומטי את מצב המשחק במרווחי זמן קבועים. צור קובץ חדש בשם auto-save.py והוסיפו את הקוד עם העדכונים הבאים:

יְבוּא זְמַן
מעמדGameWindow(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 self.game_state = GameState()
# שמור כל 6 שניות
 self.autosave_interval = 6
 self.last_save_time = time.time()
defעדכון(עצמי, זמן_דלתא):
 current_time = time.time()
 time_diff = current_time - self.last_save_time
אם time_diff >= self.autosave_interval:
 self.save_game()
 הדפס("שמור")
 self.last_save_time = השעה הנוכחית

בקטע קוד זה, ה- עדכון השיטה בודקת אם מרווח הזמן שצוין חלף מאז השמירה האחרונה. אם כן, זה מפעיל את שמור משחק שיטת ה GameWindow מחלקה כדי לשמור אוטומטית את מצב המשחק. התאם את autosave_interval ערך בהתאם לדרישות המשחק שלך.

אימות נתוני משחק

אימות נתוני המשחק הטעונים חיוני כדי להבטיח את שלמותם ועקביותם. אתה יכול לשלב בקלות אימות נתונים במערכת השמירה והטעינה שלנו:

מעמדGameState:
def__init__(עצמי):
 self.player_x = 0
defsave_state(עצמי):
אם self.is_valid_state():
 נתונים = {
'player_x': self.player_x
 }
עם לִפְתוֹחַ('save.json', 'וו') כפי ש קוֹבֶץ:
 json.dump (נתונים, קובץ)
defload_state(עצמי):
עם לִפְתוֹחַ('save.json', 'ר') כפי ש קוֹבֶץ:
 data = json.load (קובץ)
אם self.validate_loaded_data (נתונים):
 self.player_x = נתונים['player_x']
אַחֵר:
 הדפס("שְׁגִיאָה!")
defis_valid_state(עצמי):
# בצע היגיון אימות כאן
# החזר True אם המצב תקף, False אחרת
לַעֲבוֹר
defvalidate_loaded_data(עצמי, נתונים):
# בצע אימות על הנתונים הטעונים
# החזר True אם הנתונים תקפים, False אחרת
לַעֲבוֹר

על ידי שילוב תכונות נוספות אלה במערכת השמירה והטעינה, תוכל ליצור משחק רב תכליתי וחזק יותר ניסיון, מציע לשחקנים את היכולת לשמור מספר מצבי משחק, לעקוב אחר ציונים גבוהים, לאפשר שמירה אוטומטית ולהבטיח נתונים יושרה.

שיטות עבודה מומלצות למערכת השמירה והטעינה

הטמעת מערכת שמירה וטעינה היא היבט חשוב בפיתוח המשחק. כדי להבטיח מערכת חזקה ואמינה, חיוני לפעול לפי שיטות עבודה מומלצות. הנה כמה שיטות עיקריות שכדאי לקחת בחשבון:

הצפנת נתונים רגישים

אם המשחק שלך כולל מידע רגיש כמו סיסמאות, נתונים אישיים או רכישות בתוך האפליקציה, חיוני להצפין את מצב המשחק השמור. הצפנה מוסיפה שכבת אבטחה נוספת, מגינה על פרטיות השחקן ומונעת גישה לא מורשית לנתונים שלו. השתמש באלגוריתמי הצפנה וספריות כדי להגן על מידע רגיש.

אימות נתונים נטענים

לפני טעינת נתוני המשחק, חיוני לאמת אותם כדי להבטיח את שלמותם ועקביותם. ודא שהנתונים הטעונים עומדים בפורמט, המבנה והאילוצים הצפויים של המשחק שלך.

בצע בדיקות אימות בשדות נתונים קריטיים כדי למנוע קריסות או רמאות. הטמע מנגנוני אימות נתונים חזקים כדי לטפל בשגיאות פוטנציאליות או נתונים בלתי צפויים.

טפל בשגיאות בחן

כאשר עוסקים בפעולות קלט/פלט של קבצים, עלולות להתרחש שגיאות. זה חיוני לטפל בשגיאות אלה בחן ולספק הודעות שגיאה אינפורמטיביות לנגן. לתפוס ולטפל בחריגים, כגון FileNotFoundError אוֹ PermissionError, במהלך פעולות שמירה וטעינה.

הצג הודעות שגיאה ידידותיות למשתמש כדי להדריך שחקנים ולמנוע תסכול. בנוסף, שקול ליישם רישום שגיאות כדי לסייע באבחון ותיקון בעיות.

בדוק את פונקציונליות השמירה והטעינה

בדוק היטב את פונקציונליות השמירה והטעינה של המשחק שלך כדי להבטיח את מהימנותו ונכונותו. צור מקרי בדיקה המכסים תרחישים שונים, כגון שמירה במצבי משחק שונים, טעינה מקבצי שמירה חוקיים ולא חוקיים ובדיקת מקרי קצה.

ודא שמצב המשחק נשמר ונטען כהלכה ושההתנהגות הצפויה מתרחשת. מסגרות בדיקה אוטומטיות יכולות לסייע ביצירת חבילות בדיקה מקיפות.

הפוך את המשחקים למהנים יותר עם מערכת שמירה וטעינה

הוספת מערכת שמירה וטעינה יכולה להפוך את המשחקים למרתקים יותר על ידי מתן תחושה של המשכיות והתקדמות לשחקנים. שחקנים יכולים להתנסות בחופשיות, לנסות גישות שונות ולחזור למשחק מאוחר יותר מבלי לאבד את ההישגים שלהם.

תכונה זו גם מאפשרת לשחקנים להתחרות עם חברים או לאתגר את עצמם לנצח את הציונים הגבוהים הקודמים שלהם, מה שמוסיף יכולת משחק חוזרת ומעורבות ארוכת טווח למשחק שלך.