יישום פיזיקה בסיסית וזיהוי התנגשות ב-Pygame

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

למד כיצד להוסיף פיזיקה בסיסית והתנגשויות במשחק שלך באמצעות מודול ה-pygame.

פונקציות זיהוי התנגשות מובנות של Pygame

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

collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, נָכוֹן)

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

collision_dict = pygame.sprite.groupcollide (קבוצה1, קבוצה2, נָכוֹן, נָכוֹן)

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

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

להתחיל, התקן את מודול ה-pygame באמצעות pip:

pip להתקין pygame

אחרי זה, ליצור שיעורים פשוטים עבור הנגן והפלטפורמה, שניהם צריכים לרשת ממחלקת Sprite של Pygame. למחלקת Player צריכה להיות שיטת עדכון לטיפול במיקום השחקן על סמך המהירות. כמו כן, צריך להיות לו משתנה y_velocity כדי להחיל את אפקט הכבידה. למחלקה Platform צריכה להיות שיטה __init__ שלוקחת את הקואורדינטות של הפלטפורמה ויוצרת משטח בגודל זה.

כיתת שחקנים

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

יְבוּא pygame
מעמדשחקן(pygame.sprite. שֵׁדוֹן):
def__init__(עצמי, x, y):
 super().__init__()
 self.image = pygame. משטח((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
defעדכון(עצמי):
 self.rect.y += self.y_velocity

כיתת פלטפורמה

מחלקת הפלטפורמה משתמשת גם ב-pygame.sprite. מודול ספרייט. מחלקה זו תאתחל את הפלטפורמה עם קואורדינטות x ו-y נתונות, כמו גם רוחב וגובה.

מעמדפּלַטפוֹרמָה(pygame.sprite. שֵׁדוֹן):
def__init__(עצמי, x, y, רוחב, גובה):
 super().__init__()
 self.image = pygame. משטח ((רוחב, גובה))
 self.rect = self.image.get_rect (topleft=(x, y))

לולאת המשחק

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

שחקן = שחקן(100, 300)
player_group = pygame.sprite. קְבוּצָה()
player_group.add (שחקן)
פלטפורמה = פלטפורמה(50, 400, 100, 20)
platform_group = pygame.sprite. קְבוּצָה()
platform_group.add (פלטפורמה)
# אתחול pygame וצור חלון
pygame.init()
screen = pygame.display.set_mode((640, 480))
# לולאת משחק ראשית
פועל = נָכוֹן
בזמן רץ:
ל מִקרֶה ב pygame.event.get():
אם event.type == pygame. לְהַפְסִיק:
 פועל = שֶׁקֶר

 player_group.update()
 collided = pygame.sprite.spritecollide (player, platform_group, שֶׁקֶר)
אם התנגש:
 player.y_velocity = 0
 screen.fill((255, 255, 255))
 player_group.draw (מסך)
 platform_group.draw (מסך)
 pygame.display.flip()
pygame.quit()

להלן הפלט:

יישום כוח המשיכה וקפיצות

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

מעמדשחקן(pygame.sprite. שֵׁדוֹן):
def__init__(עצמי, x, y):
 super().__init__()
 self.image = pygame. משטח((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
defעדכון(עצמי):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVITY # החל כוח הכבידה על מהירות Y

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

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

JUMP_VELOCITY = -10
# בתוך לולאת המשחק
אם event.type == pygame. KEYDOWN ו event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

שימו לב שתצטרכו לבדוק את ה-event.type כדי לוודא שהאירוע הוא אירוע KEYDOWN לפני בדיקת ערך המפתח.

הוספת פיזיקה בסיסית כגון חיכוך ותאוצה

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

חיכוך = 0.9
מעמדשחקן(pygame.sprite. שֵׁדוֹן):
def__init__(עצמי, x, y):
 super().__init__()
 self.image = pygame. משטח((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
 self.x_velocity = 0
defעדכון(עצמי):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVITY # החל כוח הכבידה על מהירות Y
 self.x_velocity *= FRICTION # החל חיכוך על מהירות x

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

האצה = 0.5
player_movement = 0
אם event.type == pygame. מקש:
אם event.key == pygame. K_LEFT:
 player_movement = -1
אליף event.key == pygame. K_RIGHT:
 player_movement = 1
אליף event.type == pygame. מפתח למעלה:
אם event.key ב (pygame. K_LEFT, pygame. K_RIGHT):
 player_movement = 0

player.x_velocity += player_movement * האצה

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

אתה יכול למצוא את הקוד המלא ב- מאגר GitHub.

להלן הפלט:

שפר את מעורבות המשתמש עם התנגשויות

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

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