Fautes ?

[Étienne9]

Bonjour,

Je voudrais savoir s'il y a des fautes, merci beaucoup :

XXXXXXXXXXXXXXX L1 Informatique

XXXXXXXXXXXXXXX

TÉTRIS

Dans le cadre de notre cursus Informatique à la Faculté des Sciences, nous avons procédé à la création du jeu Tétris programmé en Java.

Nous allons, par conséquent, dans ce rapport, expliquer de façon générale comment nous avons créé ce jeu de réflexion. De plus, nous y incorporerons et expliquerons les difficultés rencontrées lors de la programmation.

Pour faciliter le travail, plusieurs fonctions ont été créées ce qui permet de diviser le problème en plusieurs parties, facilitant alors la tâche.

Pour commencer, nous avons créé une fonction randomPiece qui renvoie un entier sur l’intervalle [0,6] correspond à une pièce. Par la suite, les fonctions affichePieceAfficheur et effacePieceAfficheur étaient nécessaires pour afficher les pièces suivantes en bas dans l’afficheur sachant que par soucis de simplifications, la fonction effacePieceAfficheur efface complètement tout.

Notre première intuition a été de travailler sur une matrice à deux dimensions qui contient des entiers sur l’intervalle [-3,6] et d’évaluer toutes les possibilités (avec plusieurs fonctions) de pièces, d’orientations, de positions etc. Cette méthode de travail a été conservée car lorsque M Frédéric Fürst nous a expliqué que l’idéal aurait été de travailler avec des enregistrements, nous avions déjà bien travaillé et il aurait été vraiment dommage de supprimer nos (environ) 300 ou 400 lignes déjà faites. Les valeurs de 0 à 6 correspondent aux 7 pièces, -1 correspond à une case libre, et -2, -3 seront expliquées un peu plus bas. La fonction drawArrayGrille permet alors de convertir un tableau à deux dimensions en un affichage sur la Grille.

Notre prochain objectif a été de créer une fonction possibleTournerPiece qui renvoie un booléen indiquant s’il est possible de faire tourner une pièce ou pas, sachant qu’au départ il y avait un problème et on ne connaissait pas vraiment son origine, ce n’est qu’après qu’on s’est aperçu qu’on devait d’abord traiter les cas où la pièce serait sur les bords et renvoyer faux si c’est le cas puis traiter s’il y a des pièces sur les côtés, en effet, car même dans les conditions Java essayait d’accéder à des cases inaccessibles.

Il est bien évident que la fonction suivante a été tournerPiece, celle-ci regarde la pièce et l’orientation, et agit en conséquence sur le tableau à double dimension, puis renvoie le tableau d’entiers. Elle ne fait que supprimer une ou plusieurs cases (attribuer la valeur -1 à toutes les cases à supprimer) et ajouter des cases (attribuer une valeur entre 0 et 6 suivant la pièce sachant que les valeurs correspondent en fait aux couleurs).

La fonction principale met par la suite à jour l’orientation de la pièce, si l’orientation est inférieure à 4 elle rajoute +1, sinon elle remet l’orientation à 1. (Il existe 4 orientations pour chaque pièce, 0° 90°, 180°, 270°).

Après pouvoir tourner les pièces, il fallait faire une autre fonction qui renvoie un booléen pour savoir s’il est possible de descendre une pièce à savoir possibleDescendrePiece. Le principe est presque le même que possibleTournerPiece dans la mesure où on teste d’abord si on n’est pas arrivé au bout avant de regarder s’il n’y a pas de pièce en dessous dans le tableau à deux dimensions.

Puis, après celle-ci il fallait tout simplement faire une fonction descendrePiece qui s’occupe de faire tout simplement descendre une pièce dans le tableau toujours et encore à deux dimensions. Par la suite, bien sûr, la fonction renvoie le tableau après avoir fait son travail qui consiste à faire descendre la pièce. La fonction principale met par la suite à jour sa variable yPieceCourante.

Après avoir fait tout cela, nous avions eu besoin d’une fonction lanceur qui prend dans ses paramètres juste le tableau, la pièce donc un entier, et un entier x (pas besoin de y : il vaut 0). Cette fonction est chargée d’afficher la pièce en haut aux coordonnées [x][0], x est donné par la fonction principale et est égal à 4. Cette fonction vérifie avant de mettre la pièce s’il y a bien la place pour la mettre, si malheureusement il n’y en a pas alors celle-ci insère la valeur -2 aux coordonnées [x][0], cette valeur à cet endroit est testée dans la fonction principale, si la fonction principale voit la valeur -2 alors le jeu s’arrête, c’est un « Game Over ». Sinon le jeu continue normalement…

