Comment programmer un jeu en Python avec Pygame

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.

Première partie de huit:
Installation de Pygame

1. 1 Téléchargez Pygame. Trouvez-le pour votre plate-forme à l'adresse http://www.pygame.org/download.shtml.
2. 2Exécutez le programme d'installation.
3. 3 Vérifiez que l'installation a fonctionné. Ouvrez un terminal Python. Tapez "import pygame". Si vous ne voyez aucune erreur, Pygame a été installé avec succès.

    importer pygame 

Deuxième partie de huit:
Configuration d'une fenêtre de base

1. 1Ouvrez un nouveau fichier.
2. 2 Import Pygame. Pygame est une bibliothèque qui permet d'accéder aux fonctions graphiques. Si vous souhaitez plus d'informations sur le fonctionnement de ces fonctions, vous pouvez les rechercher sur le site Web de Pygame. https://www.pygame.org/docs/

    importer pygame de pygamedes locaux importer * 

3. 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 pour pouvoir le modifier ultérieurement. Pour les projets avancés, il serait préférable de placer ces informations dans un fichier séparé.

    résolution = (400,300) 

4. 4 Définir des couleurs. Les couleurs de 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) 

5. 5 Initialiser l'écran. Utilisez la variable de résolution définie précédemment.

    écran = pygameafficher.mode réglages(résolution) 

6. 6 Faites une boucle de jeu. Répétez certaines actions dans chaque cadre de notre jeu. Faites une boucle qui se répètera toujours pour faire défiler toutes ces actions.

    tandis que Vrai: 

7. 7 Coloriez l'écran.

    écran.remplir(blanc) 

8. 8 Afficher l'écran. Si vous exécutez le programme, l'écran deviendra blanc et le programme se bloquera. 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 va tomber en panne.

    tandis que Vrai:… pygame.afficher.retourner() 

9. 9 Gérer les événements Obtenez une liste de tous les événements survenus dans chaque image. Vous allez seulement vous soucier d'un événement, l'événement d'abandon. Cela se produit lorsque l'utilisateur ferme la fenêtre du jeu. Cela empêchera également notre programme de tomber en panne à cause d'un trop grand nombre d'événements.

    tandis que Vrai:… pour un événement dans pygameun événement.obtenir(): si un événement.type == QUIT: pygame.quitter() 

10. 10 Essaye le! Voici à quoi le code devrait ressembler maintenant:

     importer pygame de pygamedes locaux importer * résolution = (400,300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) tandis que Vrai: écran.remplir(blanc) pygameafficher.retourner() pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() 

Troisième partie de huit:
Faire un objet de jeu

1. 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.

    classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" 

2. 2 Définir comment dessiner l'objet. Utilisez les propriétés définies dans le constructeur pour dessiner la boule en tant que cercle et pour faire passer une surface dans la fonction afin de dessiner l'objet. La surface sera l'objet écran créé précédemment avec la résolution.

    déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (soi.X, soi.y), soi.rayon) 

3. 3 Faites une instance de la classe ainsi que de dire à la boucle de jeu de tirer la balle dans chaque boucle.

    ballon = Ballon() tandis que Vrai:… ballon.dessiner(écran) 

4. 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.

    classe Ballon:… déf mettre à jour(soi): soi.X += soi.dx soi.y += soi.dy 

5. 5 Limitez le taux de trame. La balle bougera très vite car la boucle de jeu tourne des centaines de fois par seconde. Utilisez l'horloge de Pygame pour limiter la fréquence d'images à 60 ips.

    l'horloge = pygametemps.L'horloge() tandis que Vrai:… l'horloge.cocher(60) 

6. 6 Gardez la balle sur l'écran. Ajoutez des contrôles dans la fonction de mise à jour pour inverser la direction de la balle si elle touche l'un des bords de l'écran.

    classe Ballon:… déf mettre à jour(soi):… si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 

7. 7 Essaye le! Voici à quoi le code devrait ressembler maintenant:

    importer pygame de pygamedes locaux importer * résolution = (400,300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi): soi.X += soi.dx soi.y += soi.dy si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 ballon = Ballon() l'horloge = pygametemps.L'horloge() tandis que Vrai: écran.remplir(blanc) ballon.dessiner(écran) ballon.mettre à jour() pygameafficher.retourner() l'horloge.cocher(60) pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() 

Quatrième partie de huit:
Organiser le jeu

