Download - Projet d'ISN · Limage correspondant au fond « fond du tetris.png » : C'est l'image de fond du jeu. Pour utiliser le jeu, il faut avoir installé le langage Python ainsi que Pygame

UNGERER Jean Projet Tétris d'ISN 14/05/2014

Projet d'ISN

Tétris

Lycée Louis Marchal/Lycée Henri Meck Année scolaire 2013/2014

1


Sommaire

I- Introduction Page 3

II- Principe du jeu Page 4

III- Réalisation du jeu Page 5-13

1- La répartition des taches Page 52- Le fonctionnement du jeu. Page 5-123- Les problèmes rencontrés Page 134- Les pistes d'amélioration Page 13

IV- Conclusion Page 14

V- Annexes Page 13-23


2


I- Introduction

Cette année scolaire, nous devons réaliser un programme pour un projet de fin d'année dans le cadrede la spécialité ISN. Le projet était libre. Nous avons codé ces projets par groupes de deux ou trois.Nous utilisons le langage Python que nous avons appris à utiliser au cours de l'année. Pour écrire leprogramme nous nous servons de l'éditeur Pyscripter. Nous utilisons également la bibliothèquePygame qui nous permet une meilleure gestion de l'interface graphique.

Nous avons formé un groupe avec Aymeric HAMON et Antony SANTORO. Notre projet est deréaliser le jeu très connu Tétris nous même. Ce jeu consiste compléter des lignes de carrés en plaçantdes pièces tombantes composées chacune de quatre carrés afin de réaliser le plus haut score possible.

Notre programme est constitué de 3 parties : Le programme du jeu « Tétris 4.1.py » : C'est la partie principale qui fait fonctionner le jeu.L'image correspondant aux carré « Brick.png » : C'est les images des carrés dans le jeu.Limage correspondant au fond « fond du tetris.png » : C'est l'image de fond du jeu.

Pour utiliser le jeu, il faut avoir installé le langage Python ainsi que Pygame sur son ordinateur et avoir les 3 parties citées ci-dessus.


3


II- Principe du jeu

Dans ce jeu des briques de différentes formes tombent du sommet du puits jusqu’à toucher le sol ouune autre brique et se bloquer. Le joueur doit arranger la chute des pièces afin de créer une lignecomplète qui s'éliminera. Cela permet d'augmenter son score en fonction du nombre de briquesplacées et du nombre de lignes complétées. Plus le score est grand plus la vitesse de chute desbriques augmente et donc la difficulté est accrue. Lorsqu'une pièce est placée, une nouvelle segénère c'est celle qui est annoncée. Si une brique touche le sommet du puits, par empilement, lapartie s’arrête et le score est verrouillé : c’est la fin de la partie.

Affiche le score de la partie en cours.

Affiche le meilleur score réalisé sur le jeu.(pas encore présent)

La pièce tombe.

Le niveau en cours.

Le nombre de lignes éliminées.

Les pièces s'empilent en bas du puits.

La prochaine pièce.


4


III- Réalisation du jeu

1- La répartition des taches

Aymeric a réalisé la première esquisse du projet tout seul car Anthony et moi étions absents àcause d'une sortie scolaire.

La semaine suivante nous avons commencé à coder ensemble et j'ai eu l'idée du tableau pour placer les briques. Nous avons d'abord réalisé un schéma de la fenêtre de jeu puis on s’est réparti les tâches rapidement :

Anthony s’occupe de l’interface graphique ainsi que de la gestion des points et des niveaux.Aymeric s'occupe du déplacement des pièces ainsi que leur empilement et leur générationJe m'occupe de la rotation des pièces, la disparition des lignes et aussi de la génération des pièces..

2- Le fonctionnement du jeu.

Les pièces se génèrent, se déplacent et se fixent dans un tableau « zero » : « tab » du modulenumpy. C'est un tableau de 21 X 11 cases. Initialement, la valeur des cases est 0 car elles sont vides. Les pièces peuvent uniquement se déplacer dans les cases vides. Les bordures valent 9 pour que les pièces ne puissent pas les dépasser.

Tout d'abord, le programme s'initialise avec la fonction « init » qui charge les images, met enplace la fenêtre, le score et le niveau.

Pour interagir avec le programme, on utilise le module « pygame » qui nous permet dedétecter des évènements dans le jeu et les actions du joueur. En effet, chaque évolution duprogramme correspond à un événement. Chaque événement est détecté grâce à la commandesuivante : « for event in pygame.event.get() ».

