Aquesta és una introducció a Pygame per a persones que ja coneixen Python. Aquest article us ensenyarà els passos per construir un joc senzill que faci que el jugador esquivi boles que reboten.
Passos
Part 1 de 8: Instal·lació de Pygame
Pas 1. Descarregueu Pygame
Cerqueu-lo per a la vostra plataforma a
Pas 2. Executeu l'instal·lador
Pas 3. Verifiqueu que la instal·lació hagi funcionat
Obriu un terminal Python. Escriviu "importa Pygame". Si no veieu cap error, llavors Pygame s'ha instal·lat correctament.
importa Pygame
Part 2 de 8: Configuració d'una finestra bàsica
Pas 1. Obriu un fitxer nou
Pas 2. Importa Pygame
Pygame és una biblioteca que proporciona accés a funcions gràfiques. Si voleu obtenir més informació sobre el funcionament d’aquestes funcions, podeu consultar-les al lloc web de Pygame.
importa pygame des de pygame.locals import *
Pas 3. Definiu la resolució de la finestra
Fareu una variable global per a la resolució de la pantalla de manera que es pugui fer referència a diverses parts del joc. També és fàcil trobar-lo a la part superior del fitxer perquè es pugui canviar més endavant. Per a projectes avançats, posar aquesta informació en un fitxer separat seria una millor idea.
resolució = (400, 300)
Pas 4. Definiu alguns colors
Els colors en pygame són (RBGA que oscil·la entre 0 i 255. El valor alfa (A) és opcional, però els altres colors (vermell, blau i verd són obligatoris).
blanc = (255, 255, 255) negre = (0, 0, 0) vermell = (255, 0, 0)
Pas 5. Inicialitzeu la pantalla
Utilitzeu la variable de resolució definida anteriorment.
screen = pygame.display.set_mode (resolució)
Pas 6. Feu un bucle de joc
Repetiu certes accions en tots els fotogrames del nostre joc. Feu un bucle que sempre es repetirà per recórrer totes aquestes accions.
mentre que és cert:
Pas 7. Acoloreix la pantalla
screen.fill (blanc)
Pas 8. Mostra la pantalla
Si executeu el programa, la pantalla es tornarà blanca i el programa es bloquejarà. Això es deu al fet que el sistema operatiu envia esdeveniments al joc i el joc no fa res amb ells. Un cop el joc rebi massa esdeveniments no gestionats, es bloquejarà.
mentre és cert: … pygame.display.flip ()
Pas 9. Manejar els esdeveniments
Obteniu una llista de tots els esdeveniments que s'han produït a cada fotograma. Només us importarà un esdeveniment, l’esdeveniment de deixar de fumar. Això passa quan l'usuari tanca la finestra del joc. Això també evitarà que el nostre programa falli a causa de massa esdeveniments.
mentre que True: … per a esdeveniments a pygame.event.get (): si event.type == QUIT: pygame.quit ()
Pas 10. Proveu-ho
A continuació s’explica el codi:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode (resolució) mentre que True: screen.fill (blanc) pygame.display.flip () per a esdeveniments a pygame.event.get (): si event.type == QUIT: pygame.quit ()
Part 3 de 8: Fer un objecte de joc
Pas 1. Feu una nova classe i un constructor
Definiu totes les propietats de l'objecte. També proporcioneu valors predeterminats per a totes les propietats.
classe Ball: def _init _ (self, xPos = resolució [0] / 2, yPos = resolució [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 = "pilota"
Pas 2. Definiu com dibuixar l'objecte
Utilitzeu les propietats definides al constructor per dibuixar la bola com un cercle, així com per passar una superfície a la funció on dibuixar l’objecte. La superfície serà l'objecte de pantalla que s'ha creat amb la resolució anterior.
dibuix per defecte (self, surface): pygame.draw.circle (superfície, negre, (self.x, self.y), self.radius)
Pas 3. Feu una instància de la classe a més de dir al bucle del joc que dibuixi la pilota a cada bucle
ball = Ball () mentre que True:… ball.draw (pantalla)
Pas 4. Feu que l’objecte es mogui
Creeu una funció que actualitzarà la posició de l'objecte. Anomeneu aquesta funció a tots els bucles del joc.
classe Ball:… def update (self): self.x + = self.dx self.y + = self.dy
Pas 5. Limiteu la velocitat de fotogrames
La pilota es mourà molt ràpid perquè el bucle del joc s’executa centenars de vegades per segon. Utilitzeu el rellotge de Pygame per limitar la velocitat de fotogrames a 60 fps.
clock = pygame.time. Clock () mentre és True:… clock.tick (60)
Pas 6. Mantingueu la pilota a la pantalla
Afegiu xecs a la funció d'actualització per invertir la direcció de la pilota si toca una de les vores de la pantalla.
classe Ball: … def update (auto): … if (self.x <= 0 o self.x> = resolució [0]): self.dx * = -1 if (self.y <= 0 o self.y > = resolució [1]): self.dy * = -1
Pas 7. Proveu-ho
A continuació s’explica el codi:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode (resolució) classe Bola: def _init _ (self, xPos = resolució [0] / 2, yPos = resolució [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 = dibuix de "bola" (self, superfície): pygame.draw.circle (superfície, negre, (self.x, self.y), self.radius) def update (auto): self.x + = self.dx self.y + = self.dy si (self.x <= 0 o self.x> = resolució [0]): self.dx * = -1 if (self.y <= 0 o self.y> = resolució [1]): self.dy * = -1 ball = Ball () clock = pygame.time. Clock () mentre True: screen. 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 ()
Part 4 de 8: organització del joc
Pas 1. Utilitzeu les classes per organitzar-ho tot
El joc es complicarà. Utilitzeu tècniques orientades a objectes per organitzar el vostre codi.
Pas 2. Converteix el bucle del joc en una classe
Com que ara el nostre joc té dades que inclouen els vostres objectes i funcions, és lògic convertir el vostre bucle de joc en una classe.
joc de classe ():
Pas 3. Afegiu un constructor
Aquí instanciarà alguns objectes del joc, crearà la nostra pantalla i rellotge i inicialitzarà Pygame. Cal inicialitzar Pygame per utilitzar determinades funcions, com ara text o so.
joc de classe (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolution) self.clock = pygame.time. Clock ()
Pas 4. Manejar esdeveniments en una funció
class game ():… def handleEvents (self): per a esdeveniment a pygame.event.get (): si event.type == QUIT: pygame.quit ()
Pas 5. Feu que el bucle del joc funcioni
Truqueu a la funció de tractament d'esdeveniments cada bucle.
class game ():… def run (self): while True: self.handleEvents () self.screen.fill (blanc) self.clock.tick (60) pygame.display.flip ()
Pas 6. Manejar diversos objectes de joc
Ara mateix, aquest codi ha de cridar dibuixar i actualitzar cada objecte del nostre objecte. Això quedaria desordenat si tinguéssiu molts objectes. Afegim el nostre objecte a una matriu i actualitzem i dibuixem tots els objectes de la matriu cada bucle. Ara podeu afegir fàcilment un altre objecte i donar-li una posició inicial diferent.
class game (): def _init _ (self):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): mentre que True: self.handleEvents () per gameObj a self.gameObjects: gameObj.update () self.screen.fill (blanc) per gameObj a self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Pas 7. Proveu-ho
A continuació s’explica el codi:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode (resolució) classe Bola: def _init _ (self, xPos = resolució [0] / 2, yPos = resolució [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 = "bola" def draw (auto, superfície): pygame.draw.circle (superfície, negre, (self.x, self.y), self.radius) def update (auto): self.x + = self.dx self.y + = self.dy si (self.x <= 0 o self.x> = resolució [0]): self.dx * = -1 si (self.y <= 0 o self.y> = resolució [1]): self.dy * = -1 joc de classe (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolució) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): per a esdeveniments a pygame.event.get (): si event.type == QUIT: pygame.quit () def run (self): mentre que True: self.handleEvent s () per gameObj a self.gameObjects: gameObj.update () self.screen.fill (blanc) per gameObj a self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () game (). run ()
Part 5 de 8: Afegir un objecte de jugador
Pas 1. Feu una classe de jugador i un constructor
Fareu un altre cercle controlat pel ratolí. Inicialitzeu els valors del constructor. El radi és l’únic valor important.
Class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Pas 2. Definiu com dibuixar l'objecte del jugador
Serà de la mateixa manera que vau dibuixar els altres objectes del joc.
Class Player:… def draw (self, surface): pygame.draw.circle (superfície, vermell, (self.x, self.y), self.radius)
Pas 3. Afegiu el control del ratolí per a l'objecte del reproductor
A cada fotograma, comproveu la ubicació del ratolí i configureu la ubicació dels objectes dels jugadors en aquest punt.
Class Player:… def update (auto): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Pas 4. Afegiu un objecte de jugador a gameObjects
Creeu una nova instància de reproductor i afegiu-la a la llista.
joc de classe (): def _init _ (self):… self.gameObjects.append (Player ())
Pas 5. Proveu-ho
A continuació s’explica el codi:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode (resolució) classe Bola: def _init _ (auto, xPos = resolució [0] / 2, yPos = resolució [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 = dibuix de "bola" (self, superfície): pygame.draw.circle (superfície, negre, (self.x, self.y), self.radius) def update (auto): self.x + = self.dx self.y + = self.dy si (self.x <= 0 o self.x> = resolució [0]): self.dx * = -1 if (self.y <= 0 o self.y> = resolució [1]): self.dy * = -1 class Jugador: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "jugador" dibuix def (self, superfície): pygame.draw.circle (superfície, vermell, (self.x, self.y), self.radius) actualització def (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 (resolució) 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 (blanc) per gameObj a self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). correr()
Part 6 de 8: Interacció d'objectes amb el jugador
Pas 1. Canvieu les funcions d'actualització
Per tal que els objectes puguin interactuar, hauran de tenir accés els uns als altres. Afegim un altre paràmetre a Actualització per passar a la llista gameObjects. L'haureu d'afegir tant a l'objecte del jugador com als objectes Ball. Si teniu molts objectes de joc, l'herència us pot ajudar a mantenir iguals totes les signatures del vostre mètode.
class Ball: … def actualització (self, gameObjects): … class Player: … def actualització (self, gameObjects):
Pas 2. Comproveu si hi ha col·lisions entre el jugador i les boles
Reviseu tots els objectes del joc i comproveu si el tipus d’objectes és bola. A continuació, utilitzeu els radis dels dos objectes i la fórmula de la distància per comprovar si xoquen. Els cercles són molt fàcils de comprovar les col·lisions. Aquest és el motiu principal pel qual no heu utilitzat cap altra forma per a aquest joc.
class Jugador:… def actualització (self, gameObjects):… per gameObj a gameObjects: if gameObj.type == "pilota": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Pas 3. Acabeu la partida si el jugador rep "cop"
Deixem el joc per ara.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Pas 4. Proveu-ho
A continuació s’explica el codi:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode (resolució) classe Bola: def _init _ (auto, xPos = resolució [0] / 2, yPos = resolució [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 = "bola" def draw (auto, superfície): pygame.draw.circle (superfície, negre, (self.x, self.y), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 o self.x> = resolució [0]): self.dx * = -1 if (self.y <= 0 o self.y> = resolució [1]): self.dy * = -1 Class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = dibuix de "jugador" (self, superfície): pygame.draw.circle (superfície, vermell, (self.x, self.y), self.radius) actualització per defecte (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] per gameObj a gameObjects: si gameObj.type == "pilota": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () joc de classe (): 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): per a esdeveniments a pygame.event.get (): si event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () per gameObj a self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (blanc) per gameObj a self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Part 7 de 8: Afegir un controlador de joc per crear objectes
Pas 1. Creeu una classe de controladors de jocs
Els controladors de jocs són responsables de "executar" el joc. És diferent de la nostra classe de jocs que s’encarrega de dibuixar i actualitzar tots els nostres objectes. Periòdicament, el controlador afegirà una altra bola a la pantalla per dificultar el joc. Afegiu un constructor i inicialitzeu alguns valors bàsics. L'interval serà el temps abans que s'afegeixi una altra pilota.
class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "controlador de joc"
Pas 2. Afegiu la funció d'actualització
Això comprovarà quant ha passat el temps des que es va afegir una pilota o des del començament del joc. Si el temps és superior a l'interval, restablireu el temps i afegirà una bola.
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 ()))
Pas 3. Doneu a les boles velocitats aleatòries
Haureu d’utilitzar números aleatoris per fer que el joc sigui diferent cada vegada. Tot i això, les velocitats de les boles ara són un número de coma flotant en lloc d’un nombre enter.
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 = random () * 2, yVel = random () * 2))
Pas 4. Corregiu la funció de dibuix
La funció de dibuix no accepta flotacions. Convertim la posició de la bola a enters abans que es dibuixin les boles.
classe Ball: … def draw (self, superfície): pygame.draw.circle (superfície, negre, (int (self.x), int (self.y)), self.radius)
Pas 5. Definiu un mètode de dibuix per al controlador del joc
Com que és un objecte de joc, el bucle principal intentarà dibuixar-lo. Haureu de definir una funció de dibuix que no faci res perquè el joc no falli.
classe GameController: … def draw (auto, pantalla): pass
Pas 6. Afegiu el controlador del joc a gameObjects i traieu les 2 boles
Ara el joc hauria de generar una pilota cada cinc segons.
class game (): def _init _ (self):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Pas 7. Proveu-ho
A continuació s’explica el codi:
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 = resolució [0] / 2, yPos = resolució [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 = "bola" def draw (auto, superfície): pygame.draw.circle (superfície, negre, (int (auto. x), int (self.y)), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy si (self.x <= 0 o self. x> = resolució [0]): self.dx * = -1 if (self.y <= 0 o self.y> = resolució [1]): self.dy * = -1 class Jugador: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "jugador" def draw (self, superfície): pygame.draw.circle (superfície, vermell, (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 Objectes: if gameObj.type == "pilota": 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 = "controlador de jocs "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): per a esdeveniments a 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.fill (blanc) per gameObj a self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Part 8 de 8: Afegir una puntuació i acabar el joc
Pas 1. Afegiu una puntuació a la classe de controlador de joc
Creeu un objecte de tipus de lletra i una variable de puntuació. Dibuixareu el tipus de lletra a cada fotograma per mostrar la puntuació i augmentar la puntuació a cada fotograma actualitzat.
class GameController: def _init _ (self, interval = 5): … self.score = 0 self.scoreText = pygame.font. Font (None, 12) def update (self, gameObjects): … self.score + = 1 draw draw (self, screen): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Pas 2. Modifiqueu com acaba el joc
Desfem-nos de l’abandonament quan el jugador detecti una col·lisió. En lloc d'això, establireu una variable al jugador que el joc pot comprovar. Quan gameOver està configurat, deixeu d'actualitzar objectes. Això congelarà tot el seu lloc perquè el jugador pugui veure què ha passat i comprovar la seva puntuació. Tingueu en compte que els objectes encara es dibuixen, però no s’actualitzen.
class Jugador: def _init _ (self, rad = 20):… self.gameOver = Actualització def falsa (self, gameObjects):… per gameObj a gameObjects: if gameObj.type == "pilota": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Joc de classe vertadera (): def _init _ (self): … self.gameOver = False def run (self): while True: self.handleEvents () si no self.gameOver: per gameObj a self.gameObjects: gameObj.update (self.gameObjects) si gameObj.type == "jugador": self.gameOver = gameObj.gameOver
Pas 3. Proveu-ho
A continuació s’explica el codi acabat:
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 = resolució [0] / 2, yPos = resolució [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 = "bola" def draw (auto, superfície): pygame.draw.circle (superfície, negre, (int (auto. x), int (self.y)), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy si (self.x <= 0 o self. x> = resolució [0]): self.dx * = -1 if (self.y <= 0 o self.y> = resolució [1]): self.dy * = -1 class Jugador: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "jugador" self.gameOver = Dibuix fals def (self, superfície): pygame.draw.circle (superfície, vermell, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] per gameObj a gameObjects: if gameObj.type == "pilota": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = GameController de classe veritable: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self. type = "controlador de 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 (auto, pantalla): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) joc de classe (): 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 = Fals def handleEvents (self): per a esdeveniments a pygame.event.get (): si ev ent.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () si no self.gameOver: per gameObj en self.gameObjects: gameObj.update (self.gameObjects) si gameObj. escriviu == "jugador": self.gameOver = gameObj.gameOver self.screen.fill (blanc) per gameObj a self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
