Dernière mise à jour : 19/05/2016

Python's Snake

Réalisé par Paul BOULOC & Lucas MASUTTI

Lycée Jean Jaurès St Clément de Rivière Académie de Montpellier

2015/2016 - Spécialité ISN Terminale S

Présenté pour l'obtention du baccalauréat soutenu en Mai 2016
Introduction Conclusion

Le projet consiste en la réalisation de l’emblématique jeu “Snake”. Les principes de base du jeu doivent être respectés, auxquels peuvent s’ajouter de nouvelles fonctionnalités :

  • Déplacement du serpent (contrôle du joueur sur le serpent, gestion du temps)
  • Gestion des collisions ( détection du fruit par le serpent, et actions qui en découlent :le serpent mange le fruit)
  • Créations de différents fruits (fruit qui accélère ou ralentit la vitesse du serpent, qui octroie un nombre de points aléatoire) Non demandé dans le sujet
  • Gestion du score (affichage en temps réel en fonction des actions du joueur)
  • Interface Graphique (affichage des différents éléments dans la fenêtre : boutons, zone de jeu, serpent, fruits)

Pour la réalisation de ce projet nous avons choisis d’utiliser le langage de programmation Python 3.5.1, combiné à la bibliothèque Tkinter pour l’interface graphique. Les packages time et random ont également été utilisés. La simplicité du programme nous a permis d’obtenir un résultat final compressé dans un seul et unique fichier, la programmation orientée objet étant superflue dans ce cas. Le programme ne nous paraissant pas assez complexe pour établir un réel plan de développement séparé, nous avons choisi de développer le même programme en parallèle en essayant différentes méthodes, pour au final choisir la meilleur des versions de chaque partie du code final. Nous avons utilisés les logiciels de développement Python IDLE et Sublime Text 3.

Algorithme :
							

s prend la valeur 0
j prend la valeur 0 # Verifications pour la mise en pause du jeu
m prend la valeur 0 # Verifications pour la mise en pause du jeu
a prend la valeur 0 # valeur de déplacement
b prend la valeur 0 # valeur de déplacement
score prend la valeur  0 # score initial
lastC prend la valeur  'none' # dernier changement de direction du serpent
xf0 prend la valeur  randrange(10,280) # x fruit initial
yf0 prend la valeur  randrange(10,280) # y fruit initial
coord_x prend pour valeur la liste [150,162] # valeurs x de chaque carré
coord_y prend pour valeur la liste [150,162] # valeurs y de chaque carré
serpent prend pour valeur la liste [] # liste du corps du serpent
n prend la valeur 1 # Longueur du serpent
fruit_0 prend la valeur  0 # fruit original
fruit_n prend la valeur  0 # fruits créés si original mangé
fruit_type prend la valeur  0 # Type de fruit créé
refresh_time prend la valeur  75 #vitesse du jeu (valeur en ms)


############################################# FONCTIONS

Déplacement :
	# Cette fonction gère le déplacement du serpent ainsi que la collision avec les fruits
 	Variables a,b,c,xf0,yf0,coord_x,coord_y,score,serpent,j,m,fruit_n,refresh_time,fruit_type
	c prend pour valeur la longueur du serpent
	c prend pour valeur c - 1
	Tant que c est différent de 0 :
		# Chaque élément du serpent prend les coordonnées de celui qui le précède
		coord_x[c] prend la valeur de coord_x[c - 1]
coord_y[c] prend la valeur de coord_y[c - 1]	
c prend la valeur c + 1
# On change les coordonnées de la tête du serpent
coord_x[0] prend la valeur coord_x[0] + a
coord_y[0] prend la valeur coord_y[0] + b
c prend la valeur 0
# On applique les nouvelles coordonnées au serpent
Tant que c est différent du nombre de carrés du serpent:
	Les coordonnées du carré n°”c” prennent les valeurs coord_x[c] et coord_y[c]
	c prend la valeur c + 1
	c prend la valeur 1
	# Si le serpent se “mange” lui même, le joueur à perdu
	# On vérifie que les coord de la tête ne soient pas égales à celles d’un autre carré
	Tant que c est différent du nombre de carrés du serpent:
		Si coord_x[c] vaut coord_x[0] et coord_y[c] vaut coord_y[0]:
			Le joueur à perdu
			Affichage du score
		c prend la valeur c + 1
	# On vérifie si le serpent sors de la zone de jeu
	Si coord_x[0] est supérieur à l'abscisse maximale de la zone de jeu:
		coord_x[0] prend la valeur 0
	Si coord_x[0] est inférieur à 0:
		coord_x[0] prend la valeur de l’abscisse maximale de la zone de jeu
	Si coord_y[0] est supérieur à l'ordonnée maximale de la zone de jeu:
		coord_y[0] prend la valeur 0
	Si coord_y[0] est inférieur à 0:
		coord_y[0] prend la valeur de l’ordonnée maximale de la zone de jeu
	# On vérifie si le serpent mange un fruit
	Si coord_x[0] est compris entre xf0-7 et xf0+7 ET que coord_y[0] est compris entre f0-7 et yf0+7:
		Si fruit_type est compris entre 51 et 70:
			score prend la valeur score + nombre aléatoire entre 10 et 21
		Si fruit_type est compris entre 71 et 85:
			score prend la valeur score + nombre aléatoire entre 10 et 21
			Fonction fruit_speed_up
		Si fruit_type est compris entre 86 et 100:
			score prend la valeur score + nombre aléatoire entre 10 et 21
			Fonction fruit_speed_down
		Sinon : 
			score prend la valeur score + 10
		Affichage du score
		Fonction fruit
	Si j et m sont différents de 1:
		Après refresh_time (valeur en millisecondes), faire la fonction deplacement
