Construire un jeu d'astéroïdes avec Python et Pygame – Real Python

Projet Python

Pour organiser votre projet, commencez par créer un dossier pour celui-ci:

$ mkdir awesome_pygame_project
$ CD awesome_pygame_project

Comme pour tout projet Python, vous devez également créer un environnement virtuel pour votre jeu Asteroids. Vous pouvez en savoir plus sur les environnements virtuels dans Python Virtual Environments: A Primer.

Lorsque vous avez terminé, créez un requirements.txt fichier et ajoutez une dépendance Pygame. Pour ce projet, il est recommandé d'utiliser la dernière version, qui permettra à votre jeu Asteroids de fonctionner de manière transparente sur Linux et macOS. Votre fichier doit ressembler à ceci:

Ensuite, installez les dépendances:

(venv) $ python -m pip install -r requirements.txt

Vous pouvez vérifier si Pygame a été correctement installé en exécutant cette commande:

(venv) $ python -m pygame.examples.aliens

Si tout s'est bien passé, vous devriez voir une fenêtre avec le jeu Pygame Aliens.

Code Pygame

Il est maintenant temps de commencer à travailler sur votre propre code! En général, la structure d'un programme Pygame ressemble à ceci:

    1initialize_pygame()
    2
    3tandis que Vrai:
    4    handle_input()
    5    process_game_logic()
    6    draw_game_elements()

La ligne 3 démarre une boucle, appelée le boucle de jeu. Chaque itération de cette boucle génère une seule image du jeu et effectue généralement les opérations suivantes:

1. Gestion des entrées: Les entrées telles que les boutons enfoncés, le mouvement de la souris et la position des contrôleurs VR sont collectées puis gérées. Selon le jeu, cela peut amener les objets à changer de position, créer de nouveaux objets, demander la fin du jeu, etc.

2. Logique du jeu: C'est là que la plupart des mécanismes de jeu sont mis en œuvre. Ici, les règles de la physique sont appliquées, les collisions sont détectées et gérées, l'intelligence artificielle fait son travail, etc. Cette partie est également chargée de vérifier si le joueur a gagné ou perdu la partie.

3. Dessin: Si le jeu n’est pas encore terminé, c’est là que le cadre sera dessiné à l’écran. Il comprendra tous les éléments qui sont actuellement dans le jeu et qui sont visibles par le joueur.

La structure générale d'un programme Pygame n'est pas compliquée, et vous pourriez probablement vous en tirer en le mettant dans une boucle de base. Cependant, étant donné que vous pourriez étendre votre jeu Asteroids à l'avenir, il est judicieux d'encapsuler toutes ces opérations dans une classe Python.

Créer une classe signifie que vous devez choisir un nom pour votre jeu, mais «Asteroids» est déjà pris. Que diriez-vous de «Space Rocks»?

Créer un space_rocks répertoire, et à l'intérieur, créez un fichier appelé game.py. C'est ici que vous placerez la classe principale de votre jeu Asteroids: SpaceRocks. Le fichier devrait ressembler à ceci:

    1importer pygame
    2
    3classer SpaceRocks:
    4    def __init__(soi):
    5        soi._init_pygame()
    6        soi.écran = pygame.affichage.mode réglages((800, 600))
    7
    8    def boucle principale(soi):
    9        tandis que Vrai:
dix            soi._handle_input()
11            soi._process_game_logic()
12            soi._tirer()
13
14    def _init_pygame(soi):
15        pygame.init()
16        pygame.affichage.set_caption("Space Rocks")
17
18    def _handle_input(soi):
19        passe
20
21    def _process_game_logic(soi):
22        passe
23
24    def _tirer(soi):
25        soi.écran.remplir((0, 0, 255))
26        pygame.affichage.retourner()

Voici ce qui se passe dans le code, étape par étape:

• Ligne 1 importe le module Pygame pour accéder à toutes ses fonctionnalités étonnantes.

• Ligne 3 crée le SpaceRocks classer.

• Ligne 4 est le constructeur du SpaceRocks class, et c’est l’endroit idéal pour placer toutes les méthodes nécessaires à l’initialisation de Pygame. L'initialisation réelle de Pygame se produit dans _init_pygame (). Vous en apprendrez plus sur cette méthode dans un instant.

• Ligne 6 crée une surface d'affichage. Les images dans Pygame sont représentées par les surfaces. Voici quelques choses à savoir à leur sujet:

  • Les surfaces peuvent être dessinées les unes sur les autres, ce qui vous permet de créer des scènes complexes à partir d'images simples.

  • Il y a une surface spéciale dans chaque projet Pygame. Cette surface représente l'écran et est celle qui sera éventuellement affichée aux joueurs. Toutes les autres surfaces doivent être dessinées sur celle-ci à un moment donné. Sinon, ils ne seront pas affichés.

  • Pour créer la surface d'affichage, votre programme utilise pygame.display.set_mode (). Le seul argument que vous passez à cette méthode est la taille de l'écran, représentée par un tuple de deux valeurs: largeur et hauteur. Dans ce cas, Pygame créera un écran d'une largeur de 800 pixels et une hauteur de 600 pixels.

• Ligne 8 est la boucle de jeu décrite ci-dessus. Il contient les trois mêmes étapes pour chaque image:

  1. Ligne 10 contient la gestion des entrées.

  2. Ligne 11 contient la logique du jeu.

  3. Ligne 12 contient un dessin.

• Ligne 14 définit une méthode appelée _init_pygame (). C'est là qu'une initialisation unique de Pygame se produit. La méthode fait deux choses:

  1. Ligne 15 appels pygame.init (). Cette seule ligne de code est responsable de la mise en place des fonctionnalités étonnantes de Pygame. Chaque fois que vous travaillez avec Pygame, vous devez appeler pygame.init () au début de votre programme pour vous assurer que le framework fonctionnera correctement.

  2. Ligne 16 définit la légende de votre programme Pygame en utilisant pygame.display.set_caption (). Dans ce cas, la légende sera le nom de votre jeu: Space Rocks.

• Lignes 18 et 21 définir _handle_input () et _process_game_logic (). Ils sont vides pour le moment, mais dans les sections suivantes, vous ajouterez du code pour rendre votre jeu plus intéressant.