La prochaine fonction a été dg, autrement dit, une fonction qui permet de déplacer la pièce à gauche ou à droite. Elle prend en paramètre le tableau, le sens (-1 pour gauche et +1 pour droite), la pièce, l’orientation, x et y. Pour diminuer le nombre de fonction, nous avons décidé de faire la vérification de la place en même temps que le déplacement éventuel, par conséquent, cela a engendré pas mal de difficultés mais nous avons réussi tout de même. La fonction doit tester si la pièce n’est pas sur un bord en fonction du sens, si c’est le cas elle met la valeur -3 dans une case, mais laquelle ? C’était là une difficulté mais qui a été surmontée, en effet, nous avons utilisé les coordonnées [5][0] car cette case est nécessairement libre car si elle ne l’était pas il y aurait déjà eu un Game Over à cause du lanceur. La fonction principale regarde bien entendu cette case pour agir en conséquence, si elle voit -3 elle remet immédiatement la valeur à -1 et cela s’arrête là, si elle ne voit pas la valeur -3 c’est que la pièce a bougé donc il faut qu’elle (fonction principale) met à jour sa variable xPieceCourante.

Une fonction pour supprimer les lignes était nécessaire, nous avons séparé ce problème en deux.

La première fonction pour supprimer les lignes pleines s’appelle testligne , elle prend en paramètre le tableau à deux dimensions d’entiers et une ligne. Elle est seulement chargée de renvoyer 0 si la ligne est vide, 2 si elle est pleine et si ni l’un ni l’autre elle renvoie 1.

Grâce à celle ci-dessus, nous avons pu créer une autre fonction, qui elle, s’occupe de supprimer les lignes pleines. Cette fonction s’arrête soit car la fonction s’est occupée de toutes les lignes ou soit car il y a une ligne juste au dessus vide donc cela ne sert à rien de continuer. (Voir ci-dessous les figures pour mieux comprendre)

La fonction efface les lignes du bas vers le haut.

Pour ce qui est de la figure de gauche, elle s’arrêtera donc à la ligne blanche car comme la ligne au dessus est vide, toutes les autres au dessus sont forcément vides. Pour la figure de droite, les pièces sont empilées mais tant qu’il y a au moins une case de couleur sur une ligne on est obligé de regarder au dessus car on pourrait très bien un peu plus haut avoir une ligne pleine malgré tout, par conséquent, on a testé toutes lignes et donc on s’arrête.

Par la suite nous avons fait la fonction principale qui contient plusieurs variables dont deux pour la position de la pièce, un tableau à double dimension, etc. Celle-ci fonctionne, de façon générale, avec trois boucles « tant que » : une pour les niveaux qui contient un booléen au cas où on perd, une pour compter le nombre de pièces qui descendent (30 pièces par niveau) et qui contient aussi un booléen, et une dernière boucle pour « tant que possibleDescendrePiece ». Par la suite, il a juste suffit d’ajouter les changements de valeurs des variables, les reconnaissances de clavier, en bref toutes les fonctions précédentes étaient juste à lier entre-elles et le tour est joué.

Nous avons dû corriger beaucoup d’erreurs, cela a pris quand même quelque temps et le plus dur était de trouver les erreurs car elles pouvaient être dans descendrePiece, dans pivoterPiece...

Ayant eu du temps libre, nous avons ajouté le score qui est enregistré dans une variable globale. 20 points par niveau, 10 par ligne et nous avons même eu le temps de rajouter un bonus de 40 points si toute une ligne est de la même couleur.

Et pour finir, nous avons eu encore un peu de temps libre pour stocker les scores dans un fichier « classement.txt ». Pour cela, nous avons donc créé deux autres fonctions et nous avons rajouté quelques lignes dans la fonction principale pour faire fonctionner le tout.

Tout d’abord il a fallu avant tout réfléchir sur la structure du fichier .txt et c’est d’ailleurs ce qui a été le plus dur. La voici :

Nombre de joueurs

***

Prénom du joueur 1

Nom du joueur 1

Score du joueur 1

***

Prénom du joueur 2

Nom du joueur 2

Score du joueur 2

***

[….]

***

Le nombre de joueur est stocké dans le fichier .txt car nous en avons eu besoin après par la suite pour connaître la dimension du tableau de joueurs à créer lors de la lecture. En fait, nous avons créé un enregistrement Joueur (chaîne nom, chaîne prénom, entier score) et dans la fonction principale nous avons travaillé sur un tableau de Joueurs. D’ailleurs, dans celle-ci il a fallu chercher si le joueur est déjà enregistré, si oui on change le score s’il a fait un meilleur score et on réécrit tout dans le fichier .txt, sinon on doit créer un autre tableau de joueurs mais avec une case en plus et il faut ajouter le joueur puis tout écrire dans le fichier .txt.

La première fonction que nous avons créée pour cela a donc été lecture, celle-ci permet juste de transformer le fichier en un tableau de joueurs qui sert par la suite à la fonction principale.

La deuxième fonction, quant à elle, s’appelle ecriture et fait l’opération inverse en écrivant le tableau de joueurs donné par la fonction principale dans le fichier classement.txt (sous la structure du fichier). Elle a aussi une autre fonctionnalité, celle de trouver en même temps qu’elle écrit l’indice de la case du tableau qui contient le plus gros score pour ensuite afficher le nom, prénom et le score du meilleur joueur (comme il s’agit d’un tableau de joueurs et qu’il s’agit d’enregistrements, juste avec l’indice du tableau on peut retrouver le prénom, le nom et le score).