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

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

יצירת משחק פשוט

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

pip להתקין pygame

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

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

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

יְבוּא pygame
# אתחול Pygame
pygame.init()


# הגדר את חלון המשחק
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("שמור וטען מערכת הדרכה")


# משתני משחק
player_x = 400
player_y = 500
player_speed = 5


# לולאת משחק
פועל = נָכוֹן
בזמן רץ:
ל מִקרֶה ב pygame.event.get():
אם event.type == pygame. לְהַפְסִיק:
 פועל = שֶׁקֶר







instagram viewer



 keys = pygame.key.get_pressed()
אם keys[pygame. K_LEFT]:
 player_x -= player_speed
אם keys[pygame. K_RIGHT]:
 player_x += player_speed


# נקה את המסך
 window.fill((0, 0, 0))


# צייר את השחקן
 pygame.draw.rect (window, (255, 255, 255), (player_x, player_y, 50, 50))


# עדכן את התצוגה
 pygame.display.flip()
# צא מהמשחק
pygame.quit()

ניהול מצב משחק ועמידות נתונים

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

# משתני משחק
game_state = {
'player_x': 400,
'player_y': 500
}
# לולאת משחק
פועל = נָכוֹן
בזמן רץ:
# ...


 keys = pygame.key.get_pressed()
אם keys[pygame. K_LEFT]:
 מצב_משחק['player_x'] -= player_speed
אם keys[pygame. K_RIGHT]:
 מצב_משחק['player_x'] += player_speed


# ...
 pygame.display.flip()

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

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

game_state = {
'player_x': player_x,
'player_y': player_y
}
# שמור מצב משחק
defsave_game_state(מצב_משחק, שם_קובץ):
לְנַסוֹת:
עם פתוח (שם_קובץ, 'wb') כפי ש קוֹבֶץ:
 pickle.dump (game_state, file)
 הדפס("מצב המשחק נשמר בהצלחה!")
מלבד שגיאה IOE:
 הדפס("שגיאה: לא ניתן לשמור את מצב המשחק.")


# טען מצב משחק
defload_game_state(שם קובץ):
לְנַסוֹת:
עם פתוח (שם_קובץ, 'רב') כפי ש קוֹבֶץ:
 game_state = pickle.load (קובץ)
 הדפס("מצב המשחק נטען בהצלחה!")
לַחֲזוֹר מצב_משחק
מלבד (IOError, מלפפון חמוץ. Unpickling Error):
 הדפס("שגיאה: לא ניתן לטעון את מצב המשחק.")


# לולאת משחק
פועל = נָכוֹן
בזמן רץ:


# ...


 keys = pygame.key.get_pressed()
אם keys[pygame. K_LEFT]:
 player_x -= player_speed
 מצב_משחק['player_x'] = player_x
אם keys[pygame. K_RIGHT]:
 player_x += player_speed
 מצב_משחק['player_x'] = player_x


אם keys[pygame. K_s]:
 save_game_state (מצב_משחק, 'save_game.pickle')
אם keys[pygame. K_l]:
 game_state = load_game_state('save_game.pickle')
 player_x = game_state['player_x']

# ...
# ...

להלן הפלט:

עיצוב ממשק משתמש ל-Save Slots

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

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

הצג את משבצות השמירה הזמינות כאשר השחקן לוחץ על לחצן השמירה (K_s). השחקן יכול לבחור משבצת על ידי לחיצה על מקש הספרה המתאים (K_1, K_2, או K_3). אם נבחר משבצת, מצב המשחק נשמר בקובץ הנקרא על שם המשבצת שנבחרה.

באופן דומה, כאשר הנגן לוחץ על לחצן הטעינה (K_l), הצג את חריצי השמירה. השחקן יכול לבחור משבצת על ידי לחיצה על המקשים ק_א, K_b, או K_c כדי לטעון את מצב המשחק. לחילופין, אתה יכול השתמש בכניסות מגע במקום כניסות מקלדת לבחירת חריץ. אם נבחר משבצת, מצב המשחק נטען מהקובץ המתאים.

צור קובץ חדש בשם interface.py והוסיפו את הקוד עם העדכונים הבאים:

# משתני משחק
save_slots = ['משבצת 1', 'חריץ 2', 'חריץ 3']
select_slot = אף אחד
# לולאת משחק
פועל = נָכוֹן
בזמן רץ:
ל מִקרֶה ב pygame.event.get():
אם event.type == pygame. לְהַפְסִיק:
 פועל = שֶׁקֶר


אם event.type == pygame. מקש:
אם event.key == pygame. K_s:
# הצג משבצות שמירה
 select_slot = אף אחד
ל אני, משבצת ב מנה (save_slots):
 הדפס(f"שמור חריץ {i+1}: {חָרִיץ}")
 הדפס("בחר משבצת כדי לשמור את המשחק.")


אם event.key == pygame. K_l:
 הדפס("בחר חריץ:- a - חריץ 1, b - חריץ 3, c - חריץ 3")
# הצג משבצות שמירה
 select_slot = אף אחד
ל אני, משבצת ב מנה (save_slots):
 הדפס(f"שמור חריץ {i+1}: {חָרִיץ}")
 הדפס("בחר משבצת לטעינת המשחק.")


אם event.key ב [pygame. K_1, pygame. K_2, pygame. K_3]:
# שמור או טען משחק על סמך המשבצת שנבחרה
 slot_index = event.key - pygame. K_1
 select_slot = save_slots[slot_index]

 save_game_state (מצב_משחק, ו"{selected_slot}.מלפפון חמוץ")
 הדפס(f"המשחק נשמר ב {selected_slot}!")


אם event.key ב [pygame. K_a, pygame. K_b, pygame. K_c]:

 slot_index = event.key - pygame. ק_א
 select_slot = save_slots[slot_index]
 game_state = load_game_state(ו"{selected_slot}.מלפפון חמוץ")
 player_x = game_state['player_x']
 הדפס(f"המשחק נטען מ {selected_slot}!")
# ...


 pygame.display.flip()
# ...

להלן הפלט:

אין צורך בייחוס: צילום מסך מאת Imran

טיפול באפשרויות כתיבה

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

# שמור מצב משחק
defsave_game_state(מצב_משחק, שם_קובץ):
אם os.path.exists (שם_קובץ):
# בקש אישור כדי להחליף קובץ שמירה קיים
 overwrite = input("קובץ שמור כבר קיים. האם אתה רוצה להחליף? (י/נ): ")
אם overwrite.lower() != 'י':
 הדפס("השמירה בוטלה.")
לַחֲזוֹר
לְנַסוֹת:
עם פתוח (שם_קובץ, 'wb') כפי ש קוֹבֶץ:
 pickle.dump (game_state, file)
 הדפס("מצב המשחק נשמר בהצלחה!")
מלבד שגיאה IOE:
 הדפס("שגיאה: לא ניתן לשמור את מצב המשחק.")


# ...


# טען מצב משחק
defload_game_state(שם קובץ):
אםלֹא os.path.exists (שם_קובץ):
 הדפס("שגיאה: קובץ שמירת אינו קיים.")
לַחֲזוֹראף אחד


לְנַסוֹת:
עם פתוח (שם_קובץ, 'רב') כפי ש קוֹבֶץ:
 game_state = pickle.load (קובץ)
 הדפס("מצב המשחק נטען בהצלחה!")
לַחֲזוֹר מצב_משחק
מלבד (IOError, מלפפון חמוץ. Unpickling Error):
 הדפס("שגיאה: לא ניתן לטעון את מצב המשחק.")
לַחֲזוֹראף אחד
# ...

בקוד לעיל, לפני שמירת מצב משחק, אתה בודק אם קובץ השמירה כבר קיים באמצעות os.path.exists(). אם כן, אתה מבקש מהנגן לאשר להחליף את קובץ השמירה הקיים. אם הנגן בוחר לא להחליף, פעולת השמירה תבוטל.

באופן דומה, לפני טעינת מצב משחק, אתה בודק אם קובץ השמירה קיים באמצעות os.path.exists(). אם לא, אתה מודיע לנגן בהודעת שגיאה.

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

בעת הטמעת מערכת שמירה וטעינה ב-PyGame או כל פרויקט פיתוח משחקים, שקול את השיטות המומלצות הבאות:

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

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

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

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