rapport projet C TETRIS bartak/behar · -Etienne Projet C | Ecole des Mines de Saint-Etienne |...

Projet C | Ecole des Mines de Saint-Etienne | Joachim BEHAR, Julien BARTAK |

tuteur Mohamed Essafi

|19/12/08

1

PROJET C RAPPORT TETRIS

Julien BARTAK &

Joachim BEHAR

TUTEUR : Mohamed ESSAFI

Tetris

Projet C

Mines de Saint -Etienne



|19/12/08

2

Table des matières

I. Introduction .................................................................................................................................... 3

II. Présentation du jeu ....................................................................................................................... 4

III. Phases d’analyse et de conception .............................................................................................. 5

IV. Les différentes procédures .......................................................................................................... 11

1) Les fonctions de sauvegarde ................................................................................................ 11

2) Fonction d’aide ........................................................................................................................ 14

V Apports du projet ............................................................................................................................. 16

Tetris

Projet C




|19/12/08

3

I. Introduction

Le tétris est un jeu auquel nous avons beaucoup joué quand nous étions enfants, qui était prenant par sa simplicité de prise en main et la possibilité de jouer en duo en raccordant deux Gameboy. Le jeu, associé à sa célèbre musique, est devenu un jeu mondial et nous nous réjouissons d’avoir réussi, non sans quelques difficultés passagères, à coder un jeu aussi renommé. Notre choix s’est établi directement lorsque nous avons vu la liste des projets possibles : nous voulions sélectionner en premier lieu un jeu interactif, ce qui permettait d’avoir un bon engouement à travailler dessus. Le tétris fut choisi car c’était le jeu qui nous semblait le plus complexe par la gestion à la fois du temps et de l’espace, mais c’était aussi le jeu auquel nous avions le plus joué. Il s’est révéler pour nous tel un défi. Les règles du jeu étant connues de tous, nous les rappellerons tout de même dans la première partie de ce document. Nous avons dans un premier temps étudier les différentes étapes que le jeu allait devoir réaliser, puis nous avons établi un ordre de déroulement des différentes étapes qui allaient constituer le programme principal de notre codage du jeu. Nous avons ensuite choisi un codage des données qui sera expliqué dans la seconde partie. Nous donnerons dans un troisième temps les fonctionnalités des différentes fonctions utilisées et codées pour réaliser le jeu en lui-même, les difficultés que nous avons rencontrées ainsi que leur résolution. Nous conclurons ce document par l’apport personnel qu’a permis la réalisation de ce jeu de tétris.



|19/12/08

4

II. Présentation du jeu

Sous les airs simples et primaires de Tetris, se cache un jeu d'une rare complexité mathématique. Voici un guide rapide des "Règles de Tetris". On appelle chacune des formes de Tetris, un tetramino (du grec 'tetra', signifiant 'quatre'). Chaque tetramino se compose de quatre carrés assemblés de différentes manières. Il y en a sept différents. Chaque forme qui tombe du haut de l'écran est choisie au hasard parmi l'un des sept types. Le joueur doit faire tourner les blocs durant leur chute et les assembler de façon à ce qu'ils forment des lignes horizontales qui une fois complètes disparaissent de l'écran. Si vous échouez à faire disparaître des lignes, les blocs ne tarderont pas à s'accumuler et s'ils parviennent jusqu'en haut de l'écran, c'est 'Game Over'. En faisant disparaître une ligne après l'autre, vous obtiendrez le minimum de points mais si vous en faites disparaître deux ou trois en même temps, vous pourrez grappiller plus de points. Toutefois, l'objectif ultime est de faire disparaître quatre lignes d'un seul coup (ça s'appelle un 'Tetris') pour obtenir le score maximum. Cependant, on ne peut réaliser un 'Tetris' que si l'on utilise le bloc en forme de barre en disposant les autres pièces de manière à laisser un espace vertical. Les joueurs expérimentés calculent leurs gestes en gardant un œil sur la fenêtre dans laquelle s'affiche le prochain bloc. On peut accélérer la descente du bloc en appuyant sur 'bas' sur la croix directionnelle. On peut généralement se le permettre au début, lorsque la vitesse du jeu est encore lente mais dans les niveaux plus avancés, les blocs tombent beaucoup plus vite et sont, par conséquent, plus difficiles à manœuvrer. Commandes du jeu : On utilise les touches directionnelles :