Il y a 3 évènements principaux : « QUIT » qui correspond à un clique sur la croix de lafenêtre et qui ferme la fenêtre, « depla » qui correspond à l'évenement que l'on a créé dans lafonction « init » et qui s'enclenche suivant le timer « pygame.time.set_timer(depla,speed) ».Cet évenement permet de faire descendre la pièce d'une case. Enfin il y a l'évenement« KEYDOWN » qui se divise en quatre sous évenements qui dépendent de la touche surlaquelle on a appuyé. « K_RIGHT » pour déplacer la pièce à droite, « K_LEFT » pourdéplacer la pièce à gauche, « K_UP » pour faire tourner la pièce de 90° et « K_DOWN »pour faire descendre la pièce jusqu'en bas. Chaque évenement va s'inscrir dans la liste


5


d'évenements de pygame qui s'effectuent dans l'ordre dans lequel les evenements ont étédétectés.

On prend un exemple :

On part de la situation 1 et on veut arriver à la situation 2.Ici le timer est de 280 ms. On estime donc que le joueur a le temps de réaliser 1 action avantque l'evenement « depla » se déclenche. La fonction « affichage » se declenche après chaqueévenement.

Situation 1 Situation 2


6


Les tableaux correspondants à chaque situation sont les suivants :

9 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 6 6 6 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 6 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 6 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 6 6 6 0 0 0 0 0 0 99 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

Situation 1 Situation 2


7


Ici on veut donc tourner deux fois et se deplacer de 3 cases vers la gauche. Comme le joueurne veux pas attendre que la pièce descende d'elle même il utilisera la fonctionnalité du jeupour la faire descendre la pièce jusqu'en bas. La liste des évenements sera donc :

1 : KEY_UP pour faire tourner la pièce :

La rotation des pièces est gérée par la fonction « rota ». La pièce est composée de 4 carrésplus ou moins indépendant, on prend en compte les coordonnées qu'aurait la pièce ausommet du puits dans chacune des positions de rotation et on ajoute aux coordonnées dedépart la différence de numéro de colonne et de ligne grâce aux variables « ligne » et« colonne » dont la valeur évolue en fonction du déplacement de la pièce. La liste« piece_jouee » est composée de 32 coordonnées, 8 pour chaque position de la pièce. Ainsi,on fait varier l'indice des valeurs de coordonnées utilisées de 8 pour réaliser une rotationgrâce à la variable « tourner ».

Ici, les coordonnées de la pièce sont [0,4,0,5,0,6,1,6,1,4,1,5,0,5,-1,5,-1,4,0,4,0,5,0,6,1,5,0,5,-1,5,-1,6]

La rotation n'est possible que si sa nouvelle position est libre. On réalise donc une rotationfictive de la pièce pour vérifier si la place est disponible. Si oui, le déplacement est validé etla nouvelle série de coordonnées est conservée. Sinon, on reprend l'ancienne série decoordonnées. Comme la pièce ne se gêne pas elle-même lors de la rotation, lors du test lavaleur des cases qu'elle occupe devient 0, ainsi ces cases sont considérées comme vides.Pour cela, on utilise la fonction « valeur0_case ». Lorsque le test est fini, On remet la valeurdes cases occupées par la pièce à la valeur de la forme « alea+1 » avec la fonction« valeur1_case ».

2 : depla qui fait descendre la pièce d'une case :

La pièce ne peux descendre que si la place est libre. On réalise donc un deplacement fictifvers le bas et on verifie si la place est disponible grâce à la fonction « fall ». La variable« ligne » augmente de 1. Ici le deplacement est validé. On passe à l'évenement suivant. Lesanciennes cases prennent la valeur 0 et les nouvelles prennent la valeur de la forme« alea+1 » avec la fonction « valeur1_case »

3 : KEY_UP pour faire tourner la pièce de la même façon qu'à la première étape.

4 : depla qui fait descendre la pièce de la même façon qu'à la deuxième étape.


8


5 : KEY_LEFT qui deplace la pièce vers la gauche.

Le deplacement vers la gauche n'est possible que si la place est libre. On réalise donc undéplacement fictif vers la gauche grâce à la fonction « depla_gauche ». La variable« colonne » diminue de 1. Ici le deplacement est validé. Les anciennes cases prennent lavaleur 0 et les nouvelles prennent la valeur de la forme « alea+1 ».


7 : KEY_LEFT qui déplace la pièce de la même façon que pour l'étape 5.


