See on sissejuhatus Pygame'i inimestele, kes juba tunnevad Pythoni. See artikkel õpetab teile lihtsa mängu loomise samme, kus mängija põrkavaid palle väldib.
Sammud
Osa 1 /8: Pygame'i installimine
Samm 1. Laadige alla Pygame
Leidke see oma platvormi jaoks aadressilt
Samm 2. Käivitage installer
Samm 3. Veenduge, et installimine toimis
Avage Pythoni terminal. Tippige "impordi mäng". Kui te ei näe vigu, installiti Pygame edukalt.
impordi pügame
Osa 2/8: Põhiakna seadistamine
Samm 1. Avage uus fail
Samm 2. Importige Pygame
Pygame on raamatukogu, mis pakub juurdepääsu graafikafunktsioonidele. Kui soovite lisateavet nende funktsioonide toimimise kohta, saate neid otsida Pygame'i veebisaidilt.
impordi pygame saidilt pygame.locals import *
Samm 3. Määrake akna eraldusvõime
Teete ekraani eraldusvõime jaoks globaalse muutuja, millele saab viidata mängu mitmes osas. Seda on lihtne leida ka faili ülaosast, nii et seda saab hiljem muuta. Arenenud projektide puhul oleks parem see teave eraldi faili panna.
resolutsioon = (400, 300)
Samm 4. Määratlege mõned värvid
Värvid mängus on (RBGA, mille väärtused on vahemikus 0 kuni 255. Alfa -väärtus (A) on valikuline, kuid muud värvid (punane, sinine ja roheline) on kohustuslikud.
valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0)
Samm 5. Vormindage ekraan
Kasutage varem määratletud eraldusvõime muutujat.
ekraan = pygame.display.set_mode (resolutsioon)
Samm 6. Tehke mängu silmus
Korrake teatud toiminguid meie mängu igas raamis. Tehke silmus, mis kordub alati kõigi nende toimingute läbimiseks.
kuigi tõsi:
Samm 7. Värvige ekraan
screen.fill (valge)
Samm 8. Kuvage ekraan
Kui käivitate programmi, muutub ekraan valgeks ja programm jookseb kokku. Seda seetõttu, et opsüsteem saadab mängu sündmusi ja mäng ei tee nendega midagi. Kui mäng saab liiga palju käsitlemata sündmusi, jookseb see kokku.
kuigi tõsi:… pygame.display.flip ()
Samm 9. Hallake sündmusi
Hankige loend kõikidest kaadris toimunud sündmustest. Teid huvitab ainult üks sündmus, loobumisüritus. See juhtub siis, kui kasutaja sulgeb mänguakna. See hoiab ära ka meie programmi krahhi liiga paljude sündmuste tõttu.
kuigi tõsi:… sündmuse jaoks pygame.event.get (): if event.type == QUIT: pygame.quit ()
Samm 10. Proovige järele
Kood peaks nüüd välja nägema järgmine:
importige mäng mängust pygame.locals import * resolutsioon = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = pygame.display.set_mode (resolutsioon), kuigi tõsi: screen.fill (valge) pygame.display.flip () sündmuse jaoks pygame.event.get (): if event.type == QUIT: pygame.quit ()
Osa 3 /8: Mänguobjekti tegemine
Samm 1. Tehke uus klass ja konstruktor
Määrake kõik objekti omadused. Samuti esitate kõigi atribuutide vaikeväärtused.
klassi pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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"
Samm 2. Määratlege, kuidas objekti joonistada
Kasutage konstruktoris määratletud omadusi, et joonistada pall ringina ja anda pinnale objekti joonistamise funktsioon. Pind on ekraani objekt, mis loodi varem eraldusvõimega.
def draw (ise, pind): pygame.draw.circle (pind, must, (self.x, self.y), self.radius)
Samm 3. Tehke klassi eksemplar ja käskige mänguahelal palli igasse silmusesse tõmmata
pall = pall (), kuigi tõsi:… ball.draw (ekraan)
Samm 4. Pane objekt liikuma
Looge funktsioon, mis värskendab objekti asukohta. Helistage sellele funktsioonile igas mängusilmus.
klassi pall:… def update (ise): self.x += self.dx self.y += self.dy
Samm 5. Piirake kaadrisagedust
Pall liigub tõesti kiiresti, sest mänguahel jookseb sadu kordi sekundis. Kasutage Pygame'i kella, et piirata kaadrisagedust 60 kaadrini sekundis.
clock = pygame.time. Clock () samas True:… clock.tick (60)
Samm 6. Hoidke palli ekraanil
Lisage värskendusfunktsiooni tšekid, et palli suunda pöörata, kui see tabab ekraani ühte serva.
klassi pall:… def update (ise):… if (self.x <= 0 or self.x> = resolutsioon [0]): self.dx *= -1 if (self.y <= 0 or self.y > = resolutsioon [1]): ise.dy *= -1
Samm 7. Proovige järele
Kood peaks nüüd välja nägema järgmine:
importige mäng mängust pygame.locals import * resolutsioon = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = pygame.display.set_mode (resolutsioon) klassi pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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 (ise, pind): pygame.draw.circle (pind, must, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolutsioon [0]): self.dx *= -1, kui (self.y <= 0 või self.y> = resolutsioon [1]): self.dy *= -1 ball = Ball () kell = pygame.time. Clock (), samas kui True: ekraan. täida (valge) ball.draw (ekraan) ball.update () pygame.display.flip () kella.tick (60) sündmuse jaoks mängus.event.get (): if event.type == QUIT: pygame.quit ()
Osa 4/8: Mängu korraldamine
Samm 1. Kasutage klasside korraldamiseks kõike
Mäng läheb keerulisemaks. Kasutage koodi korraldamiseks objektorienteeritud tehnikaid.
Samm 2. Muutke mängu silmus klassiks
Kuna meie mängus on nüüd andmeid, sealhulgas teie mänguobjekte ja funktsioone, on mõttekas muuta oma mänguahela klassiks.
klassi mäng ():
Samm 3. Lisage konstruktor
Siin näete mõnda mänguobjekti, loote meie ekraani ja kella ning lähtestate Pygame'i. Pygame tuleb teatud funktsioonide (nt teksti või heli) kasutamiseks lähtestada.
klassi mäng (): def _init _ (ise): pygame.init () self.screen = pygame.display.set_mode (resolutsioon) self.clock = pygame.time. Clock ()
Samm 4. Käsitlege funktsiooni sündmusi
klassi mäng ():… def handleEvents (ise): sündmuse jaoks pygame.event.get (): if event.type == QUIT: pygame.quit ()
Samm 5. Muutke mänguahel funktsiooniks
Helistage sündmuste käitlemise funktsioonile igast tsüklist.
klassi mäng ():… def run (self): samas True: self.handleEvents () self.screen.fill (valge) self.clock.tick (60) pygame.display.flip ()
Samm 6. Käsitsege mitu mänguobjekti
Praegu peab see kood iga kaadri korral kutsuma joonistama ja värskendama meie objekti. See läheks segaseks, kui teil oleks palju esemeid. Lisame oma objekti massiivi ja seejärel värskendame ja joonistame kõik massiivi objektid igal silmusel. Nüüd saate hõlpsalt lisada teise objekti ja anda sellele teistsuguse lähtepositsiooni.
klassi mäng (): def _init _ (ise):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): samas True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (valge) mängu jaoksObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Samm 7. Proovige järele
Kood peaks nüüd välja nägema järgmine:
importige mäng mängust pygame.locals import * resolutsioon = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = pygame.display.set_mode (resolutsioon) klassi pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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 (ise, pind): pygame.draw.circle (pind, must, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolutsioon [0]): self.dx *= -1 kui (self.y <= 0 või self.y> = resolutsioon [1]): self.dy *= -1 klassi mäng (): def _init _ (ise): pygame.init () ise.ekraan = pygame.display.set_mode (resolutsioon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (ise): sündmuse jaoks pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): samas True: self.handleEvent s () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (valge) mängu jaoksObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. klapp () mäng (). jooksma ()
Osa 5/8: Mängija objekti lisamine
Samm 1. Tehke mängijaklass ja konstruktor
Teete uue ringi, mida juhib hiir. Vormista konstruktoris väärtused. Raadius on ainus oluline väärtus.
klassi mängija: def _init _ (ise, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Samm 2. Määratlege, kuidas mängijaobjekti joonistada
See läheb samamoodi, nagu joonistasite teisi mänguobjekte.
klassi mängija:… def draw (ise, pind): pygame.draw.circle (pind, punane, (self.x, self.y), self.radius)
Samm 3. Lisage mängijaobjektile hiire juhtimine
Kontrollige igas kaadris hiire asukohta ja seadke mängijate objektide asukoht sellesse punkti.
klassi mängija:… def update (ise): juhe = pygame.mouse.get_pos () self.x = juhe [0] self.y = juhe [1]
Samm 4. Lisa mängijaobjekt gameObjects
Looge uus mängija eksemplar ja lisage see loendisse.
klassi mäng (): def _init _ (ise):… self.gameObjects.append (mängija ())
Samm 5. Proovige järele
Kood peaks nüüd välja nägema järgmine:
importige mäng mängust pygame.locals import * resolutsioon = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = pygame.display.set_mode (resolutsioon) klassi pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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 (ise, pind): pygame.draw.circle (pind, must, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolutsioon [0]): self.dx *= -1 kui (self.y <= 0 või self.y> = resolutsioon [1]): self.dy *= -1 klass Mängija: def _init _ (ise, rad = 20): self.x = 0 ise.y = 0 self.radius = rad self.type = "player" def draw (ise, pind): pygame.draw.circle (pind, punane, (self.x, self.y), self.radius) def update (ise): nöör = mäng.display.set_ mode (resolutsioon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def kezel.gameObjects: gameObj.update () self.screen.fill (valge) mängu jaoksObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () mäng (). jooksma ()
Osa 6/8: Objektide suhtlemine mängijaga
Samm 1. Muutke värskendusfunktsioone
Objektide suhtlemiseks peavad neil olema teineteisele juurdepääs. Lisame mängule Objektide loendisse edastamiseks veel ühe parameetri. Peate selle lisama nii mängija- kui ka palliobjektidele. Kui teil on palju mänguobjekte, võib pärimine aidata teil kõiki oma meetodi allkirju samaks jätta.
klassi pall:… def uuendus (ise, gameObjects):… klassi mängija:… def update (ise, gameObjects):
Samm 2. Kontrollige mängija ja pallide kokkupõrkeid
Minge läbi kõik mänguobjektid ja kontrollige, kas objektide tüüp on pall. Seejärel kontrollige kahe objekti raadiusi ja kauguse valemit, kas need põrkuvad. Suhtlusringides on kokkupõrkeid tõesti lihtne kontrollida. See on suurim põhjus, miks te ei kasutanud selle mängu jaoks mõnda muud kuju.
klassi mängija:… def uuendus (ise, gameObjects):… gameObj jaoks mängusObjects: kui gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Samm 3. Lõpetage mäng, kui mängija saab "löögi"
Lõpetame mängu praegu.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Samm 4. Proovige järele
Kood peaks nüüd välja nägema:
importige mäng mängust pygame.locals import * resolutsioon = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = pygame.display.set_mode (resolutsioon) klassi pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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 (ise, pind): pygame.draw.circle (pind, must, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 või self.x> = resolutsioon [0]): ise.dx *= -1, kui (self.y <= 0 või self.y> = resolutsioon [1]): self.dy *= -1 klass Mängija: def _init _ (ise, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (ise, pind): pygame.draw.circle (pind, punane, (self.x, self.y), self.radius) def update (self, gameObjects): nöör = pygame.mouse.get_pos () self.x = nöör [0] self.y = nöör [1] gameObj jaoks mängusObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klassi mäng (): def _init _ (ise): pygame.init () self.screen = pygame.display.set_mode (resolutsioon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (ise): sündmuse jaoks pygame.event.get (): if event.type == QIT: pygame.quit () def run (self): samas 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 () mäng (). run ()
Osa 7/8: Mängukontrolleri lisamine objektide loomiseks
Samm 1. Looge mängukontrolleri klass
Mängu kontrollerid vastutavad mängu "jooksmise" eest. See erineb meie mänguklassist, mis vastutab kõigi meie objektide joonistamise ja värskendamise eest. Mängu raskendamiseks lisab kontroller perioodiliselt ekraanile veel ühe palli. Lisage konstruktor ja lähtestage mõned põhiväärtused. Intervall on aeg enne teise palli lisamist.
klassi GameController: def _init _ (ise, intervall = 5): self.inter = intervall self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "mängujuht"
Samm 2. Lisage värskendusfunktsioon
See kontrollib, kui palju aega on möödunud palli lisamisest või mängu algusest. Kui aeg ületab intervalli, lähtestate aja ja lisate palli.
klassi GameController:… def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
Samm 3. Andke pallidele juhuslikud kiirused
Mängu iga kord erinevaks muutmiseks peate kasutama juhuslikke numbreid. Kuid pallide kiirused on nüüd täisarvu asemel ujukomaarv.
klassi 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 = juhuslik ()*2, yVel = juhuslik ()*2))
Samm 4. Parandage joonistusfunktsioon
Loosimisfunktsioon ei aktsepteeri ujukeid. Enne pallide loosimist teisendame palli positsiooni täisarvudeks.
klassi pall:… def draw (ise, pind): pygame.draw.circle (pind, must, (int (self.x), int (self.y)), self.radius)
Samm 5. Määratlege mängukontrolleri jaoks viigimeetod
Kuna tegemist on mänguobjektiga, proovib põhisilmus seda joonistada. Peate määratlema viigifunktsiooni, mis ei tee midagi, et mäng ei jookseks kokku.
klassi GameController:… def draw (ise, ekraan): pass
Samm 6. Lisage gameObjects mängu kontroller ja eemaldage 2 palli
Mäng peaks nüüd iga viie sekundi järel palli kudema.
klassi mäng (): def _init _ (ise):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Samm 7. Proovige järele
Kood peaks nüüd välja nägema järgmine:
impordige pügame juhuslikust importimisest juhuslikult pygame'ist. kohalikud import * resolutsioon = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = mäng. display.set_mode (resolutsioon) klass Pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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 (ise, pind): pygame.draw.circle (pind, must, (int (ise.) x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 või self.) x> = resolutsioon [0]): self.dx *= -1, kui (self.y <= 0 või self.y> = resolutsioon [1]): self.dy *= -1 klass Mängija: def _init _ (ise, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (ise, pind): pygame.draw.circle (pind, punane, (self.x), self.y), self.radius) def update (self, gameObjects): nöör = pygame.mouse.get_pos () self.x = juhe [0] self.y = nöör [1] gameObj jaoks mängus Objektid: kui gameObj.type == "pall": kui (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klassi GameController: def _init _ (ise, intervall = 5): self.inter = intervall self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "mängujuht "def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = juhuslik ()*2, yVel = juhuslik ()*2)) def draw (ise, ekraan): pass klassi mäng (): def _init _ (ise): pygame.init () self.screen = pygame.display.set_mode (resolutsioon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (ise): sündmuse jaoks pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): samas True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.täitke (valge) gameObj jaoks ise. gameO bjects: gameObj.draw (ise.ekraan) self.clock.tick (60) pygame.display.flip () mäng (). run ()
Osa 8/8: Skoori lisamine ja mäng läbi
Samm 1. Lisage mängujuhtide klassi skoor
Looge fondiobjekt ja skoori muutuja. Joonistate fondi igasse kaadrisse, et kuvada skoor ja suurendada iga värskendatud kaadri skoori.
klassi GameController: def _init _ (ise, intervall = 5):… self.score = 0 self.scoreText = pygame.font. Font (puudub, 12) def update (self, gameObjects):… self.score += 1 def viik (ise, ekraan): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Samm 2. Muutke mängu lõppu
Vabanegem lõpetamisest, kui mängija avastab kokkupõrke. Selle asemel määrate mängijale muutuja, mida mäng saab kontrollida. Kui gameOver on seatud, lõpetage objektide värskendamine. See külmutab kõik paigas, nii et mängija saab juhtunut näha ja oma skoori kontrollida. Pange tähele, et objekte alles joonistatakse, kuid neid ei värskendata.
klassi mängija: def _init _ (ise, rad = 20):… self.gameOver = vale def uuendus (ise, gameObjects):… gameObj jaoks gameObjects: if gameObj.type == "ball": if (gameObj.x - ise.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Tõeline klassi mäng (): def _init _ (ise): … Self.gameOver = False def run (self): samas True: self.handleEvents () kui mitte self.gameOver: gameObj jaoks self.gameObjects: gameObj.update (self.gameObjects), kui gameObj.type == "player": self.gameOver = gameObj.gameOver
Samm 3. Proovige järele
Valmis kood peaks nüüd välja nägema järgmine:
impordige pügame juhuslikust importimisest juhuslikult pygame'ist. kohalikud import * eraldusvõime = (400, 300) valge = (255, 255, 255) must = (0, 0, 0) punane = (255, 0, 0) ekraan = mäng. display.set_mode (resolutsioon) klass Pall: def _init _ (ise, xPos = resolutsioon [0] / 2, yPos = resolutsioon [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 (ise, pind): pygame.draw.circle (pind, must, (int (ise.) x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 või self.) x> = resolutsioon [0]): self.dx *= -1, kui (self.y <= 0 või self.y> = resolutsioon [1]): self.dy *= -1 klass Mängija: def _init _ (ise, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = False def draw (ise, pind): pygame.draw.circle (pind, punane, (self.x, self.y), self.radius) def update (self, gameObjects): nöör = pygame.mouse.get_pos () self.x = juhe [0] self.y = juhe [1] gameObj jaoks gameObjects: kui gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Tõeline klass GameController: def _init _ (ise, intervall = 5): self.inter = intervall self.next = pygame.time.get_ticks () + (2*1000) self. type = "mängujuht" self.score = 0 self.scoreText = pygame.font. Font (puudub, 12) def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter*1000) mäng): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) klassi mäng (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolutsioon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = Vale def handleEvents (ise): sündmuse jaoks pygame.event.get (): kui ev ent.type == QUIT: pygame.quit () def run (self): samas True: self.handleEvents () kui mitte self.gameOver: gameObj jaoks self.gameObjects: gameObj.update (self.gameObjects) kui gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (valge) gameObj jaoks self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () mäng (). jooks ()
