Python4Games

Créer un casse-brique en Python avec Pygame

Posted on by Lucan

Introduction

Le casse-brique est un jeu vidéo classique où le joueur contrôle une raquette pour renvoyer une balle et détruire des briques placées en haut de l'écran. Grâce à Pygame, une bibliothèque populaire de Python dédiée au développement de jeux, vous pouvez créer votre propre version de ce jeu emblématique avec des mécanismes de base comme le mouvement de la raquette, le rebond de la balle, et la destruction des briques.

Dans cet article, nous allons vous guider à travers les étapes de création d’un casse-brique en Python en utilisant Pygame. Ce projet comprend :

  1. La création d'une raquette contrôlable.
  2. L'ajout d'une balle rebondissante.
  3. La mise en place de briques destructibles.
  4. La gestion des collisions et du score.

1. Préparer l'environnement et initialiser Pygame

Installation de Pygame

Si vous n'avez pas encore Pygame installé, vous pouvez l'installer avec pip :

pip install pygame

Initialiser Pygame et créer la fenêtre de jeu

Commencez par initialiser Pygame et créer une fenêtre où se déroulera le jeu. Définissons les dimensions de l’écran, les couleurs et le titre de la fenêtre.

import pygame
import sys

# Initialisation de Pygame
pygame.init()

# Dimensions de la fenêtre
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Couleurs
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)

# Créer la fenêtre
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Casse-Brique")

# Horloge pour contrôler le FPS
clock = pygame.time.Clock()

2. Créer la raquette contrôlable

La raquette est un rectangle contrôlé par le joueur avec les touches fléchées gauche et droite. Nous allons créer une classe Raquette pour gérer son mouvement et son affichage.

Définition de la classe Raquette

class Raquette:
    def __init__(self):
        self.width = 100
        self.height = 20
        self.x = (SCREEN_WIDTH - self.width) // 2
        self.y = SCREEN_HEIGHT - 50
        self.speed = 10
        self.rect = pygame.Rect(self.x, self.y, self.width, self.height)

    def move(self, keys):
        if keys[pygame.K_LEFT] and self.rect.left > 0:
            self.rect.x -= self.speed
        if keys[pygame.K_RIGHT] and self.rect.right < SCREEN_WIDTH:
            self.rect.x += self.speed

    def draw(self, screen):
        pygame.draw.rect(screen, BLUE, self.rect)

Explication :

  • self.rect : Définit la position et la taille de la raquette.
  • move() : Gère le déplacement en fonction des touches pressées.
  • draw() : Dessine la raquette à l’écran.

3. Ajouter une balle rebondissante

La balle est un cercle qui se déplace et rebondit sur les murs, la raquette et les briques. Créez une classe Balle pour gérer son mouvement et son interaction avec les autres éléments.

Définition de la classe Balle

class Balle:
    def __init__(self):
        self.radius = 10
        self.x = SCREEN_WIDTH // 2
        self.y = SCREEN_HEIGHT // 2
        self.speed_x = 5
        self.speed_y = -5
        self.rect = pygame.Rect(self.x - self.radius, self.y - self.radius, self.radius * 2, self.radius * 2)

    def move(self):
        self.rect.x += self.speed_x
        self.rect.y += self.speed_y

        # Rebonds sur les murs
        if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH:
            self.speed_x = -self.speed_x
        if self.rect.top <= 0:
            self.speed_y = -self.speed_y

    def draw(self, screen):
        pygame.draw.circle(screen, RED, (self.rect.x + self.radius, self.rect.y + self.radius), self.radius)

Explication :

  • move() : Déplace la balle et gère les rebonds sur les bords de l’écran.
  • draw() : Affiche la balle à l’écran sous forme de cercle.

Détection de la collision entre la balle et la raquette

Ajoutez une méthode dans la classe Balle pour gérer la collision entre la balle et la raquette.

    def check_collision(self, raquette):
        if self.rect.colliderect(raquette.rect):
            self.speed_y = -self.speed_y

4. Créer et gérer des briques destructibles

Les briques sont placées en haut de l'écran et sont détruites lorsqu'elles sont touchées par la balle. Chaque brique sera un rectangle, et nous utiliserons une liste pour stocker toutes les briques.

Définition de la classe Brique

class Brique:
    def __init__(self, x, y):
        self.width = 80
        self.height = 30
        self.rect = pygame.Rect(x, y, self.width, self.height)

    def draw(self, screen):
        pygame.draw.rect(screen, BLACK, self.rect)

Créer plusieurs briques

Nous allons créer un mur de briques en ajoutant des briques dans une grille à l'écran.

def creer_briques():
    briques = []
    for row in range(5):  # 5 lignes de briques
        for col in range(10):  # 10 colonnes
            brique = Brique(col * 80 + 10, row * 30 + 10)
            briques.append(brique)
    return briques

briques = creer_briques()

Collision entre la balle et les briques

Ajoutez une méthode pour vérifier la collision de la balle avec les briques et détruire celles qui sont touchées.

    def check_collision_briques(self, briques):
        for brique in briques:
            if self.rect.colliderect(brique.rect):
                briques.remove(brique)
                self.speed_y = -self.speed_y
                break