9 : KEY_LEFT qui déplace la pièce de la même façon que pour l'étape 5.


11 : KEY_DOWN qui fait descendre la pièce jusqu'en bas du tableau.

En fait, cet événement modifie la vitesse du timer de l'évènement « depla » pour qu'il soitinstantané et permet donc d'effectuer l'évenement « depla » jusqu'à ce que la pièce atteigne lefond du puits. Lorsqu'elle l'atteint, elle ne peut plus descendre et on arrive donc dans lafonction « fall » dans le cas où le déplacement vers le bas ne peut pas se faire. Alors unenouvelle pièce se génère et le timer reprend sa vitesse normale :

Les pièces sont composées de 4 carrés, représentée chacune par une case du tableau. Lescases où sont placées les pièces prennent une valeur de 1 à 7 en fonction de la forme de lapièce. Leur valeur est différente car chaque forme a une couleur différente et lors del'affichage, la couleur affichée dépend de la valeur de la case du tableau.

La forme de la pièce générée est choisie aléatoirement en choisissant une valeur de 0 à 6 quiva correspondre à une suite de coordonnées de la liste « pieces ». Les coordonnées sontstockées sous forme de sous listes, pour chaque forme, dans la liste « pieces ». Lescoordonnées stockées correspondent aux coordonnées de la pièce choisie pour chaque carréde la forme, pour chacune des quatre positions de la forme. Pour chaque position de laforme, on a 8 valeurs de coordonnées soit 32 coordonnées pour chaque forme. On récupèreles coordonnées dans la liste « piece_suivante », pour afficher la prochaine pièce, puis dansla liste « piece_jouee », pour afficher la pièce dans le puits. Lors de la génération, la pièce setrouve au sommet du puit, elle se trouve toujours dans le sens correspondant aux 8 premièrescoordonnées de la liste « piece_jouee ». Au début, on génère directement une pièce dans lepuis et la prochaine pièce avec la fonction « créa_piece». Ensuite, on génère une nouvelle


9


pièce avec la pièce prévue par « piece_suivante », puis « piece_suivante » prend lesnouvelles valeurs de coordonnées d'une pièce aléatoire. Une nouvelle pièce est générée decette façon dès que la pièce ne peux plus descendre.

On augmente le score de 1 à chaque fois qu'une pièce est placée.

Après avoir placé plusieurs pièces de cette façon, on aboutira à la création d'une lignecomplète. C'est lorsqu'on génère une nouvelle pièce qu'on test si une ligne est complète.

Lorsqu'une ligne est pleine, elle s'élimine et toutes les autre briques qui sont au dessustombent. Le score augmente de 100 points.

Pour vérifier qu'une ligne est pleine on vérifie si il ne reste aucun 0 dans cette ligne. Si leproduit de toutes les cases de la ligne est différent de 0, alors il ne reste plus de 0. On vérifiechaque ligne lorsqu'une pièce est placée de la plus haute à la plus basse.

Pour éliminer la ligne et faire tomber les cases plus haute, on attribue, en partant de la ligneéliminée jusqu'en haut du puis, à chaque case la valeur de la case qui se trouve au-dessus. Laligne la plus haute prend pour valeur 0.

Cet effacement est réalisé grâce à la fonction « disparition ».


10


La ligne est complète et va s'éliminer.Une nouvelle pièce va se générer, celle qui est prévue.


11


9 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 0 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 0 0 5 0 0 0 0 0 9 9 0 0 0 0 0 0 0 0 0 99 0 5 5 5 0 0 0 0 0 9 9 0 0 0 5 0 0 0 0 0 99 5 5 5 5 7 7 7 0 0 9 9 0 5 5 5 0 0 0 0 0 99 5 5 5 5 7 7 7 0 3 9 9 5 5 5 5 7 7 7 0 0 99 5 5 5 7 1 1 7 3 3 9 9 5 5 5 5 7 7 7 0 3 99 5 3 2 7 1 1 7 2 3 9 9 5 5 5 7 1 1 7 3 3 99 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

Le tableau correspondant à la Le tableau correspondant à lafenêtre de jeu précédante. même fenêtre après la disparition

de la ligne.


12


3- Les problèmes rencontrés

Le principal problème a été la génération et le déplacement des véritables pièces qui nouségalement causé des soucis. Nous avons donc opté pour la solution des listes, plus économeet plus facile à manipuler pour le déplacement.

