Comment créer un jeu de serpent en Python

Si vous aimez jouer au jeu du serpent, je suis sûr que vous trouverez cet article intéressant.

Dans cet article, je vais vous apprendre à créer un jeu de serpent simple que même un débutant en Python trouvera facile à développer.

Il existe plusieurs façons de créer ce jeu. L’une d’entre elles consiste à utiliser la bibliothèque PyGame de Python, qui est une bibliothèque Python que nous utilisons pour créer des jeux.

L’autre méthode consiste à utiliser la bibliothèque turtle. Ce module est préinstallé avec Python et fournit une toile virtuelle permettant aux utilisateurs de créer des formes et des images.

Par conséquent, cet article utilisera la bibliothèque turtle pour mettre en œuvre notre jeu de serpent simple qui est convivial pour les débutants, en particulier pour les développeurs Python novices.

En plus de ce module, nous utiliserons également deux autres modules, à savoir

Module Time – Cette méthode nous permettra de suivre le nombre de secondes qui se sont écoulées depuis l’heure précédente.
Module Random – Il génère des nombres de manière aléatoire en Python.

Les autres outils de base dont vous aurez besoin comprennent un éditeur de texte de votre choix. J’utiliserai VSCode dans cet article. Bien entendu, vous devrez installer Python 3 sur votre machine si vous ne l’avez pas déjà. Vous pouvez également utiliser le compilateur Geekflare.

Cela devrait être amusant !

Comment fonctionne le jeu du serpent

Le but ultime de ce jeu est que le joueur atteigne le score le plus élevé en contrôlant le serpent pour collecter la nourriture affichée à l’écran.

Le joueur contrôle le serpent à l’aide de quatre touches de direction qui sont relatives à la direction vers laquelle le serpent se déplace. Si le serpent heurte un bloc ou se heurte lui-même, le joueur perd la partie.

Les étapes suivantes seront suivies pour mettre en œuvre ce jeu.

Importer dans nos programmes les modules préinstallés (tortue, temps et aléatoire).
Création de l’affichage de l’écran du jeu à l’aide du module turtle.
Définition des touches pour la direction de déplacement du serpent autour de l’écran.
L’implémentation du jeu.

Créez un fichier snakegame.py dans lequel nous ajouterons le code d’implémentation.

Importation des modules

Cette partie du code importera les modules turtle, time et random qui sont préinstallés par défaut dans Python. En outre, nous définirons des valeurs par défaut pour le score initial du joueur, le score le plus élevé qu’il atteindra et le temps de retard pris par le joueur à chaque coup. Le module time est utilisé ici pour calculer le temps de retard.

Ajoutez le code suivant à votre fichier snakegame.py.

import turtle
import random
import time

score_joueur = 0
score_le plus élevé = 0
temps_délai = 0,1

Création de l’écran du jeu

Le module turtle que nous importons ici va nous permettre de créer une toile virtuelle qui sera la fenêtre d’affichage du jeu. A partir de là, nous pouvons créer le corps du serpent et la nourriture qu’il collectera. Notre écran affichera également le score suivi par le joueur.

Ajoutez ce code au fichier Python.

# écran de fenêtre créé
wind = turtle.Screen()
wind.title("Snake Maze🐍")
wind.bgcolor("red")

# La taille de l'écran
wind.setup(width=600, height=600)


# créer le serpent 
snake = turtle.Turtle()
snake.shape("square")
snake.color("noir")
snake.penup()
snake.goto(0, 0)
snake.direction = "Stop"

# création de la nourriture
snake_food = turtle.Turtle()
shapes = random.choice('triangle','cercle')
snake_food.shape(shapes)
snake_food.color("blue")
snake_food.speed(0)
snake_food.penup()
snake_food.goto(0, 100)

pen = turtle.Turtle()
pen.speed(0)
pen.shape('square')
pen.color('white')
pen.penup()
pen.hideturtle()
pen.goto(0, 250)
pen.write("Votre_score : 0 Highest_Score : 0", align="center", 
font=("Arial", 24, "normal"))
turtle.mainloop()

L’extrait de code ci-dessus commence par initialiser l’écran de la tortue et lui transmet un titre et une couleur de fond. Après avoir défini la taille de la fenêtre de notre écran, nous dessinons la forme du serpent sur la toile virtuelle.

La méthode penup() récupère simplement le stylo de la tortue afin qu’une ligne ne soit pas dessinée lorsque la tortue se déplace. La méthode goto(x,y) contient des positions de coordonnées qui déplacent la tortue vers une position absolue.

Nous créons ensuite la nourriture que le serpent collecte. Nous voulons afficher le score du joueur à chaque fois que le serpent ramasse la nourriture et le score le plus élevé atteint par le joueur au cours du jeu. Nous utilisons donc la méthode pen.write() pour mettre cela en œuvre. La méthode hideturtle() cache l’icône de la tortue à l’écran dans la section de l’en-tête où ce texte est écrit.

Il est important d’ajouter la méthode turtle.mainloop() à la fin de votre code, qui affichera l’écran plus longtemps pour permettre à l’utilisateur de faire quelque chose à l’écran.

Exécutez le fichier et vous devriez obtenir la sortie suivante :

The snake and food display with the player's initial and highest score.

Configuration des touches de direction pour le serpent

Ici, nous allons configurer des touches spécifiques qui guideront la direction dans laquelle le serpent se déplacera à l’écran. Nous utiliserons les touches ‘L’ pour la gauche, ‘R’ pour la droite, ‘U’ pour le haut, ‘D’ pour le bas. Nous mettrons en œuvre ces directions en utilisant la fonction direction de la tortue que nous appellerons sur le serpent.

Ajoutez l’extrait de code suivant à votre code.

# Attribution des directions
def moveleft() :
    if snake.direction != "right" :
        snake.direction = "left"

def moveright() :
    si snake.direction != "left" :
        snake.direction = "right"

def moveup() :
    si snake.direction != "down" :
        snake.direction = "up"

def movedown() :
    si snake.direction != "up" :
        snake.direction = "down"

def move() :
    si snake.direction == "up" :
        coord_y = snake.ycor()
        snake.sety(coord_y 20)

    si snake.direction == "down" :
        coord_y = snake.ycor()
        snake.sety(coord_y-20)

    si snake.direction == "right" :
        coord_x = snake.xcor()
        snake.setx(coord_x 20)

    si snake.direction == "left" :
        coord_x = snake.xcor()
        snake.setx(coord_x-20)

wind.listen()
wind.onkeypress(moveleft, 'L')
wind.onkeypress(moveright, 'R')
wind.onkeypress(moveup, 'U')
wind.onkeypress(moveown, 'D')

La fonction move() ci-dessus définit le mouvement du serpent dans la position définie à l’intérieur d’une valeur de coordonnées précise.

La fonction listen() est un écouteur d’événements qui appelle les méthodes qui déplacent le serpent dans une direction particulière lorsque le joueur appuie sur une touche.

Mise en œuvre du gameplay du jeu du serpent

Après avoir posé les bases de notre jeu de serpent, nous allons devoir le faire fonctionner en temps réel.

Pour ce faire, nous devrons

Augmenter la longueur du serpent à chaque fois qu’il collecte de la nourriture en utilisant de préférence une couleur différente.
Incrémenter le score du joueur à chaque fois que le serpent ramasse la nourriture et suivre le score le plus élevé.
Le joueur peut empêcher le serpent d’entrer en collision avec le mur ou avec son propre corps.
Le jeu recommence lorsque le serpent entre en collision.
Le score du joueur est remis à zéro lorsque le jeu redémarre, tandis que l’écran conserve le score le plus élevé du joueur.

Ajoutez le reste de ce code à votre fichier python.

segments = []

