Creer un jeu Snake en Python avec Pygame

Introduction : Pourquoi coder Snake en NSI ?

Salut futur développeur ! Si tu es en spécialité NSI, tu sais que la théorie c'est bien, mais la pratique c'est encore mieux. Créer un jeu vidéo classique comme Snake est un projet parfait pour consolider tes compétences en Python. Ce projet te permettra de manipuler :

• Les structures de données (listes pour le corps du serpent).
• La programmation orientée objet (une classe pour le serpent, une pour le jeu).
• La logique algorithmique (gestion des collisions, déplacement).
• Une bibliothèque graphique (Pygame).

À la fin de cet article, tu auras un jeu fonctionnel que tu pourras même personnaliser. C'est parti !

Mise en place : Installer Pygame et structurer le projet

Avant de coder, il faut préparer ton environnement. Pygame est une bibliothèque externe, il faut donc l'installer.

Installation de Pygame

Ouvre ton terminal ou l'invite de commandes et tape :

pip install pygame

Si tu utilises un environnement virtuel ou un IDE comme PyCharm, assure-toi de l'installer au bon endroit.

Architecture de base du code

Crée un nouveau fichier Python, par exemple snake_game.py. Nous allons structurer notre code avec une approche modulaire. On va créer :

• Les constantes du jeu (couleurs, taille de la fenêtre, taille des blocs).
• Une classe Serpent.
• Une classe Jeu ou une fonction principale qui gère la boucle du jeu.

Cette structure est essentielle pour un code propre et maintenable, une compétence clé en NSI et dans le monde professionnel.

Le cœur du jeu : Coder la classe Serpent

Le serpent est l'élément central. Modélisons-le par une classe. Son état sera défini par une liste de segments (coordonnées x, y).

Voici le squelette de la classe :

class Serpent:
def __init__(self):
self.corps = [(100, 50), (90, 50), (80, 50)] # Liste de tuples (x, y)
self.direction = "DROITE" # Direction initiale
self.couleur = (0, 255, 0) # Vert en RVB

Maintenant, ajoutons les méthodes essentielles :

Méthode pour se déplacer

Le principe est simple : on ajoute une nouvelle "tête" dans la direction actuelle, et on retire la dernière partie de la queue (sauf si le serpent a mangé une pomme).

def avancer(self):
tete_x, tete_y = self.corps[0]
if self.direction == "DROITE":
nouvelle_tete = (tete_x + 10, tete_y)
elif self.direction == "GAUCHE":
nouvelle_tete = (tete_x - 10, tete_y)
elif self.direction == "HAUT":
nouvelle_tete = (tete_x, tete_y - 10)
elif self.direction == "BAS":
nouvelle_tete = (tete_x, tete_y + 10)
self.corps.insert(0, nouvelle_tete) # Ajoute la nouvelle tête
self.corps.pop() # Retire l'ancienne queue

Méthode pour changer de direction

Il faut empêcher le serpent de faire demi-tour sur lui-même (ex: aller à droite alors qu'il va à gauche).

def changer_direction(self, nouvelle_direction):
opposées = {"HAUT": "BAS", "BAS": "HAUT", "GAUCHE": "DROITE", "DROITE": "GAUCHE"}
if nouvelle_direction != opposées.get(self.direction):
self.direction = nouvelle_direction

Méthode pour grandir

Quand le serpent mange, on ne retire pas le dernier segment lors du prochain avancer(). On peut simplement ajouter un flag ou gérer cela dans la boucle principale.

Gestion du jeu : Boucle principale, nourriture et collisions

Maintenant, créons la logique qui fait tourner le jeu. On va initialiser Pygame, gérer les événements (touches du clavier), faire apparaître la nourriture aléatoirement et détecter les collisions.

Initialisation et boucle principale

import pygame
import random

# Initialisation et constantes
pygame.init()
TAILLE_FENETRE = 600
TAILLE_BLOC = 10
ecran = pygame.display.set_mode((TAILLE_FENETRE, TAILLE_FENETRE))
clock = pygame.time.Clock()

serpent = Serpent()
nourriture = (random.randrange(0, TAILLE_FENETRE, TAILLE_BLOC),
random.randrange(0, TAILLE_FENETRE, TAILLE_BLOC))

en_jeu = True
while en_jeu:
for event in pygame.event.get():
if event.type == pygame.QUIT:
en_jeu = False
# Gestion des touches pour changer la direction du serpent
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
serpent.changer_direction("DROITE")
elif event.key == pygame.K_LEFT:
serpent.changer_direction("GAUCHE")
# ... Gérer HAUT et BAS

# Logique du jeu
serpent.avancer()
# Vérifier si le serpent mange la nourriture
if serpent.corps[0] == nourriture:
# Faire grandir le serpent et repositionner la nourriture
nourriture = (random.randrange(0, TAILLE_FENETRE, TAILLE_BLOC),
random.randrange(0, TAILLE_FENETRE, TAILLE_BLOC))
# On ajoute un segment en ne le retirant pas au prochain avancer()

# Vérifier les collisions (murs ou avec soi-même)
tete_x, tete_y = serpent.corps[0]
if (tete_x < 0 or tete_x >= TAILLE_FENETRE or
tete_y < 0 or tete_y >= TAILLE_FENETRE or
serpent.corps[0] in serpent.corps[1:]):
en_jeu = False # Game Over

# Affichage
ecran.fill((0, 0, 0)) Fond noir
for segment in serpent.corps:
pygame.draw.rect(ecran, serpent.couleur, (segment[0], segment[1], TAILLE_BLOC, TAILLE_BLOC))
pygame.draw.rect(ecran, (255, 0, 0), (nourriture[0], nourriture[1], TAILLE_BLOC, TAILLE_BLOC))
pygame.display.update()
clock.tick(15) # Vitesse du jeu (images par seconde)

pygame.quit()

Améliorations et idées pour ton projet NSI

Félicitations, tu as une version basique de Snake ! Pour en faire un vrai projet NSI et impressionner ton professeur, voici des idées d'améliorations :

• Ajouter un score : Incrémente un compteur à chaque pomme mangée et affiche-le à l'écran avec pygame.font.
• Écran de démarrage et Game Over : Affiche des messages, propose de rejouer.
• Augmenter la difficulté : Accélère progressivement le jeu (clock.tick(15 + score//5)).
• Barrières ou obstacles : Ajoute des murs immobiles que le serpent doit éviter.
• Personnalisation graphique : Remplace les carrés par des sprites, ajoute des sons avec pygame.mixer.
• Mode deux joueurs : Un défi ambitieux ! Deux serpents contrôlés avec des touches différentes.

Ces ajouts te permettront de montrer que tu maîtrises non seulement la syntaxe Python, mais aussi la conception et l'optimisation d'un logiciel.

Conclusion et ressources

Tu viens de créer ton premier jeu vidéo en Python ! Ce projet Snake est une excellente synthèse des concepts vus en NSI : algorithmes, structures de données, gestion d'événements et programmation orientée objet. N'hésite pas à partager ton code avec tes camarades, à le commenter proprement et à expérimenter. La clé pour progresser est de pratiquer et de décortiquer le code des autres.

Pour aller plus loin, consulte la documentation officielle de Pygame. Bonne continuation dans ton apprentissage de la programmation !