Dit is 'n inleiding tot Pygame vir mense wat reeds Python ken. Hierdie artikel sal u die stappe leer om 'n eenvoudige spel te bou waarin die speler balle kan weerstaan.
Stappe
Deel 1 van 8: Pygame installeer
Stap 1. Laai Pygame af
Vind dit vir u platform op
Stap 2. Begin die installeerder
Stap 3. Verifieer dat die installasie gewerk het
Maak 'n Python -terminale oop. Tik "invoer pygame." As u geen foute sien nie, is Pygame suksesvol geïnstalleer.
voer pigame in
Deel 2 van 8: Die opstel van 'n basiese venster
Stap 1. Maak 'n nuwe lêer oop
Stap 2. Voer Pygame in
Pygame is 'n biblioteek wat toegang bied tot grafiese funksies. As u meer inligting wil hê oor hoe hierdie funksies werk, kan u dit op die Pygame -webwerf opsoek.
voer pigame van pygame in. lokale invoer *
Stap 3. Stel die vensterresolusie in
U maak 'n globale veranderlike vir die skermresolusie, sodat daar in verskillende dele van die spel na verwys kan word. Dit is ook maklik om bo -aan die lêer te vind, sodat dit later verander kan word. Vir gevorderde projekte is dit beter om hierdie inligting in 'n aparte lêer te plaas.
resolusie = (400, 300)
Stap 4. Definieer 'n paar kleure
Kleure in pigame is (RBGA wat wissel tussen 0 en 255. Die alfa -waarde (A) is opsioneel, maar die ander kleure (rooi, blou en groen is verpligtend).
wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0)
Stap 5. Initialiseer die skerm
Gebruik die resolusie veranderlike wat vroeër gedefinieer is.
skerm = pygame.display.set_mode (resolusie)
Stap 6. Maak 'n spellus
Herhaal sekere aksies in elke raam van ons spel. Maak 'n lus wat altyd sal herhaal word om deur al hierdie aksies te blaai.
terwyl dit waar is:
Stap 7. Kleur die skerm in
skerm.vul (wit)
Stap 8. Wys die skerm
As u die program uitvoer, word die skerm wit en dan val die program neer. Dit is omdat die bedryfstelsel gebeurtenisse na die spel stuur en die spel niks daarmee doen nie. As die spel te veel onbehandelde gebeurtenisse ontvang, val dit neer.
terwyl dit waar is: … pygame.display.flip ()
Stap 9. Hanteer gebeure
Kry 'n lys van alle gebeurtenisse wat in elke raam plaasgevind het. U sal slegs omgee vir een gebeurtenis, die ophou -geleentheid. Dit gebeur wanneer die gebruiker die spelvenster toemaak. Dit sal ook voorkom dat ons program ineenstort weens te veel geleenthede.
terwyl dit waar is: … vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit ()
Stap 10. Probeer dit
Hier is hoe die kode nou moet lyk:
voer pigame in uit pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = pygame.display.set_mode (resolusie) terwyl True: screen.fill (wit) pygame.display.flip () vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit ()
Deel 3 van 8: Maak 'n spelvoorwerp
Stap 1. Maak 'n nuwe klas en konstrukteur
Stel al die eienskappe van die voorwerp in. U verskaf ook standaardwaardes vir al die eiendomme.
klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal"
Stap 2. Definieer hoe om die voorwerp te teken
Gebruik die eienskappe wat in die konstruktor gedefinieer is om die bal as 'n sirkel te teken, sowel as om 'n oppervlak in die funksie te plaas om die voorwerp op te trek. Die oppervlak is die skermvoorwerp wat vroeër met die resolusie geskep is.
def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (self.x, self.y), self.radius)
Stap 3. Maak 'n voorbeeld van die klas en vertel die spellus om die bal in elke lus te trek
bal = Bal () terwyl dit waar is: … bal.teken (skerm)
Stap 4. Laat die voorwerp beweeg
Skep 'n funksie wat die posisie van die voorwerp opdateer. Noem hierdie funksie in elke spellus.
klas Bal: … def update (self): self.x += self.dx self.y += self.dy
Stap 5. Beperk die raamtempo
Die bal sal baie vinnig beweeg, want die spellus loop honderde kere per sekonde. Gebruik die klok van Pygame om die raamtempo tot 60 fps te beperk.
klok = pygame.time. Clock () terwyl True: … clock.tick (60)
Stap 6. Hou die bal op die skerm
Voeg tjeks by in die opdateringsfunksie om die bal se rigting om te draai as dit een van die skermrande raak.
klas Bal: … def update (self): … if (self.x <= 0 of self.x> = resolusie [0]): self.dx *= -1 if (self.y <= 0 of self.y > = resolusie [1]): self.dy *= -1
Stap 7. Probeer dit
Hier is hoe die kode nou moet lyk:
invoer pigame uit pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = pygame.display.set_mode (resolusie) klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal" def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x> = resolusie [0]): self.dx *= -1 as (self.y <= 0 of self.y> = resolusie [1]): self.dy *= -1 bal = Ball () klok = pygame.time. Clock () terwyl True: skerm. vul (wit) ball.draw (skerm) ball.update () pygame.display.flip () clock.tick (60) vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit ()
Deel 4 van 8: Organisering van die spel
Stap 1. Gebruik klasse om alles te organiseer
Die spel gaan meer ingewikkeld raak. Gebruik objekgeoriënteerde tegnieke om u kode te organiseer.
Stap 2. Maak die spellus in 'n klas
Aangesien ons spel nou data bevat, insluitend u spelvoorwerpe en funksies, is dit sinvol om u spellus in 'n klas te verander.
klas spel ():
Stap 3. Voeg 'n konstruktor by
Hier sal u 'n paar spelvoorwerpe installeer, ons skerm en horlosie skep en Pygame inisialiseer. Pygame moet geïnitialiseer word om sekere funksies soos teks of klank te gebruik.
klas spel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusie) self.clock = pygame.time. Clock ()
Stap 4. Hanteer gebeure in 'n funksie
klas spel (): … def handleEvents (self): vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit ()
Stap 5. Maak die spellus 'n funksie
Bel die gebeurtenishanteringsfunksie elke lus.
klas spel (): … def run (self): terwyl True: self.handleEvents () self.screen.fill (wit) self.clock.tick (60) pygame.display.flip ()
Stap 6. Hanteer verskeie spelvoorwerpe
Op die oomblik moet hierdie kode teken en elke raamwerk op ons voorwerp opdateer. Dit sal deurmekaar raak as u baie voorwerpe het. Kom ons voeg ons voorwerp by 'n skikking en werk dan elke lus op en teken alle voorwerpe in die skikking. Nou kan u maklik 'n ander voorwerp byvoeg en 'n ander beginposisie gee.
klas spel (): def _init _ (self): … self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) … def run (self): terwyl True: self.handleEvents () vir gameObj in self.gameObjects: gameObj.update () self.screen.fill (wit) vir gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Stap 7. Probeer dit
Hier is hoe die kode nou moet lyk:
invoer pigame uit pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = pygame.display.set_mode (resolusie) klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal" def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x> = resolusie [0]): self.dx *= -1 as (self.y <= 0 of self.y> = resolusie [1]): self.dy *= -1 klas spel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusie) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit () def run (self): terwyl True: self.handleEvent s () vir gameObj in self.gameObjects: gameObj.update () self.screen.fill (wit) vir gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () game (). run ()
Deel 5 van 8: Voeg 'n spelervoorwerp by
Stap 1. Maak 'n spelersklas en konstruktor
Jy gaan nog 'n sirkel maak wat deur die muis beheer word. Initialiseer die waardes in die konstruktor. Die radius is die enigste belangrike waarde.
klas Speler: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Stap 2. Definieer hoe om die spelervoorwerp te teken
Dit sal dieselfde wees as wat jy die ander spelvoorwerpe geteken het.
klas Speler: … def draw (self, oppervlak): pygame.draw.circle (oppervlak, rooi, (self.x, self.y), self.radius)
Stap 3. Voeg muisbeheer by vir die spelervoorwerp
Kontroleer in elke raam die ligging van die muis en stel die ligging van die voorwerpe van die spelers op daardie punt.
klas speler: … def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Stap 4. Voeg 'n spelervoorwerp by gameObjects
Skep 'n nuwe speler -instansie en voeg dit by die lys.
klas spel (): def _init _ (self): … self.gameObjects.append (Player ())
Stap 5. Probeer dit
Hier is hoe die kode nou moet lyk:
invoer pigame uit pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = pygame.display.set_mode (resolusie) klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal" def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x> = resolusie [0]): self.dx *= -1 as (self.y <= 0 of self.y> = resolusie [1]): self.dy *= -1 klas speler: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "speler" def draw (self, oppervlak): pygame.draw.circle (oppervlak, rooi, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] klas spel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ modus (resolusie) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def handleEvents (self): vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit () def run (self): terwyl True: self.handleEvents () vir gameObj in self.gameObjects: gameObj.update () self.screen.fill (wit) vir gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). hardloop ()
Deel 6 van 8: Maak voorwerpe in wisselwerking met die speler
Stap 1. Verander die opdateringsfunksies
Om voorwerpe in wisselwerking te hê, moet hulle toegang tot mekaar hê. Kom ons voeg nog 'n parameter by Update om in die gameObjects -lys te slaag. U moet dit by beide die spelervoorwerp en die balvoorwerpe voeg. As u baie spelvoorwerpe het, kan erfenis u help om al u metodehandtekeninge dieselfde te hou.
klasbal:… def update (self, gameObjects):… class Player:… def update (self, gameObjects):
Stap 2. Kyk vir botsings tussen die speler en balle
Gaan deur al die spelvoorwerpe en kyk of die tipe voorwerp 'n bal is. Gebruik dan die radius van die twee voorwerpe en die afstandformule om te kyk of dit bots. Sirkels is regtig maklik om botsings na te gaan. Dit is die grootste rede waarom u nie 'n ander vorm vir hierdie speletjie gebruik het nie.
klas Speler: … def update (self, gameObjects): … vir gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Stap 3. Beëindig die spel as die speler 'treffer' kry
Laat ons eers die spel stop.
as (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Stap 4. Probeer dit
Hier is hoe die kode nou moet lyk:
voer pigame in uit pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = pygame.display.set_mode (resolusie) klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal" def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x> = resolusie [0]): self.dx *= -1 as (self.y <= 0 of self.y> = resolusie [1]): self.dy *= -1 klas speler: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "speler" def draw (self, oppervlak): pygame.draw.circle (oppervlak, rooi, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] vir gameObj in gameObjects: if gameObj.type == "bal": as (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klas spel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusie) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): vir gebeurtenis in pygame.event.get (): as event.type == QUIT: pygame.quit () def run (self): terwyl True: self.handleEvents () vir gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (wit) vir gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Deel 7 van 8: Voeg 'n spelbeheerder by om voorwerpe te skep
Stap 1. Skep 'n spelbeheerderklas
Spelbeheerders is verantwoordelik vir die 'bestuur' van die spel. Dit verskil van ons spelklas, wat verantwoordelik is vir die teken en bywerk van al ons voorwerpe. Die beheerder sal gereeld 'n ander bal op die skerm voeg om die spel moeiliker te maak. Voeg 'n konstruktor by en initialiseer 'n paar basiese waardes. Die interval is die tyd voordat nog 'n bal bygevoeg word.
klas GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller"
Stap 2. Voeg die opdateringsfunksie by
Dit sal bepaal hoeveel tyd verloop het sedert die tyd dat 'n bal bygevoeg is of vanaf die begin van die spel. As die tyd langer is as die interval, stel u die tyd terug en voeg u 'n bal by.
klas GameController: … def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
Stap 3. Gee die balle ewekansige snelhede
U moet ewekansige getalle gebruik om die spel elke keer anders te maak. Die balle se snelhede is egter nou 'n swewende puntgetal in plaas van 'n heelgetal.
klas 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 = random ()*2, yVel = random ()*2))
Stap 4. Maak die tekenfunksie reg
Die tekenfunksie aanvaar nie vlotte nie. Kom ons verander die posisie van die bal in heelgetalle voordat die balle getrek word.
klas Bal: … def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (int (self.x), int (self.y)), self.radius)
Stap 5. Definieer 'n trekkingsmetode vir die spelbeheerder
Aangesien dit 'n spelvoorwerp is, sal die hooflus probeer om dit te teken. U moet 'n tekenfunksie definieer wat niks doen nie, sodat die spel nie neerstort nie.
klas GameController: … def draw (self, screen): slaag
Stap 6. Voeg die spelbeheerder by gameObjects en verwyder die 2 balle
Die spel behoort nou elke vyf sekondes 'n bal te gee.
klas spel (): def _init _ (self): … self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Stap 7. Probeer dit
Hier is hoe die kode nou moet lyk:
invoer pygame van ewekansige invoer ewekansig van pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = pigame. display.set_mode (resolusie) klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal" def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 of self. x> = resolusie [0]): self.dx *= -1 as (self.y <= 0 of self.y> = resolusie [1]): self.dy *= -1 klas speler: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "speler" def draw (self, oppervlak): pygame.draw.circle (oppervlak, rooi, (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 Voorwerpe: as gameObj.type == "bal": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klas GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "spelbeheerder "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): slaag klas spel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusie) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): vir gebeurtenis 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.vul (wit) vir gameObj in self.gameO voorwerpe: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Deel 8 van 8: 'n telling byvoeg en 'n spel verby
Stap 1. Voeg 'n telling by die spelbeheerderklas
Skep 'n lettertipe -voorwerp en 'n tellingveranderlike. U teken die lettertipe in elke raam om die telling te vertoon en die telling by elke raam in opdatering te verhoog.
klas 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, skerm): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Stap 2. Verander hoe die spel eindig
Laat ons ontslae raak van die ophou as die speler 'n botsing opspoor. In plaas daarvan stel u 'n veranderlike in die speler in wat die spel kan kontroleer. Hou op met die opdatering van voorwerpe as gameOver ingestel is. Dit vries alles in plek sodat die speler kan sien wat gebeur het en sy telling kan kontroleer. Let daarop dat die voorwerpe steeds geteken word, net nie opgedateer nie.
klas Speler: def _init _ (self, rad = 20): … self.gameOver = Valse def update (self, gameObjects): … vir gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = True class game (): def _init _ (self): … self.gameOver = Valse def run (self): terwyl True: self.handleEvents () indien nie self.gameOver: vir gameObj in self.gameObjects: gameObj.update (self.gameObjects) as gameObj.type == "speler": self.gameOver = gameObj.gameOver
Stap 3. Probeer dit
Hier is hoe die voltooide kode nou moet lyk:
invoer vygame van ewekansige invoer ewekansig van pygame.locals invoer * resolusie = (400, 300) wit = (255, 255, 255) swart = (0, 0, 0) rooi = (255, 0, 0) skerm = vyfspel. display.set_mode (resolusie) klas Bal: def _init _ (self, xPos = resolusie [0] / 2, yPos = resolusie [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 = "bal" def draw (self, oppervlak): pygame.draw.circle (oppervlak, swart, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 of self. x> = resolusie [0]): self.dx *= -1 as (self.y <= 0 of self.y> = resolusie [1]): self.dy *= -1 klas speler: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "speler" self.gameOver = Valse def draw (self, oppervlak): pygame.draw.circle (oppervlak, rooi, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] vir gameObj in gameObjects: as gameObj.type == "bal": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = GameController van ware klas: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2*1000) self. type = "game controller" 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)) klas spel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusie) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = Onwaar def handleEvents (self): vir gebeurtenis in pygame.event.get (): as ev ent.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. tipe == "speler": self.gameOver = gameObj.gameOver self.screen.fill (wit) vir gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spel (). hardloop ()