• Ligne 24 définit _tirer(). Cela n'aurait pas beaucoup de sens de créer un modèle pour votre jeu sans rien afficher à l'écran, donc cette méthode a déjà du code. Il est appelé chaque image pour dessiner le contenu de l'écran, et cela en deux étapes:

  1. Ligne 25 remplit l'écran d'une couleur en utilisant screen.fill (). La méthode prend un tuple avec trois valeurs, représentant trois couleurs de base: rouge, vert et bleu. Chaque valeur de couleur varie entre 0 et 255, représentant son intensité. Dans cet exemple, un tuple de (0, 0, 255) signifie que la couleur sera uniquement composée de bleu, sans trace de rouge ou de vert.

  2. Ligne 26 met à jour le contenu de l'écran en utilisant pygame.display.flip (). Étant donné que votre jeu finira par afficher des objets en mouvement, vous appellerez cette méthode à chaque image pour mettre à jour l'affichage. Pour cette raison, vous devez remplir votre écran de couleur à chaque image, car la méthode effacera le contenu généré lors de l'image précédente.

Cela peut sembler beaucoup d'étapes supplémentaires, mais maintenant votre code est bien structuré et comporte des méthodes avec des noms descriptifs. La prochaine fois que vous devrez modifier quelque chose en rapport avec le dessin, vous saurez comment utiliser _tirer(). Pour ajouter la gestion des entrées, vous allez modifier _handle_input (), etc.

Ensuite, créez un __main__.py fichier dans votre space_rocks dossier. Ce fichier se chargera de créer une nouvelle instance de votre jeu et de la démarrer en exécutant boucle principale(). Ça devrait ressembler à ça:

de Jeu importer SpaceRocks

si __Nom__ == "__principale__":
    space_rocks = SpaceRocks()
    space_rocks.boucle principale()

La structure de votre projet devrait maintenant ressembler à ceci:

awesome_pygame_project /
|
├── space_rocks /
| ├── __main__.py
| └── game.py
|
└── requirements.txt

Allez-y et lancez le jeu:

(venv) $ python space_rocks

Vous verrez une fenêtre avec un arrière-plan bleu:

Félicitations, vous venez de créer un projet Pygame! Cependant, il n'y a pas de condition de sortie à ce stade, vous devez donc toujours utiliser Ctrl+C dans la ligne de commande pour le quitter. C'est pourquoi vous découvrirez ensuite la gestion des entrées.

Comportement avancé

Vous avez déjà utilisé des surfaces, mais Pygame propose également une autre classe, Lutin, qui est conçue comme une classe de base pour les objets visibles. Il contient des méthodes utiles, mais vous pouvez également rencontrer quelques limitations.

Une limitation est qu'un objet de jeu est plus qu'un simple sprite. Il contient des données supplémentaires, comme sa direction et sa vitesse. Il a également besoin de comportements plus avancés, comme tirer des balles ou jouer des sons. La plupart de ces informations et comportements supplémentaires ne sont pas fournis par le Lutin class, vous devrez donc l'ajouter vous-même.

Un autre problème est que Pygame dessine des sprites à partir du coin supérieur gauche. Dans votre jeu, il peut être plus facile de stocker la position centrale d'un objet dans le but de le déplacer et de le faire pivoter. Dans ce cas, vous devrez mettre en œuvre un moyen de transformer cette position en un coin supérieur gauche comme l'exige Pygame.

Enfin, bien que Pygame dispose déjà de méthodes pour détecter les chevauchements entre les images, elles peuvent ne pas être bonnes pour détecter les collisions entre objets. Un vaisseau spatial rotatif ou un astéroïde ne remplira probablement pas toute l'image, mais plutôt la zone ronde qui s'y trouve. Dans ce cas, la collision ne doit prendre en compte que cette zone ronde, pas toute la surface du sprite. Sinon, vous risquez d'obtenir des résultats incorrects:

Dans cet exemple, les sprites entrent en collision, mais pas les objets du jeu.

C'est en fait là que le Lutin la classe pourrait vous aider, car vous pouvez l'utiliser avec pygame.sprite.collide_circle (). Cette méthode détecte les collisions entre deux sprites à l'aide de cercles centrés sur leurs surfaces. Cependant, détecter une collision de cercles n'est pas un processus très compliqué et vous pouvez le mettre en œuvre vous-même.

Compte tenu de ces problèmes, il devient rapidement évident que le Pygame intégré Lutin La classe est destinée à être augmentée, pas simplement utilisée seule. Dans le cas de votre jeu, les sprites Pygame fournissent quelques fonctionnalités utiles. Il peut être judicieux d'implémenter à la place une classe personnalisée pour les objets de jeu. Cela devrait vous donner plus de contrôle et vous aider à comprendre certains concepts puisque vous les implémenterez vous-même.

Classe GameObject

Dans cette section, vous présenterez le GameObject classer. Il encapsulera certains comportements et données génériques pour tous les autres objets du jeu. Les classes qui représentent des objets spécifiques (comme le vaisseau spatial) en hériteront et l'étendront avec leur propre comportement et leurs propres données. Si vous souhaitez actualiser vos connaissances sur les classes et l'héritage, consultez la programmation orientée objet (POO) dans Python 3.

Le GameObject class stockera les données suivantes:

• positionner: Un point au centre de l'objet sur l'écran 2D
• lutin: Une image utilisée pour afficher l'objet
• rayon: Une valeur représentant la zone de collision autour de la position de l'objet
• rapidité: Une valeur utilisée pour le mouvement

Voici une représentation graphique de l'objet du jeu:

Le lutin sera une surface chargée de load_sprite () à partir des exemples précédents. Le rayon est un entier indiquant le nombre de pixels du centre de l'objet au bord de la zone de collision. Cependant, le positionner lui-même et le rapidité aura besoin d'un nouveau type: a vecteur.

Les vecteurs sont similaires aux tuples. Dans un monde 2D (comme celui de votre jeu), les vecteurs sont représentés par deux valeurs indiquant les coordonnées x et y. Ces coordonnées peuvent pointer vers une position, mais elles peuvent également représenter un mouvement ou une accélération dans une direction donnée. Des vecteurs peuvent être ajoutés, soustraits ou même multipliés pour mettre à jour rapidement la position d'un sprite. Vous pouvez en savoir plus sur les vecteurs dans les vecteurs dans l'espace à 2 dimensions.

En raison de l'utilité des vecteurs dans les jeux, Pygame a déjà une classe pour eux: Vecteur2 dans le pygame.math module. Il offre des fonctionnalités supplémentaires, comme le calcul de la distance entre les vecteurs et l'ajout ou la soustraction de vecteurs. Ces fonctionnalités rendront votre logique de jeu beaucoup plus facile à implémenter.