1. 1 Utilisez des classes pour tout organiser. Le jeu va devenir plus compliqué. Utilisez des techniques orientées objet pour organiser votre code.
2. 2 Faites la boucle du jeu dans une classe. Comme notre jeu contient maintenant des données, y compris vos objets et fonctions de jeu, il est logique de transformer votre boucle de jeu en une classe.

    classe Jeu(): 

3. 3 Ajouter un constructeur Ici, vous instanciez des objets de jeu, créez votre écran et votre horloge et initialisez Pygame. Pygame doit être initialisé pour utiliser certaines fonctionnalités comme le texte ou le son.

    classe Jeu(): déf __init__(soi): pygame.init() soi.écran = pygameafficher.mode réglages(résolution) soi.l'horloge = pygametemps.L'horloge() 

4. 4 Gérer les événements dans une fonction.

    classe Jeu():… déf handleEvents(soi): pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() 

5. 5 Faites de la boucle de jeu une fonction. Appelez la fonction de gestion des événements à chaque boucle.

    classe Jeu():… déf courir(soi): tandis que Vrai: soi.handleEvents() soi.écran.remplir(blanc) soi.l'horloge.cocher(60) pygameafficher.retourner() 

6. 6 Manipulez plusieurs objets de jeu. Pour le moment, 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.

    classe Jeu(): déf __init__(soi):… soi.gameObjects = [] soi.gameObjects.ajouter(Ballon()) soi.gameObjects.ajouter(Ballon(100))… déf courir(soi): tandis que Vrai: soi.handleEvents() pour gameObj dans soi.gameObjects: gameObj.mettre à jour() soi.écran.remplir(blanc) pour gameObj dans soi.gameObjects: gameObj.dessiner(soi.écran) soi.l'horloge.cocher(60) pygameafficher.retourner() 

7. 7 Essaye le! Voici à quoi le code devrait ressembler maintenant:

    importer pygame de pygamedes locaux importer * résolution = (400,300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi): soi.X += soi.dx soi.y += soi.dy si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 classe Jeu(): déf __init__(soi): pygame.init() soi.écran = pygameafficher.mode réglages(résolution) soi.l'horloge = pygametemps.L'horloge() soi.gameObjects = [] soi.gameObjects.ajouter(Ballon()) soi.gameObjects.ajouter(Ballon(100)) déf handleEvents(soi): pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() déf courir(soi): tandis que Vrai: soi.handleEvents() pour jeuObj dans soi.gameObjects: gameObj.mettre à jour() soi.écran.remplir(blanc) pour gameObj dans soi.gameObjects: gameObj.dessiner(soi.écran) soi.l'horloge.cocher(60) pygameafficher.retourner() Jeu().courir() 

Cinquième partie de huit:
Ajouter un objet de lecteur

1. 1 Créez une classe de joueur et un constructeur. Vous allez créer un autre cercle contrôlé par la souris. Initialiser les valeurs dans le constructeur. Le rayon est la seule valeur importante.

    classe Joueur: déf __init__(soi, rad = 20): soi.X = 0 soi.y = 0 soi.rayon = rad 

2. 2 Définissez comment dessiner l'objet joueur. Cela va être la même façon que vous avez dessiné les autres objets du jeu.

    classe Joueur:… déf dessiner(soi, surface): pygame.dessiner.cercle(surface, rouge, (soi.X, soi.y), soi.rayon) 

3. 3 Ajoutez le contrôle de la souris pour l'objet joueur. Dans chaque cadre, vérifiez l'emplacement de la souris et définissez l'emplacement des objets des joueurs sur ce point.

    classe Joueur:… déf mettre à jour(soi): corde = pygameSouris.get_pos() soi.X = corde[0] soi.y = corde[1] 

4. 4 Ajoutez un objet joueur à gameObjects. Créez une nouvelle instance de lecteur et ajoutez-la à la liste.

    classe Jeu(): déf __init__(soi):… soi.gameObjects.ajouter(Joueur()) 

