Ajout de l'image du vaisseau

Nous allons intégrer le vaisseau dans le jeu. Pour afficher le vaisseau du joueur à l’écran, nous chargeons une image et utilisons la méthode blit() de Pygame.

Pour choisir des ressources visuelles, il est crucial de respecter les licences. La solution la plus simple et économique consiste à utiliser des images libres de droits provenant de plateformes comme Pixabay.

Pygame prend en charge nativement les fichiers bitmap (.bmp). D’autres formats (.jpg, .png) nécessitent l’installasion de bibliothèques supplémentaires. Privilégiez des images avec un fond transparent ou une couleur unie pour faciliter l’intégration dans le jeu.

Dans le cadre de ce projet, nous utilisons le fichier ship.bmp. Créez un dossier images dans le répertoire du projet (alien_invasion) et placez-y ce fichier.

Création de la classe Ship

Créons un module ship.py contenant la classe Ship qui gère le comportement du vaisseau.

import pygame

class Ship:
    """Classe pour gérer le vaisseau."""

    def __init__(self, ai_game):
        """Initialise le vaisseau et sa position de départ."""
        self.screen = ai_game.screen
        self.screen_rect = ai_game.screen.get_rect()

        # Charge l'image du vaisseau et récupère son rectangle
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()

        # Positionne le vaisseau en bas au centre
        self.rect.midbottom = self.screen_rect.midbottom

    def blitme(self):
        """Dessine le vaisseau à sa position actuelle."""
        self.screen.blit(self.image, self.rect)

Pygame traite tous les éléments de jeu comme des rectangles (rect), ce qui simplifie la détection de collisions. La classe Ship reçoit une référence à l’instance principale du jeu (ai_game) pour accéder à l’écran. La méthode get_rect() permet de récupérer les dimensions de l’écran et de l’image.

Le point d’origine (0,0) se trouve en haut à gauche de l’écran. Les coordonnées augmentent vers la droite et vers le bas. Nous plaçons le vaisseau en bas au centre en définissant midbottom sur celui de l’écran.

Affichage du vaisseau

Mettons à jour alien_invasion.py pour instancier et afficher le vaisseau :

--snip--
from settings import Settings
from ship import Ship

class AlienInvasion:
    """Classe principale gérant les ressources et le comportement du jeu."""

    def __init__(self):
        --snip--
        pygame.display.set_caption("Alien Invasion")
        self.ship = Ship(self)

    def run_game(self):
        --snip--
        # Redessine l'écran à chaque itération
        self.screen.fill(self.settings.bg_color)
        self.ship.blitme()
        pygame.display.flip()
--snip--

Après avoir importé la classe Ship, nous créons une instance en passant self en argument. L’appel à blitme() dessine le vaisseau après le remplissage de l’arrière-plan.

Refactorisation : méthodes _check_events() et _update_screen()

Avant d’ajouter de nouvelles fonctionnalités, nous restructurons le code pour le rendre plus modulaire. Les méthodes auxiliaires (préfixées par un tiret bas) isolent des tâches spécifiques.

Méthode _check_events()

Extrayons la gestion des événements :

def run_game(self):
    while True:
        self._check_events()
        self._update_screen()

def _check_events(self):
    """Répond aux pressions de touches et aux événements souris."""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

La nouvelle méthode centralise la détection des événements, ce qui allège la boucle principale.

Méthode _update_screen()

De même, isolons le rafraîchissement de l’écran :

def _update_screen(self):
    """Met à jour l’affichage et bascule vers le nouvel écran."""
    self.screen.fill(self.settings.bg_color)
    self.ship.blitme()
    pygame.display.flip()

La boucle principale devient plus concise : chaque itération vérifie les événements et met à jour l’écran. Cette organisation facilite l’extension future du jeu.