Nous voulions aussi que le score augmente plus si on complète plusieurs lignes d'un coupmais nous n'avons pas encore trouvé de formule de calcul qui nous fait progressivementpasser de 100 points la ligne à 1000 points les 4 lignes uniquement en connaissant le nombrede lignes.

4- Les pistes d'amélioration

Nous cherchons toujours à améliorer notre jeu. Nous envisageons de mettre en place unsystème record qui serait enregistré dans un fichier. Nous pouvons également intégrer unemusique de fond pour donner une ambiance sonore au jeu tétris. Nous voulons ensuiteaméliorer le design de notre fenêtre de jeu, toujours pour améliorer l'ambiance. Enfin onsouhaite créer un écran de départ qui récapitule les données du jeu, nous propose dedirectement commencer à un niveau supérieur à 1 ou nous permet directement d'interagiravec la fenêtre, avant de lancer le jeu lui-même.

On pourrait ensuite créer un système d'installation de notre jeu. Cela nous permettrait de voird'autres formes de codage tout en continuant à améliorer notre premier concept.


13


IV – Conclusion

J’ai beaucoup aimé cette année scolaire en ISN, car j’ai appris beaucoup de choses eninformatique. J’ai également découvert le langage html, CSS et Python que je ne connaissaispas. J’ai appris à créer des sites Web et à coder des programmes divers et variés. Cela m’apermis de prendre goût à la programmation, de savoir répondre à des demandes et derésoudre des problèmes.

J'ai choisis de rejoindre une classe préparatoire scientifique après le bac. Je pense que laspécialité ISN pourra m'aider car je possède des bases désormais que les autres élèvespourront ne pas encore posséder.


14


V – annexe

Le code du jeu :

#-------------------------------------------------------------------------------# Name: Tetris# Purpose: Pygame## Author: Chengele, Touffe et Shadow## Created: 31/01/2014# Copyright: (c) Darkness 2014# Licence: <Darkness Corp>#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------# On importe les différents modules nécéssaires au jeu#-------------------------------------------------------------------------------

import pygameimport osimport tracebackfrom pygame.locals import *from random import randrangefrom numpy import zeros

pygame.init()

#-------------------------------------------------------------------------------# On crée les différentes fonctions#-------------------------------------------------------------------------------

def init () : """ Fonction qui initialise le jeu """ os.environ['SDL_VIDEO_WINDOW_POS']="100,100" #On définit la taille de la fenêtre (800px/800px) et à quel endroit elle doit apparaître fenetre=pygame.display.set_mode((800,800)) fond=pygame.image.load("fond du tetris.png").convert_alpha () # On charge l'interface de fond

# On charge les 7 carrés différents qui correspondent à une pièce précise brick1=pygame.image.load("Brick_Jaune.png").convert_alpha () brick2=pygame.image.load("Brick_Gris.png").convert_alpha () brick3=pygame.image.load("Brick_Marron.png").convert_alpha () brick4=pygame.image.load("Brick_Bleu.png").convert_alpha () brick5=pygame.image.load("Brick_Rouge.png").convert_alpha () brick6=pygame.image.load("Brick_Rose.png").convert_alpha () brick7=pygame.image.load("Brick_Violet.png").convert_alpha ()

# On donne la taille souhaitée au fond et aux carrées fond=pygame.transform.scale (fond,(800,800))

brick1=pygame.transform.scale(brick1,(40,40)) brick2=pygame.transform.scale(brick2,(40,40)) brick3=pygame.transform.scale(brick3,(40,40))


15


brick4=pygame.transform.scale(brick4,(40,40)) brick5=pygame.transform.scale(brick5,(40,40)) brick6=pygame.transform.scale(brick6,(40,40)) brick7=pygame.transform.scale(brick7,(40,40))

Rfond=fond.get_rect () # On crée un rectangle entourant l'image Rbrick1=brick1.get_rect() fenetre.blit (fond,Rfond) # On blitte l'image dans ce rectangle fenetre.blit(brick1,Rbrick1) pygame.key.set_repeat(400,30) # On active la répétition des touches pygame.display.flip () # On actualise la fenêtre du jeu depla=USEREVENT+1 # Création d'un évenement de l'utilisateur : déplacement de la brique laps = 280 # Cela correspond à 280 ms niv = 20 # C'est le palier de changement de niveau : quand on dépasse les 20 lignes complétées, le joueur passe au niveau supérieur pygame.time.set_timer(depla,laps) # On défini le laps de temps au bout duquel l'évenement se reproduit pygame.display.flip ()