5. 5 Essaye le! Voici à quoi le code devrait ressembler maintenant:

    importer pygame de pygamedes locaux importer * résolution = (400,300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi): soi.X += soi.dx soi.y += soi.dy si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 classe Joueur: déf __init__(soi, rad = 20): soi.X = 0 soi.y = 0 soi.rayon = rad soi.type = "joueur" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, rouge, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi): corde = pygameSouris.get_pos() soi.X = corde[0] soi.y = corde[1] classe Jeu(): déf __init__(soi): pygame.init() soi.écran = pygameafficher.mode réglages(résolution) soi.l'horloge = pygametemps.L'horloge() soi.gameObjects = [] soi.gameObjects.ajouter(Joueur()) soi.gameObjects.ajouter(Ballon()) soi.gameObjects.ajouter(Ballon(100)) déf handleEvents(soi): pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() déf courir(soi): tandis que Vrai: soi.handleEvents() pour gameObj dans soi.gameObjects: gameObj.mettre à jour() soi.écran.remplir(blanc) pour gameObj dans soi.gameObjects: gameObj.dessiner(soi.écran) soi.l'horloge.cocher(60) pygameafficher.retourner() Jeu().courir() 

Sixième partie de huit:
Faire des objets interagir avec le lecteur

1. 1 Changer les fonctions de mise à jour. Pour que les objets interagissent, ils doivent avoir accès l'un à l'autre. Ajoutons un autre paramètre à Update pour passer dans la liste gameObjects. Vous devrez l'ajouter à l'objet joueur et aux objets Ball. Si vous avez beaucoup d'objets de jeu, l'héritage pourrait vous aider à conserver toutes les signatures de vos méthodes.

    classe Ballon:… déf mettre à jour(soi, gameObjects):… classe Joueur:… déf mettre à jour(soi, gameObjects): 

2. 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 ball. 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 sur les collisions. C'est la principale raison pour laquelle vous n'avez pas utilisé d'autre forme pour ce jeu.

    classe Joueur:… déf mettre à jour(soi, gameObjects):… pour gameObj dans gameObjects: si gameObj.type == "ballon": si (gameObj.X - soi.X)**2 + (gameObj.y - soi.y)**2 <= (gameObj.rayon + soi.rayon)**2: 

3. 3 Terminez le jeu si le joueur est "touché". Permet de quitter le jeu pour le moment.

    si (gameObj.X - soi.X)**2 + (gameObj.y - soi.y)**2 <= (gameObj.rayon + soi.rayon)**2: pygame.quitter() 

4. 4 Essaye le! Voici ce que le code devrait ressembler maintenant:

    importer pygame de pygamedes locaux importer * résolution = (400, 300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi, gameObjects): soi.X += soi.dx soi.y += soi.dy si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 classe Joueur: déf __init__(soi, rad = 20): soi.X = 0 soi.y = 0 soi.rayon = rad soi.type = "joueur" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, rouge, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi, gameObjects): corde = pygameSouris.get_pos() soi.X = corde[0] soi.y = corde[1] pour gameObj dans gameObjects: si gameObj.type == "ballon": si (gameObj.X - soi.X)**2 + (gameObj.y - soi.y)**2 <= (gameObj.rayon + soi.rayon)**2: pygame.quitter() classe Jeu(): déf __init__(soi): pygame.init() soi.écran = pygameafficher.mode réglages(résolution) soi.l'horloge = pygametemps.L'horloge() soi.gameObjects = [] soi.gameObjects.ajouter(Joueur()) soi.gameObjects.ajouter(Ballon()) soi.gameObjects.ajouter(Ballon(100)) déf handleEvents(soi): pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() déf courir(soi): tandis que Vrai: soi.handleEvents() pour gameObj dans soi.gameObjects: gameObj.mettre à jour(soi.gameObjects) soi.écran.remplir(blanc) pour gameObj dans soi.gameObjects: gameObj.dessiner(soi.écran) soi.l'horloge.cocher(60) pygameafficher.retourner() Jeu().courir() 

Septième partie de huit:
Ajout d'un contrôleur de jeu pour créer des objets

1. 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 responsable 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 certaines valeurs de base. L'intervalle sera le temps avant qu'une autre balle soit ajoutée.

    classe Une manette: déf __init__(soi, intervalle = 5): soi.entre = intervalle soi.prochain = pygametemps.get_ticks() + (2 * 1000) soi.type = "une manette" 

2. 2 Ajoutez la fonction de mise à jour. Cela permettra de vérifier combien de temps s'est écoulé depuis l'ajout d'une balle ou depuis le début de la partie. Si le temps est supérieur à l'intervalle, vous réinitialisez l'heure et ajoutez une balle.

    classe Une manette:… déf mettre à jour(soi, gameObjects): si soi.prochain < pygametemps.get_ticks(): soi.prochain = pygametemps.get_ticks() + (soi.entre * 1000) gameObjects.ajouter(Ballon()) 