BAS : descente de la pièce DROITE : déplacement de la pièce à droite

GAUCHE : déplacement de la pièce à gauche HAUT : faire tourner la pièce Ctrl+C : Quitter le programme

Le jeu de tétris comporte 10 niveaux : ils vont de 1 à 10 et déterminent la fréquence de chute des pièces (la vitesse à laquelle tombent les pièces). Le score est calculé de manières différentes selon les versions du jeu. Il est ici déterminé de la façon suivante :



|19/12/08

5

Lignes/Niveaux 1 2 3 4 5 6 7 8 9 10 1 40 80 120 160 200 240 280 320 360 400 2 100 200 300 400 500 600 700 800 900 1000 3 400 800 1200 1600 2000 2400 2800 3200 3600 4000 4 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000

Les pièces évoluent dans une grille de dimension 20X10.

III. Phases d’analyse et de conception La première phase fut de déterminer quelles allaient être les fonctions fondamentales dont nous aurions besoin dans notre programme. Aussi nous avons commencé par écrire les mots clefs du jeu tels que :

� Game over � Interface clavier � Affichage � Rotation d’une pièce � Déplacer une pièce � Supprimer une ligne � Gestion du temps � Score …

La seconde étape consistait à commencer la rédaction du programme principal, c'est-à-dire l’enchainement des fonctions qui allaient constituer les différentes étapes du programme. La troisième étape, cruciale s’il en est, fut de choisir le codage des données : la grille et les pièces.

� Le Tétris est composé de 7 pièces qui peuvent tourner dans le sens trigonométrique.



|19/12/08

6

Nous remarquons que chaque pièce est constituée de 4 cases et qu’une case repère (point noir) qui permet de localiser la pièce et de gérer le déplacement de celle-ci. On a donc choisi de représenter chaque case d’une pièce en considérant les décalages horizontaux et verticaux de celle-ci par rapport au repère. Nous avons choisi de stocker les représentations de toutes les pièces dans un même tableau à quatre dimensions appelé pieces[7][4][4][2] de la façon suivante.

Schéma 1 : les différentes pièces du Tetris et leurs configurations

Projet C | Ecole des Mines de Saint


|19/12/08

7

� La grille définit l’espace où évoluent les pièces. Elle doit représenter la taille

