Logo Zéphyrnet

Intelligence de données générative

Big Data

Créez votre premier jeu avec Python : Snake Game

Republié par Platon
Republié par Platon

Date :

Vues: 97

Python est à la fois amusant et simple à utiliser. Avec un large éventail de bibliothèques disponibles, Python nous facilite la vie en simplifiant la création de jeux et d'applications. Dans cet article, nous allons créer un jeu classique auquel beaucoup d’entre nous ont probablement joué à un moment donné de leur vie : le jeu du serpent. Si vous n'avez jamais expérimenté ce jeu auparavant, c'est maintenant votre chance d'explorer et de créer votre propre version sans avoir besoin d'installer de lourdes bibliothèques sur votre système. Tout ce dont vous avez besoin pour commencer à créer ce jeu de serpent nostalgique est une compréhension de base de Python et un éditeur de codage en ligne comme repl.it.

Le jeu du serpent est un classique d'arcade intemporel dans lequel le joueur contrôle un serpent qui grandit à mesure qu'il consomme de la nourriture. Dans cette implémentation, décomposons le code pour comprendre comment le jeu est structuré et comment la bibliothèque Turtle est utilisée pour les graphiques et l'interaction utilisateur.

Table des matières

Utiliser Turtle Graphics pour le développement de jeux simples

Les graphismes de la Tortue bibliothèque en Python offre une manière amusante et interactive de créer des formes, de dessiner sur l'écran et de répondre aux entrées de l'utilisateur. Il est souvent utilisé à des fins éducatives, pour enseigner les concepts de programmation via un retour visuel. Ce code utilise Turtle pour créer les éléments du jeu tels que le serpent, la nourriture et l'affichage des scores.

Éditeur de codage en ligne : Repl.it

Une plateforme de codage Web appelée Repl.it vous permet de développer, d'exécuter et de collaborer sur du code directement dans votre navigateur Web. Il prend en charge de nombreux langages de programmation différents et dispose de compilateurs et d'interprètes intégrés en plus de fonctionnalités telles que le partage de code, le contrôle de version et le travail d'équipe. Les développeurs l'utilisent largement pour l'apprentissage, le prototypage rapide et le partage de code, car il est simple à utiliser et ne nécessite aucune configuration.

Algorithme

Commençons par créer notre premier jeu avec python. Pour ce faire, nous devons suivre certaines étapes ci-dessous :

Créer un fichier Repl

Étape 1 : Installation des bibliothèques nécessaires

Cela marque la première étape du développement du jeu connu sous le nom de Snake. La tortue, le hasard et le temps en font partie.

  • Tortue: Nous avons besoin de cette bibliothèque pour créer les graphismes de notre jeu. Nous sommes capables de manipuler les mouvements de la nourriture et du serpent sur l'écran et de les dessiner.
  • Aléatoire: Pour créer des emplacements aléatoires pour la nourriture sur l'écran, nous utilisons la bibliothèque aléatoire. Cela garantit que chaque fois que la nourriture est consommée, elle apparaît à un endroit différent.
  • Heure : Le serpent se déplace avec un léger retard entre chaque mouvement grâce à la bibliothèque temporelle. Cela rend le jeu plus facile à utiliser et plus agréable pour les joueurs.
import turtle
import time
import random

Étape 2 : Configuration de l'environnement de jeu.

Cela inclut l'établissement des dimensions de l'écran, l'ajout d'un fond bleu et l'ajout d'un petit délai pour garantir un gameplay fluide. Nous avons également configuré des variables telles que high_score pour conserver le score le plus élevé atteint, score pour surveiller le score du joueur et des segments pour suivre le corps du serpent.

# Initialize the screen
sc = turtle.Screen()
sc.bgcolor("blue")
sc.setup(height=1000, width=1000)
delay = 0.1

# Initialize variables
segments = []
score = 0
high_score = 0
Sortie

Étape 3 : Création du serpent

