Aceasta este o introducere în Pygame pentru persoanele care cunosc deja Python. Acest articol vă va învăța pașii pentru a construi un joc simplu care să-l facă pe jucător să se ferească de mingi care sări.
Pași
Partea 1 din 8: Instalarea Pygame
Pasul 1. Descărcați Pygame
Găsiți-l pentru platforma dvs. de la
Pasul 2. Rulați programul de instalare
Pasul 3. Verificați dacă instalarea a funcționat
Deschideți un terminal Python. Tastați „import pygame”. Dacă nu vedeți erori, Pygame a fost instalat cu succes.
import pygame
Partea 2 din 8: Configurarea unei ferestre de bază
Pasul 1. Deschideți un fișier nou
Pasul 2. Import Pygame
Pygame este o bibliotecă care oferă acces la funcții grafice. Dacă doriți mai multe informații despre cum funcționează aceste funcții, le puteți căuta pe site-ul Pygame.
import pygame din pygame.locals import *
Pasul 3. Setați rezoluția ferestrei
Veți crea o variabilă globală pentru rezoluția ecranului, astfel încât să poată fi menționată în mai multe părți ale jocului. De asemenea, este ușor de găsit în partea de sus a fișierului, astfel încât să poată fi modificat ulterior. Pentru proiectele avansate, plasarea acestor informații într-un fișier separat ar fi o idee mai bună.
rezoluție = (400, 300)
Pasul 4. Definiți câteva culori
Culorile din pygame sunt (RBGA care variază între 0 și 255. Valoarea alfa (A) este opțională, dar celelalte culori (roșu, albastru și verde sunt obligatorii).
alb = (255, 255, 255) negru = (0, 0, 0) roșu = (255, 0, 0)
Pasul 5. Inițializați ecranul
Utilizați variabila de rezoluție care a fost definită anterior.
ecran = pygame.display.set_mode (rezoluție)
Pasul 6. Realizează o buclă de joc
Repetați anumite acțiuni în fiecare cadru al jocului nostru. Faceți o buclă care se va repeta mereu pentru a parcurge toate aceste acțiuni.
în timp ce este adevărat:
Pasul 7. Colorează ecranul
screen.fill (alb)
Pasul 8. Afișați ecranul
Dacă rulați programul, ecranul va deveni alb și apoi programul se va prăbuși. Acest lucru se datorează faptului că sistemul de operare trimite evenimente în joc și jocul nu face nimic cu ele. Odată ce jocul primește prea multe evenimente nesoluționate, acesta se va prăbuși.
în timp ce este adevărat: … pygame.display.flip ()
Pasul 9. Gestionarea evenimentelor
Obțineți o listă cu toate evenimentele care au avut loc în fiecare cadru. Veți avea grijă de un singur eveniment, evenimentul de renunțare. Acest lucru se întâmplă atunci când utilizatorul închide fereastra jocului. Acest lucru va preveni, de asemenea, programul nostru să se blocheze din cauza prea multor evenimente.
în timp ce este adevărat: … pentru eveniment în pygame.event.get (): dacă event.type == QUIT: pygame.quit ()
Pasul 10. Încercați
Iată cum ar trebui să arate codul acum:
import pygame din pygame.locals import * rezoluție = (400, 300) alb = (255, 255, 255) negru = (0, 0, 0) roșu = (255, 0, 0) ecran = pygame.display.set_mode (rezoluție) în timp ce True: screen.fill (alb) pygame.display.flip () pentru eveniment în pygame.event.get (): dacă event.type == QUIT: pygame.quit ()
Partea 3 din 8: Realizarea unui obiect de joc
Pasul 1. Faceți o nouă clasă și un constructor
Setați toate proprietățile obiectului. De asemenea, furnizați valori implicite pentru toate proprietățile.
clasa Ball: 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 = "mingea"
Pasul 2. Definiți cum să desenați obiectul
Utilizați proprietățile care au fost definite în constructor pentru a desena mingea ca un cerc, precum și pentru a trece o suprafață în funcția de a desena obiectul. Suprafața va fi obiectul ecranului care a fost creat folosind rezoluția mai devreme.
desen desen (auto, suprafață): pygame.draw.circle (suprafață, negru, (self.x, self.y), self.radius)
Pasul 3. Faceți o instanță a clasei, precum și spuneți buclei de joc să deseneze mingea în fiecare buclă
ball = Ball () while True:… ball.draw (ecran)
Pasul 4. Faceți obiectul să se miște
Creați o funcție care va actualiza poziția obiectului. Apelați această funcție în fiecare buclă de joc.
clasa Ball:… def update (self): self.x + = self.dx self.y + = self.dy
Pasul 5. Limitați rata cadrelor
Mingea se va mișca foarte repede, deoarece bucla de joc rulează de sute de ori pe secundă. Utilizați ceasul Pygame pentru a limita rata de cadre la 60 fps.
clock = pygame.time. Clock () în timp ce True:… clock.tick (60)
Pasul 6. Păstrați mingea pe ecran
Adăugați cecuri în funcția de actualizare pentru a inversa direcția mingii dacă lovește una dintre marginile ecranului.
clasa Ball: … actualizare def (auto): … dacă (self.x <= 0 sau self.x> = rezoluție [0]): self.dx * = -1 if (self.y <= 0 sau self.y > = rezoluție [1]): self.dy * = -1
Pasul 7. Încercați
Iată cum ar trebui să arate codul acum:
import pygame din pygame.locals import * rezoluție = (400, 300) alb = (255, 255, 255) negru = (0, 0, 0) roșu = (255, 0, 0) ecran = pygame.display.set_mode (rezoluție) clasă Ball: 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 = "mingea" def draw (self, surface): pygame.draw.circle (surface, black, (self.x, self.y), self.radius) actualizare def (self): self.x + = self.dx self.y + = self.dy dacă (self.x <= 0 sau self.x> = rezoluție [0]): self.dx * = -1 dacă (self.y <= 0 sau self.y> = rezoluție [1]): self.dy * = -1 ball = Ball () clock = pygame.time. Clock () în timp ce True: ecran. fill (white) ball.draw (screen) ball.update () pygame.display.flip () clock.tick (60) for event in pygame.event.get (): if event.type == QUIT: pygame.quit ()
Partea 4 din 8: Organizarea jocului
Pasul 1. Folosiți cursurile pentru a organiza totul
Jocul va deveni mai complicat. Folosiți tehnici orientate obiect pentru a vă organiza codul.
Pasul 2. Transformă bucla de joc într-o clasă
Deoarece jocul nostru are acum date, inclusiv obiectele și funcțiile dvs. de joc, este logic să vă transformați bucla de joc într-o clasă.
joc de clasă ():
Pasul 3. Adăugați un constructor
Aici veți instantanee câteva obiecte de joc, veți crea ecranul și ceasul și veți inițializa Pygame. Pygame trebuie inițializat pentru a utiliza anumite caracteristici precum text sau sunet.
joc de clasă (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolution) self.clock = pygame.time. Clock ()
Pasul 4. Gestionarea evenimentelor într-o funcție
clasă joc ():… def handleEvents (self): pentru eveniment în pygame.event.get (): dacă event.type == QUIT: pygame.quit ()
Pasul 5. Faceți din bucla jocului o funcție
Apelați funcția de gestionare a evenimentelor la fiecare buclă.
joc de clasă ():… def run (self): în timp ce True: self.handleEvents () self.screen.fill (alb) self.clock.tick (60) pygame.display.flip ()
Pasul 6. Manipulați mai multe obiecte de joc
În acest moment, acest cod trebuie să apeleze draw și să actualizeze pe obiectul nostru fiecare cadru. Acest lucru ar deveni dezordonat dacă ați avea o mulțime de obiecte. Să adăugăm obiectul nostru la o matrice și apoi să actualizăm și să desenăm toate obiectele din matrice în fiecare buclă. Acum puteți adăuga cu ușurință un alt obiect și îi puteți oferi o poziție de pornire diferită.
joc de clasă (): def _init _ (self):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): în timp ce True: self.handleEvents () pentru gameObj în self.gameObjects: gameObj.update () self.screen.fill (alb) pentru gameObj în self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Pasul 7. Încercați
Iată cum ar trebui să arate codul acum:
import pygame din pygame.locals import * rezoluție = (400, 300) alb = (255, 255, 255) negru = (0, 0, 0) roșu = (255, 0, 0) ecran = pygame.display.set_mode (rezoluție) clasă Ball: 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 = "mingea" def draw (self, surface): pygame.draw.circle (surface, black, (self.x, self.y), self.radius) actualizare def (self): self.x + = self.dx self.y + = self.dy dacă (self.x <= 0 sau self.x> = rezoluție [0]): self.dx * = -1 if (self.y <= 0 sau self.y> = rezoluție [1]): self.dy * = -1 joc de clasă (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolution) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): pentru eveniment în pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): în timp ce True: self.handleEvent s () pentru gameObj în self.gameObjects: gameObj.update () self.screen.fill (alb) pentru gameObj în self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () game (). run ()
Partea 5 din 8: Adăugarea unui obiect Player
Pasul 1. Faceți o clasă de jucător și un constructor
Veți face un alt cerc care este controlat de mouse. Inițializați valorile din constructor. Raza este singura valoare importantă.
clasă Jucător: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Pasul 2. Definiți cum să atrageți obiectul jucătorului
Va fi la fel cum ai desenat celelalte obiecte de joc.
clasa Jucător:… def draw (self, surface): pygame.draw.circle (surface, red, (self.x, self.y), self.radius)
Pasul 3. Adăugați controlul mouse-ului pentru obiectul player
În fiecare cadru, verificați locația mouse-ului și setați locația obiectelor jucătorilor în acel punct.
clasă Player:… actualizare def (auto): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Pasul 4. Adăugați un obiect player la gameObjects
Creați o nouă instanță de jucător și adăugați-o la listă.
joc de clasă (): def _init _ (self):… self.gameObjects.append (Player ())
Pasul 5. Încercați
Iată cum ar trebui să arate codul acum:
import pygame din pygame.locals import * rezoluție = (400, 300) alb = (255, 255, 255) negru = (0, 0, 0) roșu = (255, 0, 0) ecran = pygame.display.set_mode (rezoluție) clasă Ball: 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 = "mingea" def draw (self, surface): pygame.draw.circle (surface, black, (self.x, self.y), self.radius) actualizare def (self): self.x + = self.dx self.y + = self.dy dacă (self.x <= 0 sau self.x> = rezoluție [0]): self.dx * = -1 dacă (self.y <= 0 sau self.y> = rezoluție [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (surface, red, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] joc de clasă (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ mod (rezoluție) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def handleEvents (self): pentru eveniment în pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (alb) pentru gameObj în self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). alerga()
Partea 6 din 8: Interacționarea obiectelor cu jucătorul
Pasul 1. Schimbați funcțiile de actualizare
Pentru ca obiectele să interacționeze, vor trebui să aibă acces unul la altul. Să adăugăm un alt parametru la Actualizare pentru a trece în lista gameObjects. Va trebui să-l adăugați atât obiectului jucător, cât și obiectelor Ball. Dacă aveți o mulțime de obiecte de joc, moștenirea vă poate ajuta să păstrați toate semnăturile metodei la fel.
clasa Ball:… actualizare def (self, gameObjects):… clasă Player:… actualizare def (self, gameObjects):
Pasul 2. Verificați dacă există coliziuni între jucător și bile
Parcurgeți toate obiectele jocului și verificați dacă tipul obiectelor este bilă. Apoi utilizați razele celor două obiecte și formula distanței pentru a verifica dacă acestea se ciocnesc. Cercurile sunt foarte ușor de verificat coliziunile. Acesta este cel mai mare motiv pentru care nu ați folosit altă formă pentru acest joc.
clasă Jucător:… actualizare def (self, gameObjects):… pentru gameObj în gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Pasul 3. Încheia jocul dacă jucătorul este „lovit”
Să ieșim din joc pentru moment.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Pasul 4. Încercați
Iată cum ar trebui să arate codul acum:
import pygame din pygame.locals import * rezoluție = (400, 300) alb = (255, 255, 255) negru = (0, 0, 0) roșu = (255, 0, 0) ecran = pygame.display.set_mode (rezoluție) clasă Ball: 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 = "mingea" def draw (self, surface): pygame.draw.circle (surface, black, (self.x, self.y), self.radius) actualizare def (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 sau self.x> = rezoluție [0]): self.dx * = -1 if (self.y <= 0 or self.y> = resolution [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "jucător" def draw (self, surface): pygame.draw.circle (surface, red, (self.x, self.y), self.radius) actualizare def (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 () joc de clasă (): 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): pentru eveniment în pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () pentru gameObj în self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (alb) pentru gameObj în self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Partea 7 din 8: Adăugarea unui controler de joc pentru a crea obiecte
Pasul 1. Creați o clasă de controler de joc
Controlorii de joc sunt responsabili de „rularea” jocului. Este diferit de clasa noastră de joc care este responsabilă pentru desenarea și actualizarea tuturor obiectelor noastre. Controlerul va adăuga periodic o altă minge pe ecran pentru a face jocul mai greu. Adăugați un constructor și inițializați câteva valori de bază. Intervalul va fi timpul înainte de adăugarea unei alte mingi.
class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "controler de joc"
Pasul 2. Adăugați funcția de actualizare
Aceasta va verifica cât timp a trecut de când s-a adăugat o minge sau de la începutul jocului. Dacă timpul este mai mare decât intervalul, veți reseta ora și adăugați o minge.
clasă GameController:… actualizare def (self, gameObjects): dacă self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ()))
Pasul 3. Dați bilelor viteze aleatorii
Va trebui să utilizați numere aleatorii pentru a face jocul diferit de fiecare dată. Cu toate acestea, viteza bilelor este acum un număr în virgulă mobilă în loc de un număr întreg.
clasa GameController:… actualizare def (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))
Pasul 4. Remediați funcția de extragere
Funcția de extragere nu acceptă flotări. Să convertim poziția mingii în numere întregi înainte ca bilele să fie extrase.
clasa Ball:… def draw (self, surface): pygame.draw.circle (surface, black, (int (self.x), int (self.y)), self.radius)
Pasul 5. Definiți o metodă de extragere pentru controlerul jocului
Deoarece este un obiect de joc, bucla principală va încerca să o deseneze. Va trebui să definiți o funcție de extragere care nu face nimic, astfel încât jocul să nu se blocheze.
clasa GameController:… def draw (auto, ecran): pass
Pasul 6. Adăugați controlerul de joc la gameObjects și scoateți cele 2 bile
Jocul ar trebui să apară acum o minge la fiecare cinci secunde.
joc de clasă (): def _init _ (self):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Pasul 7. Încercați
Iată cum ar trebui să arate codul acum:
import pygame from random import random from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame. display.set_mode (resolution) class Ball: 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 = "mingea" def draw (self, surface): pygame.draw.circle (surface, black, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 sau self. x> = resolution [0]): self.dx * = -1 if (self.y <= 0 or self.y> = resolution [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "jucător" def draw (self, surface): pygame.draw.circle (surface, red, (self.x, self.y), self.radius) actualizare def (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] pentru gameObj în joc Obiecte: if gameObj.type == "mingea": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) * * 2: pygame.quit () class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "controler de joc "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 (resolution)) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): pentru eveniment în pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () pentru gameObj în self.gameObjects: gameObj.update (self.gameObjects) self.screen.umplere (alb) pentru gameObj în self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Partea 8 din 8: Adăugarea unui scor și jocul terminat
Pasul 1. Adăugați un scor la clasa controlerului de joc
Creați un obiect de font și o variabilă de scor. Veți desena fontul în fiecare cadru pentru a afișa scorul și pentru a crește scorul la fiecare cadru în actualizare.
class GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (None, 12) def update (self, gameObjects):… self.score + = 1 def draw (self, screen): screen.blit (self.scoreText.render (str (self.score), True, negru), (5, 5))
Pasul 2. Modificați modul în care se termină jocul
Să scăpăm de renunțare atunci când jucătorul detectează o coliziune. În schimb, veți seta o variabilă în jucător pe care jocul o poate verifica. Când GameOver este setat, opriți actualizarea obiectelor. Acest lucru va îngheța totul în loc, astfel încât jucătorul să poată vedea ce s-a întâmplat și să-și verifice scorul. Rețineți că obiectele sunt încă desenate, dar nu sunt actualizate.
clasă Jucător: def _init _ (self, rad = 20):… self.gameOver = Actualizare def falsă (self, gameObjects):… pentru gameObj în gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Joc de clasă adevărată (): def _init _ (self): … Self.gameOver = Fal def def run (self): while True: self.handleEvents () dacă nu self.gameOver: pentru gameObj în self.gameObjects: gameObj.update (self.gameObjects) dacă gameObj.type == "player": self.gameOver = gameObj.gameOver
Pasul 3. Încercați
Iată cum ar trebui să arate codul finalizat acum:
import pygame from random import random from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame. display.set_mode (resolution) class Ball: 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 = "mingea" def draw (self, surface): pygame.draw.circle (surface, black, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 sau self. x> = resolution [0]): self.dx * = -1 if (self.y <= 0 or self.y> = resolution [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "jucător" self.gameOver = Desen fals fals (auto, suprafață): pygame.draw.circle (suprafață, roșu, (self.x, self.y), self.radius) actualizare def (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] pentru gameObj în gameObjects: if gameObj.type == "mingea": 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 = interval self.next = pygame.time.get_ticks () + (2 * 1000) self. type = "controler joc" self.score = 0 self.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 + = 1 def draw (self, screen): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) joc de clasă (): 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 = False def handleEvents (self): pentru eveniment în pygame.event.get (): if ev ent.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () dacă nu self.gameOver: pentru gameObj în self.gameObjects: gameObj.update (self.gameObjects) dacă gameObj. tastați == "jucător": self.gameOver = gameObj.gameOver self.screen.fill (alb) pentru gameObj în self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