Dans le space_rocks répertoire, créez un nouveau fichier appelé models.py. Pour l'instant, il stockera le GameObject classe, mais plus tard, vous ajouterez des classes pour les astéroïdes, les balles et le vaisseau spatial. Le fichier devrait ressembler à ceci:

    1de pygame.math importer Vecteur2
    2
    3classer GameObject:
    4    def __init__(soi, positionner, lutin, rapidité):
    5        soi.positionner = Vecteur2(positionner)
    6        soi.lutin = lutin
    7        soi.rayon = lutin.get_width() / 2
    8        soi.rapidité = Vecteur2(rapidité)
    9
dix    def tirer(soi, surface):
11        blit_position = soi.positionner - Vecteur2(soi.rayon)
12        surface.blit(soi.lutin, blit_position)
13
14    def bouge toi(soi):
15        soi.positionner = soi.positionner + soi.rapidité
16
17    def collision_avec(soi, autre_obj):
18        distance = soi.positionner.distance_to(autre_obj.positionner)
19        revenir distance < soi.rayon + autre_obj.rayon

Voici une ventilation:

• Ligne 1 importe le Vecteur2 classe mentionnée précédemment.

• Ligne 3 crée le GameObject class, que vous utiliserez pour représenter tous les objets du jeu dans Space Rocks.

• Ligne 4 est le constructeur du GameObject classer. Il a besoin de trois arguments:

  1. positionner: Le centre de l'objet

  2. lutin: L'image utilisée pour dessiner cet objet

  3. rapidité: Met à jour le positionner de l'objet chaque image

• Lignes 5 et 8 assurez-vous que le positionner et le rapidité seront toujours représentés comme des vecteurs pour les calculs futurs, même si les tuples sont passés au constructeur. Vous faites cela en appelant le Vecteur2 () constructeur. Si un tuple lui est attribué, il en créera un nouveau vecteur. Si un vecteur lui est attribué, il créera une copie de ce vecteur.

• Ligne 7 calcule le rayon égale à la moitié de la largeur du lutin image. Dans ce programme, les sprites d'objets de jeu seront toujours des carrés avec un arrière-plan transparent. Vous pouvez également utiliser la hauteur de l'image – cela ne ferait aucune différence.

• Ligne 10 définit tirer(), qui dessinera l’objet lutin en surface passé comme argument.

• Ligne 11 calcule la position correcte pour le blitting de l'image. Le processus est décrit plus en détail ci-dessous. Notez que le Vecteur2 () Le constructeur reçoit un seul nombre au lieu d'un tuple. Dans ce cas, il utilisera ce nombre pour les deux valeurs. Alors Vector2 (self.radius) est l'équivalent de Vector2 ((self.radius, self.radius)).

• Ligne 12 utilise la position de Blit nouvellement calculée pour placer l'image-objet de votre objet à un endroit correct sur la surface donnée.

• Ligne 14 définit bouge toi(). Cela mettra à jour la position de l'objet de jeu.

• Ligne 15 ajoute la vitesse à la position et obtient en conséquence un vecteur de position mis à jour. Pygame simplifie la manipulation des vecteurs, vous permettant de les ajouter comme des nombres.

• Ligne 17 définit le collision_avec () méthode, qui sera utilisée pour détecter les collisions.

• Ligne 18 calcule la distance entre deux objets en utilisant Vector2.distance_to ().

• Ligne 19 vérifie si cette distance est inférieure à la somme des rayons des objets. Si tel est le cas, les objets entrent en collision.

Veuillez noter que vos objets de jeu ont une position centrale, mais blit () nécessite un coin supérieur gauche. Ainsi, la position blit doit être calculée en déplaçant la position réelle de l'objet par un vecteur:

Ce processus se déroule dans tirer().

Vous pouvez tester cela en ajoutant un vaisseau spatial et un seul astéroïde. Tout d'abord, copiez les images du vaisseau spatial et de l'astéroïde actifs / sprites. Vous pouvez télécharger le code source en cliquant sur le lien ci-dessous:

La structure de votre projet doit ressembler à ceci:

awesome_pygame_project /
|
├── actifs /
| |
│ └── sprites /
│ ├── asteroid.png
│ ├── space.png
│ └── vaisseau spatial.png
|
├── space_rocks /
│ ├── __main__.py
│ ├── game.py
│ ├── models.py
│ └── utils.py
|
└── requirements.txt

Modifiez maintenant le space_rocks / game.py déposer:

importer pygame

de des modèles importer GameObject
de utils importer load_sprite

classer SpaceRocks:
    def __init__(soi):
        soi._init_pygame()
        soi.écran = pygame.affichage.mode réglages((800, 600))
        soi.Contexte = load_sprite("espacer", Faux)
        soi.vaisseau spatial = GameObject(
            (400, 300), load_sprite("vaisseau spatial"), (0, 0)
        )
        soi.astéroïde = GameObject(
            (400, 300), load_sprite("astéroïde"), (1, 0)
        )

    def boucle principale(soi):
        tandis que Vrai:
            soi._handle_input()
            soi._process_game_logic()
            soi._tirer()

    def _init_pygame(soi):
        pygame.init()
        pygame.affichage.set_caption("Space Rocks")

    def _handle_input(soi):
        pour un événement dans pygame.un événement.obtenir():
            si un événement.taper == pygame.QUITTER ou (
                un événement.taper == pygame.TOUCHE BAS et un événement.clé == pygame.K_ESCAPE
            ):
                quitter()

    def _process_game_logic(soi):
        soi.vaisseau spatial.bouge toi()
        soi.astéroïde.bouge toi()

    def _tirer(soi):
        soi.écran.blit(soi.Contexte, (0, 0))
        soi.vaisseau spatial.tirer(soi.écran)
        soi.astéroïde.tirer(soi.écran)
        pygame.affichage.retourner()

Les deux objets sont placés au milieu de l'écran, en utilisant les coordonnées (400, 300). La position des deux objets sera mise à jour à chaque image en utilisant _process_game_logic (), et ils seront dessinés en utilisant _tirer().

Exécutez ce programme et vous verrez un astéroïde se déplacer vers la droite et un vaisseau spatial immobile au milieu de l'écran:

Vous pouvez également tester collision_avec () en ajoutant temporairement une ligne à la fin de _tirer():

impression("Collision:", soi.vaisseau spatial.collision_avec(soi.astéroïde))

Dans la ligne de commande, vous remarquerez comment la méthode s’imprime initialement Vrai since the asteroid covers the spaceship. Later, as the asteroid moves further to the right, it starts printing False.

Controlling the Speed

Now that you have moving objects on the screen, it’s time to think about how your game will perform on different machines with different processors. Sometimes it’ll run faster, and sometimes it’ll run slower.

Because of that, the asteroids (and soon bullets) will move with different speed, making the game sometimes easier and sometimes harder. That’s not something that you want. What you want is for your game to run with a fixed number of frames per second (FPS).

Luckily, Pygame can take care of that. It offers a pygame.time.Clock class with a tick() method. This method will wait long enough to match the desired FPS value, passed as an argument.

Go ahead and update space_rocks/game.py:

import pygame

de models import GameObject
de utils import load_sprite

classer SpaceRocks:
    def __init__(self):
        self._init_pygame()
        self.screen = pygame.display.set_mode((800, 600))
        self.Contexte = load_sprite("space", False)
        self.l'horloge = pygame.time.Clock()
        self.spaceship = GameObject(
            (400, 300), load_sprite("spaceship"), (0, 0)
        )
        self.astéroïde = GameObject(
            (400, 300), load_sprite("asteroid"), (1, 0)
        )

    def main_loop(self):
        while True:
            self._handle_input()
            self._process_game_logic()
            self._draw()

    def _init_pygame(self):
        pygame.init()
        pygame.display.set_caption("Space Rocks")

    def _handle_input(self):
        pour un événement dans pygame.un événement.get():
            if un événement.taper == pygame.QUIT ou (
                un événement.taper == pygame.KEYDOWN et un événement.clé == pygame.K_ESCAPE
            ):
                quit()

    def _process_game_logic(self):
        self.spaceship.move()
        self.astéroïde.move()

    def _draw(self):
        self.screen.blit(self.Contexte, (0, 0))
        self.spaceship.tirer(self.screen)
        self.astéroïde.tirer(self.screen)
        pygame.display.retourner()
        self.l'horloge.cocher(60)

If you run your game now, then the asteroid might move at a different speed than it initially had. However, you can now be sure that this speed will remain the same, even on computers with super-fast processors. That’s because your game will always run at 60 FPS. You can also experiment with different values passed to tick() to see the difference.

You just learned how to show and move objects on the screen. Now you can add some more advanced logic to your game.

Creating a Class

The image of the spaceship is already in the space_rocks/assets directory that you added in Step 4. However, earlier it was used in the main game file, and now you need to load it in one of the models. To be able to do this, update the imports section in the space_rocks/models.py file:

de pygame.math import Vector2

de utils import load_sprite

Now you can create, in the same file, the Spaceship class that inherits from GameObject:

classer Spaceship(GameObject):
    def __init__(self, positionner):
        super().__init__(positionner, load_sprite("spaceship"), Vector2(0))

It doesn’t do a lot at this point—it just calls the GameObject constructor with a specific image and a zero velocity. However, you’ll soon add more functionality.

To use this new class, you first need to import it. Update the imports in the space_rocks/game.py file like this:

import pygame

de models import Spaceship
de utils import load_sprite

You probably noticed that the original import of the GameObject class is gone. That’s because GameObject is used as a base class to be inherited by other classes. You shouldn’t use it directly, but rather import the classes that represent actual game objects.

This means that the asteroid from the previous step will stop working, but that’s not a big issue. You’ll soon add a proper class that represents asteroids. Until then, you should focus on the spaceship.

Go ahead and edit the SpaceRocks class to look like this:

    1classer SpaceRocks:
    2    def __init__(self):
    3        self._init_pygame()
    4        self.screen = pygame.display.set_mode((800, 600))
    5        self.Contexte = load_sprite("space", False)
    6        self.l'horloge = pygame.time.Clock()
    7        self.spaceship = Spaceship((400, 300))
    8
    9    def main_loop(self):
dix        while True:
11            self._handle_input()
12            self._process_game_logic()
13            self._draw()
14
15    def _init_pygame(self):
16        pygame.init()
17        pygame.display.set_caption("Space Rocks")
18
19    def _handle_input(self):
20        pour un événement dans pygame.un événement.get():
21            if un événement.taper == pygame.QUIT ou (
22                un événement.taper == pygame.KEYDOWN et un événement.clé == pygame.K_ESCAPE
23            ):
24                quit()
25
26    def _process_game_logic(self):
27        self.spaceship.move()
28
29    def _draw(self):
30        self.screen.blit(self.Contexte, (0, 0))
31        self.spaceship.tirer(self.screen)
32        pygame.display.retourner()
33        self.l'horloge.cocher(60)

Two things happened:

1. In line 7, you replaced the base GameObject class with a dedicated Spaceship class.

2. You removed all self.asteroid references from __init__(), _process_game_logic() et _draw().

If you run your game now, then you’ll see a spaceship in the middle of the screen:

The changes didn’t add any new behavior yet, but now you have a class that you can extend.

Rotating the Spaceship

By default, the spaceship is facing up, toward the top of the screen. Your players should be able to rotate it left and right. Luckily, Pygame has built-in methods for rotating sprites, but there’s a small problem.

In general, image rotation is a complex process that requires recalculating pixels in the new image. During that recalculation, information about the original pixels is lost and the image is deformed a bit. With each rotation, the deformation becomes more and more visible.

Because of that, it might be a better idea to store the original sprite in the Spaceship class and have another sprite, which will be updated every time the spaceship rotates.

For that approach to work, you’ll need to know the angle by which the spaceship is rotated. This can be done in two ways:

1. Keep the angle as a floating point value and update it during rotation.
2. Keep the vector representing the direction the spaceship is facing and calculate the angle using that vector.

Both ways are good, but you need to pick one before you proceed. Since the position and the velocity of the spaceship are already vectors, it makes sense to use another vector to represent the direction. That will make it more straightforward to add vectors and update the position later. Heureusement, le Vector2 class can be rotated very easily, and the result won’t be deformed.

First, create a constant vector called EN HAUT dans le space_rocks/models.py file. You’ll use it as a reference later:

Remember that Pygame’s y-axis goes from top to bottom, so a negative value actually points upwards:

Next, modify the Spaceship class:

classer Spaceship(GameObject):
    MANEUVERABILITY = 3

Le MANEUVERABILITY value determines how fast your spaceship can rotate. You learned earlier that vectors in Pygame can be rotated, and this value represents an angle in degrees by which your spaceship’s direction can rotate each frame. Using a larger number will rotate the spaceship faster, while a smaller number will allow more granular control over the rotation.

Next, add a direction to the Spaceship class by modifying the constructor:

def __init__(self, positionner):
    # Make a copy of the original UP vector
    self.direction = Vector2(EN HAUT)

    super().__init__(positionner, load_sprite("spaceship"), Vector2(0))

The direction vector will initially be the same as the EN HAUT vector. However, it will be modified later, so you need to create a copy of it.

Next, you need to create a new method in the Spaceship class called rotate():

def rotate(self, clockwise=True):
    sign = 1 if clockwise else -1
    angle = self.MANEUVERABILITY * sign
    self.direction.rotate_ip(angle)

This method will change the direction by rotating it either clockwise or counterclockwise. Le rotate_ip() method of the Vector2 class rotates it in place by a given angle in degrees. The length of the vector doesn’t change during this operation. You can learn a bit more about the advanced math behind 2D vector rotation from Rotating Points Using Rotation Matrices.

All that’s left is to update the drawing of the Spaceship. To do this, you first need to import rotozoom, which is responsible for scaling and rotating images:

de pygame.math import Vector2
de pygame.transform import rotozoom

de utils import load_sprite, wrap_position

Then, you can override the draw() method in the Spaceship class:

    1def tirer(self, surface):
    2    angle = self.direction.angle_to(EN HAUT)
    3    rotated_surface = rotozoom(self.sprite, angle, 1.0)
    4    rotated_surface_size = Vector2(rotated_surface.get_size())
    5    blit_position = self.positionner - rotated_surface_size * 0,5
    6    surface.blit(rotated_surface, blit_position)

Here’s a step-by-step breakdown:

• Ligne 2 uses the angle_to() method of the Vector2 class to calculate the angle by which one vector needs to be rotated in order to point in the same direction as the other vector. This makes it painless to translate the spaceship’s direction into the rotation angle in degrees.

• Ligne 3 rotates the sprite using rotozoom(). It takes the original image, the angle by which it should be rotated, and the scale that should be applied to the sprite. In this case, you don’t want to change the size, so you keep the scale as 1.0.

• Lines 4 and 5 recalculate the blit position, using the size of rotated_surface. The process is described below.

• Ligne 5 contains the rotated_surface_size * 0.5 opération. That’s another thing you can do with vectors in Pygame. When you multiply a vector by a number, all its coordinates are multiplied by that number. As a result, multiplying by 0,5 will return a vector with half the length of the original.

• Ligne 6 uses the newly calculated blit position to put the image on the screen.

Note that rotozoom() returns a new surface with a rotated image. However, in order to keep all the contents of the original sprite, the new image might have a different size. In that case, Pygame will add some additional, transparent background:

The size of the new image can be significantly different than that of the original image. That’s why draw() recalculates the blit position of rotated_surface. Souviens-toi que blit() starts in the upper-left corner, so to center the rotated image, you also need to move the blit position by half the size of the image.

Now you need to add input handling. However, the event loop won’t exactly work here. Events are recorded when they happen, but you need to constantly check if a key is pressed. After all, the spaceship should accelerate for as long as you press Up, and it should rotate constantly when you press Gauche ou Droit.

You could create a flag for each key, set it when the key is pressed, and reset when it’s released. However, there’s a better way.

The current state of the keyboard is stored in Pygame and can be obtained using pygame.key.get_pressed(). It returns a dictionary where key constants (like pygame.K_ESCAPE that you used previously) are keys, and the value is True if the key is pressed or False otherwise.

Knowing this, you can edit the space_rocks/game.py file and update the _handle_input() method of SpaceRocks class. The constants you need to use for arrow keys are pygame.K_RIGHT et pygame.K_LEFT:

def _handle_input(self):
    pour un événement dans pygame.un événement.get():
        if un événement.taper == pygame.QUIT ou (
            un événement.taper == pygame.KEYDOWN et un événement.clé == pygame.K_ESCAPE
        ):
            quit()

    is_key_pressed = pygame.clé.get_pressed()

    if is_key_pressed[[[[pygame.K_RIGHT]:
        self.spaceship.rotate(clockwise=True)
    elif is_key_pressed[[[[pygame.K_LEFT]:
        self.spaceship.rotate(clockwise=False)

Now your spaceship will rotate left and right when you press arrow keys:

As you can see, the spaceship rotates correctly. However, it still doesn’t move. You’ll fix that next.

Accelerating the Spaceship

In this section, you’ll add acceleration to your spaceship. Remember that, according to the game mechanics of Asteroids, the spaceship can only move forward.

In your game, when you press Up, the spaceship’s speed will increase. When you release the key, the spaceship will maintain its current speed but should no longer accelerate. So in order to slow it down, you’ll have to turn the spaceship around and press Up de nouveau.

The process might already seem a bit complicated, so before you proceed, here is a short recap:

• direction is a vector describing where the spaceship is pointing.
• velocity is a vector describing where the spaceship moves each frame.
• ACCELERATION is a constant number describing how fast the spaceship can speed up each frame.

You can calculate the change in velocity by multiplying the direction vector by the ACCELERATION value and adding the result to the current velocity. This happens only when the engine is on—that is, when the player presses Up. The new position of the spaceship is calculated by adding the current velocity to the current position of the spaceship. This happens each frame, regardless of the engine status.

Knowing this, you can add the ACCELERATION value to the Spaceship class:

classer Spaceship(GameObject):
    MANEUVERABILITY = 3
    ACCELERATION = 0,25

Then, create accelerate() dans le Spaceship class:

def accelerate(self):
    self.velocity += self.direction * self.ACCELERATION

Now you can add input handling to _handle_input() dans SpaceRocks. Similarly to the rotation, this will check the current state of the keyboard, not the keypress events. The constant for Up is pygame.K_UP:

def _handle_input(self):
    pour un événement dans pygame.un événement.get():
        if un événement.taper == pygame.QUIT ou (
            un événement.taper == pygame.KEYDOWN et un événement.clé == pygame.K_ESCAPE
        ):
            quit()

    is_key_pressed = pygame.clé.get_pressed()

    if is_key_pressed[[[[pygame.K_RIGHT]:
        self.spaceship.rotate(clockwise=True)
    elif is_key_pressed[[[[pygame.K_LEFT]:
        self.spaceship.rotate(clockwise=False)
    if is_key_pressed[[[[pygame.K_UP]:
        self.spaceship.accelerate()

Go ahead and test this. Run your game, rotate the spaceship, and turn on the engine:

Your spaceship can now move and rotate! However, when it reaches the edge of the screen, it just keeps moving. That’s something you should fix!

Wrapping Objects Around the Screen

An important element of this game is making sure that game objects don’t leave the screen. You can either have them bounce back off the edge or make them reappear on the opposite edge of the screen. In this project, you’ll implement the latter.

Start by importing the Vector2 class in space_rocks/utils.py file:

de pygame.image import load
de pygame.math import Vector2

Next, create wrap_position() in the same file:

    1def wrap_position(positionner, surface):
    2    X, y = positionner
    3    w, h = surface.get_size()
    4    revenir Vector2(X % w, y % h)

By using the modulo operator on line 4, you make sure that the position never leaves the area of the given surface. In your game, that surface will be the screen.

Import this new method in space_rocks/models.py:

de pygame.math import Vector2
de pygame.transform import rotozoom

de utils import load_sprite, wrap_position

Now you can update move() dans le GameObject class:

def move(self, surface):
    self.positionner = wrap_position(self.positionner + self.velocity, surface)

Notice that using the wrap_position() isn’t the only change here. You also add a new surface argument to this method. That’s because you need to know the area around which the position should be wrapped. Remember to update the method call in the SpaceRocks class as well:

def _process_game_logic(self):
    self.spaceship.move(self.screen)

Now your spaceship reappears on the other side of the screen.

The logic of moving and rotating the spaceship is ready. But the ship is still alone in the empty space. Time to add some asteroids!

Creating a Class

Semblable à Spaceship, you’ll start by creating a class called Astéroïde that inherits from GameObject. Edit the space_rocks/models.py file like so:

classer Astéroïde(GameObject):
    def __init__(self, positionner):
        super().__init__(positionner, load_sprite("asteroid"), (0, 0))

Just like before, you start by calling the GameObject constructor with a specific image. You added the image in one of the previous steps.

Next, import the new class in space_rocks/game.py:

import pygame

de models import Astéroïde, Spaceship
de utils import load_sprite

Finally, edit the constructor of the SpaceRocks class in the same file to create six asteroids:

def __init__(self):
    self._init_pygame()
    self.screen = pygame.display.set_mode((800, 600))
    self.Contexte = load_sprite("space", False)
    self.l'horloge = pygame.time.Clock()

    self.astéroïdes = [[[[Astéroïde(0, 0) pour _ dans gamme(6)]
    self.spaceship = Spaceship((400, 300))

Now that you have more game objects, it would be a good idea to create a helper method in the SpaceRocks class that returns all of them. This method will then be used by the drawing and moving logic. That way, you can later introduce new types of game objects and modify only this single method, or you can exclude some objects from this group if necessary.

Call this method _get_game_objects():

def _get_game_objects(self):
    revenir [[[[*self.astéroïdes, self.spaceship]

Now use it to move all game objects in a single loop by editing _process_game_logic():

def _process_game_logic(self):
    pour game_object dans self._get_game_objects():
        game_object.move(self.screen)

Il en va de même _draw():

def _draw(self):
    self.screen.blit(self.Contexte, (0, 0))

    pour game_object dans self._get_game_objects():
        game_object.tirer(self.screen)

    pygame.display.retourner()
    self.l'horloge.cocher(60)

Run your game now and you should see a screen with the asteroids:

Unfortunately, all the asteroids are piled up in one corner of the screen.

Well, that was kind of expected, since all the asteroids are created with a position of (0, 0), which represents the top-left corner. You can change this by setting a random position on the screen.

Randomizing the Position

To generate a random position, you’ll have to add some imports to space_rocks/utils.py file:

import random

de pygame.image import load
de pygame.math import Vector2

Then, create a method called get_random_position() in the same file:

def get_random_position(surface):
    revenir Vector2(
        random.randrange(surface.get_width()),
        random.randrange(surface.get_height()),
    )

This will generate a random set of coordinates on a given surface and return the result as a Vector2 instance.

Next, import this method in the space_rocks/game.py file:

import pygame

de models import Astéroïde, Spaceship
de utils import get_random_position, load_sprite

Now use get_random_position() to place all six asteroids in random locations. Modify the constructor of the SpaceRocks class:

def __init__(self):
    self._init_pygame()
    self.screen = pygame.display.set_mode((800, 600))
    self.Contexte = load_sprite("space", False)
    self.l'horloge = pygame.time.Clock()

    self.astéroïdes = [[[[
        Astéroïde(get_random_position(self.screen)) pour _ dans gamme(6)
    ]
    self.spaceship = Spaceship((400, 300))

Now when you run the game, you’ll see a nice, random distribution of asteroids on the screen:

This looks much better, but there’s a small problem: the asteroids were generated in the same area as the spaceship. After you add collisions, this would cause the player to lose immediately after starting the game. That would be very unfair!

One solution to this problem is to check if the position is too close to the spaceship, and if so, generate a new one until a valid position is found.

Start by creating a constant representing an area that has to remain empty. A value of 250 pixels should be enough:

classer SpaceRocks:
    MIN_ASTEROID_DISTANCE = 250

Now you can modify the constructor of the SpaceRocks class to make sure that your players always have a chance to win:

def __init__(self):
    self._init_pygame()
    self.screen = pygame.display.set_mode((800, 600))
    self.Contexte = load_sprite("space", False)
    self.l'horloge = pygame.time.Clock()

    self.astéroïdes = []
    self.spaceship = Spaceship((400, 300))

    pour _ dans gamme(6):
        while True:
            positionner = get_random_position(self.screen)
            if (
                positionner.distance_to(self.spaceship.positionner)
                > self.MIN_ASTEROID_DISTANCE
            ):
                Pause

        self.astéroïdes.append(Astéroïde(positionner))

In a loop, your code checks if the position of an asteroid is larger than the minimal asteroid distance. If not, then the loop runs again until such a position is found.

Run the program again, and none of the asteroids will overlap with the spaceship:

You can run the game several times to make sure that each time there’s some free space around the spaceship.

Moving the Asteroids

At the moment, your program shows six asteroids at random positions, and you’re ready to spice things up a bit by moving them! Similar to the position, the velocity of an asteroid should also be random, not only in terms of the direction, but also value.

Start by creating a method called get_random_velocity() dans le space_rocks/utils.py file:

def get_random_velocity(min_speed, max_speed):
    speed = random.randint(min_speed, max_speed)
    angle = random.randrange(0, 360)
    revenir Vector2(speed, 0).rotate(angle)

The method will generate a random value between min_speed et max_speed and a random angle between 0 and 360 degrees. Then it will create a vector with that value, rotated by that angle.

Because the asteroid’s velocity should be random no matter where it is placed, let’s use this method directly in the Astéroïde class. Start with updating the imports in the space_rocks/models.py file:

de pygame.math import Vector2
de pygame.transform import rotozoom
de utils import get_random_velocity, load_sprite, wrap_position

Note that you’re setting a your random position in one place and your random velocity somewhere else. That’s because the position should be random only for the six asteroids you start with, so it’s being set in in the space_rocks/game.py file, where the game is initialized. However, the velocity is random for every asteroid, so you set it in the constructor of the Astéroïde class.

Then use the new method in the constructor of the Astéroïde class:

def __init__(self, positionner):
    super().__init__(
        positionner, load_sprite("asteroid"), get_random_velocity(1, 3)
    )

Notice that the method uses the minimum value of 1. That’s because the asteroid should always move, at least a bit.

Run your game again to see moving asteroids:

You can also move the spaceship around the screen. Unfortunately, when it encounters an asteroid, nothing happens. It’s time to add some collisions.

Colliding With the Spaceship

A very important part of this game is the possibility of your spaceship being destroyed by an asteroid collision. You can check the collisions using GameObject.collides_with() introduced in Step 4. All you need to do it call this method for each asteroid.

Edit the _process_game_logic() method in the SpaceRocks class like this:

def _process_game_logic(self):
    pour game_object dans self._get_game_objects():
        game_object.move(self.screen)

    if self.spaceship:
        pour astéroïde dans self.astéroïdes:
            if astéroïde.collides_with(self.spaceship):
                self.spaceship = Aucun
                Pause

If any of the asteroids collides with the spaceship, then the spaceship is destroyed. In this game, you’ll represent this by setting self.spaceship à Aucun.

Notice that there’s also a check for self.spaceship at the beginning of the loop. That’s because, when the spaceship is destroyed, there’s no reason to check any collisions with it. Also, detecting a collision with a Aucun object would result in an error.

Now that it’s possible for the spaceship to have a value of Aucun, it’s important to update _get_game_objects() dans le SpaceRocks class to avoid trying to render or move a destroyed spaceship:

def _get_game_objects(self):
    game_objects = [[[[*self.astéroïdes]

    if self.spaceship:
        game_objects.append(self.spaceship)

    revenir game_objects

The same goes for input handling:

def _handle_input(self):
    pour un événement dans pygame.un événement.get():
        if un événement.taper == pygame.QUIT ou (
            un événement.taper == pygame.KEYDOWN et un événement.clé == pygame.K_ESCAPE
        ):
            quit()

    is_key_pressed = pygame.clé.get_pressed()

    if self.spaceship:
        if is_key_pressed[[[[pygame.K_RIGHT]:
            self.spaceship.rotate(clockwise=True)
        elif is_key_pressed[[[[pygame.K_LEFT]:
            self.spaceship.rotate(clockwise=False)
        if is_key_pressed[[[[pygame.K_UP]:
            self.spaceship.accelerate()

You can run your game now and see that the spaceship disappears after colliding with an asteroid:

Your spaceship can now fly around and be destroyed when it collides with asteroids. You’re ready to make it possible for the asteroids to be destroyed too.

Creating a Class

Start with adding an image of a bullet to assets/sprites. You can download the source code by clicking the link below:

The structure of your project should look like this:

awesome_pygame_project/
|
├── assets/
| |
│   └── sprites/
│       ├── asteroid.png
│       ├── bullet.png
│       ├── space.png
│       └── spaceship.png
|
├── space_rocks/
│   ├── __main__.py
│   ├── game.py
│   ├── models.py
│   └── utils.py
|
└── requirements.txt

Then edit the space_rocks/models.py file by creating a class called Balle that inherits from GameObject:

classer Balle(GameObject):
    def __init__(self, positionner, velocity):
        super().__init__(positionner, load_sprite("bullet"), velocity)

Just like before, this will only call the GameObject constructor with a specific sprite. However, this time the velocity will be a required argument because a bullet has to move.

Next, you should add a way to keep track of the bullets, similar to what you did for the asteroids. Edit the constructor of the SpaceRocks class in the space_rocks/game.py file:

def __init__(self):
    self._init_pygame()
    self.screen = pygame.display.set_mode((800, 600))
    self.Contexte = load_sprite("space", False)
    self.l'horloge = pygame.time.Clock()

    self.astéroïdes = []
    self.bullets = []
    self.spaceship = Spaceship((400, 300))

    pour _ dans gamme(6):
        while True:
            positionner = get_random_position(self.screen)
            if (
                positionner.distance_to(self.spaceship.positionner)
                > self.MIN_ASTEROID_DISTANCE
            ):
                Pause

        self.astéroïdes.append(Astéroïde(positionner))

Bullets should be treated the same way as other game objects, so edit the _get_game_object() method in SpaceRocks:

def _get_game_objects(self):
    game_objects = [[[[*self.astéroïdes, *self.bullets]

    if self.spaceship:
        game_objects.append(self.spaceship)

    revenir game_objects

The list of bullets is there, but it’s empty for now. You can fix that.

Shooting a Bullet

There’s a small issue with shooting. Bullets are stored in the main game object, represented by the SpaceRocks class. However, the shooting logic should be determined by the spaceship. It’s the spaceship that knows how to create a new bullet, but it’s the game that stores and later animates the bullets. Le Spaceship class needs a way to inform the SpaceRocks class that a bullet has been created and should be tracked.

To fix this, you can add a callback function to the Spaceship class. That function will be provided by the SpaceRocks class when the spaceship is initialized. Every time the spaceship creates a bullet, it will initialize a Balle object and then call the callback. The callback will add the bullet to the list of all bullets stored by the game.

Start by adding a callback to the constructor of the Spaceship class in the space_rocks/models.py file:

def __init__(self, positionner, create_bullet_callback):
    self.create_bullet_callback = create_bullet_callback
    # Make a copy of the original UP vector
    self.direction = Vector2(EN HAUT)

    super().__init__(positionner, load_sprite("spaceship"), Vector2(0))

You’ll also need the value of the bullet’s speed:

classer Spaceship(GameObject):
    MANEUVERABILITY = 3
    ACCELERATION = 0,25
    BULLET_SPEED = 3

Next, create a method called shoot() dans le Spaceship class:

def shoot(self):
    bullet_velocity = self.direction * self.BULLET_SPEED + self.velocity
    balle = Balle(self.positionner, bullet_velocity)
    self.create_bullet_callback(balle)

You start by calculating the velocity of the bullet. The bullet is always shot forward, so you use the direction of the spaceship multiplied by the speed of the bullet. Because the spaceship doesn’t necessarily stand still, you add its velocity to the velocity of the bullet. That way, you can create high-speed bullets if the spaceship is moving very fast.

Then you create an instance of the Balle class at the same location as the spaceship, using the velocity that was just calculated. Finally, the bullet is added to all the bullets in the game by using the callback method.

Now add the callback to the spaceship when it’s created. Bullets are stored as a list, and the only thing the callback has to do is add new items to that list. Therefore, the append() method should do the job. Edit the constructor of the SpaceRocks class in the space_rocks/game.py file:

def __init__(self):
    self._init_pygame()
    self.screen = pygame.display.set_mode((800, 600))
    self.Contexte = load_sprite("space", False)
    self.l'horloge = pygame.time.Clock()

    self.astéroïdes = []
    self.bullets = []
    self.spaceship = Spaceship((400, 300), self.bullets.append)

    pour _ dans gamme(6):
        while True:
            positionner = get_random_position(self.screen)
            if (
                positionner.distance_to(self.spaceship.positionner)
                > self.MIN_ASTEROID_DISTANCE
            ):
                Pause

        self.astéroïdes.append(Astéroïde(positionner))

The last thing you need to add is input handling. The bullet should be generated only when Espacer pressed, so you can use the event loop. The constant for Espacer is pygame.K_SPACE.

Modify the _handle_input() method in the SpaceRocks class:

def _handle_input(self):
    pour un événement dans pygame.un événement.get():
        if un événement.taper == pygame.QUIT ou (
            un événement.taper == pygame.KEYDOWN et un événement.clé == pygame.K_ESCAPE
        ):
            quit()
        elif (
            self.spaceship
            et un événement.taper == pygame.KEYDOWN
            et un événement.clé == pygame.K_SPACE
        ):
            self.spaceship.shoot()

    is_key_pressed = pygame.clé.get_pressed()

    if self.spaceship:
        if is_key_pressed[[[[pygame.K_RIGHT]:
            self.spaceship.rotate(clockwise=True)
        elif is_key_pressed[[[[pygame.K_LEFT]:
            self.spaceship.rotate(clockwise=False)
        if is_key_pressed[[[[pygame.K_UP]:
            self.spaceship.accelerate()

Notice that the new input handling also checks if the spaceship exists. Otherwise, you could encounter errors when trying to call shoot() on a Aucun object.

Run your game now and shoot some bullets:

Your spaceship can finally shoot! However, the bullets don’t leave the screen, which might be an issue.

Wrapping the Bullets

At the moment, all game objects are wrapped around the screen. That includes bullets. However, because of this wrapping, the screen quickly gets filled with bullets flying in all directions. That might make the game a bit too easy!

You can solve this issue by disabling the wrapping only for bullets. Override move() dans le Balle class in the space_rocks/models.py file like this:

def move(self, surface):
    self.positionner = self.positionner + self.velocity

That way the bullets won’t wrap around the screen. However, they also won’t be destroyed. Instead, they’ll continue flying into the infinite abyss of the cosmos. Soon, your list of bullets will contain thousands of elements, and all of them will be processed in each frame, resulting in a decline of the performance of your game.

To avoid that situation, your game should remove the bullets as soon as they leave the screen. Update the _process_game_logic() method of the SpaceRocks class in the space_rocks/game.py file:

    1def _process_game_logic(self):
    2    pour game_object dans self._get_game_objects():
    3        game_object.move(self.screen)
    4
    5    if self.spaceship:
    6        pour astéroïde dans self.astéroïdes:
    7            if astéroïde.collides_with(self.spaceship):
    8                self.spaceship = Aucun
    9                Pause
dix
11    pour balle dans self.bullets[:]:
12        if ne pas self.screen.get_rect().collidepoint(balle.positionner):
13            self.bullets.remove(balle)

Notice that instead of using the original list, self.bullets, you create a copy of it using self.bullets[:] in line 11. That’s because removing elements from a list while iterating over it can cause errors.

Surfaces in Pygame have a get_rect() method that returns a rectangle representing their area. That rectangle, in turn, has a collidepoint() method that returns True if a point is included in the rectangle and False otherwise. Using these two methods, you can check if the bullet has left the screen, and if so, remove it from the list.

Colliding With Asteroids

A crucial element of your bullets is still missing: the ability to destroy asteroids! You’ll fix that in this section.

Update the _process_game_logic() method of the SpaceRocks class like this:

    1def _process_game_logic(self):
    2    pour game_object dans self._get_game_objects():
    3        game_object.move(self.screen)
    4
    5    if self.spaceship:
    6        pour astéroïde dans self.astéroïdes:
    7            if astéroïde.collides_with(self.spaceship):
    8                self.spaceship = Aucun
    9                Pause
dix
11    pour balle dans self.bullets[:]:
12        pour astéroïde dans self.astéroïdes[:]:
13            if astéroïde.collides_with(balle):
14                self.astéroïdes.remove(astéroïde)
15                self.bullets.remove(balle)
16                Pause
17
18    pour balle dans self.bullets[:]:
19        if ne pas self.screen.get_rect().collidepoint(balle.positionner):
20            self.bullets.remove(balle)

Now, whenever a collision is detected between a bullet and an asteroid, both will be removed from the game. Notice that, just like before in the bullet loop, you don’t use the original lists here. Instead, you create copies using [:] in lines 11 and 12.

If you run your game now and take a good aim when shooting, then you should be able to destroy some asteroids:

Your spaceship can finally protect itself! However, there are only six big targets in the game. Next, you’ll make it a bit more challenging.