Dette er en introduksjon til Pygame for folk som allerede kjenner Python. Denne artikkelen vil lære deg trinnene for å bygge et enkelt spill som har spilleren som unngår hoppende baller.
Trinn
Del 1 av 8: Installere Pygame
Trinn 1. Last ned Pygame
Finn den for plattformen din fra
Trinn 2. Kjør installasjonsprogrammet
Trinn 3. Kontroller at installasjonen fungerte
Åpne en Python -terminal. Skriv "import pygame." Hvis du ikke ser noen feil, ble Pygame installert.
importer pygame
Del 2 av 8: Sette opp et grunnleggende vindu
Trinn 1. Åpne en ny fil
Trinn 2. Importer Pygame
Pygame er et bibliotek som gir tilgang til grafikkfunksjoner. Hvis du vil ha mer informasjon om hvordan disse funksjonene fungerer, kan du slå dem opp på nettstedet til Pygame.
importer pygame fra pygame.locals import *
Trinn 3. Still inn vinduets oppløsning
Du lager en global variabel for skjermoppløsningen, slik at den kan refereres til i flere deler av spillet. Det er også enkelt å finne øverst i filen, slik at den kan endres senere. For avanserte prosjekter er det bedre å sette denne informasjonen i en egen fil.
oppløsning = (400, 300)
Trinn 4. Definer noen farger
Farger i pygame er (RBGA som varierer i verdier mellom 0 og 255. Alfa -verdien (A) er valgfri, men de andre fargene (rød, blå og grønn er obligatorisk).
hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0)
Trinn 5. Initialiser skjermen
Bruk oppløsningsvariabelen som ble definert tidligere.
skjerm = pygame.display.set_mode (oppløsning)
Trinn 6. Lag en spillløkke
Gjenta visse handlinger i alle rammer i spillet vårt. Lag en løkke som alltid vil gjenta seg for å bla gjennom alle disse handlingene.
mens det er sant:
Trinn 7. Farg skjermen
skjerm. fyll (hvit)
Trinn 8. Vis skjermen
Hvis du kjører programmet, blir skjermen hvit og deretter krasjer programmet. Dette er fordi operativsystemet sender hendelser til spillet og spillet ikke gjør noe med dem. Når spillet mottar for mange ubehandlede hendelser, krasjer det.
mens det er sant: … pygame.display.flip ()
Trinn 9. Håndtere hendelser
Få en liste over alle hendelser som har skjedd i hver ramme. Du kommer bare til å bry deg om en hendelse, avslutt hendelsen. Dette skjer når brukeren lukker spillvinduet. Dette vil også forhindre at programmet krasjer på grunn av for mange hendelser.
while True: … for event in pygame.event.get (): if event.type == QUIT: pygame.quit ()
Trinn 10. Prøv det
Slik skal koden se ut nå:
importer pygame fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame.display.set_mode (oppløsning) mens True: screen.fill (hvit) pygame.display.flip () for hendelse i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Del 3 av 8: Lag et spillobjekt
Trinn 1. Lag en ny klasse og konstruktør
Angi alle egenskapene til objektet. Du oppgir også standardverdier for alle eiendommene.
klasse 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 = "ball"
Trinn 2. Definer hvordan du tegner objektet
Bruk egenskapene som ble definert i konstruktøren for å tegne ballen som en sirkel, så vel som å føre en overflate inn i funksjonen for å tegne objektet på. Overflaten vil være skjermobjektet som ble opprettet ved hjelp av oppløsningen tidligere.
def draw (selv, overflate): pygame.draw.circle (overflate, svart, (self.x, self.y), self.radius)
Trinn 3. Gjør en forekomst av klassen, så vel som å be spillesløyfen om å tegne ballen i hver løkke
ball = Ball () mens True: … ball.draw (skjerm)
Trinn 4. Få objektet til å bevege seg
Lag en funksjon som oppdaterer posisjonen til objektet. Kall denne funksjonen i hver spillløkke.
klasse Ball: … def oppdatering (self): self.x += self.dx self.y += self.dy
Trinn 5. Begrens bildefrekvensen
Ballen vil bevege seg veldig fort fordi spillesløyfen går hundrevis av ganger i sekundet. Bruk Pygames klokke for å begrense bildefrekvensen til 60 bps.
klokke = pygame.time. Clock () mens True: … clock.tick (60)
Trinn 6. Hold ballen på skjermen
Legg til sjekker i oppdateringsfunksjonen for å snu ballens retning hvis den treffer en av skjermkantene.
klasse Ball:… def oppdatering (self):… if (self.x <= 0 eller self.x> = oppløsning [0]): self.dx *= -1 if (self.y <= 0 eller self.y > = oppløsning [1]): self.dy *= -1
Trinn 7. Prøv det
Slik skal koden se ut nå:
importer pygame fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame.display.set_mode (oppløsning) klasse 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 = "ball" def draw (self, surface): pygame.draw.circle (overflate, svart, (self.x, self.y), self.radius) def oppdatering (self): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self.x> = oppløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = oppløsning [1]): self.dy *= -1 ball = Ball () klokke = pygame.time. Clock () mens True: skjermen. fyll (hvit) ball.draw (skjerm) ball.update () pygame.display.flip () clock.tick (60) for hendelse i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Del 4 av 8: Organisering av spillet
Trinn 1. Bruk klasser til å organisere alt
Spillet kommer til å bli mer komplisert. Bruk objektorienterte teknikker for å organisere koden din.
Trinn 2. Gjør spillesløyfen til en klasse
Siden spillet vårt nå har data inkludert spillobjekter og funksjoner, er det fornuftig å gjøre spillløkken til en klasse.
klassespill ():
Trinn 3. Legg til en konstruktør
Her vil du instantiere noen spillobjekter, lage skjermen og klokken vår og initialisere Pygame. Pygame må initialiseres for å bruke visse funksjoner som tekst eller lyd.
klassespill (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (oppløsning) self.clock = pygame.time. Clock ()
Trinn 4. Håndter hendelser i en funksjon
class game (): … def handleEvents (self): for event in pygame.event.get (): if event.type == QUIT: pygame.quit ()
Trinn 5. Gjør spillløkken til en funksjon
Ring hendelseshåndteringsfunksjonen hver sløyfe.
klassespill (): … def run (self): while True: self.handleEvents () self.screen.fill (white) self.clock.tick (60) pygame.display.flip ()
Trinn 6. Håndter flere spillobjekter
Akkurat nå må denne koden kalle draw og oppdatere på objektet vårt hver ramme. Dette ville bli rotete hvis du hadde mange gjenstander. La oss legge til objektet vårt i en matrise og deretter oppdatere og tegne alle objektene i matrisen hver sløyfe. Nå kan du enkelt legge til et annet objekt og gi det en annen startposisjon.
klassespill (): def _init _ (self): … self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) … def run (self): mens True: self.handleEvents () for gameObj i self.gameObjects: gameObj.update () self.screen.fill (hvit) for gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Trinn 7. Prøv det
Slik skal koden se ut nå:
importer pygame fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame.display.set_mode (oppløsning) klasse 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 = "ball" def draw (self, surface): pygame.draw.circle (overflate, svart, (self.x, self.y), self.radius) def oppdatering (self): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self.x> = oppløsning [0]): self.dx *= -1 if (self.y <= 0 or self.y> = resolution [1]): self.dy *= -1 class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (oppløsning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): for hendelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvent s () for gameObj i self.gameObjects: gameObj.update () self.screen.fill (hvit) for gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () game (). run ()
Del 5 av 8: Legge til et spillerobjekt
Trinn 1. Lag en spillerklasse og konstruktør
Du kommer til å lage en annen sirkel som styres av musen. Initialiser verdiene i konstruktøren. Radius er den eneste viktige verdien.
klasse Spiller: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Trinn 2. Definer hvordan du tegner spillerobjektet
Det kommer til å være på samme måte som du tegnet de andre spillobjektene.
klasse Spiller: … def draw (self, surface): pygame.draw.circle (overflate, rød, (self.x, self.y), self.radius)
Trinn 3. Legg til musekontroll for spillerobjektet
I hver ramme må du kontrollere plasseringen av musen og sette plasseringen av spillerobjektene til det punktet.
class Player: … def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Trinn 4. Legg til et spillerobjekt i gameObjects
Lag en ny spillerforekomst og legg den til på listen.
klassespill (): def _init _ (self): … self.gameObjects.append (Player ())
Trinn 5. Prøv det
Slik skal koden se ut nå:
importer pygame fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame.display.set_mode (oppløsning) klasse 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 = "ball" def draw (self, surface): pygame.draw.circle (overflate, svart, (self.x, self.y), self.radius) def oppdatering (self): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self.x> = oppløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = oppløsning [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "spiller" def draw (self, surface): pygame.draw.circle (overflate, rød, (self.x, self.y), self.radius) def oppdatering (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_ modus (oppløsning) 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 (hvit) for gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). løpe()
Del 6 av 8: Få objekter til å samhandle med spilleren
Trinn 1. Endre oppdateringsfunksjonene
For at objekter skal samhandle, må de ha tilgang til hverandre. La oss legge til en annen parameter i Update for å passere i gameObjects -listen. Du må legge den til både spillerobjektet og Ballobjektene. Hvis du har mange spillobjekter, kan arv hjelpe deg med å holde alle metodesignaturene dine like.
klasse Ball:… def oppdatering (self, gameObjects):… class Player:… def update (self, gameObjects):
Trinn 2. Se etter kollisjoner mellom spilleren og ballene
Gå gjennom alle spillobjektene og sjekk om objektets type er ball. Bruk deretter de to objektenes radier og avstandsformelen for å sjekke om de kolliderer. Sirkler er veldig enkle å kontrollere kollisjoner på. Dette er den største grunnen til at du ikke brukte noen annen form for dette spillet.
class Player:… def update (self, gameObjects):… for gameObj i gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Trinn 3. Avslutt spillet hvis spilleren får "hit"
La oss bare avslutte spillet for nå.
hvis (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Trinn 4. Prøv det
Slik skal koden se ut nå:
importer pygame fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame.display.set_mode (oppløsning) klasse 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 = "ball" def draw (self, surface): pygame.draw.circle (overflate, svart, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = oppløsning [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "spiller" def draw (self, surface): pygame.draw.circle (overflate, rød, (self.x, self.y), self.radius) def oppdatering (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj i gameObjects: if gameObj.type == "ball": hvis (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klassespill (): 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 hendelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj i self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (hvit) for gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Del 7 av 8: Legge til en spillkontroller for å lage objekter
Trinn 1. Lag en spillkontrollerklasse
Spillkontrollører er ansvarlige for å "kjøre" spillet. Det er forskjellig fra spillklassen vår som er ansvarlig for å tegne og oppdatere alle objektene våre. Kontrolleren vil med jevne mellomrom legge til en annen ball på skjermen for å gjøre spillet vanskeligere. Legg til en konstruktør og initialiser noen grunnleggende verdier. Intervallet vil være tiden før en annen ball legges til.
klasse GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller"
Trinn 2. Legg til oppdateringsfunksjonen
Dette vil kontrollere hvor lang tid som har gått siden ballen ble lagt til eller fra starten av spillet. Hvis tiden er mer enn intervallet, tilbakestiller du tiden og legger til en ball.
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 ())
Trinn 3. Gi ballene tilfeldige hastigheter
Du må bruke tilfeldige tall for å gjøre spillet annerledes hver gang. Imidlertid er kulenes hastigheter nå et flytende tall i stedet for et heltall.
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 = tilfeldig ()*2, yVel = tilfeldig ()*2))
Trinn 4. Fix tegnefunksjonen
Tegnfunksjonen godtar ikke flyter. La oss konvertere ballens posisjon til heltall før ballene trekkes.
klasse Ball: … def draw (self, surface): pygame.draw.circle (overflate, svart, (int (self.x), int (self.y)), self.radius)
Trinn 5. Definer en uavgjort metode for spillkontrolleren
Siden det er et spillobjekt, vil hovedløkken prøve å tegne det. Du må definere en trekkfunksjon som ikke gjør noe, slik at spillet ikke krasjer.
klasse GameController: … def draw (self, screen): pasning
Trinn 6. Legg spillkontrolleren til gameObjects og fjern de to ballene
Spillet skal nå gyte en ball hvert femte sekund.
klassespill (): def _init _ (self): … self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Trinn 7. Prøv det
Slik skal koden se ut nå:
importer pygame fra tilfeldig import tilfeldig fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame. display.set_mode (oppløsning) klasse 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 = "ball" def draw (self, surface): pygame.draw.circle (overflate, svart, (int (self. x), int (self.y)), self.radius) def oppdatering (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self. x> = oppløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = oppløsning [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "spiller" def draw (self, surface): pygame.draw.circle (overflate, rød, (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 i spillet Objekter: hvis gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klasse GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "spillkontroller "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 = tilfeldig ()*2)) def draw (selv, skjerm): bestått klassespill (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (oppløsning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): for hendelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj i self.gameObjects: gameObj.update (self.gameObjects) self.screen.fyll (hvit) for gameObj i self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Del 8 av 8: Legge til en score og spillet er over
Trinn 1. Legg til en poengsum i spillkontrollerklassen
Lag et fontobjekt og en score -variabel. Du tegner skriften i hver ramme for å vise poengsummen og øke poengsummen for hver ramme i oppdateringen.
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, black), (5, 5))
Trinn 2. Endre hvordan spillet ender
La oss bli kvitt avslutningen når spilleren oppdager en kollisjon. I stedet vil du angi en variabel i spilleren som spillet kan kontrollere. Når gameOver er angitt, må du slutte å oppdatere objekter. Dette vil fryse alt på plass slik at spilleren kan se hva som skjedde og sjekke poengsummen sin. Vær oppmerksom på at objektene fortsatt tegnes, bare ikke oppdateres.
class Player: def _init _ (self, rad = 20):… self.gameOver = False def update (self, gameObjects):… for gameObj i 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 = Falsk def run (self): mens True: self.handleEvents () hvis ikke self.gameOver: for gameObj i self.gameObjects: gameObj.update (self.gameObjects) hvis gameObj.type == "player": self.gameOver = gameObj.gameOver
Trinn 3. Prøv det
Slik skal den ferdige koden se ut nå:
importer pygame fra tilfeldig import tilfeldig fra pygame.locals import * oppløsning = (400, 300) hvit = (255, 255, 255) svart = (0, 0, 0) rød = (255, 0, 0) skjerm = pygame. display.set_mode (oppløsning) klasse 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 = "ball" def draw (self, surface): pygame.draw.circle (overflate, svart, (int (self. x), int (self.y)), self.radius) def oppdatering (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self. x> = oppløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller 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 = "player" self.gameOver = Falsk def draw (selv, overflate): pygame.draw.circle (overflate, rød, (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 i gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = TrueClass GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2*1000) self. type = "spillkontroller" 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)) class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (oppløsning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (self): for hendelse i pygame.event.get (): hvis 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. type == "spiller": self.gameOver = gameObj.gameOver self.screen.fill (hvit) for gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