Un objet tortue de forme carrée symbolise le serpent. Nous localisons le stylet au centre de l'écran (goto(0, 100)), définissons sa couleur sur noir, puis l'élevons pour éviter de tracer des lignes. Initialement réglé sur « stop », la direction du serpent reste stationnaire jusqu'à ce que le joueur commence à le déplacer.

# Create the snake
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 100)
snake.direction = "stop"
Créer un serpent

Étape 4 : Fonctions de mouvement

Nous définissons les fonctions de mouvement du serpent (move()) en fonction de sa direction à ce moment-là. Ces fonctions contrôlent la capacité du serpent à se déplacer vers le haut, le bas, la gauche et la droite. Ils déplacent la tête du serpent de 20 unités dans la direction appropriée lorsqu'on leur demande.

# Functions to move the snake
def move():
    if snake.direction == "up":
        y = snake.ycor()
        snake.sety(y + 20)
    if snake.direction == "down":
        y = snake.ycor()
        snake.sety(y - 20)
    if snake.direction == "left":
        x = snake.xcor()
        snake.setx(x - 20)
    if snake.direction == "right":
        x = snake.xcor()
        snake.setx(x + 20)

Étape 5 : Contrôler le serpent

En utilisant sc.listen() et sc.onkey(), nous configurons les écouteurs clés pour contrôler le serpent. Les routines associées (go_up(), go_down(), go_left(), go_right()) modifient la direction du serpent en réponse aux pressions sur les touches du clavier w, s, a ou d.

# Functions to link with the keys
def go_up():
    snake.direction = "up"

def go_down():
    snake.direction = "down"

def go_left():
    snake.direction = "left"

def go_right():
    snake.direction = "right"

# Listen for key inputs
sc.listen()
sc.onkey(go_up, "w")
sc.onkey(go_down, "s")
sc.onkey(go_left, "a")
sc.onkey(go_right, "d")

Étape 6 : Créer la nourriture

La nourriture est représentée par un objet tortue circulaire de couleur rouge. Initialement placé aux coordonnées (100, 100), il sert de cible à manger au serpent. Lorsque le serpent entre en collision avec la nourriture, il « mange » la nourriture et une nouvelle apparaît à un endroit aléatoire.

# Create the food
food = turtle.Turtle()
food.shape("circle")
food.color("red")
food.penup()
food.goto(100, 100)
Créer la nourriture

Étape 7 : Affichage du score

Un objet tortue (stylo) affiche le score du joueur et le score le plus élevé obtenu. Ces informations sont mises à jour chaque fois que le serpent mange de la nourriture.