global fenetre global fond global Rfond global brick1 global brick2 global brick3 global brick4 global brick5 global brick6 global brick7 global Rbrick1 global depla global laps global niv

def tablo () : """ Fonction qui crée le tableau nécéssaire au jeu """ tab=zeros((22,11),'i') # On crée un tableau uniquement composé de 0 et de 9, pour faciliter le positionnement des pièces, # ainsi que leurs déplacements for i in range (0,21): # Ici on délimite les bordures à l'aides des 9 tab[i,0]=9 tab[i,10]=9

for i in range(0,11): tab[21,i]=9

global tab # On "globalise" ces variables pour qu'elles soient utilisables dans tout le programme

def tab_next (): """crée le tableau pour la piece suivante""" tabsuivant=zeros((4,4),'i') global tabsuivant

def créa_piece () : """ Crée les pièces """ pieces=[[0,5,0,6,1,5,1,6,0,5,0,6,1,5,1,6,0,5,0,6,1,5,1,6,0,5,0,6,1,5,1,6] ,[0,4,0,5,0,6,0,7,0,5,1,5,2,5,3,5,0,4,0,5,0,6,0,7,0,5,1,5,2,5,3,5],\ [0,4,0,5,0,6,1,5,-1,5,0,5,1,5,0,4,0,4,0,5,0,6,-1,5,-1,5,0,5,1,5,0,6],[0,5,0,6,1,4,1,5,0,4,0,5,-1,4,1,5,0,5,0,6,1,4,1,5,0,4,0,5,-1,4,1,5],\


16


[0,5,0,4,1,5,1,6,0,5,0,4,-1,5,1,4,0,5,0,4,1,5,1,6,0,5,0,4,-1,5,1,4],[0,4,0,5,0,6,1,6,1,4,1,5,0,5,-1,5,-1,4,0,4,0,5,0,6,1,5,0,5,-1,5,-1,6],\ [0,4,0,5,0,6,1,4,-1,4,-1,5,0,5,1,5,0,4,0,5,0,6,-1,6,-1,5,0,5,1,5,1,6]] # Ici on crée la liste des pièces, chacune des pièces étant définies par ses 4 coordonnées dans chacune des positions qu'elle peut prendre

# On crée deux variables qui ont pour valeur une valeur aléatoire de la liste des pièces alea=randrange(0,7) aleasuiv=randrange(0,7)

global alea global aleasuiv

piece_jouee=pieces[alea] piece_suivante=pieces[aleasuiv]

global pieces global piece_jouee global piece_suivante

def valeur1_case () : """ Fonction qui fait prendre aux cases de la pièce la valeur 1 """ tab[piece_jouee[0+tourner]+ligne,piece_jouee[1+tourner]+colonne]=alea+1 tab[piece_jouee[2+tourner]+ligne,piece_jouee[3+tourner]+colonne]=alea+1 tab[piece_jouee[4+tourner]+ligne,piece_jouee[5+tourner]+colonne]=alea+1 tab[piece_jouee[6+tourner]+ligne,piece_jouee[7+tourner]+colonne]=alea+1

def valeur0_case () : """ Fonction qui fait prendre aux cases de la pièce la valeur 0 """ tab[piece_jouee[0+tourner]+ligne,piece_jouee[1+tourner]+colonne]=0 # On met la valeur des cases de la piece jouée à 0 pour ne pas gêner les mouvements, tab[piece_jouee[2+tourner]+ligne,piece_jouee[3+tourner]+colonne]=0 # ainsi la pièce en mouvement ne se bloque pas elle-même ! tab[piece_jouee[4+tourner]+ligne,piece_jouee[5+tourner]+colonne]=0 tab[piece_jouee[6+tourner]+ligne,piece_jouee[7+tourner]+colonne]=0

def blittage () : """ Fonction qui garde en mémoire les anciennes pièces """ for i in range (10): # On parcourt le tableau, pour chaque case =! 0, on blitte son image a ses coordonées for j in range (21): # On fait répéte cette action pour chaque carré différent if tab[j,i]==1: Rbrick1.center=(i*40+278,j*40-20) fenetre.blit(brick1,Rbrick1)

if tab[j,i]==2: Rbrick1.center=(i*40+278,j*40-20) fenetre.blit(brick2,Rbrick1)





17