de l’espace d’évolution des pièces plus les contours pour pouvoir délimiter cet espace. Ceci nous amène à une grille de taille 12X22. Or lorsque l’on vefaire tourner la barre, elle peut avoir une case qui sort de la grille, d’où un contour de double épaisseur (Taille de 14X24). De plus, lors de la suppression de lignes (4 au maximum), on a besoin de faire descendre au maximum 4 lignes : pour notre codahaut de la grille, ce qui fait au final une taille de 14X26 pour la grille.Les cases qui constituent le contour sont codées par des 2 pour les différencier des cases vides, codées tout simplement pas deremplies, codées par des 1. Seules exceptions, les cases des 4 premières lignes qui font le contour supérieur sont codées par des 0 pour pouvoir supprimer plus facilement les lignes pleines (pas besoin de réaffectée la valeur nulle pour ces lignes qui sont descendues), ce qui ne pose pas de problème pour le déplacement des piècesvers le haut et une condition sur leur repère les empêche de tourner quand il se trouve sur la première ligne d’évolution (la cin


La grille définit l’espace où évoluent les pièces. Elle doit représenter la taille de l’espace d’évolution des pièces plus les contours pour pouvoir délimiter cet espace. Ceci nous amène à une grille de taille 12X22. Or lorsque l’on vefaire tourner la barre, elle peut avoir une case qui sort de la grille, d’où un contour de double épaisseur (Taille de 14X24). De plus, lors de la suppression de lignes (4 au maximum), on a besoin de faire descendre au maximum 4

: pour notre codage, il nous faut donc deux lignes supplémentaires en haut de la grille, ce qui fait au final une taille de 14X26 pour la grille.Les cases qui constituent le contour sont codées par des 2 pour les différencier des cases vides, codées tout simplement pas deremplies, codées par des 1. Seules exceptions, les cases des 4 premières lignes qui font le contour supérieur sont codées par des 0 pour pouvoir supprimer plus facilement les lignes pleines (pas besoin de réaffectée la

es lignes qui sont descendues), ce qui ne pose pas de problème pour le déplacement des pièces : les pièces ne se déplacent pas vers le haut et une condition sur leur repère les empêche de tourner quand il se trouve sur la première ligne d’évolution (la cinquième ligne de la grille).

Julien BARTAK |

La grille définit l’espace où évoluent les pièces. Elle doit représenter la taille de l’espace d’évolution des pièces plus les contours pour pouvoir délimiter cet espace. Ceci nous amène à une grille de taille 12X22. Or lorsque l’on veut faire tourner la barre, elle peut avoir une case qui sort de la grille, d’où un contour de double épaisseur (Taille de 14X24). De plus, lors de la suppression de lignes (4 au maximum), on a besoin de faire descendre au maximum 4

ge, il nous faut donc deux lignes supplémentaires en haut de la grille, ce qui fait au final une taille de 14X26 pour la grille. Les cases qui constituent le contour sont codées par des 2 pour les différencier des cases vides, codées tout simplement pas des 0, et des cases remplies, codées par des 1. Seules exceptions, les cases des 4 premières lignes qui font le contour supérieur sont codées par des 0 pour pouvoir supprimer plus facilement les lignes pleines (pas besoin de réaffectée la

es lignes qui sont descendues), ce qui ne pose pas de : les pièces ne se déplacent pas

vers le haut et une condition sur leur repère les empêche de tourner quand il quième ligne de la grille).



|19/12/08

8

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

� L’interface avec le clavier fait aussi parti de nos choix : nous avons tout simplement choisi d’utiliser les touches directionnelles et la touche ENTER pour faciliter l’utilisation du jeu, notamment pour déplacer les pièces et se déplacer dans les différents menus.

Schéma 2 : représentation de la grille du Tetris



|19/12/08

9

Le programme principal qui permet de

Avancement du projet :

Notre but pour ce projet était de repron peut jouer avec une game boy.

Nous avons réalisé un menuse déplacer avec facilité et qui répond réussi à coder :

� Faire une nouvelle parti� Charger une partie préalablement sauvega� Afficher la liste des meilleurs scores� Afficher une aide� Quitter le programme� Choisir entre deux modes de jeu

mode défi où les lignes inférieures sont partiellement remplies.� Choix du niveau et nombre de lignes � Faire une pause pe� Reprendre une partie en cours


pal qui permet de jouer fonctionne de la façon suivante

ut pour ce projet était de représenter un tétris qui ressemblait à celuiavec une game boy.

menu en utilisant la bibliothèque menu.h dans lequel on peut er avec facilité et qui répond aux différentes fonctionnalités

une nouvelle partie partie préalablement sauvegardée

Afficher la liste des meilleurs scores une aide

uitter le programme Choisir entre deux modes de jeu : une partie normale et une partie en

ù les lignes inférieures sont partiellement remplies.du niveau et nombre de lignes pré remplies une pause pendant la partie

une partie en cours

Julien BARTAK |

de la façon suivante :

senter un tétris qui ressemblait à celui auquel

dans lequel on peut différentes fonctionnalités que nous avons