3. 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.

    classe Une manette:… déf mettre à jour(soi, gameObjects): si soi.prochain < pygametemps.get_ticks(): soi.prochain = pygametemps.get_ticks() + (soi.entre * 1000) gameObjects.ajouter(Ballon(xvel=au hasard()*2, yVel=au hasard()*2)) 

4. 4 Corrige la fonction de dessin. La fonction de dessin n'accepte pas les flottants. Convertissons la position de la balle en nombres entiers avant que les balles ne soient tirées.

    classe Ballon:… déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (int(soi.X), int(soi.y)), soi.rayon) 

5. 5 Définissez une méthode de dessin pour le contrôleur de jeu. Comme il s'agit d'un objet de jeu, la boucle principale essaiera de la dessiner. Vous devrez définir une fonction de dessin qui ne fait rien pour que le jeu ne plante pas.

    classe Une manette:… déf dessiner(soi, écran): passer 

6. 6 Ajoutez le contrôleur de jeu à gameObjects et retirez les 2 balles. Le jeu devrait maintenant générer une balle toutes les cinq secondes.

    classe Jeu(): déf __init__(soi):… soi.gameObjects = [] soi.gameObjects.ajouter(Une manette()) soi.gameObjects.ajouter(Joueur()) 

7. 7 Essaye le! Voici à quoi le code devrait ressembler maintenant:

    importer pygame de au hasard importer au hasard de pygamedes locaux importer * résolution = (400,300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (int(soi.X), int(soi.y)), soi.rayon) déf mettre à jour(soi, gameObjects): soi.X += soi.dx soi.y += soi.dy si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 classe Joueur: déf __init__(soi, rad = 20): soi.X = 0 soi.y = 0 soi.rayon = rad soi.type = "joueur" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, rouge, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi, gameObjects): corde = pygameSouris.get_pos() soi.X = corde[0] soi.y = corde[1] pour gameObj dans gameObjects: si gameObj.type == "ballon": si (gameObj.X - soi.X)**2 + (gameObj.y - soi.y)**2 <= (gameObj.rayon + soi.rayon)**2: pygame.quitter() classe Une manette: déf __init__(soi, intervalle = 5): soi.entre = intervalle soi.prochain = pygametemps.get_ticks() + (2 * 1000) soi.type = "une manette" déf mettre à jour(soi, gameObjects): si soi.prochain < pygametemps.get_ticks(): soi.prochain = pygametemps.get_ticks() + (soi.entre * 1000) gameObjects.ajouter(Ballon(xvel=au hasard()*2, yVel=au hasard()*2)) déf dessiner(soi, écran): passer classe Jeu(): déf __init__(soi): pygame.init() soi.écran = pygameafficher.mode réglages(résolution) soi.l'horloge = pygametemps.L'horloge() soi.gameObjects = [] soi.gameObjects.ajouter(Une manette()) soi.gameObjects.ajouter(Joueur()) déf handleEvents(soi): pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() déf courir(soi): tandis que Vrai: soi.handleEvents() pour gameObj dans soi.gameObjects: gameObj.mettre à jour(soi.gameObjects) soi.écran.remplir(blanc) pour gameObj dans soi.gameObjects: gameObj.dessiner(soi.écran) soi.l'horloge.cocher(60) pygameafficher.retourner() Jeu().courir() 

Partie huit de huit:
Ajouter un score et un jeu terminé

1. 1 Ajoutez un score à la classe du contrôleur de jeu. Créez un objet de police et une variable de score. Vous allez dessiner la police dans chaque cadre pour afficher le score et augmenter le score à chaque image de la mise à jour.

    classe Une manette: déf __init__(soi, intervalle = 5):… soi.But = 0 soi.scoreTexte = pygamePolice de caractère.Police de caractère(Aucun, 12) déf mettre à jour(soi, gameObjects):… soi.But += 1 déf dessiner(soi, écran): écran.blit(soi.scoreTexte.rendre(str(soi.But), Vrai, noir), (5,5)) 

