זוהי מבוא ל- Pygame לאנשים שכבר מכירים את פייתון. מאמר זה ילמד אתכם את השלבים לבניית משחק פשוט שבו השחקן מתחמק מכדורים מקפיצים.
צעדים
חלק 1 מתוך 8: התקנת Pygame
שלב 1. הורד Pygame
מצא את זה לפלטפורמה שלך מ
שלב 2. הפעל את תוכנית ההתקנה
שלב 3. ודא שההתקנה עבדה
פתח מסוף פייתון. הקלד "יבוא pygame". אם אינך רואה שגיאות, Pygame הותקן בהצלחה.
לייבא משחק משחקים
חלק 2 מתוך 8: הגדרת חלון בסיסי
שלב 1. פתח קובץ חדש
שלב 2. ייבא Pygame
Pygame היא ספרייה המספקת גישה לפונקציות גרפיות. אם אתה רוצה מידע נוסף על אופן הפעולה של פונקציות אלה, תוכל לחפש אותן באתר Pygame.
ייבוא pygame מ pygame.locals יבוא *
שלב 3. הגדר את רזולוציית החלון
אתה תעשה משתנה גלובלי לרזולוציית המסך כך שניתן יהיה להתייחס אליו במספר חלקים של המשחק. קל למצוא אותו גם בחלק העליון של הקובץ, כך שניתן יהיה לשנות אותו מאוחר יותר. לפרויקטים מתקדמים, הכנסת מידע זה לקובץ נפרד תהיה רעיון טוב יותר.
רזולוציה = (400, 300)
שלב 4. הגדר כמה צבעים
הצבעים בפאגם הם (RBGA אשר נעים בערכים שבין 0 ל -255. ערך האלפא (A) הוא אופציונלי אך הצבעים האחרים (אדום, כחול וירוק הם חובה).
לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0)
שלב 5. אתחל את המסך
השתמש במשתנה הרזולוציה שהוגדר קודם לכן.
מסך = pygame.display.set_mode (רזולוציה)
שלב 6. צור לולאת משחק
חזור על פעולות מסוימות בכל מסגרת של המשחק שלנו. צור לולאה שתמיד תחזור על עצמה כדי לעבור בין כל הפעולות האלה.
בעוד שזה נכון:
שלב 7. צבע את המסך
מסך.מילוי (לבן)
שלב 8. הצג את המסך
אם אתה מפעיל את התוכנית, המסך יהפוך ללבן ואז התוכנית תקרוס. הסיבה לכך היא שמערכת ההפעלה שולחת אירועים למשחק והמשחק לא עושה איתם כלום. ברגע שהמשחק יקבל יותר מדי אירועים לא מטופלים, הוא יקרוס.
בעוד שזה נכון: … pygame.display.flip ()
שלב 9. לטפל באירועים
קבל רשימה של כל האירועים שהתרחשו בכל מסגרת. יהיה לך אכפת מאירוע אחד בלבד, האירוע צא. זה קורה כאשר המשתמש סוגר את חלון המשחק. זה גם ימנע מהתוכנית שלנו לקרוס בגלל יותר מדי אירועים.
בעוד נכון: … לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit ()
שלב 10. נסה את זה
כך צריך להיראות הקוד כעת:
ייבוא pygame מ pygame.locals ייבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = pygame.display.set_mode (בזמן אמת: screen.fill (לבן) pygame.display.flip () לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit ()
חלק 3 מתוך 8: יצירת אובייקט משחק
שלב 1. צור כיתה ובנאי חדש
הגדר את כל המאפיינים של האובייקט. אתה גם מספק ערכי ברירת מחדל עבור כל הנכסים.
כיתת כדור: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball"
שלב 2. הגדר כיצד לצייר את האובייקט
השתמש במאפיינים שהוגדרו בבנאי כדי לצייר את הכדור כמעגל וכן להעביר משטח לפונקציה לצייר את האובייקט עליו. המשטח יהיה אובייקט המסך שנוצר באמצעות הרזולוציה קודם לכן.
Def Draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (self.x, self.y), self.radius)
שלב 3. צור מופע של הכיתה כמו גם לספר ללולאת המשחק לצייר את הכדור בכל לולאה
ball = Ball () בעוד True:… ball.draw (מסך)
שלב 4. גרמו לאובייקט לזוז
צור פונקציה שתעדכן את המיקום של האובייקט. קראו לפונקציה זו בכל לולאת משחקים.
כיתת כדור: … עדכון def (עצמי): self.x += self.dx self.y += self.dy
שלב 5. הגבל את קצב המסגרות
הכדור ינוע ממש מהר כי לולאת המשחק פועלת מאות פעמים בשנייה. השתמש בשעון של Pygame כדי להגביל את קצב הפריימים ל -60 fps.
שעון = pygame.time. Clock () בעוד נכון: … clock.tick (60)
שלב 6. שמור את הכדור על המסך
הוסף צ'קים בפונקציית העדכון כדי להפוך את כיוון הכדור אם הוא פוגע באחד מקצוות המסך.
class ball:… def update (self):… if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 if (self.y <= 0 or self.y > = רזולוציה [1]): self.dy *= -1
שלב 7. נסה את זה
כך צריך להיראות הקוד כעת:
ייבוא pygame מ pygame.locals ייבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = pygame.display.set_mode (רזולוציה) כדור בכיתה: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "כדור" def draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (self.x, self.y), self.radius) עדכון def (self): self.x += self.dx self.y += self.dy אם (self.x <= 0 או self.x> = רזולוציה [0]): self.dx *= -1 אם (self.y <= 0 או self.y> = רזולוציה [1]): self.dy *= -1 כדור = כדור () שעון = pygame.time. Clock () בעוד True: מסך. מילוי (לבן) ball.draw (מסך) ball.update () pygame.display.flip () clock.tick (60) לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit ()
חלק 4 מתוך 8: ארגון המשחק
שלב 1. השתמש בשיעורים כדי לארגן הכל
המשחק הולך להיות מסובך יותר. השתמש בטכניקות מונחות עצמים כדי לארגן את הקוד שלך.
שלב 2. הפוך את לולאת המשחק לכיתה
מכיוון שהמשחק שלנו מכיל כעת נתונים כולל אובייקטים והפונקציות של המשחק שלך, הגיוני להפוך את לולאת המשחק שלך למחלקה.
משחק בכיתה ():
שלב 3. הוסף בונה
כאן תוכלו לייצר כמה אובייקטים של משחק, ליצור את המסך והשעון שלנו ולאתחל את Pygame. צריך לאתחל את Pygame כדי להשתמש בתכונות מסוימות כמו טקסט או צליל.
משחק בכיתה (): def _init _ (עצמי): pygame.init () self.screen = pygame.display.set_mode (רזולוציה) self.clock = pygame.time. Clock ()
שלב 4. לטפל באירועים בפונקציה
game class ():… def handleEvents (self): לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit ()
שלב 5. הפוך את לולאת המשחק לפונקציה
התקשר לפונקציית טיפול באירועים בכל לולאה.
משחק בכיתה (): … הפעלה (עצמי): בעוד נכון: self.handleEvents () self.screen.fill (לבן) self.clock.tick (60) pygame.display.flip ()
שלב 6. לטפל בחפצי משחק מרובים
כרגע קוד זה צריך לקרוא לצייר ולעדכן על האובייקט שלנו כל מסגרת. זה יהיה מבולגן אם היו לך הרבה חפצים. הוסף את האובייקט שלנו למערך ולאחר מכן נעדכן וצייר את כל האובייקטים במערך בכל לולאה. עכשיו אתה יכול להוסיף אובייקט אחר בקלות ולתת לו מיקום מוצא אחר.
משחק בכיתה (): def _init _ (עצמי): … self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) … def run (self): בעוד True: self.handleEvents () עבור gameObj ב- self.gameObjects: gameObj.update () self.screen.fill (לבן) למשחקObj ב- self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.לְהַעִיף()
שלב 7. נסה את זה
כך צריך להיראות הקוד כעת:
ייבוא pygame מ pygame.locals ייבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = pygame.display.set_mode (רזולוציה) כדור בכיתה: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "כדור" def draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 אם (self.y <= 0 או self.y> = רזולוציה [1]): self.dy *= -1 משחק מחלקה (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (רזולוציה) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (עצמי): לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): בעוד True: self.handleEvent s () עבור gameObj ב- self.gameObjects: gameObj.update () self.screen.fill (לבן) עבור gameObj ב- self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. הפוך () משחק (). הפעלה ()
חלק 5 מתוך 8: הוספת אובייקט שחקן
שלב 1. צור כיתת שחקן ובנאי
אתה עומד ליצור עיגול נוסף הנשלט על ידי העכבר. אתחל את הערכים בבנאי. הרדיוס הוא הערך החשוב היחיד.
שחקן בכיתה: def _init _ (עצמי, rad = 20): self.x = 0 self.y = 0 self.radius = rad
שלב 2. הגדר כיצד לצייר את אובייקט השחקן
זה הולך להיות כמו שציירת את שאר חפצי המשחק.
שחקן מחלקה:… תיקו def (עצמי, משטח): pygame.draw.circle (משטח, אדום, (self.x, self.y), self.radius)
שלב 3. הוסף שליטה בעכבר לאובייקט הנגן
בכל מסגרת, בדוק את מיקום העכבר והגדר את מיקום אובייקטים השחקנים לנקודה זו.
class class: … update update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
שלב 4. הוסף אובייקט שחקן ל- gameObjects
צור מופע שחקן חדש והוסף אותו לרשימה.
משחק בכיתה (): def _init _ (עצמי): … self.gameObjects.append (Player ())
שלב 5. נסה את זה
כך צריך להיראות הקוד כעת:
ייבוא pygame מ pygame.locals ייבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = pygame.display.set_mode (רזולוציה) כדור בכיתה: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "כדור" def draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 אם (self.y <= 0 או self.y> = רזולוציה [1]): self.dy *= -1 שחקן בכיתה: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (עצמי, משטח): pygame.draw.circle (משטח, אדום, (self.x, self.y), self.radius) עדכון def (עצמי): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] משחק מחלקה (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ מצב (רזולוציה) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (כדור (100))) def handleEvents (self): לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): בעוד True: self.handleEvents () עבור gameObj בעצמי.gameObjects: gameObj.update () self.screen.fill (לבן) למשחקObj במשחק self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () משחק (). לָרוּץ()
חלק 6 מתוך 8: יצירת אינטראקציות של אובייקטים עם השחקן
שלב 1. שנה את פונקציות העדכון
על מנת שאובייקטים יתקיימו אינטראקציה, יהיה עליהם לקבל גישה זה לזה. הוסף פרמטר נוסף לעדכון כדי לעבור ברשימת gameObjects. יהיה עליך להוסיף אותו הן לאובייקט השחקן והן לאובייקטים של הכדור. אם יש לך הרבה חפצי משחק, ירושה יכולה לעזור לך לשמור על כל חתימות השיטה שלך זהות.
כיתת כדור: … עדכון def (עצמי, gameObjects): … שחקן מחלקה: … עדכון def (עצמי, gameObjects):
שלב 2. בדוק אם יש התנגשויות בין השחקן לכדורים
עברו על כל חפצי המשחק ובדקו אם סוג האובייקטים הוא כדור. לאחר מכן השתמש ברדיוס של שני האובייקטים ובנוסחת המרחק כדי לבדוק אם הם מתנגשים. מעגלים ממש קלים לבדוק התנגשויות. זו הסיבה הגדולה ביותר שלא השתמשת בצורה אחרת למשחק הזה.
שחקן בכיתה: … עדכון def (עצמי, gameObjects):… עבור gameObj ב- gameObjects: אם gameObj.type == "כדור": אם (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
שלב 3. סיימו את המשחק אם השחקן יקבל "מכה"
בואו נוותר על המשחק בינתיים.
אם (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
שלב 4. נסה את זה
כך צריך להיראות הקוד כעת:
ייבוא pygame מ pygame.locals ייבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = pygame.display.set_mode (רזולוציה) כדור בכיתה: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "כדור" def draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 אם (self.y <= 0 או self.y> = רזולוציה [1]): self.dy *= -1 שחקן בכיתה: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (עצמי, משטח): pygame.draw.circle (משטח, אדום, (self.x, self.y), self.radius) עדכון def (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] עבור gameObj ב- gameObjects: אם gameObj.type == "כדור": אם (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () משחק מחלקה (): def _init _ (עצמי): pygame.init () self.screen = pygame.display.set_mode (רזולוציה) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (white) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
חלק 7 מתוך 8: הוספת בקר משחק ליצירת אובייקטים
שלב 1. צור כיתת בקר משחקים
בקרי המשחק אחראים על "הפעלת" המשחק. הוא שונה משיעור המשחקים שלנו שאחראי על ציור ועדכון כל האובייקטים שלנו. הבקר יוסיף מעת לעת כדור נוסף למסך כדי להקשות על המשחק. הוסף בונה והתחל כמה ערכים בסיסיים. המרווח יהיה הזמן לפני הוספת כדור נוסף.
class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "בקר משחק"
שלב 2. הוסף את פונקציית העדכון
זה יבדוק כמה זמן עבר מאז הוספת כדור או מתחילת המשחק. אם הזמן הוא יותר מהמרווח, תאפס את הזמן ותוסיף כדור.
class GameController: … עדכון def (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
שלב 3. תן לכדורים מהירות אקראיות
יהיה עליך להשתמש במספרים אקראיים כדי להפוך את המשחק לשונה בכל פעם. עם זאת, מהירות הכדורים היא כעת מספר נקודה צפה במקום מספר שלם.
class GameController: … update update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = אקראי ()*2, yVel = אקראי ()*2))
שלב 4. תקן את פונקציית הציור
פונקציית הציור לא תקבל ציפים. בואו נמיר את מיקום הכדור למספרים שלמים לפני שהכדורים יימשכו.
מחלקה כדור: … תיקו def (עצמי, משטח): pygame.draw.circle (משטח, שחור, (int (self.x), int (self.y)), self.radius)
שלב 5. הגדר שיטת תיקו לבקר המשחק
מכיוון שמדובר באובייקט משחק, הלולאה הראשית תנסה לצייר אותו. יהיה עליך להגדיר פונקציית צייר שאינה עושה דבר כדי שהמשחק לא יקרוס.
כיתת GameController:… תיקו def (עצמי, מסך): לעבור
שלב 6. הוסף את בקר המשחק ל- gameObjects והסר את 2 הכדורים
המשחק אמור כעת להשריץ כדור כל חמש שניות.
משחק בכיתה (): def _init _ (עצמי): … self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
שלב 7. נסה את זה
כך צריך להיראות הקוד כעת:
יבוא פייגמה מיבוא אקראי אקראי מ pygame.locals יבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = משחק משחק. display.set_mode (רזולוציה) מחלקה כדור: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "כדור" def draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (int (עצמי. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 או עצמי. x> = רזולוציה [0]): self.dx *= -1 אם (self.y <= 0 או self.y> = רזולוציה [1]): self.dy *= -1 שחקן בכיתה: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (עצמי, משטח): pygame.draw.circle (משטח, אדום, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj in game אובייקטים: אם gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () GameController בכיתה: def _init _ (עצמי, מרווח = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "בקר משחק "def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = random) ()*2, yVel = אקראי ()*2)) תיקו def (עצמי, מסך): משחק בכיתה (): def _init _ (עצמי): pygame.init () self.screen = pygame.display.set_mode (רזולוציה) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): לאירוע ב- pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen. מילוי (לבן) עבור gameObj ב- self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
חלק 8 מתוך 8: הוספת ציון ומשחק נגמר
שלב 1. הוסף ציון למחלקת בקר המשחקים
צור אובייקט גופן ומשתנה ניקוד. תוכלו לצייר את הגופן בכל מסגרת כדי להציג את הציון ולהגדיל את הציון בכל מסגרת בעדכון.
class GameController: def _init _ (עצמי, מרווח = 5):… self.score = 0 self.scoreText = pygame.font. Font (None, 12) עדכון def (עצמי, gameObjects):… self.score += תיקו 1 def (עצמי, מסך): screen.blit (self.scoreText.render (str (self.score), נכון, שחור), (5, 5))
שלב 2. שנה את אופן המשחק
בואו להיפטר מהגמילה כשהשחקן מזהה התנגשות. במקום זאת תגדיר משתנה בנגן שהמשחק יכול לבדוק. כאשר gameOver מוגדר, הפסק לעדכן אובייקטים. זה יקפיא את הכל במקום כדי שהשחקן יוכל לראות מה קרה ולבדוק את הציון שלו. שים לב שהאובייקטים עדיין מצוירים, רק שהם לא מעודכנים.
שחקן בכיתה: def _init _ (self, rad = 20): … self.gameOver = עדכון def כוזב (self, gameObjects): … עבור gameObj ב- gameObjects: if gameObj.type == "ball": if (gameObj.x - עצמי.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = משחק ברמה אמיתית (): def _init _ (self): … self.gameOver = ריצה שגויה (self): בעוד True: self.handleEvents () אם לא self.gameOver: עבור gameObj ב- self.gameObjects: gameObj.update (self.gameObjects) אם gameObj.type == "player": self.gameOver = gameObj.gameOver
שלב 3. נסה את זה
כך צריך להיראות הקוד המוגמר כעת:
יבוא פייגמה מיבוא אקראי אקראי מ pygame.locals ייבוא * רזולוציה = (400, 300) לבן = (255, 255, 255) שחור = (0, 0, 0) אדום = (255, 0, 0) מסך = משחק משחק. display.set_mode (רזולוציה) מחלקה כדור: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "כדור" def draw (עצמי, משטח): pygame.draw.circle (משטח, שחור, (int (עצמי. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 או עצמי. x> = רזולוציה [0]): self.dx *= -1 אם (self.y <= 0 או self.y> = רזולוציה [1]): self.dy *= -1 שחקן בכיתה: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = תיקו שגוי (עצמי, משטח): pygame.draw.circle (משטח, אדום, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] עבור gameObj ב- gameObjects: אם gameObj.type == "כדור": אם (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = GameController ברמה אמיתית: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2*1000) עצמי. type = "בקר משחק" self.score = 0 self.scoreText = pygame.font. Font (None, 12) עדכון def (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter*1000) gameObjects.append (כדור (xVel = אקראי ()*2, yVel = אקראי ()*2)) self.score + = תיקו 1 Def (עצמי, מסך): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) משחק בכיתה (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (רזולוציה) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (עצמי): לאירוע ב- pygame.event.get (): אם ev ent.type == QUIT: pygame.quit () def run (self): בעוד True: self.handleEvents () אם לא self.gameOver: עבור gameObj ב- self.gameObjects: gameObj.update (self.gameObjects) אם gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (לבן) עבור gameObj ב- self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () משחק (). הפעלה ()