une partie normale et une partie en ù les lignes inférieures sont partiellement remplies.



|19/12/08

10

� Sauvegarder une partie en cours

L’affichage se fait dans des fenêtres qui sont générées par la bibliothèque ncurses.h.

Ce que nous aurions aimé faire

� La première chose que l’on pourrait améliorer, c’est le graphique en utilisant une bibliothèque graphique adaptée, pour à la fois mettre de la couleur et représenter les pièces à l’affichage par des vrais carrés.

� La seconde chose nous tenait à cœur : c’est mettre la musique du jeu pour une meilleure appréciation du jeu.

� Enfin certaines fonctions peuvent être optimisées pour diminuer le nombre d’opérations, notamment pour l’affichage car au début elles n’étaient pas faîtes pour être utilisées avec ncurses



|19/12/08

11

IV. Les différentes procédures

1) Les fonctions de sauvegarde Sauvegarde des meilleurs joueurs: -On va utiliser la structure notée struct memoire et qui contient deux champs : le score, ainsi que le nom d'un joueur. 1ère procédure : stoker_score : Objectif : fonction qui permet de stoker les scores des 3 meilleurs joueurs ainsi que leurs noms dans le fichier nom_fichier sous la forme score*nom_joueur Description générale: Cette procédure possède deux arguments. Le premier est un tableau de structure de taille S (où S est un entier défini en variable globale) qui permet de livrer au programme le nom et le score des S meilleurs joueurs. Le second correspond au nom du fichier dans lequel on veut stoker les données, c'est à dire les noms des joueurs avec leur scores associés. Description algorithme : On commence par construire un flot à l'aide de la fonction fopen (ouverture en mode "w"=write).On test si tout c'est bien passé et si c'est le cas on écrit sur le fichier à l'aide des fonctions fwrite et fprintf. En fin de programme on referme le flot gg. Nouvelles fonctions utilisées : fprintf = écriture formatée sue le float gg fwrite = qui permet d'écrire dans le flot gg des données dite binaires fclose = permet de refermer le flot gg Seconde procédure : imprim_scores Objectif : Fonction qui permet de lire les scores, les noms des trois meilleurs joueurs et de les imprimer. C'est donc la fonction d'affichage des meilleurs scores. En effet on veut pouvoir via le menu du tetris accéder aux noms des S meilleurs joueurs, d'où la nécessité de cette fonction d'impression. Description générale: Cette procédure possède un argument qui est le nom du fichier dans lequel doivent êtres lu les scores et les noms des joueurs. Description algorithme :

Tetris

Projet C




|19/12/08

12

De la même manière que précédemment on commence par construire un flot à l'aide de la fonction fopen mais cette fois l'ouverture se fait en mode "r" =read. On test pour voir si tout c'est bien déroulé et ensuite on utilise la fonction fscanf(gg,"%d*%s",&high,ident) pour lire sur le float gg un entier séparé du nom d'un joueur par une étoile. fscanf rend un entier égale au nombre d'éléments lu et noté cr (ici égale à deux si tout c'est bien déroulé), ce qui donne lieu à une procédure de test (=on vérifie que l'on a bien cr=2). Enfin on imprime les données lues. On répète la boucle S fois. Dernière étape de la procédure : on ferme le flot à l'aide de fclose. Nouvelle fonction utilisée: fscanf Troisième procédure:lire_score Objectif : Fonction de lecture des scores et des noms des joueurs stockés dans le fichier nom_fichier. La procédure permet de remplir les champs du tableau de structure mem2. Description générale: Cette procédure possède deux arguments : un tableau de structures de taille S qui est à remplir à partir du fichier nom_fichier (=deuxième argument) Description algorithme : De la même manière que l'algorithme précédent on va aller lire dans le fichier nom_fichier les scores et noms des joueurs associés. Cette fois par contre on veut stoker ces données dans le tableau de structure mem2. On va lire ligne par ligne le fichier nom_fichier et on remplit les champs de la structure. Attention cependant à bien allouer de la mémoire à mem2[i].nom en utilisant malloc. Nouvelles fonctions utilisées : malloc = permet d'allouer une zone mémoire susceptible de stoker une donnée d'au moins k octets (prototype void *malloc (size_t k) strcpy = permet de copier la chaine de caractères stockée dans ident dans mem2[i].nom (strcpy(mem2[i].nom,ident)) Quatrième procédure: changer_classement Objectif : Fonction qui permet de changer le classement lorsqu’il y a un nouveau meilleur joueur (ce n'est pas obligatoirement le meilleur joueur mais un des S meilleurs joueurs). Description générale: Cette procédure possède quatre arguments qui sont un tableau de structures de taille S, un entier nombre qui correspond au score du joueur que l'on veut ajouter, un entier i où i € [0;S-1] et où i représente la position de ce joueur dans le classement



