Dit is een introductie tot Pygame voor mensen die Python al kennen. Dit artikel leert je de stappen om een eenvoudig spel te bouwen waarbij de speler stuiterende ballen ontwijkt.
Stappen
Deel 1 van 8: Pygame installeren
Stap 1. Download Pygame
Zoek het voor uw platform op
Stap 2. Voer het installatieprogramma uit
Stap 3. Controleer of de installatie werkte
Open een Python-terminal. Typ 'import pygame'. Als u geen fouten ziet, is Pygame met succes geïnstalleerd.
import pygame
Deel 2 van 8: Een basisvenster instellen
Stap 1. Open een nieuw bestand
Stap 2. Pygame importeren
Pygame is een bibliotheek die toegang biedt tot grafische functies. Wil je meer informatie over hoe deze functies werken, dan kun je deze opzoeken op de website van Pygame.
importeer pygame van pygame.locals import *
Stap 3. Stel de vensterresolutie in
Je maakt een globale variabele voor de schermresolutie, zodat er in verschillende delen van het spel naar kan worden verwezen. Het is ook gemakkelijk bovenaan het bestand te vinden, zodat het later kan worden gewijzigd. Voor geavanceerde projecten is het een beter idee om deze informatie in een apart bestand te plaatsen.
resolutie = (400, 300)
Stap 4. Definieer enkele kleuren
Kleuren in pygame zijn (RBGA die variëren in waarden tussen 0 en 255. De alfawaarde (A) is optioneel, maar de andere kleuren (rood, blauw en groen zijn verplicht).
wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0)
Stap 5. Initialiseer het scherm
Gebruik de resolutievariabele die eerder is gedefinieerd.
scherm = pygame.display.set_mode(resolutie)
Stap 6. Maak een gameloop
Herhaal bepaalde acties in elk frame van ons spel. Maak een lus die zich altijd herhaalt om door al deze acties te bladeren.
terwijl waar:
Stap 7. Kleur het scherm in
scherm.vul (wit)
Stap 8. Geef het scherm weer
Als u het programma uitvoert, wordt het scherm wit en crasht het programma. Dit komt omdat het besturingssysteem gebeurtenissen naar de game verzendt en de game er niets mee doet. Zodra het spel te veel onverwerkte gebeurtenissen ontvangt, zal het crashen.
terwijl True: … pygame.display.flip()
Stap 9. Gebeurtenissen afhandelen
Krijg een lijst van alle gebeurtenissen die in elk frame hebben plaatsgevonden. Je gaat je maar om één gebeurtenis bekommeren, de quit-gebeurtenis. Dit gebeurt wanneer de gebruiker het spelvenster sluit. Dit zal ook voorkomen dat ons programma crasht door te veel evenementen.
while True: … voor gebeurtenis in pygame.event.get(): if event.type == QUIT: pygame.quit()
Stap 10. Probeer het uit
Zo zou de code er nu uit moeten zien:
import pygame van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = pygame.display.set_mode(resolutie) while True: screen.fill(white) pygame.display.flip() voor event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Deel 3 van 8: Een spelobject maken
Stap 1. Maak een nieuwe klasse en constructor
Stel alle eigenschappen van het object in. U geeft ook standaardwaarden op voor alle eigenschappen.
class Ball: def _init_(zelf, xPos = resolutie [0] / 2, yPos = resolutie [1] / 2, xVel = 1, yVel = 1, rad = 15): zelf.x = xPos zelf.y = yPos zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal"
Stap 2. Bepaal hoe het object moet worden getekend
Gebruik de eigenschappen die in de constructor zijn gedefinieerd om de bal als een cirkel te tekenen en om een oppervlak door te geven aan de functie waarop het object wordt getekend. Het oppervlak is het schermobject dat eerder met de resolutie is gemaakt.
def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius)
Stap 3. Maak een instantie van de klas en vertel de spellus om de bal in elke lus te tekenen
ball = Ball() terwijl True: … ball.draw(scherm)
Stap 4. Laat het object bewegen
Maak een functie die de positie van het object bijwerkt. Roep deze functie in elke spellus aan.
class Ball: … def update(self): self.x += self.dx self.y += self.dy
Stap 5. Beperk de framesnelheid
De bal zal heel snel bewegen omdat de spellus honderden keren per seconde wordt uitgevoerd. Gebruik de klok van Pygame om de framesnelheid te beperken tot 60 fps.
klok = pygame.time. Clock() terwijl True: … clock.tick(60)
Stap 6. Houd de bal op het scherm
Voeg vinkjes toe in de update-functie om de richting van de bal om te keren als deze een van de schermranden raakt.
class Ball: … def update(self): … if (self.x <= 0 of self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolutie [1]): zelf.dy *= -1
Stap 7. Probeer het uit
Zo zou de code er nu uit moeten zien:
import pygame van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = pygame.display.set_mode(resolutie) klasse Bal: def _init_(zelf, xPos = resolutie [0] / 2, yPos = resolutie [1] / 2, xVel = 1, yVel = 1, rad = 15): zelf.x = xPos zelf.y = yPos zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolution[1]): self.dy *= -1 ball = Ball() clock = pygame.time. Clock() while True: screen. fill(white) ball.draw(screen) ball.update() pygame.display.flip() clock.tick(60) voor event in pygame.event.get(): if event.type == QUIT: pygame.quit ()
Deel 4 van 8: Het spel organiseren
Stap 1. Gebruik klassen om alles te organiseren
Het spel wordt ingewikkelder. Gebruik objectgeoriënteerde technieken om uw code te ordenen.
Stap 2. Maak van de game een klas
Aangezien onze game nu gegevens bevat, waaronder je game-objecten en -functies, is het logisch om van je game-loop een klasse te maken.
klasse spel():
Stap 3. Voeg een constructor toe
Hier zul je enkele game-objecten instantiëren, ons scherm en onze klok maken en Pygame initialiseren. Pygame moet worden geïnitialiseerd om bepaalde functies zoals tekst of geluid te gebruiken.
class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock()
Stap 4. Gebeurtenissen in een functie afhandelen
class game(): … def handleEvents(self): voor evenement in pygame.event.get(): if event.type == QUIT: pygame.quit()
Stap 5. Maak van de gameloop een functie
Roep de gebeurtenisafhandelingsfunctie elke lus aan.
class game(): … def run(self): while True: self.handleEvents() self.screen.fill(white) self.clock.tick(60) pygame.display.flip()
Stap 6. Behandel meerdere game-objecten
Op dit moment moet deze code elk frame tekenen en bijwerken op ons object. Dit zou rommelig worden als je veel voorwerpen had. Laten we ons object aan een array toevoegen en vervolgens elke lus alle objecten in de array bijwerken en tekenen. Nu kun je eenvoudig een ander object toevoegen en het een andere startpositie geven.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) … def run(self): while True: self.handleEvents() voor gameObj in self.gameObjects: gameObj.update() self.screen.fill(wit) voor gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.omdraaien()
Stap 7. Probeer het uit
Zo zou de code er nu uit moeten zien:
import pygame van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = pygame.display.set_mode(resolutie) klasse Bal: def _init_(zelf, xPos = resolutie [0] / 2, yPos = resolutie [1] / 2, xVel = 1, yVel = 1, rad = 15): zelf.x = xPos zelf.y = yPos zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolution[1]): self.dy *= -1 class game(): 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): voor event in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvent s() voor gameObj in self.gameObjects: gameObj.update() self.screen.fill(wit) voor gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display. flip() spel().run()
Deel 5 van 8: Een spelersobject toevoegen
Stap 1. Maak een spelersklasse en constructor
Je gaat nog een cirkel maken die wordt bestuurd door de muis. Initialiseer de waarden in de constructor. De straal is de enige belangrijke waarde.
klasse Speler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Stap 2. Bepaal hoe het spelerobject moet worden getekend
Het zal op dezelfde manier zijn als waarop je de andere game-objecten hebt getekend.
klasse Speler: … def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius)
Stap 3. Voeg muisbesturing toe voor het spelerobject
Controleer in elk frame de locatie van de muis en stel de locatie van de spelersobjecten op dat punt in.
klasse Speler: … def update(self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1]
Stap 4. Voeg een spelerobject toe aan gameObjects
Maak een nieuwe spelerinstantie en voeg deze toe aan de lijst.
class game(): def _init_(self): … self.gameObjects.append(Player())
Stap 5. Probeer het uit
Zo zou de code er nu uit moeten zien:
import pygame van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = pygame.display.set_mode(resolutie) klasse Bal: def _init_(zelf, xPos = resolutie [0] / 2, yPos = resolutie [1] / 2, xVel = 1, yVel = 1, rad = 15): zelf.x = xPos zelf.y = yPos zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 of self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolution[1]): self.dy *= -1 class Speler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "speler" 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] class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_ mode(resolutie) 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.screen.fill(wit) voor gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game(). loop()
Deel 6 van 8: Objecten laten communiceren met de speler
Stap 1. Wijzig de update-functies
Om objecten met elkaar te laten communiceren, moeten ze toegang tot elkaar hebben. Laten we nog een parameter toevoegen aan Update om door te geven aan de gameObjects-lijst. Je moet het toevoegen aan zowel het player-object als de Ball-objecten. Als je veel game-objecten hebt, kan overerving je helpen om al je methode-handtekeningen hetzelfde te houden.
class Ball: … def update(self, gameObjects): … class Player: … def update(self, gameObjects):
Stap 2. Controleer op botsingen tussen de speler en de ballen
Doorloop alle game-objecten en controleer of het type object een bal is. Gebruik vervolgens de stralen van de twee objecten en de afstandsformule om te controleren of ze botsen. Cirkels zijn heel gemakkelijk om botsingen te controleren. Dit is de grootste reden dat je geen andere vorm hebt gebruikt voor dit spel.
class Player: … def update(self, gameObjects): … voor gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + zelf.radius)**2:
Stap 3. Beëindig het spel als de speler "geslagen" wordt
Laten we het spel nu maar stoppen.
if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit()
Stap 4. Probeer het uit
Dit is hoe de code er nu uit zou moeten zien:
import pygame van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = pygame.display.set_mode(resolutie) klasse Bal: def _init_(zelf, xPos = resolutie [0] / 2, yPos = resolutie [1] / 2, xVel = 1, yVel = 1, rad = 15): zelf.x = xPos zelf.y = yPos zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal" def draw(self, surface): pygame.draw.circle(surface, black, (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 >= resolution[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolution[1]): self.dy *= -1 class Speler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "speler" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] voor 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() 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): voor gebeurtenis in pygame.event.get(): if event.type == QUIT: pygame.quit () def run(self): while True: self.handleEvents() voor gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(white) voor gameObj in self.gameObjects: gameObj.draw(zelf.scherm) zelf.klok.tick(60) pygame.display.flip() game().run()
Deel 7 van 8: Een gamecontroller toevoegen om objecten te maken
Stap 1. Maak een gamecontroller-klasse aan
Gamecontrollers zijn verantwoordelijk voor het "runnen" van het spel. Het is anders dan onze gameklasse die verantwoordelijk is voor het tekenen en bijwerken van al onze objecten. De controller zal periodiek een nieuwe bal aan het scherm toevoegen om het spel moeilijker te maken. Voeg een constructor toe en initialiseer enkele basiswaarden. Het interval is de tijd voordat een andere bal wordt toegevoegd.
class GameController: def _init_(self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "gamecontroller"
Stap 2. Voeg de update-functie toe
Hiermee wordt gecontroleerd hoeveel tijd er is verstreken sinds het moment dat een bal is toegevoegd of vanaf het begin van het spel. Als de tijd langer is dan het interval, stelt u de tijd opnieuw in en voegt u een bal toe.
class 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. Geef de ballen willekeurige snelheden
Je moet willekeurige getallen gebruiken om het spel elke keer anders te maken. De snelheden van de ballen zijn nu echter een getal met drijvende komma in plaats van een geheel getal.
class 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=willekeurig()*2, yVel=willekeurig()*2))
Stap 4. Corrigeer de tekenfunctie
De draw-functie accepteert geen floats. Laten we de positie van de bal converteren naar gehele getallen voordat de ballen worden getrokken.
class Ball: … def draw(self, surface): pygame.draw.circle(surface, black, (int(self.x), int(self.y)), self.radius)
Stap 5. Definieer een tekenmethode voor de gamecontroller
Omdat het een spelobject is, zal de hoofdlus proberen het te tekenen. U moet een tekenfunctie definiëren die niets doet, zodat het spel niet crasht.
class GameController: … def draw(self, screen): pass
Stap 6. Voeg de gamecontroller toe aan gameObjects en verwijder de 2 ballen
Het spel zou nu elke vijf seconden een bal moeten spawnen.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player())
Stap 7. Probeer het uit
Zo zou de code er nu uit moeten zien:
import pygame van willekeurig import willekeurig van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = 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 zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal" 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 of self. x >= resolutie[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolutie[1]): self.dy *= -1 class Speler: def _init_(self, rad = 20): zelf.x = 0 zelf.y = 0 zelf.straal = rad zelf.type = "speler" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] voor gameObj in game Objecten: if gameObj.type == "ball": 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 = "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=willekeurig) ()*2, yVel=random()*2)) def draw(self, screen): pass class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolutie) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) def handleEvents(self): voor gebeurtenis in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() voor gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(wit) voor gameObj in self.gameO bjecten: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Deel 8 van 8: Een score en game-over toevoegen
Stap 1. Voeg een score toe aan de gamecontrollerklasse
Maak een font-object en een scorevariabele. Je tekent het lettertype in elk frame om de score weer te geven en verhoogt de score elk frame in de update.
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 (zelf, scherm): screen.blit(self.scoreText.render(str(self.score), True, zwart), (5, 5))
Stap 2. Wijzig hoe het spel eindigt
Laten we stoppen met stoppen wanneer de speler een botsing detecteert. In plaats daarvan stel je een variabele in de speler in die het spel kan controleren. Als gameOver is ingesteld, stop je met het bijwerken van objecten. Dit zal alles op zijn plaats bevriezen, zodat de speler kan zien wat er is gebeurd en zijn score kan controleren. Merk op dat de objecten nog steeds worden getekend, alleen niet bijgewerkt.
klasse Speler: def _init_(self, rad = 20): … self.gameOver = False def update(self, gameObjects): … voor 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 = False def run(self): while True: self.handleEvents() if not self.gameOver: for gameObj in self.gameObjects: gameObj.update(self.gameObjects) if gameObj.type == "player": zelf.gameOver = gameObj.gameOver
Stap 3. Probeer het uit
Dit is hoe de voltooide code er nu uit zou moeten zien:
import pygame van willekeurig import willekeurig van pygame.locals import * resolutie = (400, 300) wit = (255, 255, 255) zwart = (0, 0, 0) rood = (255, 0, 0) scherm = pygame. display.set_mode(resolutie) 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 zelf.dx = xVel zelf.dy = yVel zelf.radius = rad zelf.type = "bal" 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 of self. x >= resolutie[0]): self.dx *= -1 if (self.y <= 0 of self.y >= resolutie[1]): self.dy *= -1 class Speler: def _init_(self, rad = 20): zelf.x = 0 zelf.y = 0 zelf.straal = rad zelf.type = "speler" zelf.gameOver = False def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] voor 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 GameController: def _init_(self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks() + (2 * 1000) self. type = "gamecontroller" 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=willekeurig()*2, yVel=willekeurig()*2)) self.score += 1 def 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 = False def handleEvents(self): voor event in pygame.event.get(): if ev ent.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() if not self.gameOver: voor gameObj in self.gameObjects: gameObj.update(self.gameObjects) als gameObj. type == "speler": self.gameOver = gameObj.gameOver self.screen.fill(wit) voor gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip () spel().run()
