Ceci est une introduction à Pygame pour les personnes qui connaissent déjà Python. Cet article vous apprendra les étapes à suivre pour créer un jeu simple dans lequel le joueur évite les balles rebondissantes.
Pas
Partie 1 sur 8: Installation de Pygame
Étape 1. Téléchargez Pygame
Trouvez-le pour votre plate-forme à partir de
Étape 2. Exécutez le programme d'installation
Étape 3. Vérifiez que l'installation a fonctionné
Ouvrez un terminal Python. Tapez "importer pygame". Si vous ne voyez aucune erreur, Pygame a été installé avec succès.
importer pygame
Partie 2 sur 8: Configuration d'une fenêtre de base
Étape 1. Ouvrez un nouveau fichier
Étape 2. Importez Pygame
Pygame est une bibliothèque qui donne accès à des fonctions graphiques. Si vous souhaitez plus d'informations sur le fonctionnement de ces fonctions, vous pouvez les rechercher sur le site Web de Pygame.
importer pygame depuis pygame.locals importer *
Étape 3. Définissez la résolution de la fenêtre
Vous allez créer une variable globale pour la résolution de l'écran afin qu'elle puisse être référencée dans plusieurs parties du jeu. Il est également facile à trouver en haut du fichier afin qu'il puisse être modifié ultérieurement. Pour les projets avancés, mettre ces informations dans un fichier séparé serait une meilleure idée.
résolution = (400, 300)
Étape 4. Définissez des couleurs
Les couleurs dans pygame sont (RBGA dont les valeurs sont comprises entre 0 et 255. La valeur alpha (A) est facultative mais les autres couleurs (rouge, bleu et vert sont obligatoires).
blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0)
Étape 5. Initialisez l'écran
Utilisez la variable de résolution qui a été définie précédemment.
screen = pygame.display.set_mode (résolution)
Étape 6. Faites une boucle de jeu
Répétez certaines actions dans chaque image de notre jeu. Faites une boucle qui se répétera toujours pour parcourir toutes ces actions.
tant que vrai:
Étape 7. Colorez l'écran
screen.fill (blanc)
Étape 8. Affichez l'écran
Si vous exécutez le programme, l'écran deviendra blanc et le programme plantera. C'est parce que le système d'exploitation envoie des événements au jeu et que le jeu ne fait rien avec eux. Une fois que le jeu reçoit trop d'événements non gérés, il plante.
tandis que True: … pygame.display.flip()
Étape 9. Gérer les événements
Obtenez une liste de tous les événements qui se sont produits dans chaque image. Vous ne vous soucierez que d'un événement, l'événement d'arrêt. Cela se produit lorsque l'utilisateur ferme la fenêtre de jeu. Cela empêchera également notre programme de planter en raison d'un trop grand nombre d'événements.
while True: … pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit()
Étape 10. Essayez-le
Voici à quoi devrait ressembler le code maintenant:
importer pygame depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = pygame.display.set_mode(résolution) tandis que True: screen.fill(white) pygame.display.flip() pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit()
Partie 3 sur 8: Créer un objet de jeu
Étape 1. Créez une nouvelle classe et un nouveau constructeur
Définissez toutes les propriétés de l'objet. Vous fournissez également des valeurs par défaut pour toutes les propriétés.
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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "boule"
Étape 2. Définissez comment dessiner l'objet
Utilisez les propriétés qui ont été définies dans le constructeur pour dessiner la balle comme un cercle ainsi que pour passer une surface dans la fonction sur laquelle dessiner l'objet. La surface sera l'objet d'écran qui a été créé en utilisant la résolution plus tôt.
def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius)
Étape 3. Créez une instance de la classe et dites à la boucle de jeu de dessiner la balle dans chaque boucle
ball = Ball() tandis que True: … ball.draw(screen)
Étape 4. Faites bouger l'objet
Créez une fonction qui mettra à jour la position de l'objet. Appelez cette fonction dans chaque boucle de jeu.
class Ball: … def update(self): self.x += self.dx self.y += self.dy
Étape 5. Limitez la fréquence d'images
La balle se déplacera très vite car la boucle de jeu se déroule des centaines de fois par seconde. Utilisez l'horloge de Pygame pour limiter la fréquence d'images à 60 ips.
clock = pygame.time. Clock() tant que True: … clock.tick(60)
Étape 6. Gardez la balle sur l'écran
Ajoutez des vérifications dans la fonction de mise à jour pour inverser la direction de la balle si elle frappe l'un des bords de l'écran.
class Ball: … def update(self): … if (self.x <= 0 ou self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou self.y >= résolution[1]): self.dy *= -1
Étape 7. Essayez-le
Voici à quoi devrait ressembler le code maintenant:
importer pygame depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = 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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" 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 ou self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou 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) pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit ()
Partie 4 sur 8: Organisation du jeu
Étape 1. Utilisez les classes pour tout organiser
Le jeu va devenir plus compliqué. Utilisez des techniques orientées objet pour organiser votre code.
Étape 2. Faites de la boucle du jeu une classe
Étant donné que notre jeu contient désormais des données, y compris vos objets et fonctions de jeu, il est logique de transformer votre boucle de jeu en classe.
jeu de classe():
Étape 3. Ajoutez un constructeur
Ici, vous allez instancier certains objets du jeu, créer notre écran et notre horloge et initialiser Pygame. Pygame doit être initialisé pour utiliser certaines fonctionnalités comme le texte ou le son.
class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock()
Étape 4. Gérer les événements dans une fonction
class game(): … def handleEvents(self): pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit()
Étape 5. Faites de la boucle de jeu une fonction
Appelez la fonction de gestion des événements à chaque boucle.
class game(): … def run(self): while True: self.handleEvents() self.screen.fill(white) self.clock.tick(60) pygame.display.flip()
Étape 6. Manipulez plusieurs objets de jeu
À l'heure actuelle, ce code doit appeler draw et update sur notre objet à chaque image. Cela deviendrait désordonné si vous aviez beaucoup d'objets. Ajoutons notre objet à un tableau, puis mettons à jour et dessinons tous les objets du tableau à chaque boucle. Maintenant, vous pouvez facilement ajouter un autre objet et lui donner une position de départ différente.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) … def run(self): while True: self.handleEvents() pour gameObj dans self.gameObjects: gameObj.update() self.screen.fill(white) pour gameObj dans self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip()
Étape 7. Essayez-le
Voici à quoi devrait ressembler le code maintenant:
importer pygame depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = 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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" 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 ou self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou 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): pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvent s() pour gameObj dans self.gameObjects: gameObj.update() self.screen.fill(white) pour gameObj dans self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display. flip() game().run()
Partie 5 sur 8: Ajout d'un objet joueur
Étape 1. Créez une classe de joueur et un constructeur
Vous allez créer un autre cercle contrôlé par la souris. Initialisez les valeurs dans le constructeur. Le rayon est la seule valeur importante.
class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Étape 2. Définissez comment dessiner l'objet joueur
Ce sera de la même manière que vous avez dessiné les autres objets du jeu.
class Player: … def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius)
Étape 3. Ajoutez le contrôle de la souris pour l'objet joueur
Dans chaque image, vérifiez l'emplacement de la souris et définissez l'emplacement des objets des joueurs à ce point.
class Player: … def update(self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1]
Étape 4. Ajoutez un objet joueur à gameObjects
Créez une nouvelle instance de joueur et ajoutez-la à la liste.
classe game(): def _init_(self): … self.gameObjects.append(Player())
Étape 5. Essayez-le
Voici à quoi devrait ressembler le code maintenant:
importer pygame depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = 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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" 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 ou self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou 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" 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] classe game(): def _init_(self): pygame.init() self.screen = pygame.display.set_ mode (résolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() pour gameObj dans self.gameObjects: gameObj.update() self.screen.fill(white) pour gameObj dans self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game(). Cours()
Partie 6 sur 8: Faire interagir les objets avec le joueur
Étape 1. Modifiez les fonctions de mise à jour
Pour que les objets interagissent, ils doivent avoir accès les uns aux autres. Ajoutons un autre paramètre à Update pour passer dans la liste gameObjects. Vous devrez l'ajouter à la fois à l'objet joueur et aux objets Ball. Si vous avez beaucoup d'objets de jeu, l'héritage peut vous aider à conserver les mêmes signatures de méthode.
class Ball: … def update(self, gameObjects): … class Player: … def update(self, gameObjects):
Étape 2. Vérifiez les collisions entre le joueur et les balles
Parcourez tous les objets du jeu et vérifiez si le type des objets est balle. Utilisez ensuite les rayons des deux objets et la formule de distance pour vérifier s'ils entrent en collision. Les cercles sont vraiment faciles à vérifier les collisions. C'est la principale raison pour laquelle vous n'avez pas utilisé d'autre forme pour ce jeu.
class Player: … def update(self, gameObjects): … pour gameObj dans gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2:
Étape 3. Terminez le jeu si le joueur est « touché »
Quittons le jeu pour le moment.
if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit()
Étape 4. Essayez-le
Voici à quoi devrait ressembler le code maintenant:
importer pygame depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = 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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" 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 ou self.x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou 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" 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] pour gameObj dans gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit() classe game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(résolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit () def run(self): while True: self.handleEvents() pour gameObj dans self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(white) pour gameObj dans self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Partie 7 sur 8: Ajout d'un contrôleur de jeu pour créer des objets
Étape 1. Créez une classe de contrôleur de jeu
Les contrôleurs de jeu sont responsables de "l'exécution" du jeu. C'est différent de notre classe de jeu qui est chargée de dessiner et de mettre à jour tous nos objets. Le contrôleur ajoutera périodiquement une autre balle à l'écran pour rendre le jeu plus difficile. Ajoutez un constructeur et initialisez quelques valeurs de base. L'intervalle sera le temps avant qu'une autre balle soit ajoutée.
class GameController: def _init_(self, interval = 5): self.inter = intervalle self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "contrôleur de jeu"
Étape 2. Ajoutez la fonction de mise à jour
Cela vérifiera combien de temps s'est écoulé depuis le moment où une balle a été ajoutée ou depuis le début du jeu. Si le temps est supérieur à l'intervalle, vous réinitialiserez le temps et ajouterez une balle.
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())
Étape 3. Donnez aux balles des vitesses aléatoires
Vous devrez utiliser des nombres aléatoires pour rendre le jeu différent à chaque fois. Cependant, les vitesses des balles sont maintenant un nombre à virgule flottante au lieu d'un entier.
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=aléatoire()*2, yVel=aléatoire()*2))
Étape 4. Corrigez la fonction de dessin
La fonction draw n'accepte pas les flottants. Convertissons la position de la balle en nombres entiers avant que les balles ne soient dessinées.
class Ball: … def draw(self, surface): pygame.draw.circle(surface, black, (int(self.x), int(self.y)), self.radius)
Étape 5. Définissez une méthode de dessin pour le contrôleur de jeu
Puisqu'il s'agit d'un objet de jeu, la boucle principale essaiera de le dessiner. Vous devrez définir une fonction de dessin qui ne fait rien pour que le jeu ne plante pas.
class GameController: … def draw(self, screen): pass
Étape 6. Ajoutez le contrôleur de jeu à gameObjects et retirez les 2 boules
Le jeu devrait maintenant générer une balle toutes les cinq secondes.
classe game(): def _init_(self): … self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player())
Étape 7. Essayez-le
Voici à quoi devrait ressembler le code maintenant:
importer pygame depuis aléatoire importer aléatoirement depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = 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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" 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 ou self. x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou 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" 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] pour gameObj dans le jeu Objets: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)* *2: pygame.quit() classe GameController: def _init_(self, intervalle = 5): self.inter = intervalle self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "contrôleur de jeu " 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): pour l'événement dans pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() pour gameObj dans self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill (blanc) pour gameObj dans self.gameO bjets: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Partie 8 sur 8: Ajout d'un score et Game Over
Étape 1. Ajoutez un score à la classe de contrôleur de jeu
Créez un objet de police et une variable de score. Vous dessinerez la police dans chaque image pour afficher le score et augmenterez le score à chaque image en cours de mise à jour.
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 dessiner (self, screen): screen.blit(self.scoreText.render(str(self.score), True, black), (5, 5))
Étape 2. Modifiez la fin du jeu
Débarrassons-nous de l'arrêt lorsque le joueur détecte une collision. Au lieu de cela, vous définirez une variable dans le lecteur que le jeu pourra vérifier. Lorsque gameOver est défini, arrêtez la mise à jour des objets. Cela gèlera tout en place afin que le joueur puisse voir ce qui s'est passé et vérifier son score. Notez que les objets sont toujours en cours de dessin, mais pas mis à jour.
class Player: def _init_(self, rad = 20): … self.gameOver = False def update(self, gameObjects): … for 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() sinon self.gameOver: pour gameObj dans self.gameObjects: gameObj.update(self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
Étape 3. Essayez-le
Voici à quoi devrait ressembler le code terminé maintenant:
importer pygame depuis aléatoire importer aléatoirement depuis pygame.locals importer * résolution = (400, 300) blanc = (255, 255, 255) noir = (0, 0, 0) rouge = (255, 0, 0) écran = 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 self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" 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 ou self. x >= resolution[0]): self.dx *= -1 if (self.y <= 0 ou 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 = 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] pour gameObj dans 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 = intervalle self.next = pygame.time.get_ticks() + (2 * 1000) self. type = "contrôleur de jeu" 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)) classe 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): pour l'événement dans pygame.event.get(): if ev ent.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() sinon self.gameOver: pour gameObj dans self.gameObjects: gameObj.update(self.gameObjects) si gameObj. tapez == "player": self.gameOver = gameObj.gameOver self.screen.fill(white) pour gameObj dans self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip () jeu().run()