|19/12/08

13

(par exemple si le joueur que l'on veut entrer a battu l'ancien meilleur joueur on entre i=0) et enfin une chaine de caractères qui correspond au nom du nouveau meilleur joueur. Description de l’algorithme : On décale les champs du tableau de structure pour j allant de S-1 à i+1 et on entre le nom et le score du nouveau joueur. Exemple: si i=1, alors la structure S-1 devient la S, la structure S-2 devient la S-1... jusqu'à arriver à mem2[1] que l'on rempli à l'aide des arguments nombre et str. On ne touche pas à mem2[0]. Sauvegarde d’une partie en cours On commence par définir une structure struct scores dans laquelle on a trois entiers : le nombre de lignes, le score et le niveau. 1ère procédure : sauvegarde Objectif : Fonction de sauvegarde de la grille ainsi que du score, du nombre de lignes et du niveau de la partie dans le fichier externe sauv.out . On veut pouvoir avec cette fonction sauvegarder notre partie pour y revenir plus tard. Description générale: La procédure possède trois arguments qui sont : un tableau représentant la grille du tetris, une structure scores *score, le fichier dans lequel on veut stoker les données. Le premier argument correspond à la grille que l’on veut conserver et le second au score, au niveau ainsi qu’au nombre de lignes au moment de la sauvegarde. Description de l’algorithme : On commence par ouvrir un flot gg sur le fichier de sauvegarde. On stocke ensuite les données contenues dans la grille tab[A][B] puis celle contenues dans la structure. 2ème procédure : charger_grille Objectif : Fonction pour charger une partie sauvegardée : on charge la grille, le score, le nombre de lignes ainsi que le niveau (stockés dans le fichier str). Cette fonction permet donc de retrouver une partie sauvegardée et de la continuer. Description générale :

Tetris

Projet C




|19/12/08

14

La procédure possède trois argument qui sont tab[A][B], struct scores *score et le nom du fichier dans lequel on va chercher la partie sauvegardée (argument noté stdr). On va aller chercher les données dans se fichier et remplir le tableau tab ainsi que la structure. En sortie de la procédure on a dispose donc des données suffisantes pour reconstituer la partie. Description algorithme : On ouvre le flot en mode read et on lit à l’aide de fscanf le fichier de sauvegarde. On remplit ainsi le tableau tab[A][B] ( double boucle for de l’algorithme ) puis on refait fscanf trois fois pour lire score, niveau, nombre de ligne que l’on stocke dans la structure.

2) Fonction d’aide

Objectif : Cette fonction permet d’afficher les règles du jeu. L’utilisateur ne connaissant pas le jeu ou ne sachant pas quelles sont les touches à utiliser pour joueur peut ainsi consulter le manuel que nous mettons à disposition. Description générale : Sur simple appel à cette procédure on affiche dans la fenêtre le contenu du fichier regles_tetris.txt