for i in range(4): for y in range(4): # Ici on affiche la pièce suivante dans un petit tableau situé sur l'interface # On répéte de nouveau cette action pour chaque carré différent if tabsuivant[y,i]==1: Rbrick1.center=(i*40+95,y*40+590) fenetre.blit(brick1,Rbrick1)

if tabsuivant[y,i]==2: Rbrick1.center=(i*40+95,y*40+590) fenetre.blit(brick2,Rbrick1)






def disparition () : """ Fonction qui fait disparaître les lignes complètes """ for y in range (0,21): # Ici, on vérifie que le produit de chacune des cases d'une ligne (une case vaut 0 si elle est vide\ # et 1 si elle est occupée) est différent de 0, donc que la ou les lignes sont pleines if tab[y,1]*tab[y,2]*tab[y,3]*tab[y,4]*tab[y,5]*tab[y,6]*tab[y,7]*tab[y,8]*tab[y,9]*tab[y,10] !=0: score=score+100 # On ajoute 100 pts par lignes complétées l=l+1 # On rajoute 1 lignes par nombre de lignes complétées if l==niv: # Si on atteint le palier du nombre de lignes : niv=niv+15 # On augmente le palier laps=laps-20 # On réduit la vitesse pygame.time.set_timer(depla,laps) # On met à jour le timer lvl+=1 # On change de niveau

for u in range(1,10):

for x in range (y): # On parcourt toutes les lignes au-dessus de celle quiest pleine pour les faire descendre

tab[y-x,u]=tab[y-x-1,u] # Les lignes descendent colonne par


18


colonne tab[0,u]=0 # On fait disparaître la ligne en vidant toutes les cases pleines de cette ligne

global score global l global lvl global laps global niv

def piecesuiv_1 () : """ Fonction qui attribue à la piece suivante la valeur de la forme """ tabsuivant[piece_suivante[0]+1,piece_suivante[1]-4]=aleasuiv+1 tabsuivant[piece_suivante[2]+1,piece_suivante[3]-4]=aleasuiv+1 tabsuivant[piece_suivante[4]+1,piece_suivante[5]-4]=aleasuiv+1 tabsuivant[piece_suivante[6]+1,piece_suivante[7]-4]=aleasuiv+1

def piecesuiv_0 () : """ Fonction qui attribue à la pièce suivante la valeur 0 """ tabsuivant[piece_suivante[0]+1,piece_suivante[1]-4]=0 tabsuivant[piece_suivante[2]+1,piece_suivante[3]-4]=0 tabsuivant[piece_suivante[4]+1,piece_suivante[5]-4]=0 tabsuivant[piece_suivante[6]+1,piece_suivante[7]-4]=0

def depla_droite () : """ Fonction qui gère le déplacement latéral droit """ colonne=colonne+1 # On fait une projection de la pièce sur la droite # On vérifie si elle peut se placer if tab[piece_jouee[0+tourner]+ligne,piece_jouee[1+tourner]+colonne]!=0 or\ tab[piece_jouee[2+tourner]+ligne,piece_jouee[3+tourner]+colonne]!=0 or\ tab[piece_jouee[4+tourner]+ligne,piece_jouee[5+tourner]+colonne]!=0 or\ tab[piece_jouee[6+tourner]+ligne,piece_jouee[7+tourner]+colonne]!=0 :

colonne=colonne-1 # Si elle ne peut pas, on annule le déplacement

global colonne

def depla_gauche () : """ Fonction qui gère le déplacement latéral gauche """ colonne=colonne-1

if tab[piece_jouee[0+tourner]+ligne,piece_jouee[1+tourner]+colonne]!=0 or\ tab[piece_jouee[2+tourner]+ligne,piece_jouee[3+tourner]+colonne]!=0 or\ tab[piece_jouee[4+tourner]+ligne,piece_jouee[5+tourner]+colonne]!=0 or\ tab[piece_jouee[6+tourner]+ligne,piece_jouee[7+tourner]+colonne]!=0 :

colonne=colonne+1

global colonne

def rota () : """ Fonction qui gère la rotation des pièces """ if tourner==24: # Les coordonées totales de la pièce nécéssitent une combinaisonde 8 chiffres donc 32 pour les 4 positions tourner=0 # On effectue un décalage de 8 dans l'indice de la liste des coordonnées, si on atteint le bout de la liste, else: # alors on retour à l'indice 0 tourner=tourner+8

if tab[piece_jouee[0+tourner]+ligne,piece_jouee[1+tourner]+colonne]!=0 or\


19


