refactor: wrong println

app/src/main/java/org/Controllers/IO.java

@@ -7,14 +7,28 @@ import org.Models.Direction;
 import org.Models.Jeu;
 import org.Models.Orientation;
 
+/**
+ * Gère les entrées clavier pour contrôler le jeu.
+ */
+
 public class IO implements KeyListener {
 
     private Jeu jeu;
 
+    /**
+     * Crée un gestionnaire d'entrées clavier pour le jeu donné.
+     *
+     * @param jeu le jeu à contrôler
+     */
     public IO(Jeu jeu) {
         this.jeu = jeu;
     }
 
+    /**
+     * Gère les actions à effectuer lors de l'appui sur une touche.
+     *
+     * @param e l'événement de touche pressée
+     */
     @Override
     public void keyPressed(KeyEvent e) {
         if (jeu.getGrille().estEnPause()) {
@@ -51,10 +65,20 @@ public class IO implements KeyListener {
         }
     }
 
+    /**
+     * Méthode appelée lors de la saisie d'un caractère (non utilisée).
+     *
+     * @param e l'événement de touche tapée
+     */
     @Override
     public void keyTyped(KeyEvent e) {
     }
 
+    /**
+     * Méthode appelée lors du relâchement d'une touche (non utilisée).
+     *
+     * @param e l'événement de touche relâchée
+     */
     @Override
     public void keyReleased(KeyEvent e) {
     }

app/src/main/java/org/Controllers/TetrisBandeauControleur.java

@@ -7,6 +7,10 @@ import org.Views.VueBandeauControle;
 
 import javax.swing.*;
 
+/**
+ * Contrôleur pour le bandeau de contrôle du jeu Tetris.
+ * Gère les actions des boutons (pause, quitter, aide, relancer) et l'état de la partie.
+ */
 public class TetrisBandeauControleur {
     private boolean partieEnPause = false;
     private boolean partieTerminee = false;
@@ -15,6 +19,14 @@ public class TetrisBandeauControleur {
     private Grille grille;
     private Jeu jeu;
 
+    /**
+     * Crée un contrôleur pour le bandeau de contrôle.
+     *
+     * @param vueControle la vue du bandeau de contrôle
+     * @param musique le gestionnaire de musique
+     * @param grille la grille de jeu
+     * @param jeu l'instance du jeu
+     */
     public TetrisBandeauControleur(VueBandeauControle vueControle, Musique musique, Grille grille, Jeu jeu) {
         this.vueControle = vueControle;
         this.musique = musique;
@@ -39,6 +51,10 @@ public class TetrisBandeauControleur {
         });
     }
 
+    /**
+     * Bascule l'état de la partie entre pause et reprise.
+     * Met à jour la grille, la musique et le texte du bouton pause.
+     */
     public void switchPlayPause() {
         if (partieTerminee) {
             return;
@@ -51,13 +67,10 @@ public class TetrisBandeauControleur {
         System.out.println(partieEnPause ? "Partie en pause" : "Partie en cours");
     }
 
-    public void setPartieTerminee() {
+    /**
-        partieTerminee = true;
+     * Affiche une page d'aide avec les commandes du jeu.
-        musique.arreterMusique();
+     * Met la partie en pause pendant l'affichage de l'aide.
-        vueControle.getPauseButton().setEnabled(false);
+     */
-        System.out.println("Partie terminée");
-    }
-
     public void afficherAide() {
         String messageAide = "Utilisez les flèches du clavier pour déplacer la pièce courante :\n" +
                 "Flèche gauche : Déplacer à gauche\n" +

app/src/main/java/org/Models/Direction.java

@@ -1,5 +1,7 @@
 package org.Models;
-
+/**
+ * Enumère les directions possibles pour le déplacement d'une pièce dans le jeu Tetris.
+ */
 public enum Direction {
     BAS,
     GAUCHE,

app/src/main/java/org/Models/Grille.java

@@ -9,6 +9,10 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Observable;
 
+/**
+ * Représente la grille de jeu du Tetris, gère l'état des cases, la pièce courante,
+ * le score, la suppression des lignes et les déplacements/rotations des pièces.
+ */
 @SuppressWarnings("deprecation")
 public class Grille extends Observable {
     private boolean[][] grille;
@@ -23,6 +27,12 @@ public class Grille extends Observable {
     private int score = 0;
     private int nbLignesSupprimees = 0;
 
+    /**
+     * Crée une nouvelle grille de jeu avec le nombre de lignes et de colonnes spécifié.
+     *
+     * @param nbLignes nombre de lignes de la grille
+     * @param nbColonnes nombre de colonnes de la grille
+     */
     public Grille(int nbLignes, int nbColonnes) {
         this.nbLignes = nbLignes;
         this.nbColonnes = nbColonnes;
@@ -30,6 +40,9 @@ public class Grille extends Observable {
         initGrille();
     }
 
+    /**
+     * Initialise toutes les cases de la grille à vide (false).
+     */
     public void initGrille() {
         for (int i = 0; i < nbLignes; i++) {
             for (int j = 0; j < nbColonnes; j++) {
@@ -38,6 +51,13 @@ public class Grille extends Observable {
         }
     }
 
+    /**
+     * Modifie l'état d'une case de la grille.
+     *
+     * @param i indice de ligne
+     * @param j indice de colonne
+     * @param value true si la case est occupée, false sinon
+     */
     public void setCase(int i, int j, boolean value) {
         if (i >= 0 && i < nbLignes && j >= 0 && j < nbColonnes) {
             this.grille[i][j] = value;
@@ -46,6 +66,13 @@ public class Grille extends Observable {
         }
     }
 
+    /**
+     * Retourne l'état d'une case de la grille.
+     *
+     * @param i indice de ligne
+     * @param j indice de colonne
+     * @return true si la case est occupée, false sinon
+     */
     public boolean getCase(int i, int j) {
         if (i >= 0 && i < nbLignes && j >= 0 && j < nbColonnes) {
             return this.grille[i][j];
@@ -53,10 +80,20 @@ public class Grille extends Observable {
         return false;
     }
 
+    /**
+     * Retourne la pièce courante.
+     *
+     * @return la pièce courante
+     */
     public PieceCourante getPieceCourante() {
         return pieceCourante;
     }
 
+    /**
+     * Définit la pièce courante et la place en haut de la grille.
+     *
+     * @param pieceCourante la nouvelle pièce courante
+     */
     public void setPieceCourante(PieceCourante pieceCourante) {
         this.pieceCourante = pieceCourante;
         this.pieceCouranteX = 3;
@@ -65,14 +102,29 @@ public class Grille extends Observable {
         notifyObservers();
     }
 
+    /**
+     * Retourne la position X de la pièce courante.
+     *
+     * @return position X
+     */
     public int getPieceCouranteX() {
         return pieceCouranteX;
     }
 
+    /**
+     * Retourne la position X de la pièce courante.
+     *
+     * @return position X
+     */
     public int getPieceCouranteY() {
         return pieceCouranteY;
     }
 
+    /**
+     * Déplace la pièce courante dans la direction spécifiée si possible.
+     *
+     * @param direction direction du déplacement
+     */
     public void deplacerPiece(Direction direction) {
 
         switch (direction) {
@@ -100,6 +152,9 @@ public class Grille extends Observable {
         }
     }
 
+    /**
+     * Déplace la pièce courante d'une case vers le bas.
+     */
     private void deplacerPieceBas() {
         pieceCouranteY++;
 
@@ -107,6 +162,9 @@ public class Grille extends Observable {
         notifyObservers();
     }
 
+    /**
+     * Déplace la pièce courante d'une case vers la gauche.
+     */
     private void deplacerPieceGauche() {
         pieceCouranteX--;
 
@@ -114,6 +172,9 @@ public class Grille extends Observable {
         notifyObservers();
     }
 
+    /**
+     * Déplace la pièce courante d'une case vers la droite.
+     */
     private void deplacerPieceDroite() {
         pieceCouranteX++;
 
@@ -121,20 +182,38 @@ public class Grille extends Observable {
         notifyObservers();
     }
 
+    /**
+     * Fait descendre la pièce courante jusqu'à ce qu'elle ne puisse plus descendre.
+     */
     private void deplacerPieceToutEnBas() {
         while (peuxBouger(Direction.BAS, this.motifPieceCouranteColoriee())) {
             deplacerPieceBas();
         }
     }
 
+    /**
+     * Retourne le nombre de lignes de la grille.
+     *
+     * @return nombre de lignes
+     */
     public int getNbLignes() {
         return nbLignes;
     }
 
+    /**
+     * Retourne le nombre de colonnes de la grille.
+     *
+     * @return nombre de colonnes
+     */
     public int getNbColonnes() {
         return nbColonnes;
     }
 
+    /**
+     * Retourne la liste des points occupés par la pièce courante dans la grille.
+     *
+     * @return liste des points colorés
+     */
     public List<Point> motifPieceCouranteColoriee() {
         List<Point> casesColores = new ArrayList<>();
 
@@ -150,6 +229,13 @@ public class Grille extends Observable {
         return casesColores;
     }
 
+    /**
+     * Vérifie si la pièce peut bouger dans la direction donnée.
+     *
+     * @param direction direction du déplacement
+     * @param motif motif de la pièce
+     * @return true si le déplacement est possible, false sinon
+     */
     public boolean peuxBouger(Direction direction, List<Point> motif) {
         int deltaX = 0;
         int deltaY = 0;
@@ -174,10 +260,19 @@ public class Grille extends Observable {
         return positionValide(nouvellePosition);
     }
 
+    /**
+     * Retourne la matrice représentant la grille.
+     *
+     * @return matrice de booleans
+     */
     public boolean[][] getGrille() {
         return grille;
     }
 
+
+    /**
+     * Fixe la pièce courante sur la grille et vérifie la suppression de lignes.
+     */
     public void fixerPiece() {
         for (Point caseColoree : motifPieceCouranteColoriee()) {
             setCase(caseColoree.y, caseColoree.x, true);
@@ -187,6 +282,11 @@ public class Grille extends Observable {
         verifierEtSupprimerLignesSiBesoin();
     }
 
+    /**
+     * Vérifie si la pièce courante doit être fixée (ne peut plus descendre).
+     *
+     * @return true si la pièce doit être fixée, false sinon
+     */
     public boolean doitFixerPiece() {
         if (!peuxBouger(Direction.BAS, this.motifPieceCouranteColoriee())) {
             return true;
@@ -195,14 +295,27 @@ public class Grille extends Observable {
         return false;
     }
 
+    /**
+     * Met la grille en pause ou la reprend.
+     *
+     * @param enPause true pour mettre en pause, false pour reprendre
+     */
     public void setEnPause(boolean enPause) {
         this.enPause = enPause;
     }
 
+    /**
+     * Indique si la grille est en pause.
+     *
+     * @return true si en pause, false sinon
+     */
     public boolean estEnPause() {
         return enPause;
     }
 
+    /**
+     * Vérifie et supprime les lignes complètes si besoin, met à jour le score.
+     */
     public void verifierEtSupprimerLignesSiBesoin() {
         int tmpNbLignesSupprimees = 0;
         System.out.println("Debut uppression d'une ligne......");
@@ -242,22 +355,47 @@ public class Grille extends Observable {
         }
     }
 
+    /**
+     * Retourne le score actuel.
+     *
+     * @return score
+     */
     public int getScore() {
         return score;
     }
 
+    /**
+     * Définit le score.
+     *
+     * @param score nouveau score
+     */
     public void setScore(int score) {
         this.score = score;
     }
 
+    /**
+     * Retourne le nombre total de lignes supprimées.
+     *
+     * @return nombre de lignes supprimées
+     */
     public int getNbLignesSupprimees() {
         return nbLignesSupprimees;
     }
 
+    /**
+     * Définit le nombre de lignes supprimées.
+     *
+     * @param nbLignesSupprimees nouveau nombre de lignes supprimées
+     */
     public void setNbLignesSupprimees(int nbLignesSupprimees) {
         this.nbLignesSupprimees = nbLignesSupprimees;
     }
 
+    /**
+     * Supprime la ligne d'indice i et fait descendre les lignes au-dessus.
+     *
+     * @param i indice de la ligne à supprimer
+     */
     public void supprimerLigne(int i) {
         for (int ligne = i; ligne > 0; ligne--) {
             for (int j = 0; j < nbColonnes; j++) {
@@ -273,6 +411,12 @@ public class Grille extends Observable {
         notifyObservers();
     }
 
+    /**
+     * Retourne la liste des points d'une ligne donnée.
+     *
+     * @param i indice de la ligne
+     * @return liste des points de la ligne
+     */
     public List<Point> getLignePoints(int i) {
         List<Point> coordonnesCase = new ArrayList<>();
 
@@ -283,6 +427,11 @@ public class Grille extends Observable {
         return coordonnesCase;
     }
 
+    /**
+     * Fait descendre une ligne d'une position.
+     *
+     * @param i indice de la ligne à descendre
+     */
     public void descendreLigne(int i) {
         for (int j = 0; j < nbColonnes; j++) {
             List<Point> coordonnesCase = new ArrayList<>();
@@ -296,6 +445,11 @@ public class Grille extends Observable {
         }
     }
 
+    /**
+     * Tente de tourner la pièce courante dans l'orientation donnée.
+     *
+     * @param orientation sens de rotation
+     */
     public void tournerPiece(Orientation orientation) {
         if (peuxTournerPiece(orientation)) {
             boolean[][] motif = pieceCourante.getMotif();
@@ -314,11 +468,23 @@ public class Grille extends Observable {
         }
     }
 
+    /**
+     * Vérifie si la pièce courante peut tourner dans l'orientation donnée.
+     *
+     * @param orientation sens de rotation
+     * @return true si la rotation est possible, false sinon
+     */
     public boolean peuxTournerPiece(Orientation orientation) {
         List<Point> positionApresRotation = calculerPositionApresRotation(orientation);
         return positionValide(positionApresRotation);
     }
 
+    /**
+     * Calcule la position de la pièce après rotation.
+     *
+     * @param orientation sens de rotation
+     * @return liste des points après rotation
+     */
     private List<Point> calculerPositionApresRotation(Orientation orientation) {
         List<Point> nouvellePosition = new ArrayList<>();
         boolean[][] motifActuel = pieceCourante.getMotif();
@@ -348,6 +514,12 @@ public class Grille extends Observable {
         return nouvellePosition;
     }
 
+    /**
+     * Vérifie si la position donnée est valide (dans la grille et non occupée).
+     *
+     * @param points liste des points à vérifier
+     * @return true si la position est valide, false sinon
+     */
     public boolean positionValide(List<Point> points) {
         for (Point point : points) {
             if (point.x < 0 || point.x >= nbColonnes || point.y < 0 || point.y >= nbLignes) {
@@ -361,6 +533,15 @@ public class Grille extends Observable {
         return true;
     }
 
+
+    /**
+     * Calcule la nouvelle position d'une liste de points après déplacement.
+     *
+     * @param points liste de points d'origine
+     * @param deltaX déplacement en X
+     * @param deltaY déplacement en Y
+     * @return nouvelle liste de points déplacés
+     */
     private List<Point> calculerNouvellePosition(List<Point> points, int deltaX, int deltaY) {
         List<Point> nouvellePosPoints = new ArrayList<>();
 
@@ -371,6 +552,9 @@ public class Grille extends Observable {
         return nouvellePosPoints;
     }
 
+    /**
+     * Réinitialise la grille, le score, le nombre de lignes supprimées et la pièce courante.
+     */
     public void reinitialiserGrille() {
         initGrille();
         score = 0;

app/src/main/java/org/Models/Jeu.java

@@ -16,6 +16,10 @@ import org.Models.Pieces.PieceS;
 import org.Models.Pieces.PieceT;
 import org.Models.Pieces.PieceZ;
 
+/**
+ * Gère la logique principale du jeu Tetris, y compris la gestion de la grille,
+ * des pièces, de la musique, de l'ordonnancement et de l'état de la partie.
+ */
 @SuppressWarnings("deprecation")
 public class Jeu extends Observable implements Runnable {
     private Grille grille;
@@ -27,6 +31,12 @@ public class Jeu extends Observable implements Runnable {
     private int pieceSuivanteY;
     public boolean jeuEnCours = true;
 
+    /**
+     * Crée une nouvelle instance du jeu avec la grille et la musique spécifiées.
+     *
+     * @param grille la grille de jeu
+     * @param musique le gestionnaire de musique
+     */
     public Jeu(Grille grille, Musique musique) {
 
         this.grille = grille;
@@ -41,6 +51,11 @@ public class Jeu extends Observable implements Runnable {
         this.ordonnanceur.start();
     }
 
+    /**
+     * Génère et retourne une nouvelle pièce aléatoire.
+     *
+     * @return une nouvelle pièce courante
+     */
     private PieceCourante getNouvellePiece() {
         Random random = new Random();
         int randomiiii = random.nextInt(7);
@@ -82,6 +97,11 @@ public class Jeu extends Observable implements Runnable {
         return nouvellePiece;
     }
 
+    /**
+     * Retourne la pièce suivante.
+     *
+     * @return la pièce suivante
+     */
     public PieceCourante getPieceSuivante() {
         return pieceSuivante;
     }
@@ -94,10 +114,20 @@ public class Jeu extends Observable implements Runnable {
         return pieceSuivanteY;
     }
 
+    /**
+     * Retourne la grille de jeu.
+     *
+     * @return la grille
+     */
     public Grille getGrille() {
         return grille;
     }
 
+    /**
+     * Vérifie si la partie est terminée (collision en haut de la grille).
+     *
+     * @return true si la partie est terminée, false sinon
+     */
     public boolean estFinPartie() {
         for (Point caseColoree : this.grille.motifPieceCouranteColoriee()) {
             if (this.grille.getCase(caseColoree.y, caseColoree.x)) {
@@ -109,6 +139,9 @@ public class Jeu extends Observable implements Runnable {
         return false;
     }
 
+    /**
+     * Termine la partie, arrête l'ordonnanceur et la musique.
+     */
     public void finPartie() {
         this.jeuEnCours = false;
         ordonnanceur.interrupt();
@@ -159,6 +192,9 @@ public class Jeu extends Observable implements Runnable {
         }
     }
 
+    /**
+     * Méthode exécutée périodiquement par l'ordonnanceur pour faire avancer le jeu.
+     */
     @Override
     public void run() {
         if (!jeuEnCours || grille.estEnPause()) {

app/src/main/java/org/Models/Musique.java

@@ -26,6 +26,9 @@ public class Musique {
         initialiserClip();
     }
 
+    /**
+     * Initialise le clip audio à partir du fichier TetrisMusic.wav.
+     */
     private void initialiserClip() {
         try {
             InputStream audioSrc = getClass().getResourceAsStream("/TetrisMusic.wav");
@@ -56,6 +59,9 @@ public class Musique {
         }
     }
 
+    /**
+     * Joue la musique à partir du début.
+     */
     public void start() {
         if (estInitialise && !estArrete) {
             clip.setFramePosition(0);
@@ -63,9 +69,12 @@ public class Musique {
             estEnPause = false;
             System.out.println("Lecture de la musique...");
         }
-        System.out.println("Fin du thread de musique.");
+        System.out.println("Fin de musique.");
     }
 
+    /**
+     * met en pause la musique. rejoue la musique à partir de la position actuelle.
+     */
     public void basculePlayPause() {
         if (!estInitialise || estArrete)
             return;
@@ -83,6 +92,9 @@ public class Musique {
         }
     }
 
+    /**
+     * Arrête la musique et libère les ressources.
+     */
     public void arreterMusique() {
         if (estInitialise) {
             estArrete = true;

app/src/main/java/org/Models/Ordonnanceur.java

@@ -1,19 +1,33 @@
 package org.Models;
-
+/**
+ * Ordonnanceur exécute périodiquement une tâche {@link Runnable} dans un thread séparé.
+ */
 public class Ordonnanceur extends Thread {
 
     Runnable runnable;
     long pause;
 
+    /**
+     * Crée un nouvel ordonnanceur.
+     *
+     * @param runnable la tâche à exécuter périodiquement
+     * @param pause la durée de pause entre chaque exécution (en millisecondes)
+     */
     public Ordonnanceur(Runnable runnable, long pause) {
         this.runnable = runnable;
         this.pause = pause;
     }
 
+    /**
+     * Arrête l'ordonnanceur en interrompant le thread.
+     */
     public void stopOrdonnanceur() {
         interrupt();
     }
 
+    /**
+     * Exécute la tâche périodiquement tant que le thread n'est pas interrompu.
+     */
     @Override
     public void run() {
         while (!Thread.currentThread().isInterrupted()) {

app/src/main/java/org/Models/Orientation.java

@@ -1,5 +1,7 @@
 package org.Models;
-
+/**
+ * Enumère les orientations possibles pour la rotation d'une pièce dans le jeu Tetris.
+ */
 public enum Orientation {
     SENSHORAIRE,
     SENSANTIHORAIRE,

app/src/main/java/org/Models/PieceCourante.java

@@ -1,5 +1,9 @@
 package org.Models;
 
+/**
+ * Interface représentant une pièce courante du jeu Tetris.
+ * Définit les méthodes pour obtenir et définir le motif de la pièce.
+ */
 public interface PieceCourante {
     abstract public boolean[][] getMotif();
 

app/src/main/java/org/Models/Pieces/PieceI.java

@@ -2,10 +2,17 @@ package org.Models.Pieces;
 
 import org.Models.PieceCourante;
 
+/**
+ * Représente la pièce I du Tetris.
+ * La pièce I est une ligne de 4 blocs disposés verticalement par défaut.
+ */
 public class PieceI implements PieceCourante {
 
     private boolean[][] motif = new boolean[4][4];
 
+    /**
+     * Crée une nouvelle pièce I avec son motif initial.
+     */
     public PieceI() {
         motif[0][1] = true;
         motif[1][1] = true;
@@ -13,11 +20,21 @@ public class PieceI implements PieceCourante {
         motif[3][1] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce I.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce I.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Models/Pieces/PieceJ.java

@@ -2,10 +2,17 @@ package org.Models.Pieces;
 
 import org.Models.PieceCourante;
 
+/**
+ * Représente la pièce J du Tetris.
+ * La pièce J est une ligne de 3 blocs disposés verticalement par défaut.
+ */
 public class PieceJ implements PieceCourante {
 
     private boolean[][] motif = new boolean[3][3];
 
+    /**
+     * Crée une nouvelle pièce J avec son motif initial.
+     */
     public PieceJ() {
         motif[0][1] = true;
         motif[1][1] = true;
@@ -13,11 +20,21 @@ public class PieceJ implements PieceCourante {
         motif[2][0] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce J.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce J.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Models/Pieces/PieceL.java

@@ -2,10 +2,17 @@ package org.Models.Pieces;
 
 import org.Models.PieceCourante;
 
+/**
+ * Représente la pièce L du Tetris.
+ * La pièce L est une ligne de 3 blocs disposés verticalement par défaut.
+ */
 public class PieceL implements PieceCourante {
 
     private boolean[][] motif = new boolean[3][3];
 
+    /**
+     * Crée une nouvelle pièce L avec son motif initial.
+     */
     public PieceL() {
         motif[0][1] = true;
         motif[1][1] = true;
@@ -13,11 +20,21 @@ public class PieceL implements PieceCourante {
         motif[2][2] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce L.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce L.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Models/Pieces/PieceO.java

@@ -2,10 +2,17 @@ package org.Models.Pieces;
 
 import org.Models.PieceCourante;
 
+/**
+ * Représente la pièce O du Tetris.
+ * La pièce O est une ligne de 4 blocs disposés verticalement par défaut.
+ */
 public class PieceO implements PieceCourante {
 
     private boolean[][] motif = new boolean[4][4];
 
+    /**
+     * Crée une nouvelle pièce O avec son motif initial.
+     */
     public PieceO() {
         motif[1][1] = true;
         motif[1][2] = true;
@@ -13,11 +20,21 @@ public class PieceO implements PieceCourante {
         motif[2][2] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce O.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce O.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Models/Pieces/PieceS.java

@@ -1,11 +1,17 @@
 package org.Models.Pieces;
 
 import org.Models.PieceCourante;
-
+/**
+ * Représente la pièce S du Tetris.
+ * La pièce S est une ligne de 3 blocs disposés verticalement par défaut.
+ */
 public class PieceS implements PieceCourante {
 
     private boolean[][] motif = new boolean[3][3];
 
+    /**
+     * Crée une nouvelle pièce S avec son motif initial.
+     */
     public PieceS() {
         motif[0][1] = true;
         motif[1][1] = true;
@@ -13,11 +19,21 @@ public class PieceS implements PieceCourante {
         motif[2][2] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce S.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce S.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Models/Pieces/PieceT.java

@@ -2,10 +2,17 @@ package org.Models.Pieces;
 
 import org.Models.PieceCourante;
 
+/**
+ * Représente la pièce T du Tetris.
+ * La pièce S est une ligne de 3 blocs disposés verticalement par défaut.
+ */
 public class PieceT implements PieceCourante {
 
     private boolean[][] motif = new boolean[3][3];
 
+    /**
+     * Crée une nouvelle pièce T avec son motif initial.
+     */
     public PieceT() {
         motif[0][1] = true;
         motif[1][1] = true;
@@ -13,11 +20,21 @@ public class PieceT implements PieceCourante {
         motif[1][2] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce T.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce T.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Models/Pieces/PieceZ.java

@@ -1,11 +1,16 @@
 package org.Models.Pieces;
 
 import org.Models.PieceCourante;
-
+/**
+ * Représente la pièce Z du Tetris.
+ * La pièce S est une ligne de 3 blocs disposés verticalement par défaut.
+ */
 public class PieceZ implements PieceCourante {
 
     private boolean[][] motif = new boolean[3][3];
-
+    /**
+     * Crée une nouvelle pièce Z avec son motif initial.
+     */
     public PieceZ() {
         motif[0][2] = true;
         motif[1][2] = true;
@@ -13,11 +18,21 @@ public class PieceZ implements PieceCourante {
         motif[2][1] = true;
     }
 
+    /**
+     * Retourne le motif actuel de la pièce Z.
+     *
+     * @return le motif sous forme de matrice de booleans
+     */
     @Override
     public boolean[][] getMotif() {
         return motif;
     }
 
+    /**
+     * Définit le motif de la pièce Z.
+     *
+     * @param motif la nouvelle matrice de booleans représentant le motif
+     */
     @Override
     public void setMotif(boolean[][] motif) {
         this.motif = motif;

app/src/main/java/org/Views/GridLayoutCarre.java

@@ -4,11 +4,20 @@ import java.awt.Component;
 import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.LayoutManager;
-
+/**
+ * LayoutManager personnalisé pour disposer les composants dans une grille carrée,
+ * centrée dans le conteneur parent, avec des cases de taille égale.
+ */
 public class GridLayoutCarre implements LayoutManager {
     private int lignes;
     private int colonnes;
 
+    /**
+     * Crée un nouveau GridLayoutCarre avec le nombre de lignes et de colonnes spécifié.
+     *
+     * @param lignes   nombre de lignes
+     * @param colonnes nombre de colonnes
+     */
     public GridLayoutCarre(int lignes, int colonnes) {
         this.lignes = lignes;
         this.colonnes = colonnes;
@@ -33,6 +42,12 @@ public class GridLayoutCarre implements LayoutManager {
         return parent.getMinimumSize();
     }
 
+    /**
+     * Dispose les composants enfants dans une grille carrée centrée,
+     * chaque case ayant la même taille.
+     *
+     * @param parent le conteneur parent
+     */
     @Override
     public void layoutContainer(Container parent) {
         int largeur = parent.getWidth();

app/src/main/java/org/Views/VueBandeauControle.java

@@ -31,6 +31,10 @@ public class VueBandeauControle extends JPanel implements Observer {
     private Jeu jeu;
     private JButton relancerButton;
 
+    /**
+     * Crée une nouvelle instance de VueBandeauControle.
+     * @param jeu
+     */
     public VueBandeauControle(Jeu jeu) {
         this.jeu = jeu;
         setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
@@ -106,22 +110,42 @@ public class VueBandeauControle extends JPanel implements Observer {
         jeu.addObserver(this);
     }
 
+    /**
+     * Met à jour le score affiché dans le bandeau de contrôle.
+     * @param score
+     */
     public void setScore(int score) {
         scoreLabel.setText("Score: " + score);
     }
 
+    /**
+     * Récupère le bouton de pause.
+     * @return
+     */
     public JButton getPauseButton() {
         return pauseButton;
     }
 
+    /**
+     * Récupère le bouton de quitter.
+     * @return
+     */
     public JButton getQuitterButton() {
         return quitterButton;
     }
 
+    /**
+     * Récupère le panneau de la prochaine pièce.
+     * @return
+     */
     public JPanel getNextPiecePanel() {
         return nextPiecePanel;
     }
 
+    /**
+     * Récupère le bouton de relancer.
+     * @return
+     */
     private void initierNextPiecePanel() {
         nextPiecePanel.removeAll();
         nextPiecePanel.setLayout(new GridLayoutCarre(4, 4));
@@ -142,6 +166,10 @@ public class VueBandeauControle extends JPanel implements Observer {
         nextPiecePanel.repaint();
     }
 
+    /**
+     * Affiche la prochaine pièce dans le panneau de la prochaine pièce.
+     * @param piece
+     */
     public void afficherPieceSuivante(PieceCourante piece) {
         for (int i = 0; i < 4; i++) {
             for (int j = 0; j < 4; j++) {
@@ -162,14 +190,26 @@ public class VueBandeauControle extends JPanel implements Observer {
         nextPiecePanel.repaint();
     }
 
+    /**
+     * Récupère le bouton d'aide.
+     * @return
+     */
     public JButton getAideButton() {
         return aideButton;
     }
 
+    /**
+     * Récupère le bouton de relancer.
+     * @return
+     */
     public JButton getRelancerButton() {
         return relancerButton;
     }
 
+    /**
+     * Récupère le label du nombre de lignes.
+     * @return
+     */
     @Override
     public void update(Observable o, Object arg) {
         if (o instanceof Jeu) {

app/src/main/java/org/Views/VueGameOver.java

@@ -4,10 +4,21 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.ActionListener;
 
+/**
+ * Fenêtre affichée à la fin de la partie, indiquant le score et proposant
+ * de quitter ou de rejouer.
+ */
 public class VueGameOver extends JFrame {
     private JButton quitterButton;
     private JButton rejouerButton;
 
+    /**
+     * Crée une nouvelle fenêtre de fin de partie.
+     *
+     * @param score le score obtenu par le joueur
+     * @param quitterListener action à effectuer lors du clic sur "Quitter"
+     * @param rejouerListener action à effectuer lors du clic sur "Rejouer"
+     */
     public VueGameOver(int score, ActionListener quitterListener, Runnable rejouerListener) {
         setTitle("FIN DE PARTIE");
         setSize(400, 400);

app/src/main/java/org/Views/VueGrille.java

@@ -13,7 +13,10 @@ import org.Models.Grille;
 import org.Models.Jeu;
 import org.Models.Ordonnanceur;
 import org.Models.PieceCourante;
-
+/**
+ * Vue graphique de la grille de jeu Tetris.
+ * Affiche l'état de la grille, la pièce courante et gère la mise à jour de l'affichage.
+ */
 @SuppressWarnings("deprecation")
 public class VueGrille extends JPanel implements Observer, Runnable {
     private JPanel grillePanel;
@@ -28,6 +31,12 @@ public class VueGrille extends JPanel implements Observer, Runnable {
     private int nbColonnes;
     private JPanel[][] casesGrille;
 
+    /**
+     * Construit la vue de la grille à partir du modèle de grille et du jeu.
+     *
+     * @param grille le modèle de la grille
+     * @param jeu le modèle du jeu
+     */
     public VueGrille(Grille grille, Jeu jeu) {
         this.grille = grille;
         this.jeu = jeu;
@@ -45,6 +54,10 @@ public class VueGrille extends JPanel implements Observer, Runnable {
         ordonnanceur.start();
     }
 
+    /**
+     * Redimensionne les cases de la grille pour qu'elles restent carrées
+     * lors du redimensionnement du panneau.
+     */
     public void resizeCases() {
         int largeurPanel = grillePanel.getWidth();
         int hauteurPanel = grillePanel.getHeight();
@@ -69,6 +82,9 @@ public class VueGrille extends JPanel implements Observer, Runnable {
         grillePanel.repaint();
     }
 
+    /**
+     * Initialise l'affichage de la grille et crée les cases graphiques.
+     */
     private void initialiserVueGrille() {
         grillePanel = new JPanel(new GridLayoutCarre(nbLignes, nbColonnes)); // pour que les cases soient carrés
         add(grillePanel, BorderLayout.CENTER);
@@ -89,6 +105,9 @@ public class VueGrille extends JPanel implements Observer, Runnable {
         }
     }
 
+    /**
+     * Met à jour l'affichage de la grille et de la pièce courante.
+     */
     public synchronized void updateGrille() {
         for (int i = 0; i < nbLignes; i++) {
             for (int j = 0; j < nbColonnes; j++) {

app/src/main/java/org/Views/VueTetris.java

@@ -10,7 +10,10 @@ import javax.swing.JFrame;
 
 import org.Models.Grille;
 import org.Models.Jeu;
-
+/**
+ * Fenêtre principale du jeu Tetris.
+ * Affiche la grille de jeu et le bandeau de contrôle.
+ */
 public class VueTetris extends JFrame {
     private static Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
     public static double tailleJFrameX = screenSize.getHeight() / 2;
@@ -18,6 +21,12 @@ public class VueTetris extends JFrame {
     private VueGrille vueGrille;
     private VueBandeauControle vueControle;
 
+    /**
+     * Construit la fenêtre principale du jeu Tetris.
+     *
+     * @param grille le modèle de la grille
+     * @param jeu le modèle du jeu
+     */
     public VueTetris(Grille grille, Jeu jeu) {
         super("Tetris");
 
@@ -62,6 +71,11 @@ public class VueTetris extends JFrame {
         vueControle.afficherPieceSuivante(jeu.getPieceSuivante());
     }
 
+    /**
+     * Retourne la vue du bandeau de contrôle.
+     *
+     * @return la vue du bandeau de contrôle
+     */
     public VueBandeauControle getVueBandeauControle() {
         return this.vueControle;
     }