3) Autres fonctions Programme 1 : initialise_grille Ce programme a pour objectif d’initialiser la grille du tetris. Cette initialisation consiste en : Pour les bords de la grille on initialise à 2 et pour l’intérieur on initialise à 0. Programme 2 : genere_grille Ce programme permet de représenter la grille (graphiquement). On a différencié, encore une fois, les bords des éléments propres de la grilles ceci pour avoir un game play plus clair. Programme 3 : test_ligne Ce programme permet de tester si une ou plusieurs lignes se sont formées. Il retourne un tableau de taille 5 dans lequel on a pour les quatre premiers éléments les valeurs i = lignes qui se sont formées (si c’est le cas, 0 sinon) et en 5ème élément le nombre de lignes formées. Aussi ce programme rend le nombre de lignes formées et leurs numéros.

Tetris

Projet C




|19/12/08

15

Programme 4 : Game over Ce programme permet de déterminer si le joueur a perdu ou non. On utilise le fait que la la nouvelle pièce est générée dans le rectangle gris qui suit :

Programme 5 : choix_piece Ce programme a pour objectif de choisir de façon aléatoire une pièce du tetris dans l’optique de générer une nouvelle pièce. Nouvelle fonction utilisée : srand Programme 6 : copie_grille Ce programme copie le tableau représentant la grille dans un autre tableau ceci dans le but de pouvoir manipuler le premier tableau sans pour autant perdre l’information de sa configuration antérieur (utilisée dans certaines procédures). Programme 7 :implante_piece Ce programme permet de représenter une pièce donnée, dans une configuration donnée, à (i,j) données. Il sauvegarde aussi l’état de la grille précédente dans le but de pouvoir y revenir si besoin.

Aussi on utilise deux grilles : la grille sans la

nouvelle pièce et la grille avec la nouvelle pièce

insérée (même si on ne peut normalement pas

l’insérer !). On compte ensuite les 1 des deux

tableaux contenus dans le rectangle gris. Si la pièce

peut être insérée on doit normalement avoir quatre

1 de plus dans la seconde grille (celle où on a la

pièce).En effet chaque pièce est représenté par

quatre 1,c'est-à-dire quatre cases. Aussi on test

cette propriété. Le programme rend ainsi la valeur

0 si l’insertion est possible et 1 si on a perdu (GAME

OVER).

Tetris

Projet C




|19/12/08

16

V Apports du projet

Ce projet nous a apporté une méthode de réalisationsommet. De plus, il nous nous a permis de mieux malangage C :

� Meilleure utilisation des entrées/sorties� Apprentissage de l’utilisation de nouvelles bibliothèques et donc de nouvelles

fonctions : ncurses.h� Meilleure maîtrise des structures avec les allocations dynamiques nécessaires

Nous remercions notre tuteur ainsinos questions, et les gens qui programme ne serait pas ce qu


Ce projet nous a apporté une méthode de réalisation : de la base du triangle à son

s nous a permis de mieux maîtriser certaines fonctionnalités du

utilisation des entrées/sorties utilisation de nouvelles bibliothèques et donc de nouvelles .h et menu.h

îtrise des structures avec les allocations dynamiques nécessaires

Nous remercions notre tuteur ainsi que les différents professeurs qui ont répondu à nos questions, et les gens qui ont rédigé le manuel du langage C sans lequel notre

erait pas ce qu’il est aujourd’hui, c'est-à-dire fonctionnel.

Julien BARTAK |

de la base du triangle à son

îtriser certaines fonctionnalités du

utilisation de nouvelles bibliothèques et donc de nouvelles

îtrise des structures avec les allocations dynamiques nécessaires

que les différents professeurs qui ont répondu à sans lequel notre

fonctionnel.

rapport projet C TETRIS bartak/behar · -Etienne Projet C | Ecole des Mines de Saint-Etienne |...

Documents

Transcript of rapport projet C TETRIS bartak/behar · -Etienne Projet C | Ecole des Mines de Saint-Etienne |...