tab[piece_jouee[2+tourner]+ligne,piece_jouee[3+tourner]+colonne]!=0 or\ tab[piece_jouee[4+tourner]+ligne,piece_jouee[5+tourner]+colonne]!=0 or\ tab[piece_jouee[6+tourner]+ligne,piece_jouee[7+tourner]+colonne]!=0 : # On vérifie si la pièce peut se placer dans sa nouvelle position # Si oui alors on continue

if tourner==0: tourner=24 else: tourner=tourner-8 # Sinon on annule

global tourner

def lost () : """ Fonction qui définit quand on a perdu """ for i in range(1,10): # Si une pièce est tout en haut du puits et qu'elle bloque la descente des autres pièces if tab[0,i]>=1 and tab [0,i] <= 7 : continuer = 0 # la variable continuer prend la valeur 0 : le jeu se stoppe game = 0 # La variable game prend la valeur 0, on lance l'affichage de fin avec la fonction aff_lost aff_lost ()

global game

def fall () : """ Fonction fait tomber la pièce """ valeur0_case () # La pièce prend la valeur 0 pour ne pas gêner ses mouvements

ligne=ligne+1 # C'est un deplacement fictif vers le bas

if tab[piece_jouee[0+tourner]+ligne,piece_jouee[1+tourner]+colonne]==0 and\ tab[piece_jouee[2+tourner]+ligne,piece_jouee[3+tourner]+colonne]==0 and\ tab[piece_jouee[4+tourner]+ligne,piece_jouee[5+tourner]+colonne]==0 and\ tab[piece_jouee[6+tourner]+ligne,piece_jouee[7+tourner]+colonne]==0 : # On vérifie si la pièce peut se trouver à sa nouvelle position

valeur1_case () # Puis elle reprend la valeur de la forme

else : # Lorsque la brique ne se déplace plus, on génère une nouvelle pièce tout en haut du tableau, l'autre étant gardée en mémoire

ligne=ligne-1 # On annule le deplacement car il n'est pas possible

valeur1_case ()

colonne=0 # On réinitialise le départ de la pièce pour la nouvelle pièce ligne=0 tourner=0 score+=1 # On ajoute 1 point par pièce placée piece_jouee=piece_suivante alea=aleasuiv

pygame.time.set_timer(depla,laps)

piecesuiv_0 ()

aleasuiv=randrange(0,7)

piece_suivante=pieces[aleasuiv] # Une nouvelle pièce aléatoire est choisie

piecesuiv_1 ()


20


lost () # On vérifie si le joueur n'a pas perdu

disparition () # On utilise la fonction permettant de faire disparître les lignes pleines

global ligne global colonne global score global tourner global piece_jouee global piece_suivante global alea global aleasuiv

def affichage () : """ Fonction qui gère l'affichage du score, du niveau et du nombre de lignes """

# Pour le niveau en cours if lvl >= 10 : # On décale le nombre pour qu'il ne soit pas décentré sur l'interface font=pygame.font.SysFont("Arial",100,bold=True,italic=False) text=font.render(str(lvl),1,(255,249,0)) fenetre.blit(text,(675,660)) else : font=pygame.font.SysFont("Arial",100,bold=True,italic=False) text=font.render(str(lvl),1,(255,249,0)) fenetre.blit(text,(705,660))

# Pour le score actuel if score >= 10000 : font=pygame.font.SysFont("Arial",30,bold=True,italic=False) text=font.render(str(score),1,(255,249,0)) fenetre.blit(text,(110,90))

elif score >= 1000 : font=pygame.font.SysFont("Arial",30,bold=True,italic=False) text=font.render(str(score),1,(255,249,0)) fenetre.blit(text,(115,90))

elif score >=100 : font=pygame.font.SysFont("Arial",30,bold=True,italic=False) text=font.render(str(score),1,(255,249,0)) fenetre.blit(text,(120,90))

else : font=pygame.font.SysFont("Arial",30,bold=True,italic=False) text=font.render(str(score),1,(255,249,0)) fenetre.blit(text,(140,90))

# Pour le nombre de lignes complétées if l >= 10 : font=pygame.font.SysFont("Arial",30,bold=True,italic=False) # Ici le nombre de lignes déjà complétées text=font.render(str(l),1,(255,249,0)) fenetre.blit(text,(127,395))

else : font=pygame.font.SysFont("Arial",30,bold=True,italic=False) text=font.render(str(l),1,(255,249,0)) fenetre.blit(text,(137,395))

def aff_lost () :


21