5. Boucle de jeu principale et gestion des événements
Nous avons maintenant tous les éléments pour faire fonctionner le jeu. Voici la boucle principale du jeu qui gère le rendu, les événements et la logique de collision.

Initialiser les objets du jeu

raquette = Raquette()
balle = Balle()
briques = creer_briques()

Boucle de jeu

running = True
while running:
clock.tick(60) # Limite à 60 FPS
keys = pygame.key.get_pressed()

# Gestion des événements
for event in pygame.event.get():
    if event.type == pygame.QUIT:
        running = False

# Déplacement de la raquette
raquette.move(keys)

# Déplacement de la balle
balle.move()

# Vérification des collisions
balle.check_collision(raquette)
balle.check_collision_briques(briques)

# Effacer l'écran et dessiner les éléments
screen.fill(WHITE)
raquette.draw(screen)
balle.draw(screen)

for brique in briques:
    brique.draw(screen)

pygame.display.flip()

pygame.quit()

6. Améliorations et extensions

Vous avez maintenant un jeu de casse-brique fonctionnel, mais vous pouvez continuer à l'améliorer. Voici quelques idées pour aller plus loin :

  • Système de score : Comptez le nombre de briques détruites et affichez le score à l'écran.
  • Niveaux : Ajoutez des niveaux supplémentaires avec des configurations de briques différentes et une balle plus rapide à chaque niveau.
  • Game Over : Gérer les situations où la balle tombe sous la raquette et ajouter des vies pour rendre le jeu plus difficile.

Conclusion

Créer un casse-brique en Python avec Pygame est un excellent projet pour se familiariser avec la programmation de jeux vidéo en 2D. En utilisant Pygame, vous avez appris à créer des éléments comme la raquette, la balle, et les briques destructibles, ainsi qu’à gérer les collisions et le mouvement des objets.

Avec ce projet, vous avez les bases pour développer des jeux plus complexes en ajoutant des niveaux, des scores, ou des mécanismes supplémentaires.

Code complet pour un casse-brique en Python :

import pygame
import sys

# Initialiser Pygame
pygame.init()

# Dimensions de la fenêtre
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Couleurs
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)

# Créer la fenêtre
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Casse-Brique")

# Horloge pour contrôler le FPS
clock = pygame.time.Clock()

# Classe Raquette
class Raquette:
    def __init__(self):
        self.width = 100
        self.height = 20
        self.x = (SCREEN_WIDTH - self.width) // 2
        self.y = SCREEN_HEIGHT - 50
        self.speed = 10
        self.rect = pygame.Rect(self.x, self.y, self.width, self.height)

    def move(self, keys):
        if keys[pygame.K_LEFT] and self.rect.left > 0:
            self.rect.x -= self.speed
        if keys[pygame.K_RIGHT] and self.rect.right < SCREEN_WIDTH:
            self.rect.x += self.speed

    def draw(self, screen):
        pygame.draw.rect(screen, BLUE, self.rect)

# Classe Balle
class Balle:
    def __init__(self):
        self.radius = 10
        self.x = SCREEN_WIDTH // 2
        self.y = SCREEN_HEIGHT // 2
        self.speed_x = 5
        self.speed_y = -5
        self.rect = pygame.Rect(self.x - self.radius, self.y - self.radius, self.radius * 2, self.radius * 2)

    def move(self):
        self.rect.x += self.speed_x
        self.rect.y += self.speed_y

        # Rebonds sur les murs
        if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH:
            self.speed_x = -self.speed_x
        if self.rect.top <= 0:
            self.speed_y = -self.speed_y

    def draw(self, screen):
        pygame.draw.circle(screen, RED, (self.rect.x + self.radius, self.rect.y + self.radius), self.radius)

    def check_collision(self, raquette):
        if self.rect.colliderect(raquette.rect):
            self.speed_y = -self.speed_y

    def check_collision_briques(self, briques):
        for brique in briques:
            if self.rect.colliderect(brique.rect):
                briques.remove(brique)
                self.speed_y = -self.speed_y
                break

# Classe Brique
class Brique:
    def __init__(self, x, y):
        self.width = 80
        self.height = 30
        self.rect = pygame.Rect(x, y, self.width, self.height)

    def draw(self, screen):
        pygame.draw.rect(screen, BLACK, self.rect)

# Créer plusieurs briques
def creer_briques():
    briques = []
    for row in range(5):  # 5 lignes de briques
        for col in range(10):  # 10 colonnes
            brique = Brique(col * 80 + 10, row * 30 + 10)
            briques.append(brique)
    return briques

# Initialiser les objets du jeu
raquette = Raquette()
balle = Balle()
briques = creer_briques()

# Boucle de jeu
running = True
while running:
    clock.tick(60)  # Limite à 60 FPS
    keys = pygame.key.get_pressed()

    # Gestion des événements
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Déplacement de la raquette
    raquette.move(keys)

    # Déplacement de la balle
    balle.move()

    # Vérification des collisions
    balle.check_collision(raquette)
    balle.check_collision_briques(briques)

    # Effacer l'écran et dessiner les éléments
    screen.fill(WHITE)
    raquette.draw(screen)
    balle.draw(screen)

    for brique in briques:
        brique.draw(screen)

    pygame.display.flip()

pygame.quit()

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *