Ako programovať hry na Python pomocou knižnice pygame

Tento článok je určený pre tých, ktorí sú už oboznámení s programovacím jazykom Python, a umožňuje čítať knižnicu Pygame pre tento jazyk. Ako vizuálny príklad je tu zobrazený jednoduchý proces programovania hier, v ktorom musí hráč darovať z jumpingových loptičiek.

Kroky

Časť 1 z 8:

Inštalácia pygame

jeden. Stiahnite si pygame. Postupujte podľa odkazu a nájdite verziu knižnice vhodná pre vašu platformu: http: // Pygame.Org / download.shtml .

2. Spustite inštalatér.

3. Uistite sa, že inštalácia bola úspešne dokončená. Otvorte terminál Python. Zadajte "Import Pygame". Ak sa nezobrazia chybové hlásenia, potom bol úspešne nainštalovaný PYGAME.

Dovoz pygame

Časť 2 z 8:

Vytvorenie hlavného okna hry

jeden. Vytvorte nový súbor.

2. Dovoz pygame. Pygame je knižnica, ktorá implementuje prístup k python programovacím jazykom grafických funkcií. Ak sa chcete dozvedieť viac o tom, ako tieto funkcie fungujú, informácie sú k dispozícii na PYGAME. https: // Pygame.Org / docs /

Import pygamefrom pygame.Miestny import *

3. Zadajte veľkosť okna hry. Vytvorte globálnu premennú pre veľkosti okien, ktoré sa na to odkazujú z rôznych častí hry. Pre pohodlie sú tieto parametre lepšie špecifikovať na začiatku súboru, aby sa v prípade potreby v prípade potreby zmenilo v budúcnosti. Pre zložitejšie projekty bude výhodné vykonať takéto údaje v samostatnom súbore.

Rozlíšenie = (400 300)

4. Určite niekoľko farieb. Farby v pygame sú definované vo formáte RGBA v rozmedzí od 0 do 255. Hodnota alfa (A) môže byť vynechaná, ale na plnenie sa vyžaduje zvyšok farieb (červená, zelená a modrá).

Biela = (255,255,255) čierna = (0.0.0) červená = (255.0.0)

päť. Inicializujte hlavnú obrazovku. Použite premennú rozlíšenie definovanú skôr.

Obrazovky = pygame.Displej.Set_mode (rozlíšenie)

6. Vytvorte cyklus hry. Nastavte opakovanie určitých akcií v každom rámci hry. Vytvorte cyklus, ktorý bude dôsledne vykonávať všetky tieto akcie.

Kým TRUE:

7. Určite farbu výplne obrazovky.

Obrazovky.Vyplňte (biela)

osem. Zobrazte obrazovku. Ak spustíte program v tomto štádiu, obrazovka je natretá bielym a potom program zastaví núdzovú situáciu. Príčinou zlyhania bude, že operačný systém pošle udalosti programu a program jednoducho nepokračuje. Keď program akumuluje príliš veľa neošetrených udalostí, zlyhanie vzniká.

Kým TRUE:...Pygame.Displej.Flip ()

deväť. Implementovať spracovanie udalostí. Získajte zoznam všetkých udalostí, ktoré vznikli medzi rámmi na výkresoch. V našom príklade by ste sa mali obávať spracovania iba jednej výstupnej udalosti (ukončenie). Vyskytuje sa, keď používateľ zatvorí okno hry. Spracovanie udalostí zabráni zlyhaniu programu z výskytu prílišných udalostí.

Kým TRUE:...Pre udalosť v pygame.Udalosť.Dostať (): ak udalosť.Typ == QUIT: PYGAME.prestať ()

10. Vyskúšajte program! Teraz by mal program program vyzerať takto:

Import pygamefrom pygame.Locals Import * Rozlíšenie = (400 300) White = (255,255,255) Black = (0.0.0) Red = (255,0,0) Screen = PYGAME.Displej.SET_MODE (Rozlíšenie) Kým TRUE: Screen.Vyplňte (biely) pygame.Displej.Flip () pre udalosť v pygame.Udalosť.Dostať (): ak udalosť.Typ == QUIT: PYGAME.prestať ()