""" Fonction qui affiche l'écran de fin de jeu """ while game == 0 : # Quand game = 0, on charge l'image de l'écran de fin os.environ['SDL_VIDEO_WINDOW_POS']="100,100" # On récrée la fenêtre fenetre=pygame.display.set_mode((800,800)) lose=pygame.image.load("Ecran Lost.png").convert_alpha() # On charge l'image Rlose=lose.get_rect() # On obtient son rect fenetre.blit (lose,Rlose) font=pygame.font.SysFont("Agency FB",50,bold=False,italic=False) # On définit la police d'écriture du score text=font.render(str(score),1,(255,0,0)) fenetre.blit(text,(350,265)) pygame.display.flip () for event in pygame.event.get () : if event.type == QUIT : # Si on appuie sur la croix rouge le jeu se ferme game = 2 continuer = 0 elif event.type == KEYDOWN : if event.key == K_KP1 : # Si on appuie sur 1 : game = 1 # On retourne à l'écran du jeu continuer = 0

elif event.key == K_KP2 : # Si on appuie sur 2 : game = 2 # Le jeu se quitte continuer = 0

global continuer global game

#-------------------------------------------------------------------------------# On lance le programme du jeu#-------------------------------------------------------------------------------

try:

game = 1

while game == 1 : # Tant que game == 1, le jeu continue et permet d'afficher les différentes fenêtres et variables

continuer=1

init () # On initialise le jeu

# On crée les deux tableaux tablo () tab_next ()

ligne=0 colonne=0

créa_piece () # On lance la fonction qui gènère les pièces

piecesuiv_1 () # la pièce suivante prend la valeur de la forme pour pouvoir s'afficher dans l'endroit prevu à cet effet

# On crée des variables pour les scores, les niveaux, le nombre de lignes remplieset l'indice de rotation de la pièce score=0 lvl=1 l=0 tourner=0

while continuer: # Tant que la variable continuer est égale à 1, le jeu continue for event in pygame.event.get():


22


if event.type==QUIT: # Lorsqu'on clique sur la croix rouge pour fermer le programme, game = 2 # On met la variable game à 2, pour qu'elle ne déclenche pas l'écran de fin et stoppe le jeu continuer=0 # la variable continuer devient nulle et le jeu se fermeainsi que la fenêtre

elif event.type == KEYDOWN : # Cet évènement est vérifié quand l'utilisateur appuie sur une touche du clavier

valeur0_case () # La pièce prend une valeur nulle pour ne pas gêner ses propres mouvements

if event.key == K_RIGHT : # Ici l'utilisateur appuie sur la flèche directionnelle droite, pour déplacer la pièce à droite

depla_droite () # On utilise la fonction pour se déplacer à droite

elif event.key == K_LEFT : # Même chose qu'avant, sauf que cette foiscela concerne le déplacement vers la gauche

depla_gauche () # On utilise la fonction pour se déplacer à gauche

elif event.key == K_UP : # Lorsque l'utilisateur appuie sur la flèchedu haut, la pièce effectue une rotation de 90°

rota () # On utilise la fonction pour faire pivoter les pièces de 90° vers la droite

elif event.key == K_DOWN : # Lorsque le joueur appuie sur la flèche dubas, la pièce se place directement en bas speed = 1 # On met la vitesse max pour la pièce, pour que le déplacment soit instantané pygame.time.set_timer(depla,speed) # On met à jour le timer

valeur1_case ()

# Les cases de la pièce reprennent la valeur 1 pour l'affichage # Dans leur nouvelles ou anciennes coordonnées suivant la validation du déplacement

elif event.type==depla : # La brique tombe et s'arrête lorsqu'elle atteintle plancher

fall () # On utilise la fonction gérant la chute des pièces ainsi que la création des nouvelles pièces

fenetre.blit(fond,Rfond) # On blitte l'interface de fond

blittage () # On garde en mémoire les anciennes pièces

affichage () # On affiche les variables utiles pour le joueur (score, niveau, nombre de lignes)

pygame.display.flip () # On oublie pas de rafraîchir la fenêtre

except : traceback.print_exc () # Imprime les erreurs

finally : # Lorsqu'on quitte le jeu, la fenêtre se ferme et on quitte pygame pygame.quit () exit ()


23

Download - Projet d'ISN · Limage correspondant au fond « fond du tetris.png » : C'est l'image de fond du jeu. Pour utiliser le jeu, il faut avoir installé le langage Python ainsi que Pygame

Top Related