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

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

Il existe plusieurs façons de créer ce jeu et l'une inclut l'utilisation de 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 de tortues. 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 de tortues pour implémenter notre jeu de serpent simple, adapté aux débutants, en particulier pour les développeurs Python novices.

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

  • Module de temps - Cette méthode nous permettra de garder une trace du nombre de secondes qui se sont écoulées depuis la dernière fois.
  • Module aléatoire - Il génère des nombres de manière aléatoire en Python.

D'autres outils de base que vous devrez utiliser incluent un éditeur de texte de votre choix. Je vais utiliser VSCode dans cet article. Bien sûr, 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 obtienne 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 frappe un bloc ou lui-même, le joueur perd la partie.

Les étapes suivantes que nous suivrons pour mettre en œuvre ce jeu.

  • Importation dans nos programmes des modules pré-installés (turtle, time et random).
  • Création de l'affichage de l'écran du jeu à l'aide du module tortue.
  • Réglage des touches pour la direction de déplacement du serpent autour de l'écran.
  • La mise en œuvre du gameplay.

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. De plus, nous définirons ensuite des valeurs par défaut pour le score initial du joueur, le score le plus élevé que le joueur atteindra et le temps de retard pris par le joueur à chaque mouvement. Le module de temps est utilisé ici pour calculer le temps de retard.

Ajoutez le morceau de code suivant à votre fichier snakegame.py.

import turtle
import random
import time

player_score = 0
highest_score = 0
delay_time = 0.1

Création de l'affichage de l'écran du jeu

Le module tortue que nous importons ici nous permettra de créer un canevas virtuel qui sera l'écran de la fenêtre du jeu. De là, nous pouvons créer le corps du serpent et la nourriture que le serpent collectera. Notre écran affichera également le score suivi du joueur.

Ajoutez ce code au fichier Python.

# window screen created
wind = turtle.Screen()
wind.title("Snake Maze🐍")
wind.bgcolor("red")

# The screen size
wind.setup(width=600, height=600)


# creating the snake 
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 0)
snake.direction = "Stop"

# creating the food
snake_food = turtle.Turtle()
shapes = random.choice('triangle','circle')
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("Your_score: 0 Highest_Score : 0", align="center", 
font=("Arial", 24, "normal"))
turtle.mainloop()

L'extrait de code ci-dessus commence par l'initialisation de l'écran de la tortue et transmet un titre et une couleur d'arrière-plan à l'écran. 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() prend simplement le stylo de la tortue afin qu'une ligne ne soit pas tracé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 recueille. Nous voudrons afficher le score du joueur chaque fois que le serpent récupère la nourriture et le score le plus élevé atteint par le joueur pendant la partie. Par conséquent, nous utilisons la méthode pen.write() pour implémenter cela. Le hideturtle () cache l'icône de tortue de l'écran sur la section d'en-tête où ce texte est écrit.

Il est important d'ajouter la tortue.mainloop() à la fin de votre code, ce qui affichera l'écran plus longtemps pour vous permettre à l'utilisateur de faire quelque chose à l'écran.

Exécutez le fichier et vous devriez avoir le résultat suivant :

Le serpent et la nourriture s'affichent avec le score initial et le plus élevé du joueur.

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 le 'L' pour la gauche, le 'R' pour la droite, le 'U' pour le haut, le 'D' pour le bas. Nous allons implémenter ces directions en utilisant la fonction direction de la tortue que nous appellerons sur le serpent.

Ajoutez l'extrait de code suivant à votre code.

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

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

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

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

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

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

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

    if 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(movedown, 'D')

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

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

L'implémentation du gameplay du jeu de serpent

Après avoir établi les perspectives de base de notre jeu de serpent, nous devrons rendre le jeu en temps réel.

Cela impliquera ce qui suit :

  • Augmenter la longueur du serpent à chaque fois qu'il récupère la nourriture en utilisant de préférence une couleur différente.
  • Incrémenter le score du joueur chaque fois que le serpent récupère la nourriture et suivre le score le plus élevé.
  • Le joueur est capable d'empêcher le serpent d'entrer en collision avec le mur ou son propre corps.
  • Le jeu redémarre 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 = []

#Implementing the 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")

        for segment in segments:
            segment.goto(1000, 1000)
            segments.clear()
            player_score = 0
            delay_time = 0.1
            pen.clear()
            pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_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)

            # Adding segment
            added_segment = turtle.Turtle()
            added_segment.speed(0)
            added_segment.shape("square")
            added_segment.color("white")
            added_segment.penup()
            segments.append(added_segment)
            delay_time -= 0.001
            player_score += 5

            if player_score > highest_score:
                highest_score = player_score
                pen.clear()
                pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

    # checking for 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)

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

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

            for segment in segments:
                segment.goto(1000, 1000)
                segment.clear()
                player_score = 0
                delay_time = 0.1
                pen.clear()
                pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

     time.sleep(delay_time)

turtle.mainloop()

Dans l'extrait de code ci-dessus, nous définissons une position aléatoire pour la nourriture du serpent dans l'écran. Chaque fois que le serpent récupère cette nourriture, son segment corporel augmente d'une couleur différente ; blanc, dans ce cas, pour distinguer sa croissance.

Une fois que le serpent a récupéré la nourriture sans entrer en collision, la nourriture est placée à une position aléatoire dans la plage de coordonnées 270 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 défini sur 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 (I.e.

L'utilisation de la bibliothèque de tortues est un moyen amusant et facile de créer le jeu du serpent, comme nous l'avons vu dans cet article. Alternativement, vous pouvez implémenter la même chose en utilisant la bibliothèque PyGame. Vous pouvez consulter le Tutoriel PyGame ici et voyez comment vous pourriez implémenter le jeu différemment.

Vous pouvez également essayer un jeu de devinettes de nombres en Python or comment obtenir des données JSON en Python.
Profitez du codage !