# Create the score display
pen = turtle.Turtle()
pen.penup()
pen.goto(0, 100)
pen.hideturtle()
pen.write("Score: 0  High Score: 0", align="center", font=("Arial", 30, "normal")
Affichage du score

Étape 8 : Boucle de jeu principale

Le cœur du jeu Snake est la boucle de jeu principale. Il gère les entrées de l'utilisateur, met à jour l'écran, déplace le serpent, recherche les collisions et régule le déroulement du jeu. Examinons plus en détail les fonctions spécifiques de chaque section de la boucle principale :

while True:
    sc.update()  # Update the screen
    move()  # Move the snake
    time.sleep(delay)  # Introduce a slight delay for smooth gameplay
  • sc.update() : met à jour l'écran pour refléter toutes les modifications apportées dans le jeu. Sans cela, l'écran ne serait pas actualisé et les joueurs ne verraient pas le mouvement du serpent ni la mise à jour du score.
  • move(): Cette fonction contrôle le mouvement du serpent en fonction de sa direction actuelle. Il déplace la tête du serpent de 20 unités dans la direction spécifiée par l'entrée du joueur. Le serpent se déplace continuellement dans la direction dans laquelle il a été dirigé jusqu'à ce que le joueur change de direction.
  • time.sleep(delay) : introduit un léger délai entre chaque mouvement du serpent. Le delay variable est définie sur 0.1 au début du code. Le but de ce délai est de contrôler la vitesse du jeu. Sans cela, le serpent se déplacerait trop rapidement pour que le joueur puisse réagir, ce qui rendrait le jeu difficile à jouer.

Manger de la nourriture et faire grandir le serpent

    if snake.distance(food) < 20:
        x = random.randint(-200, 200)
        y = random.randint(-200, 200)
        food.penup()
        food.goto(x, y)
        food.pendown()

        # Increase the length of the snake
        new_segment = turtle.Turtle()
        new_segment.shape("square")
        new_segment.color("grey")
        new_segment.penup()
        segments.append(new_segment)
        score += 1

        # Update score and high score
        if score > high_score:
            high_score = score
        pen.clear()
        pen.write("Score: {}  High Score: {}".format(score, high_score), align="center", font=("Arial", 30, "normal"))

Manger des aliments

  • Quand la tête du serpent (snake) se trouve à une distance de 20 unités de l'aliment (food), cela signifie que le serpent a « mangé » la nourriture.
  • La position de l'aliment est ensuite réinitialisée à un nouvel emplacement aléatoire sur l'écran en utilisant random.randint().
  • Cette action génère l'illusion que la nourriture « réapparaît » à différents endroits à chaque fois qu'elle est mangée.

Faire grandir le corps du serpent

  • Lorsque le serpent mange de la nourriture, le code ajoute un nouveau segment au corps du serpent pour le faire grandir.
  • Un nouvel objet tortue (new_segment) est créé, qui devient partie intégrante du segments liste.
  • Cette liste garde une trace de tous les segments qui composent le corps du serpent.
  • Le score du joueur est incrémenté (score += 1) chaque fois que le serpent mange de la nourriture.

Mise à jour des scores

  • Après avoir mangé de la nourriture et mis à jour le score, l'affichage du score est mis à jour à l'aide du pen objet.
  • La pen.clear() La fonction efface l’affichage du score précédent.
  • Ensuite, le score mis à jour et le meilleur score sont écrits à l'écran en utilisant pen.write().

Déplacer le corps du serpent

    for i in range(len(segments) - 1, 0, -1):
        x = segments[i - 1].xcor()
        y = segments[i - 1].ycor()
        segments[i].goto(x, y)

    # Move the first segment to follow the head
    if len(segments) > 0:
        x = snake.xcor()
        y = snake.ycor()
        segments[0].goto(x, y)
  • Cette section du code est chargée de faire en sorte que le corps du serpent suive sa tête.
  • Il parcourt le segments liste, en commençant par le dernier segment (len(segments) - 1) jusqu'au deuxième segment (0), déplaçant chaque segment vers la position du segment qui le précède.
  • Cela crée l'effet du corps du serpent qui suit la tête lorsqu'elle bouge.

Mise à jour du premier segment (tête)

  • Après avoir déplacé tous les segments du corps, la position du premier segment (la tête) est mise à jour pour correspondre à la position actuelle du serpent (snake).
  • Cela garantit que la tête du serpent continue de diriger le corps lors de ses mouvements.

Note de fin

Ce code fournit une structure de base pour un jeu Snake utilisant la bibliothèque graphique Turtle. Le jeu consiste à contrôler un serpent pour qu'il mange de la nourriture et grandisse tout en évitant les collisions avec les murs et sa propre queue. C'est un excellent projet pour débutants pour en apprendre davantage sur les concepts de développement de jeux, la programmation de base en Python et pour travailler avec les entrées et les graphiques des utilisateurs. N'hésitez pas à personnaliser et à développer ce code pour ajouter des fonctionnalités telles que la détection de collision, l'augmentation de la difficulté ou l'ajout de niveaux pour rendre votre jeu Snake encore plus excitant !

Si vous souhaitez en savoir plus sur Python, inscrivez-vous à notre cours python gratuit.

Lisez également nos autres articles liés à Python ici :

Podcast: Jouer dans une nouvelle fenêtre | Télécharger

spot_img

Dernières informations

spot_img

Copyright @ 2024 Platon Technologies Inc.