#Implémentation du gameplay
while True :
    wind.update()
    if snake.xcor() > 290 or snake.xcor() < -290 or snake.ycor() > 290 or snake.ycor() < -290 :
        time.sleep(1)
        snake.goto(0, 0)
        snake.direction = "Stop"
        snake.shape("square")
        snake.color("green")

        pour segment dans segments :
            segment.goto(1000, 1000)
            segments.clear()
            score_joueur = 0
            delay_time = 0.1
            pen.clear()
            pen.write("Score_du_joueur : {} Meilleur score : {}".format(score_joueur, meilleur score), align="center", font=("Arial", 24, "normal"))

        if snake.distance(snake_food) < 20 :
            coord_x = random.randint(-270, 270)
            coord_y = random.randint(-270, 270)
            snake_food.goto(coord_x, coord_y)

            # Ajout d'un segment
            segment_ajouté = turtle.Turtle()
            segment_ajouté.vitesse(0)
            segment_ajouté.forme("carré")
            segment_ajouté.couleur("blanc")
            segment_ajouté.penup()
            segments.append(segment_ajouté)
            delay_time -= 0.001
            score_joueur = 5

            si score_du_joueur > score_le_plus_élevé :
                score_le_plus_élevé = score_le_joueur
                pen.clear()
                pen.write("Score du joueur : {} Meilleur score : {}".format(score_joueur, meilleur score), align="center", font=("Arial", 24, "normal"))

    # vérification des collisions
    for i in range(len(segments)-1, 0, -1) :
        coord_x = segments[i-1].xcor()
        coord_y = segments[i-1].ycor()
        segments[i].goto(coord_x, coord_y)

    si len(segments) > 0 :
        coord_x = snake.xcor()
        coord_y = snake.ycor()
        segments[0].goto(coord_x, coord_y)
    move()

    pour segment dans segments :
        if segment.distance(snake) < 20 :
            time.sleep(1)
            snake.goto(0, 0)
            snake.direction = "stop"
            snake.color('white')
            snake.shape('square')

            pour segment dans segments :
                segment.goto(1000, 1000)
                segment.clear()
                score_joueur = 0
                delay_time = 0.1
                pen.clear()
                pen.write("Score_du_joueur : {} Score le plus élevé : {}".format(score_joueur, score le plus élevé), align="center", font=("Arial", 24, "normal"))

     time.sleep(delay_time)

turtle.mainloop()

Dans l’extrait de code ci-dessus, nous avons défini une position aléatoire pour la nourriture du serpent à l’intérieur de l’écran. Chaque fois que le serpent ramasse cette nourriture, le segment de son corps augmente d’une couleur différente ; le blanc, dans ce cas, pour distinguer sa croissance.

Une fois que le serpent a collecté la nourriture sans entrer en collision, la nourriture est placée à une position aléatoire dans la plage de 270 coordonnées de la taille de l’écran. Chaque fois que le serpent ramasse de la nourriture, le score du joueur augmente de 5. Lorsque le serpent entre en collision, le score du joueur est fixé à 0, tandis que l’écran conserve son score le plus élevé.

Renvoyez maintenant le fichier Python et vous devriez voir votre écran de tortue ressembler à ceci :

Conclusion 🐍

L’utilisation de la bibliothèque turtle est un moyen amusant et facile de créer le jeu de serpent comme nous l’avons vu dans cet article. Alternativement, vous pouvez mettre en œuvre la même chose en utilisant la bibliothèque PyGame. Vous pouvez consulter le tutoriel PyGame ici et voir comment vous pourriez mettre en œuvre le jeu différemment.

Vous pouvez également essayer un jeu de devinettes en Python ou comment obtenir des données JSON en Python.
Bon codage !

Neema Muganga
Contributeur
- LinkedIn
Neema Muganga is an experienced technical writer and skilled web developer with a flair for writing on web development and coding. Neema uses her experience to write on Python, Flask, Django, and even Blockchain, with expertise that makes even the most technical subjects easy to comprehend.