Jeu de serpent avec Python et Pygame

Introduction

Ce projet vous guidera tout au long du processus de création d'un jeu de serpent en utilisant Python et la bibliothèque Pygame. Le jeu aura une fenêtre de jeu, un serpent, un bonus et un score. Le serpent se déplacera dans la fenêtre de jeu et mangera le bonus. Lorsque le serpent mange le bonus, la longueur du serpent augmentera d'un cran. Le score sera affiché à l'écran.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment créer une fenêtre de jeu à l'aide de Pygame
• Comment gérer l'entrée utilisateur pour contrôler le mouvement du serpent
• Comment créer et mettre à jour la position du serpent
• Comment dessiner le serpent et le bonus à l'écran
• Comment détecter les collisions entre le serpent et le bonus
• Comment suivre le score
• Comment afficher le score à l'écran

🏆 Réalisations

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

• Utiliser Pygame pour créer une fenêtre de jeu graphique
• Gérer l'entrée utilisateur pour contrôler le jeu
• Créer et mettre à jour des objets de jeu
• Détecter les collisions dans un jeu
• Afficher et mettre à jour le score du jeu

Créer les fichiers du projet

Créez un nouveau fichier nommé snake_game.py et ouvrez-le dans un éditeur de code.

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

Importer les modules nécessaires

Dans le fichier snake_game.py, importez les modules pygame et random :

import pygame
import random

Initialiser Pygame

Après avoir importé les modules, initialisez Pygame :

pygame.init()

Configurer la fenêtre de jeu

Définissez la largeur, la hauteur et le nombre d'images par seconde (FPS) de la fenêtre de jeu :

LARGEUR = 800
HAUTEUR = 600
FPS = 10

Définir les couleurs

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

NOIR = (0, 0, 0)
BLANC = (255, 255, 255)
VERT = (0, 255, 0)
ROUGE = (255, 0, 0)
BLEU = (0, 0, 255)
JAUNE = (255, 255, 0)
COULEUR_FOND = (50, 50, 50)

Configurer la fenêtre de jeu

Configurez la fenêtre de jeu avec la largeur et la hauteur définies :

écran = pygame.display.set_mode((LARGEUR, HAUTEUR))
pygame.display.set_caption("Snake Game")
horloge = pygame.time.Clock()

Dans le code ci-dessus, pygame.display.set_mode() est utilisé pour initialiser l'affichage avec la largeur et la hauteur spécifiées. pygame.display.set_caption() est utilisé pour définir le titre de la fenêtre de jeu. pygame.time.Clock() est utilisé pour suivre le temps dans le jeu.

Configurer le serpent

Définissez la taille d'un bloc et la vitesse du serpent :

taille_bloc_serpent = 20
vitesse_serpent = 5

Nous définissons la taille d'un bloc sur 20 et la vitesse sur 5. Cela signifie que le serpent se déplacera de 5 pixels à la fois.

Configurer les variables du jeu

Définissez les styles de police et les tailles de police pour afficher le score :

style_police = pygame.font.SysFont(None, 50)
police_score = pygame.font.SysFont(None, 35)

Configurer le bonus

Définissez la taille d'un bloc du bonus :

taille_bloc_bonus = 20

Définir des fonctions

Définissez les fonctions suivantes :

dessiner_le_serpent(taille_bloc_serpent, liste_serpent)

Cette fonction dessine le serpent sur l'écran :

def dessiner_le_serpent(taille_bloc_serpent, liste_serpent):
    for x in liste_serpent:
        pygame.draw.rect(
            écran, VERT, [x[0], x[1], taille_bloc_serpent, taille_bloc_serpent]
        )

Dans le code ci-dessus, pygame.draw.rect() est utilisé pour dessiner un rectangle sur l'écran. Le premier paramètre est l'écran, le second paramètre est la couleur et le troisième paramètre est la position et la taille du rectangle.

dessiner_le_bonus(x_bonus, y_bonus)

Cette fonction dessine le bonus sur l'écran :

def dessiner_le_bonus(x_bonus, y_bonus):
    pygame.draw.rect(
        écran, ROUGE, [x_bonus, y_bonus, taille_bloc_bonus, taille_bloc_bonus]
    )

Dans le code ci-dessus, pygame.draw.rect() est utilisé pour dessiner un rectangle sur l'écran. Le premier paramètre est l'écran, le second paramètre est la couleur et le troisième paramètre est la position et la taille du rectangle.

afficher_le_score(score)

Cette fonction affiche le score sur l'écran :

def afficher_le_score(score):
    valeur = police_score.render("Score: " + str(score), VRAI, BLANC)
    écran.blit(valeur, [10, 10])

Dans le code ci-dessus, score_font.render() est utilisé pour rendre le score sur l'écran. Le premier paramètre est le texte à afficher, le second paramètre est l'anti-aliasing et le troisième paramètre est la couleur du texte. screen.blit() est utilisé pour dessiner le texte sur l'écran. Le premier paramètre est le texte à afficher et le second paramètre est la position du texte.

