From f6c6c5044a159c0943abab359b7afab7d0147859 Mon Sep 17 00:00:00 2001 From: ROGER Date: Thu, 22 May 2025 11:01:42 +0200 Subject: [PATCH] Ajout de la javadoc --- app/src/main/java/org/Controllers/IO.java | 24 +++ .../Controllers/TetrisBandeauControleur.java | 27 ++- app/src/main/java/org/Models/Direction.java | 4 +- app/src/main/java/org/Models/Grille.java | 184 ++++++++++++++++++ app/src/main/java/org/Models/Jeu.java | 36 ++++ app/src/main/java/org/Models/Musique.java | 12 ++ .../main/java/org/Models/Ordonnanceur.java | 16 +- app/src/main/java/org/Models/Orientation.java | 4 +- .../main/java/org/Models/PieceCourante.java | 4 + .../main/java/org/Models/Pieces/PieceI.java | 17 ++ .../main/java/org/Models/Pieces/PieceJ.java | 17 ++ .../main/java/org/Models/Pieces/PieceL.java | 17 ++ .../main/java/org/Models/Pieces/PieceO.java | 17 ++ .../main/java/org/Models/Pieces/PieceS.java | 18 +- .../main/java/org/Models/Pieces/PieceT.java | 17 ++ .../main/java/org/Models/Pieces/PieceZ.java | 19 +- .../main/java/org/Views/GridLayoutCarre.java | 17 +- .../java/org/Views/VueBandeauControle.java | 40 ++++ app/src/main/java/org/Views/VueGameOver.java | 11 ++ app/src/main/java/org/Views/VueGrille.java | 21 +- app/src/main/java/org/Views/VueTetris.java | 16 +- 21 files changed, 522 insertions(+), 16 deletions(-) diff --git a/app/src/main/java/org/Controllers/IO.java b/app/src/main/java/org/Controllers/IO.java index d8e09bd..28dcdfc 100644 --- a/app/src/main/java/org/Controllers/IO.java +++ b/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) { } diff --git a/app/src/main/java/org/Controllers/TetrisBandeauControleur.java b/app/src/main/java/org/Controllers/TetrisBandeauControleur.java index 746cb3b..7b65883 100644 --- a/app/src/main/java/org/Controllers/TetrisBandeauControleur.java +++ b/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; - musique.arreterMusique(); - vueControle.getPauseButton().setEnabled(false); - System.out.println("Partie terminée"); - } - + /** + * Affiche une page d'aide avec les commandes du jeu. + * Met la partie en pause pendant l'affichage de l'aide. + */ 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" + diff --git a/app/src/main/java/org/Models/Direction.java b/app/src/main/java/org/Models/Direction.java index 21587c6..33027d1 100644 --- a/app/src/main/java/org/Models/Direction.java +++ b/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, diff --git a/app/src/main/java/org/Models/Grille.java b/app/src/main/java/org/Models/Grille.java index 3e5a168..4935eac 100644 --- a/app/src/main/java/org/Models/Grille.java +++ b/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 motifPieceCouranteColoriee() { List 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 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 getLignePoints(int i) { List 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 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 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 calculerPositionApresRotation(Orientation orientation) { List 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 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 calculerNouvellePosition(List points, int deltaX, int deltaY) { List 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; diff --git a/app/src/main/java/org/Models/Jeu.java b/app/src/main/java/org/Models/Jeu.java index 2260b14..1926cd8 100644 --- a/app/src/main/java/org/Models/Jeu.java +++ b/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()) { diff --git a/app/src/main/java/org/Models/Musique.java b/app/src/main/java/org/Models/Musique.java index d15544c..cfbf6de 100644 --- a/app/src/main/java/org/Models/Musique.java +++ b/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); @@ -66,6 +72,9 @@ public class Musique { System.out.println("Fin du thread 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; diff --git a/app/src/main/java/org/Models/Ordonnanceur.java b/app/src/main/java/org/Models/Ordonnanceur.java index 5508cec..7eeeb59 100644 --- a/app/src/main/java/org/Models/Ordonnanceur.java +++ b/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()) { diff --git a/app/src/main/java/org/Models/Orientation.java b/app/src/main/java/org/Models/Orientation.java index 9f4cfe3..a2c9316 100644 --- a/app/src/main/java/org/Models/Orientation.java +++ b/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, diff --git a/app/src/main/java/org/Models/PieceCourante.java b/app/src/main/java/org/Models/PieceCourante.java index 0fd132d..03e24fc 100644 --- a/app/src/main/java/org/Models/PieceCourante.java +++ b/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(); diff --git a/app/src/main/java/org/Models/Pieces/PieceI.java b/app/src/main/java/org/Models/Pieces/PieceI.java index a985797..5a54967 100644 --- a/app/src/main/java/org/Models/Pieces/PieceI.java +++ b/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; diff --git a/app/src/main/java/org/Models/Pieces/PieceJ.java b/app/src/main/java/org/Models/Pieces/PieceJ.java index 11aaea2..5a5c9c8 100644 --- a/app/src/main/java/org/Models/Pieces/PieceJ.java +++ b/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; diff --git a/app/src/main/java/org/Models/Pieces/PieceL.java b/app/src/main/java/org/Models/Pieces/PieceL.java index e426937..cbb5df2 100644 --- a/app/src/main/java/org/Models/Pieces/PieceL.java +++ b/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; diff --git a/app/src/main/java/org/Models/Pieces/PieceO.java b/app/src/main/java/org/Models/Pieces/PieceO.java index 140e378..dcc1541 100644 --- a/app/src/main/java/org/Models/Pieces/PieceO.java +++ b/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; diff --git a/app/src/main/java/org/Models/Pieces/PieceS.java b/app/src/main/java/org/Models/Pieces/PieceS.java index 4c49495..c0ba952 100644 --- a/app/src/main/java/org/Models/Pieces/PieceS.java +++ b/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; diff --git a/app/src/main/java/org/Models/Pieces/PieceT.java b/app/src/main/java/org/Models/Pieces/PieceT.java index 6d41849..497fd75 100644 --- a/app/src/main/java/org/Models/Pieces/PieceT.java +++ b/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; diff --git a/app/src/main/java/org/Models/Pieces/PieceZ.java b/app/src/main/java/org/Models/Pieces/PieceZ.java index c7893c5..6d56160 100644 --- a/app/src/main/java/org/Models/Pieces/PieceZ.java +++ b/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; diff --git a/app/src/main/java/org/Views/GridLayoutCarre.java b/app/src/main/java/org/Views/GridLayoutCarre.java index a0e868c..f17ba54 100644 --- a/app/src/main/java/org/Views/GridLayoutCarre.java +++ b/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(); diff --git a/app/src/main/java/org/Views/VueBandeauControle.java b/app/src/main/java/org/Views/VueBandeauControle.java index 7d91495..260f327 100644 --- a/app/src/main/java/org/Views/VueBandeauControle.java +++ b/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) { diff --git a/app/src/main/java/org/Views/VueGameOver.java b/app/src/main/java/org/Views/VueGameOver.java index 34e7cf1..2fa9006 100644 --- a/app/src/main/java/org/Views/VueGameOver.java +++ b/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); diff --git a/app/src/main/java/org/Views/VueGrille.java b/app/src/main/java/org/Views/VueGrille.java index da3bfb7..9a750e1 100644 --- a/app/src/main/java/org/Views/VueGrille.java +++ b/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++) { diff --git a/app/src/main/java/org/Views/VueTetris.java b/app/src/main/java/org/Views/VueTetris.java index a914a9b..c75c051 100644 --- a/app/src/main/java/org/Views/VueTetris.java +++ b/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; }