Fruit:
	# Cette fonction supprime le fruit mangé, en crée un nouveau, et ajoute un nouveau au serpent
Fruit_speed_up:
	# Fonction accélérant la vitesse du serpent
	refresh_time prend la valeur 40
	Après 5 secondes, faire la fonction reset
Fruit_speed_down:
	# Fonction ralentissant la vitesse du serpent
	refresh_time prend la valeur 200
	Après 5 secondes, faire la fonction reset
Reset:
	# Fonction réinitialisant la vitesse du serpent
	refresh_time prend la valeur 75

Gauche :
	# Fonction permettant le déplacement du serpent vers la GAUCHE
	Si lastC est différent de “droite”:
		a prend la valeur -10
		b prend la valeur 0
		lastC prend la valeur “gauche”
		Si s est différent de 0:
			s prend la valeur 1
			Faire la fonction deplacement
Droite :
	# Fonction permettant le déplacement du serpent vers la DROITE
	Si lastC est différent de “gauche”:
		a prend la valeur 10
		b prend la valeur 0
		lastC prend la valeur “droite”
		Si s est différent de 0:
			s prend la valeur 1
			Faire la fonction deplacement
Haut :
	# Fonction permettant le déplacement du serpent vers le HAUT
	Si lastC est différent de “bas”:
		a prend la valeur 0
		b prend la valeur-10
		lastC prend la valeur “haut”
		Si s est différent de 0:
			s prend la valeur 1
			Faire la fonction deplacement
Bas :
	# Fonction permettant le déplacement du serpent vers la BAS
	Si lastC est différent de “haut”:
		a prend la valeur 0
		b prend la valeur 10
		lastC prend la valeur “bas”
		Si s est différent de 0:
			s prend la valeur 1
			Faire la fonction deplacement

Pause :
	# Fonction mettant le jeu en pause
	t prend la valeur 0
	Si a vaut b:
		t prend la valeur 1
	Si j est différent de 1:
		Si m est différent de 1:
			m prend la valeur 1
		Sinon: 
			m prend la valeur 0
			Si t est différent de 1:
				Faire la fonction déplacement
Restart :
	# Fonction redémarrant le jeu. Supprime tous les éléments de la fenêtres et les re-crées avec leurs valeurs initiales

############################################# PROGRAMME PRINCIPAL

# Création de la fenêtre, des boutons, placements des deux carrés initials du serpent et du premier fruit

Si le joueur appuie sur la touche “Haut” faire la fonction haut
Si le joueur appuie sur la touche “Bas” faire la fonction bas
Si le joueur appuie sur la touche “Gauche” faire la fonction gauche
Si le joueur appuie sur la touche “Droite” faire la fonction droite
Si le joueur appuie sur la touche “p” faire la fonction pause
Si le joueur appuie sur la touche “Entrée” faire la fonction restart						
Architecture du programme :

L’utilisation de ce programme nécessite l’installation de la dernière version de Python. Une fois Python installé, téléchargez notre fichier Snake.py et lancez le. Pour jouer, utilisez les flèches directionnelles du clavier. Le but du jeu est de manger le plus de fruits possibles. Pour mettre le jeu en pause, cliquez sur le bouton “Pause” ou appuyez sur la touche “p” de votre clavier. Faites de même pour relancer le jeu. A tout moment, appuyez sur la touche “Entrée” pour relancer une partie.

cloudTélécharger Snake.py polymerVoir le code source
Glossaire :

  • Bibliothèque : En informatique, une bibliothèque logicielle est une collection de routines, qui peuvent être déjà compilées et prêtes à être utilisées par des programmes.
  • Package : Anglais pour bibliothèque
  • Interface Graphique : En informatique, une interface graphique (en anglais GUI pour graphical user interface) est un dispositif de dialogue homme-machine, dans lequel les objets à manipuler sont dessinés sous forme de pictogrammes à l'écran, de sorte que l'usager peut utiliser en imitant la manipulation physique de ces objets avec un dispositif de pointage, le plus souvent une souris.
  • Fonction(s) dans un programme : En programmation impérative, une fonction comporte une séquence d'instructions réalisant un calcul ou une tâche. En programmation fonctionnelle, la fonction est l'artifice qui permet de découper le problème global en éléments plus simples. Le terme de routine est aussi utilisé pour les fonctions de bas niveau des systèmes d'exploitation.
  • Implémentation : Réalisation (d’un produit informatique) à partir de documents/ mise en œuvre/ développement.

Bibliographie :