Jeu de Pong classique avec Python et Pygame

Introduction

Dans ce projet, vous allez apprendre à créer un jeu de Pong en utilisant Python et la bibliothèque Pygame. Pong est un jeu arcade classique à deux joueurs où les joueurs contrôlent des palettes pour envoyer une balle l'une à l'autre.

Pour terminer ce projet, vous devrez suivre les étapes suivantes. Nous commencerons par créer les fichiers du projet et configurer la fenêtre du jeu. Ensuite, nous définirons les couleurs et configurerons les palettes et la balle. Enfin, nous déplacerons les palettes et la balle, gérerons les collisions et dessinons les éléments du jeu.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment créer les fichiers du projet
• Comment configurer la fenêtre du jeu
• Comment configurer les palettes et la balle
• Comment configurer les variables du jeu
• Comment configurer la boucle de jeu
• Comment déplacer les palettes
• Comment déplacer la balle
• Comment gérer les collisions de la balle
• Comment mettre à jour les scores et réinitialiser la balle
• Comment gérer les collisions et le mouvement des power-ups
• Comment dessiner les éléments du jeu
• Comment dessiner le score
• Comment mettre à jour l'affichage
• Comment définir le nombre d'images par seconde (FPS)
• Comment quitter le jeu

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Utiliser la bibliothèque Pygame pour créer une fenêtre de jeu
• Configurer et déplacer des objets de jeu tels que des palettes et une balle
• Gérer les collisions entre les objets de jeu
• Mettre à jour et afficher les scores du jeu
• Définir le nombre d'images par seconde (FPS) pour le jeu
• Quitter le jeu correctement

Créer les fichiers du projet

Créez un fichier nommé pong_game.py dans votre éditeur de code ou IDE préféré. Ce sera le fichier principal où vous écrirez le code pour le jeu de Pong.

cd ~/projet
touch pong_game.py
sudo pip install pygame

Configurer la fenêtre de jeu

Dans le fichier pong_game.py, importez les bibliothèques requises au début du code :

import pygame
import random

Ensuite, initialisez Pygame en appelant pygame.init() :

## Initialiser Pygame
pygame.init()

Ensuite, configurez la fenêtre du jeu en définissant la largeur, la hauteur et le nombre d'images par seconde (FPS) :

## Configurer la fenêtre du jeu
LARGEUR = 800
HAUTEUR = 400
FPS = 60

Définissez les couleurs utilisées dans le jeu :

## Définir les couleurs
NOIR = (0, 0, 0)
BLANC = (255, 255, 255)
BLEU = (0, 0, 255)
ORANGE = (255, 165, 0)
COULEUR_FOND = (50, 50, 50)

Créez la fenêtre du jeu, définissez le titre de la fenêtre et créez un objet horloge pour contrôler le taux de trame :

## Configurer la fenêtre du jeu
ecran = pygame.display.set_mode((LARGEUR, HAUTEUR))
pygame.display.set_caption("Jeu de Pong")
horloge = pygame.time.Clock()

Configurer les palettes et la balle

Définir les propriétés des raquettes, telles que la largeur, la hauteur, la vitesse et la couleur :

## Set up the paddles
PADDLE_WIDTH = 10
PADDLE_HEIGHT = 60
PADDLE_SPEED = 5
PADDLE_COLOR = WHITE

Créer deux objets raquettes en utilisant le constructeur pygame.Rect() et les positionner au centre de chaque côté de la fenêtre de jeu :

paddle1 = pygame.Rect(0, HEIGHT / 2 - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT)
paddle2 = pygame.Rect(
    WIDTH - PADDLE_WIDTH, HEIGHT / 2 - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT
)

Configurer les propriétés de la balle, telles que la largeur, la hauteur, la vitesse et la couleur :

## Set up the ball
BALL_WIDTH = 10
BALL_HEIGHT = 10
BALL_SPEED_X = 3
BALL_SPEED_Y = 3
BALL_COLOR = WHITE

Créer un objet balle en utilisant le constructeur pygame.Rect() et le positionner au centre de la fenêtre de jeu :

ball = pygame.Rect(
    WIDTH / 2 - BALL_WIDTH / 2, HEIGHT / 2 - BALL_HEIGHT / 2, BALL_WIDTH, BALL_HEIGHT
)

Définir la vitesse initiale de la balle dans les directions x et y de manière aléatoire :

ball_speed_x = BALL_SPEED_X * random.choice((1, -1))
ball_speed_y = BALL_SPEED_Y * random.choice((1, -1))

Configurer les power-ups, tels que la largeur, la hauteur, la vitesse et la couleur :

## Set up the power-ups
POWERUP_WIDTH = 10
POWERUP_HEIGHT = 10
POWERUP_SPEED = 2
POWERUP_COLOR = ORANGE

powerup = pygame.Rect(
    WIDTH / 2 - POWERUP_WIDTH / 2,
    HEIGHT / 2 - POWERUP_HEIGHT / 2,
    POWERUP_WIDTH,
    POWERUP_HEIGHT,
)
powerup_speed_x = POWERUP_SPEED * random.choice((1, -1))
powerup_speed_y = POWERUP_SPEED * random.choice((1, -1))
powerup_active = False

Configurer les variables du jeu

Configurez les variables pour suivre les scores des joueurs, créez un objet de police de jeu et définissez la couleur pour l'affichage du score :

## Configurer les variables du jeu
score1 = 0
score2 = 0
police_jeu = pygame.font.SysFont(None, 48)
COULEUR_SCORE = BLANC

Configurer la boucle de jeu

Créez une variable booléenne running et définissez-la sur True pour démarrer la boucle de jeu :

## Configurer la boucle de jeu
en_cours = True
while en_cours:

Dans la boucle de jeu, gérer les événements en parcourant les événements survenus :

    for evenement in pygame.event.get():
        if evenement.type == pygame.QUIT:
            en_cours = False

Déplacer les palettes

Dans la boucle de jeu, vérifiez l'entrée du clavier pour déplacer les palettes :

    ## Déplacer les palettes
    touches = pygame.key.get_pressed()
    if touches[pygame.K_w] and palette1.y > 0:
        palette1.y -= VITESSE_PALETTE
    if touches[pygame.K_s] and palette1.y < HAUTEUR - HAUTEUR_PALETTE:
        palette1.y += VITESSE_PALETTE
    if touches[pygame.K_UP] and palette2.y > 0:
        palette2.y -= VITESSE_PALETTE
    if touches[pygame.K_DOWN] and palette2.y < HAUTEUR - HAUTEUR_PALETTE:
        palette2.y += VITESSE_PALETTE

Déplacer la balle

Dans la boucle de jeu, mettez à jour la position de la balle :

    ## Déplacer la balle
    balle.x += vitesse_balle_x
    balle.y += vitesse_balle_y

Gérer les collisions de la balle

Dans la boucle de jeu, gérer les collisions de la balle avec les palettes et les murs :

    ## Collision de la balle avec les palettes
    if balle.colliderect(palette1) ou balle.colliderect(palette2):
        vitesse_balle_x *= -1

    ## Collision de la balle avec les murs
    if balle.y > HAUTEUR - HAUTEUR_BALLE ou balle.y < 0:
        vitesse_balle_y *= -1

Mettre à jour les scores et réinitialiser la balle

Dans la boucle de jeu, mettez à jour les scores et réinitialisez la balle lorsqu'elle dépasse la palette :

    ## Augmenter le score et réinitialiser la balle
    if balle.x < 0:
        score2 += 1
        balle.center = (LARGEUR / 2, HAUTEUR / 2)
        vitesse_balle_x *= random.choice((1, -1))
        vitesse_balle_y *= random.choice((1, -1))
    if balle.x > LARGEUR:
        score1 += 1
        balle.center = (LARGEUR / 2, HAUTEUR / 2)
        vitesse_balle_x *= random.choice((1, -1))
        vitesse_balle_y *= random.choice((1, -1))

Gérer les collisions et le mouvement des boosts de puissance

Dans la boucle de jeu, gérer les collisions des boosts de puissance avec les palettes et déplacer le boost de puissance :

    ## Collision du boost de puissance avec les palettes
    if boost_de_puissance.colliderect(palette1) ou boost_de_puissance.colliderect(palette2):
        boost_de_puissance_actif = True
        boost_de_puissance.x = LARGEUR / 2 - LARGEUR_BOOST_DE_PUISSANCE / 2
        boost_de_puissance.y = HAUTEUR / 2 - HAUTEUR_BOOST_DE_PUISSANCE / 2

    ## Mouvement du boost de puissance
    if boost_de_puissance_actif:
        boost_de_puissance.x += vitesse_boost_de_puissance_x
        boost_de_puissance.y += vitesse_boost_de_puissance_y

        if boost_de_puissance.x > LARGEUR - LARGEUR_BOOST_DE_PUISSANCE ou boost_de_puissance.x < 0:
            vitesse_boost_de_puissance_x *= -1
        if boost_de_puissance.y > HAUTEUR - HAUTEUR_BOOST_DE_PUISSANCE ou boost_de_puissance.y < 0:
            vitesse_boost_de_puissance_y *= -1

Dessiner les éléments du jeu

Dans la boucle de jeu, dessinez les palettes, la balle, le boost de puissance et le score sur la fenêtre de jeu :

    ## Dessiner les éléments du jeu
    screen.fill(COULEUR_FOND)
    pygame.draw.rect(screen, COULEUR_PALETTE, palette1)
    pygame.draw.rect(screen, COULEUR_PALETTE, palette2)
    pygame.draw.ellipse(screen, COULEUR_BALLE, balle)
    pygame.draw.rect(screen, COULEUR_BOOST_DE_PUISSANCE, boost_de_puissance)

Dessiner le score

Dans la boucle de jeu, dessinez les scores au centre supérieur de la fenêtre de jeu :

    ## Dessiner le score
    texte_score = police_du_jeu.render(f"{score1} : {score2}", Vrai, COULEUR_SCORE)
    screen.blit(texte_score, (LARGEUR / 2 - texte_score.get_width() / 2, 10))

Mettre à jour l'affichage

Dans la boucle de jeu, mettez à jour l'affichage pour montrer les changements :

    ## Mettre à jour l'affichage
    pygame.display.flip()

Réglage des FPS

Dans la boucle de jeu, réglez le taux d'images par seconde pour contrôler la vitesse du jeu :

    ## Régler le FPS
    clock.tick(FPS)

Quitter le jeu

Après la boucle de jeu, ajoutez la ligne suivante pour quitter Pygame lorsque le jeu est terminé :

## Quitter le jeu
pygame.quit()

Retournez sur le bureau et exécutez le projet en utilisant la commande suivante :

python pong_game.py

Maintenant, vous pouvez jouer au jeu Pong en utilisant les flèches directionnelles et les touches W et S de votre clavier.

Résumé

Félicitations ! Vous avez terminé le projet étape par étape de création d'un jeu de Pong en utilisant Python et Pygame. Vous avez appris à configurer la fenêtre de jeu, à définir les propriétés des palettes et de la balle, à gérer les événements du jeu, à déplacer les palettes et la balle, à gérer les collisions et à dessiner les éléments du jeu. Expérimentez différentes modifications pour ajouter vos propres améliorations au jeu et amusez-vous bien !