Časť 3 z 8:

Vytvorenie herných objektov

jeden. Vytvorte novú triedu objektov a jeho dizajnérov. Nastavte všetky vlastnosti objektu. Definujte aj predvolené hodnoty pre každú z vlastností.

Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"

2. Určite kresbu objektu. Použite objektové vlastnosti uvedené v konštruktore na zobrazenie lopty ako kruh na povrchu prenášanej do funkcie na funkciu. Povrch bude obrazovka, ktorú ste vytvorili skôr definovaním jeho rozmerov.

Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (self).X, ja.y), ja.POLOMER)

3. Vytvorte inštanciu triedy a pridajte prácu do herného cyklu, aby ste nakreslite loptu v každej iterácii cyklu.

Ball = Ball () Kým TRUE:...Loptička.Nakreslite (obrazovka)

4. Urobte objekt. Vytvorte funkciu, ktorá aktualizuje polohu objektu. Zavolajte túto funkciu v každej iterácii cyklu.

Trieda Ball:...Aktualizácia Def (Ja): Ja.X + = self.Dx.Y + = self.D Y

päť. Frekvencia obmedzenia. Lopta sa bude pohybovať veľmi rýchlo, pretože herný cyklus sa opakuje stovky krát za sekundu. Použite časovač pygame na obmedzenie frekvencie zmeny rámca na 60 fps.

Hodiny = pygame.Čas.Hodiny () Kým TRUE:...Hodiny.Tick (60)

Udržujte misku na obrazovke. Pridajte kontroly na funkciu aktualizácie stavu, aby ste zmenili smer pohybu lopty, ak dosiahne hranice obrazovky.

Trieda Ball:...Aktualizácia Def (Ja):...Ak (ja).X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.DY * = -1

Vyskúšajte program! Teraz by mal program program vyzerať takto:

Import pygamefrom pygame.Locals Import * Rozlíšenie = (400 300) White = (255,255,255) Black = (0.0.0) Red = (255,0,0) Screen = PYGAME.Displej.SET_MODE (Rozlíšenie) Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (self).X, ja.y), ja.RADIUS) DEF UPDATE: Self.X + = self.Dx.Y + = self.DYIF (ja.X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.DY * = -1BALL = BALL () CLOCK = PYGAME.Čas.Hodiny () Zatiaľ čo pravdivé: obrazovka.Vyplňte (bielu) loptu.Nakreslite (obrazovku).Aktualizácia () pygame.Displej.Flip () Hodiny.Tick (60) pre udalosť v pygame.Udalosť.Dostať (): ak udalosť.Typ == QUIT: PYGAME.prestať ()

Časť 4 z 8:

Štruktúrovacie hry

jeden. Použite triedy na štruktúrovanie. V budúcnosti sa hra stane zložitejšou. Použite objektovo orientované programovacie techniky na štruktúrovací kód.

2. Prevod herného cyklu do triedy. Vzhľadom k tomu, momentálne hra už obsahuje údaje, vrátane herných objektov a funkcií, má zmysel nahradiť herný cyklus do triedy.

Trieda hra ():

3. Pridajte dizajnérov. S ním popierate niekoľko objektov používaných v hre, vytvorte obrazovku, časovač a inicializujte pygame. Pygame musí byť inicializovaný, aby sa takéto schopnosti ďalej používali ako text alebo zvuk.

Trieda hra (): def __init __ (ja): pygame.Init () self.Obrazovky = pygame.Displej.Set_mode (rozlíšenie).Hodiny = pygame.Čas.Hodiny ()

4. Nastavte spracovanie udalostí vo funkcii.

Trieda hra ():...Handvents Def (vlastné): Pre udalosť v Pygame.Udalosť.Dostať (): ak udalosť.Typ == QUIT: PYGAME.prestať ()

päť. Urobte herný cyklus s funkciou. Funkcia spracovania udalostí v každej iterácii cyklu.

Trieda hra ():...Def Run (Self): Kým TRUE: SELF.Riadkov () self.Obrazovky.Vyplňte (biele) self.Hodiny.Tick (60) pygame.Displej.Flip ()

6. Nastavte spracovanie viacerých herných objektov. V tomto štádiu Kód hry spôsobí aktualizáciu a prekreslenie jednotlivých objektov v každom ráme. S týmto prístupom bude kód hry dosť objemný a neporiadok, najmä ak je v hre veľa objektov. Je múdrejší, že najprv pridajte objekty do poľa, a potom aktualizovať a prekresliť všetky objekty v poli pri každej iterácii cyklu. Teraz môžete ľahko urobiť nový objekt v hre a určiť ďalšiu štartovaciu pozíciu.

Trieda hra (): def __init __ (self):...Seba.GameObjects = [] self.GameObjects.Pripojiť (Ball ()) Ja.GameObjects.Pripojiť (Ball (100))...Def Run (Self): Kým TRUE: SELF.Riadkov () pre gameobj v self.GameObjects: Gameobj.Aktualizácia () Ja.Obrazovky.Vyplňte (biely) pre gameobj v ja.GameObjects: Gameobj.Nakreslite (ja.Obrazovky) self.Hodiny.Tick (60) pygame.Displej.Flip ()

7. Vyskúšajte program! Teraz by mal program program vyzerať takto:

Import pygamefrom pygame.Locals Import * Rozlíšenie = (400 300) White = (255,255,255) Black = (0.0.0) Red = (255,0,0) Screen = PYGAME.Displej.SET_MODE (Rozlíšenie) Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (self).X, ja.y), ja.RADIUS) DEF UPDATE: Self.X + = self.Dx.Y + = self.DYIF (ja.X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.dy * = -1class game (): def __init __ (ja): pygame.Init () self.Obrazovky = pygame.Displej.Set_mode (rozlíšenie).Hodiny = pygame.Čas.Hodiny () self.GameObjects = [] self.GameObjects.Pripojiť (Ball ()) Ja.GameObjects.Pripojiť (Ball (100)) Handves (Self): Pre udalosť v Pygame.Udalosť.Dostať (): ak udalosť.Typ == QUIT: PYGAME.QUIT () Def Run (Self): Kým TRUE: SELF.Riadkov () pre gameobj v self.GameObjects: Gameobj.Aktualizácia () Ja.Obrazovky.Vyplňte (biely) pre gameobj v ja.GameObjects: Gameobj.Nakreslite (ja.Obrazovky) self.Hodiny.Tick (60) pygame.Displej.Flip () hra ().Beh ()

Časť 5 z 8:

Pridanie objektu "Player"

jeden. Vytvorte hráč triedy a jeho dizajnér. Musíte vytvoriť ďalší kruh ovládaný pohybom myši. Inicializovať svoje parametre v dizajnéri. Jedinou dôležitou hodnotou bude polomer.

Triedy Player: Def __init __ (self, Rad = 20): Ja.x = 0.Y = 0.Radius = rad

2. Určite kresbu objektu prehrávača. Podobne je nakreslený, ako boli nakreslené iné herné objekty.

Triedy Player:...Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, červená, (vlastná.X, ja.y), ja.POLOMER)

3. Pridajte ovládač myši pre objekt prehrávača. V každom rámčeku hry musíte skontrolovať polohu ukazovateľa myši a súvisieť s polohou objektu prehrávača s týmto bodom.

Triedy Player:...Aktualizácia Def (Ja): Cord = PYGAME.Myši.get_pos () self.X = šnúra [0] self.Y = šnúra [1]

4. Pridajte objekt prehrávača na pole GameObjects. Vytvorte novú inštanciu objektu a pridajte ho do zoznamu GameObjects.

Trieda hra (): def __init __ (self):...Seba.GameObjects.Pripojiť (hráča ())

päť. Vyskúšajte program! Teraz by mal program program vyzerať takto:

Import pygamefrom pygame.Locals Import * Rozlíšenie = (400 300) White = (255,255,255) Black = (0.0.0) Red = (255,0,0) Screen = PYGAME.Displej.SET_MODE (Rozlíšenie) Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (self).X, ja.y), ja.RADIUS) DEF UPDATE: Self.X + = self.Dx.Y + = self.DYIF (ja.X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.Dy * = -1class hráč: def __init __ (self, rad = 20): self.x = 0.Y = 0.Radius = Radselselselselselself.Typ = "Hráč"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, červená, (vlastná.X, ja.y), ja.Radius) Aktualizácia Def (Self): Cord = PYGAME.Myši.get_pos () self.X = šnúra [0] self.Y = šnúra [1] trieda hry (): def __init __ (ja): pygame.Init () self.Obrazovky = pygame.Displej.Set_mode (rozlíšenie).Hodiny = pygame.Čas.Hodiny () self.GameObjects = [] self.GameObjects.Pripojiť sa (hráča ()).GameObjects.Pripojiť (Ball ()) Ja.GameObjects.Pripojiť (Ball (100)) Handves (Self): Pre udalosť v Pygame.Udalosť.Dostať (): ak udalosť.Typ == QUIT: PYGAME.QUIT () Def Run (Self): Kým TRUE: SELF.Riadkov () pre gameobj v self.GameObjects: Gameobj.Aktualizácia () Ja.Obrazovky.Vyplňte (biely) pre gameobj v ja.GameObjects: Gameobj.Nakreslite (ja.Obrazovky) self.Hodiny.Tick (60) pygame.Displej.Flip () hra ().Beh ()

Časť 6 z 8:

Vytvorenie interakcie objektu

jeden. Zmeniť funkcie aktualizácie polohy. Na implementáciu interakcie objektov je potrebné poskytnúť im prístup k sebe navzájom. Pridajte nový parameter na funkciu aktualizácie na prenos údajov zoznamu GAMEOBIKS. Parameter musí byť pridaný do tried hráča a loptových funkcií. Ak máte veľa tried, dedičstvo pomôže uložiť zoznam parametrov rovnaký.

Trieda Ball:...Aktualizácia Def (Self, GameObjects):...Triedy Player:...Aktualizácia Def (Self, GameObjects):

2. Zadajte kontroly kolízie s loptami. Zobraziť všetky objekty a definovať ich medzi nimi, ktoré sa týkajú loptičiek. Potom pomocou polomerov objektov a vzorec pre určenie vzdialenosti skontrolujte, či sa objekty zrazili navzájom. Kontrola kolízií medzi kruhmi sú jednoduché. To je hlavným dôvodom, že ako príklad v tejto hre sa čísla inej formy nepoužívajú.

Triedy Player:...Aktualizácia Def (Self, GameObjects):...Pre GameOTJ v GameObjects: Ak GameOTJJ.Typ == "Loptička": IF (GAMEOBJ.X - Ja.x) ** 2 + (GAMEOBJ.Y - self.y) ** 2 <= (gameObj.radius + self.radius)**2:

3. Nastavte koniec hry, keď hráč kolízie s loptou. V tomto štádiu jednoducho nastavte cestu z hry.

IF (GAMEOBJ.X - Ja.x) ** 2 + (GAMEOBJ.Y - self.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()

4. Vyskúšajte program! Teraz by mal program program vyzerať takto:

Import pygamefrom pygame.Miestny import * Rozlíšenie = (400, 300) biele = (255,255,255) čierne = (0,0,0) červená = (255,0,0,0) obrazovka = pygame.Displej.SET_MODE (Rozlíšenie) Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (self).X, ja.y), ja.Radius) DEF Aktualizácia (Self, GameObjects): Ja.X + = self.Dx.Y + = self.DYIF (ja.X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.Dy * = -1class hráč: def __init __ (self, rad = 20): self.x = 0.Y = 0.Radius = Radselselselselselself.Typ = "Hráč"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, červená, (vlastná.X, ja.y), ja.Radius) Aktualizácia Def (Self, GameObjects): Cord = Pygame.Myši.get_pos () self.X = šnúra [0] self.Y = šnúra [1] pre GameObj v GameObjects: Ak GameOTJJ.Typ == "Loptička": IF (GAMEOBJ.X - Ja.x) ** 2 + (GAMEOBJ.Y - self.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(Player())self.gameObjects.append(Ball())self.gameObjects.append(Ball(100))def handleEvents(self):for event in 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()

Časť 7 z 8:

Pridanie herného ovládača na vytvorenie objektov

jeden. Vytvorte triedu kontroly hier. Herné regulátory sú zodpovední za priebeh hry. Nevykonávajú sa s triedou samotnej hry, ktorá je zodpovedná za kreslenie a aktualizáciu všetkých herných objektov. Regulátor pravidelne pridá novú guľôčku na obrazovku a komplikuje hru. Pridajte dizajnérov a inicializujte niektoré východiskové hodnoty. Interval bude znamenať, že bude pridaná nová lopta.

Trieda gamecontroller: def __init __ (self, interval = 5): self.Interneself.Ďalej = pygame.Čas.get_ticks () + (2 * 1000) self.Typ = "Herný ovládač"

2. Pridajte funkciu aktualizácie. Skontroluje, koľko času odovzdal od pridania predchádzajúcej lopty alebo od začiatku hry. Ak čas presahuje zadaný interval, časovač sa obnoví a nová lopta bola pridaná.

Trieda GameController:...Def aktualizácia (Self, GameObjects): Ak sa vlastné.Ďalšie < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball())

3. Nainštalujte náhodné rýchlosti pre gule. Aby sa hra správala inak, je potrebné, aby ho umožnilo používať náhodné čísla pre parameter rýchlosti. Teraz bude rýchlosť loptičiek určená plávajúcim desatinným číslom, nie celé číslo.

Trieda GameController:...Def aktualizácia (Self, GameObjects): Ak sa vlastné.Ďalšie < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))

4. Opravte funkciu výkresu. Funkcia kreslenia nefunguje s plávajúcimi bodkočiarmi (plavák). Preto je potrebné vyjadriť pozíciu lopty v celoch pred jeho kreslením.

Trieda Ball:...Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (int (vlastný.x), Int (self.y)), ja.POLOMER)

päť. Určite spôsob výkresu pre regulátor hry. Vzhľadom k tomu, že je to tiež herný objekt, v hlavnom hernom cykle bude pokus o to, aby ho kresliť. Preto pre regulátor je potrebné určiť funkciu výkresu, ktorá nerobí nič, aby sa zabránilo zlyhaniu hry.

Trieda GameController:...Def Draw (Self, Screen): PASS

6. Pridajte herný ovládač v GameObjects a odstrániť 2 loptičky. Hra musí pridať novú loptu každých 5 sekúnd.

Trieda hra (): def __init __ (self):...Seba.GameObjects = [] self.GameObjects.ApprovedRoller (GameController ()) Ja.GameObjects.Pripojiť (hráča ())

7. Vyskúšajte program! Teraz by mal program program vyzerať takto:

Import PygameFrom Random Import RandomFROM PYGAME.Locals Import * Rozlíšenie = (400 300) White = (255,255,255) Black = (0.0.0) Red = (255,0,0) Screen = PYGAME.Displej.SET_MODE (Rozlíšenie) Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (int (vlastný.x), Int (self.y)), ja.Radius) DEF Aktualizácia (Self, GameObjects): Ja.X + = self.Dx.Y + = self.DYIF (ja.X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.Dy * = -1class hráč: def __init __ (self, rad = 20): self.x = 0.Y = 0.Radius = Radselselselselselself.Typ = "Hráč"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, červená, (vlastná.X, ja.y), ja.Radius) Aktualizácia Def (Self, GameObjects): Cord = Pygame.Myši.get_pos () self.X = šnúra [0] self.Y = šnúra [1] pre GameObj v GameObjects: Ak GameOTJJ.Typ == "Loptička": IF (GAMEOBJ.X - Ja.x) ** 2 + (GAMEOBJ.Y - self.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"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):passclass game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(GameController())self.gameObjects.append(Player())def handleEvents(self):for event in 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()

Časť 8 z 8:

Pridanie účtu a dokončenie hry

jeden. Pridajte účet do triedy kontroly hier. Vytvorte premennú objektu triedy písma a skóre. Objekt písma musí byť nakreslený v každom rámci, aby sa zobrazil aktuálny účet a pri aktualizácii ho zvýšil v každom ráme.

Trieda GameController: Def __init __ (self, interval = 5):...Seba.Skóre = 0.ScoreText = Pygame.písmo.Písmo (Žiadne, 12) Aktualizácia Def (Self, GameObjects):...Seba.Skóre + = 1Def kreslenie (self, obrazovka): obrazovka.Blit (ja.ScoreText.Render (Str (Self.Skóre), TRUE, BLACK), (5,5))

2. Zmeňte proces dokončenia hry. Odstráňte jednoduchú cestu z hry, keď hráč kolízie s loptou. Namiesto toho vytvorte premennú v triede hráča, ktorá bude skontrolovaná hraním. Keď sa premenná hra bude pravdivá, musíte zastaviť aktualizáciu objektov. Všetky objekty sú zamrznuté na mieste, takže hráč bude schopný pochopiť, čo sa stalo, a uvidí jeho účet. Objekty budú stále zobrazené na obrazovke, ale jednoducho sa zastaví.

Triedy Player: Def __init __ (self, Rad = 20):...Seba.Gamever = Aktualizácia Falsedef (Self, GameObjects):...Pre GameOTJ v GameObjects: Ak GameOTJJ.Typ == "Loptička": IF (GAMEOBJ.X - Ja.x) ** 2 + (GAMEOBJ.Y - self.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass game():def __init__(self):...self.gameOver = Falsedef run(self):while True:self.handleEvents()if not self.gameOver:for gameObj in self.gameObjects:gameObj.update(self.gameObjects)if gameObj.type == "player":self.gameOver = gameObj.gameOver

3. Vyskúšajte program! Konečný kód programu by mal vyzerať takto:

Import PygameFrom Random Import RandomFROM PYGAME.Locals Import * Rozlíšenie = (400 300) White = (255,255,255) Black = (0.0.0) Red = (255,0,0) Screen = PYGAME.Displej.SET_MODE (Rozlíšenie) Trieda Ball: Def __init __ (Self, XPOS = Rozlíšenie [0] / 2, YPOS = Rozlíšenie [1] / 2, XVZ = 1, YVEL = 1, Rad = 15): Ja.X = XPosself.Y = ypseself.Dx = xvelself.dy = yvelself.Radius = Radselselselselselself.Typ = "Loptička"Def Draw (self, povrch): pygame.Kresliť.Kruh (povrch, čierny, (int (vlastný.x), Int (self.y)), ja.Radius) DEF Aktualizácia (Self, GameObjects): Ja.X + = self.Dx.Y + = self.DYIF (ja.X <= 0 or self.x >= Rozlíšenie [0]): Ja.Dx * = -1IF (vlastné.Y <= 0 or self.y >= Rozlíšenie [1]): Ja.Dy * = -1class hráč: def __init __ (self, rad = 20): self.x = 0.Y = 0.Radius = Radselselselselselself.Typ = "Hráč"Seba.Gamever = Falsedef Chocs (self, povrch): pygame.Kresliť.Kruh (povrch, červená, (vlastná.X, ja.y), ja.Radius) Aktualizácia Def (Self, GameObjects): Cord = Pygame.Myši.get_pos () self.X = šnúra [0] self.Y = šnúra [1] pre GameObj v GameObjects: Ak GameOTJJ.Typ == "Loptička": IF (GAMEOBJ.X - Ja.x) ** 2 + (GAMEOBJ.Y - self.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"self.score = 0self.scoreText = pygame.font.Font(None, 12)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))self.score += 1def draw(self, screen):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(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(GameController())self.gameObjects.append(Player())self.gameOver = Falsedef handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()if not self.gameOver:for gameObj in self.gameObjects:gameObj.update(self.gameObjects)if gameObj.type == "player":self.gameOver = gameObj.gameOverself.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()