boucle_principale_du_jeu()

Cette fonction contient la boucle principale du jeu :

def boucle_principale_du_jeu():
    ## Code de la boucle principale du jeu ici

Compléter le code de la boucle de jeu

Complétez la fonction boucle_principale_du_jeu() en ajoutant la logique du jeu à l'intérieur de la boucle while.

def boucle_principale_du_jeu():
    partie_terminee = False
    partie_perdue = False

    ## Configurer la position de départ du serpent
    x1 = LARGEUR / 2
    y1 = HAUTEUR / 2
    changement_x1 = 0
    changement_y1 = 0

    ## Configurer le corps du serpent
    liste_serpent = []
    longueur_serpent = 1

    ## Configurer le bonus
    x_bonus = round(random.randrange(0, LARGEUR - taille_bloc_bonus) / 20) * 20
    y_bonus = round(random.randrange(0, HAUTEUR - taille_bloc_bonus) / 20) * 20

    ## Configurer la boucle principale du jeu
    while not partie_terminee:
        while partie_perdue:
            écran.fill(COULEUR_FOND)
            message = style_police.render("Appuyez sur ESPACE pour recommencer", VRAI, JAUNE)
            écran.blit(message, [LARGEUR / 2 - 200, HAUTEUR / 2 - 50])
            pygame.display.flip()

            for événement in pygame.event.get():
                if événement.type == pygame.QUIT:
                    partie_terminee = True
                    partie_perdue = False
                if événement.type == pygame.KEYDOWN:
                    if événement.key == pygame.K_SPACE:
                        boucle_principale_du_jeu()

        for événement in pygame.event.get():
            if événement.type == pygame.QUIT:
                partie_terminee = True
            if événement.type == pygame.KEYDOWN:
                if événement.key == pygame.K_LEFT:
                    changement_x1 = -taille_bloc_serpent
                    changement_y1 = 0
                elif événement.key == pygame.K_RIGHT:
                    changement_x1 = taille_bloc_serpent
                    changement_y1 = 0
                elif événement.key == pygame.K_UP:
                    changement_y1 = -taille_bloc_serpent
                    changement_x1 = 0
                elif événement.key == pygame.K_DOWN:
                    changement_y1 = taille_bloc_serpent
                    changement_x1 = 0

        if x1 >= LARGEUR or x1 < 0 or y1 >= HAUTEUR or y1 < 0:
            partie_perdue = True

        x1 += changement_x1
        y1 += changement_y1
        écran.fill(COULEUR_FOND)
        pygame.draw.rect(
            écran, BLEU, [x_bonus, y_bonus, taille_bloc_bonus, taille_bloc_bonus]
        )

        tête_serpent = []
        tête_serpent.append(x1)
        tête_serpent.append(y1)
        liste_serpent.append(tête_serpent)
        if len(liste_serpent) > longueur_serpent:
            del liste_serpent[0]

        for x in liste_serpent[:-1]:
            if x == tête_serpent:
                partie_perdue = True

        dessiner_le_serpent(taille_bloc_serpent, liste_serpent)
        afficher_le_score(longueur_serpent - 1)

        pygame.display.flip()

        if x1 == x_bonus and y1 == y_bonus:
            x_bonus = round(random.randrange(0, LARGEUR - taille_bloc_bonus) / 20) * 20
            y_bonus = (
                round(random.randrange(0, HAUTEUR - taille_bloc_bonus) / 20) * 20
            )
            longueur_serpent += 1

        horloge.tick(vitesse_serpent)

    pygame.quit()

Dans le code ci-dessus, pygame.QUIT est utilisé pour quitter le jeu. pygame.KEYDOWN est utilisé pour vérifier si une touche est enfoncée. pygame.K_LEFT, pygame.K_RIGHT, pygame.K_UP et pygame.K_DOWN sont utilisés pour vérifier si les flèches gauche, droite, haut et bas sont enfoncées respectivement. pygame.draw.rect() est utilisé pour dessiner un rectangle sur l'écran. Le premier paramètre est l'écran, le second paramètre est la couleur et le troisième paramètre est la position et la taille du rectangle. pygame.display.flip() est utilisé pour mettre à jour l'écran. pygame.time.Clock() est utilisé pour suivre le temps dans le jeu. pygame.time.Clock.tick() est utilisé pour définir les FPS du jeu.

Lancer le jeu

Ajoutez ce qui suit à la fin du fichier pour lancer le jeu :

boucle_principale_du_jeu()
pygame.quit()

Enfin, basculez sur le bureau et exécutez le projet avec la commande suivante :

python snake_game.py

Résumé

Félicitations ! Vous avez réussi à créer un jeu de serpent avec Python et la bibliothèque Pygame. Dans ce projet, vous avez appris à configurer la fenêtre du jeu, à définir des couleurs, à dessiner le serpent et le bonus, à afficher le score et à implémenter la logique du jeu. Vous pouvez désormais exécuter le jeu et l'amuser.