Ez a Pygame bevezetője azoknak, akik már ismerik a Python -ot. Ez a cikk megtanítja a lépéseket egy egyszerű játék felépítéséhez, amelyben a játékos elkerüli a pattogó labdákat.
Lépések
Rész 1 /8: A Pygame telepítése
1. lépés: A Pygame letöltése
Keresse meg platformjához a https://www.pygame.org/download.shtml címen.
2. lépés: Futtassa a telepítőt
3. lépés: Ellenőrizze, hogy a telepítés működött -e
Nyisson meg egy Python terminált. Írja be az "import pygame" lehetőséget. Ha nem lát hibát, akkor a Pygame telepítése sikeres volt.
játék importálása
2. rész a 8 -ból: Egy alapvető ablak beállítása
1. lépés: Nyisson meg egy új fájlt
2. lépés: A Pygame importálása
A Pygame egy könyvtár, amely hozzáférést biztosít a grafikus funkciókhoz. Ha további információra van szüksége ezeknek a funkcióknak a működésével kapcsolatban, keresse meg őket a Pygame weboldalán.
importálja a pygame -t a pygame.locals importból *
3. lépés. Állítsa be az ablak felbontását
Globális változót készít a képernyő felbontására, hogy a játék több részében hivatkozhasson rá. A fájl tetején is könnyen megtalálható, így később módosítható. Haladó projektek esetén jobb lenne ezeket az információkat külön fájlba helyezni.
felbontás = (400, 300)
4. lépés. Határozzon meg néhány színt
A pygame színei (RBGA, amely 0 és 255 között mozog. Az alfa érték (A) opcionális, de a többi szín (piros, kék és zöld) kötelező).
fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0)
5. lépés. Inicializálja a képernyőt
Használja a korábban meghatározott felbontási változót.
képernyő = pygame.display.set_mode (felbontás)
6. lépés. Készíts játékhurkot
Ismételje meg bizonyos műveleteket játékunk minden keretében. Hozzon létre egy ciklust, amely mindig megismétlődik, hogy végigcsinálja ezeket a műveleteket.
míg igaz:
7. lépés Színezze ki a képernyőt
screen.fill (fehér)
8. lépés. Jelenítse meg a képernyőt
Ha futtatja a programot, a képernyő fehérre vált, majd a program összeomlik. Ennek oka az, hogy az operációs rendszer eseményeket küld a játékba, és a játék nem csinál velük semmit. Ha a játék túl sok kezeletlen eseményt fogad, összeomlik.
míg igaz:… pygame.display.flip ()
9. lépés. Kezelje az eseményeket
Lista lekérése az összes képkockában bekövetkezett eseményről. Csak egy esemény fog érdekelni, a kilépés. Ez akkor fordul elő, amikor a felhasználó bezárja a játékablakot. Ez megakadályozza azt is, hogy programunk összeomoljon a túl sok esemény miatt.
míg igaz:… a pygame.event.get () eseményéhez: if event.type == QUIT: pygame.quit ()
10. lépés. Próbálja ki
Így néz ki most a kód:
importálja a játékot a pygame.locals webhelyről import * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame.display.set_mode (felbontás), míg igaz: screen.fill (fehér) pygame.display.flip () a pygame esemény eseményéhez. event.get (): if event.type == QUIT: pygame.quit ()
3. rész a 8 -ból: Játékobjektum készítése
1. lépés Készítsen új osztályt és konstruktőrt
Állítsa be az objektum összes tulajdonságát. Az összes tulajdonsághoz alapértelmezett értékeket is megad.
osztályú labda: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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 = "labda"
2. lépés. Határozza meg az objektum rajzolásának módját
Használja a konstruktorban meghatározott tulajdonságokat a labda körrajzolásához, valamint egy felület átadásához a tárgy rajzolási funkciójához. A felület lesz a képernyő objektum, amelyet korábban a felbontás használatával hoztak létre.
def draw (ön, felület): pygame.draw.circle (felület, fekete, (self.x, self.y), self.radius)
3. lépés. Készíts egy példányt az osztályból, és mondd meg a játékhuroknak, hogy húzza a labdát minden hurokba
labda = labda (), míg igaz:… ball.draw (képernyő)
4. lépés. Mozgassa az objektumot
Hozzon létre egy függvényt, amely frissíti az objektum pozícióját. Hívja meg ezt a funkciót minden játékkörben.
osztályú labda:… def update (self): self.x += self.dx self.y += self.dy
5. lépés. Korlátozza a képkockasebességet
A labda nagyon gyorsan fog mozogni, mert a játékhurok másodpercenként százszor fut. A Pygame órájával korlátozza a képkockasebességet 60 képkocka / másodpercre.
clock = pygame.time. Clock () míg True:… clock.tick (60)
6. lépés. Tartsa a labdát a képernyőn
Add hozzá a csekket a frissítési funkcióban, hogy megfordítsd a labda irányát, ha az a képernyő egyik szélét érinti.
osztályú labda:… def frissítés (ön):… if (self.x <= 0 vagy self.x> = felbontás [0]): self.dx *= -1 if (self.y <= 0 vagy self.y > = felbontás [1]): self.dy *= -1
7. lépés. Próbálja ki
Így néz ki most a kód:
importálja a játékot a pygame.locals webhelyről import * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame.display.set_mode (osztályú labda: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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" def draw (self, felület): pygame.draw.circle (felület, fekete, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 vagy self.x> = felbontás [0]): self.dx *= -1, ha (self.y <= 0 vagy self.y> = felbontás [1]): self.dy *= -1 labda = Ball () óra = pygame.time. Clock (), míg True: képernyő. fill (white) ball.draw (screen) ball.update () pygame.display.flip () clock.tick (60) eseményhez a pygame.event.get (): if event.type == QUIT: pygame.quit ()
4. rész a 8 -ból: A játék megszervezése
1. lépés: Az osztályok segítségével mindent megszervezhet
A játék bonyolultabb lesz. Használjon objektum-orientált technikákat a kód rendszerezéséhez.
2. lépés: A játék hurok osztályba
Mivel a játékunknak mostantól vannak adatai, beleértve a játék tárgyait és funkcióit, ésszerű a játékhurokot osztálygá alakítani.
osztályos játék ():
3. lépés. Konstruktor hozzáadása
Itt példányosíthat néhány játékobjektumot, létrehozhatja képernyőnket és óránkat, és inicializálhatja a Pygame -t. A Pygame -t inicializálni kell bizonyos funkciók, például szöveg vagy hang használatához.
osztályos játék (): def _init _ (ön): pygame.init () self.screen = pygame.display.set_mode (felbontás) self.clock = pygame.time. Clock ()
4. lépés: Funkciók eseményeinek kezelése
osztályú játék ():… def handleEvents (saját): a pygame.event.get () eseményéhez: if event.type == QUIT: pygame.quit ()
5. lépés. A játékhurok funkcióvá alakítása
Hívja meg az eseménykezelő funkciót minden ciklusban.
osztályos játék ():… def run (self): míg True: self.handleEvents () self.screen.fill (fehér) self.clock.tick (60) pygame.display.flip ()
6. Lépés. Több játék objektum kezelése
Jelenleg ennek a kódnak meg kell hívnia a rajzolást és a frissítést az objektumunkon minden keretben. Ez rendetlenné válna, ha sok tárgya lenne. Adjuk hozzá objektumunkat egy tömbhöz, majd frissítsük és rajzoljuk meg a tömb összes objektumát minden ciklusban. Most könnyedén hozzáadhat egy másik objektumot, és más kiindulási helyzetet adhat neki.
osztályos játék (): def _init _ (ön):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): míg True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (white) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
7. lépés. Próbálja ki
Így néz ki most a kód:
importálja a játékot a pygame.locals webhelyről import * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame.display.set_mode (osztályú labda: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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" def draw (self, felület): pygame.draw.circle (felület, fekete, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 vagy self.x> = felbontás [0]): self.dx *= -1, ha (self.y <= 0 vagy self.y> = felbontás [1]): self.dy *= -1 osztályú játék (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (felbontás) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): eseményhez a pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): míg True: self.handleEvent s () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (white) for gameObj in self.gameTárgyak: gameObj.draw (self.screen) self.clock.cick (60) pygame.display. flip () játék (). run ()
5. rész a 8 -ból: Játékos objektum hozzáadása
1. lépés. Készíts egy játékososztályt és konstruktőrt
Létrehoz egy másik kört, amelyet az egér irányít. Inicializálja az értékeket a konstruktorban. A sugár az egyetlen fontos érték.
osztályú játékos: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
2. lépés. Határozza meg, hogyan kell rajzolni a játékos objektumot
Ugyanúgy lesz, ahogy a többi játékobjektumot rajzolta.
osztályú játékos:… def draw (önálló, felület): pygame.draw.circle (felület, piros, (self.x, self.y), self.radius)
3. lépés: Adjon egérvezérlőt a lejátszó objektumhoz
Minden keretben ellenőrizze az egér helyét, és állítsa a játékosok tárgyainak helyét erre a pontra.
osztályú játékos:… def update (self): kord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
4. lépés. Játékosobjektum hozzáadása a gameObjects -hez
Hozzon létre egy új játékospéldányt, és adja hozzá a listához.
osztályos játék (): def _init _ (ön):… self.gameObjects.append (Player ())
5. lépés Próbálja ki
Így néz ki most a kód:
importálja a játékot a pygame.locals webhelyről import * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame.display.set_mode (osztályú labda: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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" def draw (self, felület): pygame.draw.circle (felület, fekete, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 vagy self.x> = felbontás [0]): self.dx *= -1, ha (self.y <= 0 vagy self.y> = felbontás [1]): self.dy *= -1 osztályú játékos: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, felület): pygame.draw.circle (felület, piros, (self.x, self.y), self.radius) def update (self): kord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ mód (felbontás) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def handleEvents (self): eseményhez a pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): míg True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (fehér) játékhozObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). fuss()
6. rész a 8 -ból: Az objektumok kölcsönhatása a lejátszóval
1. lépés. Módosítsa a frissítési funkciókat
Ahhoz, hogy az objektumok kölcsönhatásba léphessenek egymással, hozzá kell férniük egymáshoz. Adjunk hozzá egy másik paramétert a frissítéshez a gameObjects listához. Hozzá kell adnia mind a játékos, mind a labda objektumokhoz. Ha sok játékobjektuma van, az öröklődés segíthet abban, hogy az összes módszer -aláírás változatlan maradjon.
osztálylabda:… def frissítés (saját, gameObjects):… osztály játékos:… def frissítés (self, gameObjects):
2. lépés: Ellenőrizze, hogy nincsenek -e ütközések a játékos és a labdák között
Nézze meg az összes játék objektumot, és ellenőrizze, hogy az objektum típusa labda. Ezután ellenőrizze a két tárgy sugarát és a távolság képletét, hogy ütköznek -e. A körökön nagyon könnyű ellenőrizni az ütközéseket. Ez a legnagyobb oka annak, hogy nem használtál más formát ehhez a játékhoz.
osztályú játékos:… def frissítés (önálló, gameObjects):… a gameObj játékbanObjects: ha gameObj.type == "labda": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Lépés 3. Fejezze be a játékot, ha a játékos "ütést" kap
Egyelőre hagyjuk abba a játékot.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
4. lépés Próbálja ki
Így néz ki most a kód:
importálja a játékot a pygame.locals webhelyről import * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame.display.set_mode (osztályú labda: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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" def draw (self, felület): pygame.draw.circle (felület, fekete, (self.x, self.y), self.radius) def frissítés (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 vagy self.x> = felbontás [0]): self.dx *= -1, ha (self.y <= 0 vagy self.y> = felbontás [1]): self.dy *= -1 osztály Játékos: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, felület): pygame.draw.circle (felület, piros, (self.x, self.y), self.radius) def frissítés (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () osztályú játék (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (felbontás) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): eseményhez a pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): míg True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (fehér) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
7. rész a 8 -ból: Játékvezérlő hozzáadása objektumok létrehozásához
1. lépés: Hozzon létre egy játékvezérlő osztályt
A játék "irányításáért" a játékvezérlők a felelősek. Ez különbözik a mi játékosztályunktól, amely felelős az összes objektum rajzolásáért és frissítéséért. A vezérlő rendszeresen hozzáad egy újabb labdát a képernyőhöz, hogy megnehezítse a játékot. Adjon hozzá egy konstruktort, és inicializáljon néhány alapvető értéket. Az intervallum az újabb golyó hozzáadása előtti idő lesz.
osztályú GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "játékvezérlő"
2. lépés. Adja hozzá a frissítési funkciót
Ez ellenőrzi, hogy mennyi idő telt el a labda hozzáadása óta vagy a játék kezdetétől. Ha az idő meghaladja az intervallumot, akkor visszaállítja az időt, és hozzáad egy labdát.
osztályú GameController:… def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
3. Adja meg a golyók véletlenszerű sebességét
Véletlenszerű számokat kell használnia, hogy minden alkalommal más legyen a játék. A golyók sebessége azonban most egész szám helyett lebegőpontos szám.
osztályú GameController:… def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = véletlen ()*2, yVel = véletlen ()*2))
4. lépés. Rögzítse a húzási funkciót
A húzó funkció nem fogad úszókat. A labda helyzetét egész számokká alakítsuk át, mielőtt kihúzzuk a labdákat.
osztályú labda:… def draw (ön, felület): pygame.draw.circle (felület, fekete, (int (self.x), int (self.y)), self.radius)
5. lépés. Határozza meg a játékvezérlő sorsolási módját
Mivel ez egy játék objektum, a fő hurok megpróbálja megrajzolni. Meg kell határoznia egy döntetlen funkciót, amely semmit nem tesz, hogy a játék ne essen össze.
osztályú GameController:… def draw (önálló, képernyő): pass
6. lépés: Adja hozzá a játékvezérlőt a gameObjects -hez, és távolítsa el a 2 golyót
A játéknak most öt másodpercenként kell labdát szúrnia.
osztályos játék (): def _init _ (ön):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
7. lépés. Próbálja ki
Így néz ki most a kód:
importálja a játékot véletlenszerű importálásból a pygame -ből. helyi importálás * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame. display.set_mode (felbontás) osztály Ball: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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" def draw (self, felület): pygame.draw.circle (felület, fekete, (int (ön. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 vagy self. x> = felbontás [0]): self.dx *= -1, ha (self.y <= 0 vagy self.y> = felbontás [1]): self.dy *= -1 osztály Játékos: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, felület): pygame.draw.circle (felület, piros, (self.x), self.y), self.radius) def frissítés (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj in game Tárgyak: ha gameObj.type == "labda": ha (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () osztály GameController: def _init _ (self, interval = 5): self.inter = intervallum self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "játékvezérlő "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 = random ()*2)) def draw (self, screen): pass class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (felbontás) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): a pygame.event eseményéhez.get (): if event.type == QUIT: pygame.quit () def run (self): míg True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (fehér) a gameObj számára önmagában.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
8. rész a 8 -ból: Pontszám hozzáadása és a játék vége
1. lépés. Adjon pontszámot a játékvezérlő osztályhoz
Hozzon létre betűtípus objektumot és pontszámváltozót. Minden keretbe rajzolja a betűtípust, hogy megjelenítse a pontszámot, és növelje a pontszámot minden frissítéskor.
osztályú GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (Nincs, 12) def update (self, gameObjects):… self.score += 1 def draw (ön, képernyő): screen.blit (self.scoreText.render (str (self.score), True, fekete), (5, 5))
2. lépés: Módosítsa a játék végét
Szabaduljunk meg a kilépéstől, amikor a játékos ütközést észlel. Ehelyett beállít egy változót a lejátszóban, amelyet a játék ellenőrizhet. Ha a gameOver be van állítva, állítsa le az objektumok frissítését. Ez lefagyaszt mindent a helyén, hogy a játékos láthassa, mi történt, és ellenőrizze pontszámát. Vegye figyelembe, hogy az objektumok még rajzolásra kerülnek, csak nem frissülnek.
osztály Játékos: def _init _ (self, rad = 20):… self.gameOver = Hamis def frissítés (self, gameObjects):… gameObj esetén gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Igaz osztályú játék (): def _init _ (self): … Self.gameOver = Hamis def run (self): míg True: self.handleEvents () ha nem self.gameOver: gameObj esetén self.gameObjects: gameObj.update (self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
3. lépés Próbálja ki
Így néz ki most a kész kód:
importálja a játékot véletlenszerű importálásból a pygame -ből. helyi importálás * felbontás = (400, 300) fehér = (255, 255, 255) fekete = (0, 0, 0) piros = (255, 0, 0) képernyő = pygame. display.set_mode (felbontás) osztály Ball: def _init _ (self, xPos = felbontás [0] / 2, yPos = felbontás [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" def draw (self, felület): pygame.draw.circle (felület, fekete, (int (ön. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 vagy self. x> = felbontás [0]): self.dx *= -1, ha (self.y <= 0 vagy self.y> = felbontás [1]): self.dy *= -1 osztály Játékos: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = False def draw (self, felület): pygame.draw.circle (felület, piros, (self.x, self.y), self.radius) def frissítés (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] gameObj esetén gameObjects: ha gameObj.type == "labda": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = True class GameController: def _init _ (self, interval = 5): self.inter = intervallum self.next = pygame.time.get_ticks () + (2*1000) self. type = "játékvezérlő" self.score = 0 self.scoreText = pygame.font. Font (Nincs, 12) def frissítés (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 = random ()*2)) self.score + = 1 def draw (ön, képernyő): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (felbontás) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = Hamis def handleEvents (self): eseményhez a pygame.event.get (): ha ev ent.type == QUIT: pygame.quit () def run (self): míg True: self.handleEvents () ha nem self.gameOver: gameObj -hoz self.gameObjects: gameObj.update (self.gameObjects) ha gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (fehér) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