2. 2 Modifiez la façon dont le jeu se termine. Débarrassons-nous de la sortie lorsque le joueur détecte une collision. Au lieu de cela, vous définissez une variable dans le lecteur que le jeu peut vérifier. Lorsque gameOver est défini, arrêtez la mise à jour des objets. Cela gèlera tout pour que le joueur puisse voir ce qui s’est passé et vérifier son score. Notez que les objets sont toujours dessinés, mais pas mis à jour.

    classe Joueur: déf __init__(soi, rad = 20):… soi.jeu terminé = Faux déf mettre à jour(soi, gameObjects):… pour gameObj dans gameObjects: si gameObj.type == "ballon": si (gameObj.X - soi.X)**2 + (gameObj.y - soi.y)**2 <= (gameObj.rayon + soi.rayon)**2: soi.jeu terminé = Vrai classe Jeu(): déf __init__(soi):… soi.jeu terminé = Faux déf courir(soi): tandis que Vrai: soi.handleEvents() si ne pas soi.jeu terminé: pour gameObj dans soi.gameObjects: gameObj.mettre à jour(soi.gameObjects) si gameObj.type == "joueur": soi.jeu terminé = gameObj.jeu terminé 

3. 3 Essaye le! Voici à quoi le code fini devrait ressembler maintenant:

    importer pygame de au hasard importer au hasard de pygamedes locaux importer * résolution = (400,300) blanc = (255,255,255) noir = (0,0,0) rouge = (255,0,0) écran = pygameafficher.mode réglages(résolution) classe Ballon: déf __init__(soi, xPos = résolution[0] / 2, yPos = résolution[1] / 2, xvel = 1, yVel = 1, rad = 15): soi.X = xPos soi.y = yPos soi.dx = xvel soi.dy = yVel soi.rayon = rad soi.type = "ballon" déf dessiner(soi, surface): pygame.dessiner.cercle(surface, noir, (int(soi.X), int(soi.y)), soi.rayon) déf mettre à jour(soi, gameObjects): soi.X += soi.dx soi.y += soi.dy si (soi.X <= 0 ou soi.X >= résolution[0]): soi.dx *= -1 si (soi.y <= 0 ou soi.y >= résolution[1]): soi.dy *= -1 classe Joueur: déf __init__(soi, rad = 20): soi.X = 0 soi.y = 0 soi.rayon = rad soi.type = "joueur" soi.jeu terminé = Faux déf dessiner(soi, surface): pygame.dessiner.cercle(surface, rouge, (soi.X, soi.y), soi.rayon) déf mettre à jour(soi, gameObjects): corde = pygameSouris.get_pos() soi.X = corde[0] soi.y = corde[1] pour gameObj dans gameObjects: si gameObj.type == "ballon": si (gameObj.X - soi.X)**2 + (gameObj.y - soi.y)**2 <= (gameObj.rayon + soi.rayon)**2: soi.jeu terminé = Vrai classe Une manette: déf __init__(soi, intervalle = 5): soi.entre = intervalle soi.prochain = pygametemps.get_ticks() + (2 * 1000) soi.type = "une manette" soi.But = 0 soi.scoreTexte = pygamePolice de caractère.Police de caractère(Aucun, 12) déf mettre à jour(soi, gameObjects): si soi.prochain < pygametemps.get_ticks(): soi.prochain = pygametemps.get_ticks() + (soi.entre * 1000) gameObjects.ajouter(Ballon(xvel=au hasard()*2, yVel=au hasard()*2)) soi.But += 1 déf dessiner(soi, écran): écran.blit(soi.scoreTexte.rendre(str(soi.But), Vrai, noir), (5,5)) classe Jeu(): déf __init__(soi): pygame.init() soi.écran = pygameafficher.mode réglages(résolution) soi.l'horloge = pygametemps.L'horloge() soi.gameObjects = [] soi.gameObjects.ajouter(Une manette()) soi.gameObjects.ajouter(Joueur()) soi.jeu terminé = Faux déf handleEvents(soi): pour un événement dans pygameun événement.obtenir(): si un événement.type == QUITTER: pygame.quitter() déf courir(soi): tandis que Vrai: soi.handleEvents() si ne pas soi.jeu terminé: pour gameObj dans soi.gameObjects: gameObj.mettre à jour(soi.gameObjects) si gameObj.type == "joueur": soi.jeu terminé = gameObj.jeu terminé soi.écran.remplir(blanc) pour gameObj dans soi.gameObjects: gameObj.dessiner(soi.écran) soi.l'horloge.cocher(60) pygameafficher.retourner() Jeu().courir()