diff --git a/fr/iut_fbleau/Avalam/AvalamBoard.java b/fr/iut_fbleau/Avalam/AvalamBoard.java index 2a0decc..6c23677 100644 --- a/fr/iut_fbleau/Avalam/AvalamBoard.java +++ b/fr/iut_fbleau/Avalam/AvalamBoard.java @@ -9,15 +9,44 @@ import fr.iut_fbleau.GameAPI.Result; import java.util.ArrayDeque; import java.util.Iterator; +/** +* La classe AvalamBoard +* +* Représente le plateau et les règles du jeu Avalam. +* Cette classe étend AbstractBoard (GameAPI) et fournit : +* - la génération des coups (iterator) +* - le test de légalité (isLegal) +* - l’application d’un coup (doPly) +* - la détection de fin de partie (isGameOver) +* - le calcul du résultat (getResult) +*/ public class AvalamBoard extends AbstractBoard { + //Attributs + + /** Taille du plateau Avalam (9x9). */ public static final int SIZE = 9; + + /** Hauteur maximale autorisée pour une tour après fusion. */ private static final int MAX_HEIGHT = 5; + /** Grille du plateau : chaque case contient une tour (Tower) ou null si vide. */ private final Tower[][] grid; + + /** Indique si la partie est terminée (mémoïsation). */ private boolean gameOver = false; + + /** Résultat de la partie si elle est terminée (mémoïsation). */ private Result result = null; + //Constructeur + + /** + * Construit un plateau Avalam à partir d’une grille initiale et d’un joueur qui commence. + * + * @param initialGrid grille initiale (Tower ou null) + * @param startingPlayer joueur qui commence (PLAYER1 ou PLAYER2) + */ public AvalamBoard(Tower[][] initialGrid, Player startingPlayer) { super(startingPlayer, new ArrayDeque<>()); this.grid = new Tower[SIZE][SIZE]; @@ -27,10 +56,24 @@ public class AvalamBoard extends AbstractBoard { this.grid[r][c] = initialGrid[r][c]; } + /** + * Construit un plateau Avalam à partir d’une grille initiale. + * Par défaut, PLAYER1 commence. + * + * @param initialGrid grille initiale (Tower ou null) + */ public AvalamBoard(Tower[][] initialGrid) { this(initialGrid, Player.PLAYER1); } + /** + * Constructeur interne utilisé par safeCopy(). + * + * @param grid grille à réutiliser + * @param current joueur courant + * @param gameOver état “partie terminée” + * @param result résultat mémorisé + */ private AvalamBoard(Tower[][] grid, Player current, boolean gameOver, Result result) { super(current, new ArrayDeque<>()); this.grid = grid; @@ -38,24 +81,61 @@ public class AvalamBoard extends AbstractBoard { this.result = result; } + //Méthodes + + /** + * Retourne la tour située à la position (row, col), ou null si hors bornes ou vide. + * + * @param row ligne + * @param col colonne + * @return tour présente ou null + */ public Tower getTowerAt(int row, int col) { return inBounds(row, col) ? grid[row][col] : null; } + /** + * Teste si une position est à l’intérieur du plateau. + * + * @param r ligne + * @param c colonne + * @return true si (r,c) est dans [0..SIZE-1] + */ private boolean inBounds(int r, int c) { return r >= 0 && r < SIZE && c >= 0 && c < SIZE; } + /** + * Teste si deux cases sont adjacentes (8-voisinage). + * + * @param r1 ligne source + * @param c1 colonne source + * @param r2 ligne destination + * @param c2 colonne destination + * @return true si les cases sont voisines et différentes + */ private boolean areAdjacent(int r1, int c1, int r2, int c2) { int dr = Math.abs(r1 - r2); int dc = Math.abs(c1 - c2); return (dr <= 1 && dc <= 1 && !(dr == 0 && dc == 0)); } + /** + * Associe un joueur GameAPI à une couleur Avalam. + * + * @param p joueur (PLAYER1/PLAYER2) + * @return couleur correspondante (YELLOW/RED) + */ private Color colorForPlayer(Player p) { return (p == Player.PLAYER1 ? Color.YELLOW : Color.RED); } + /** + * Indique si la partie est terminée. + * Ici : fin lorsque l’itérateur de coups légaux ne produit plus aucun coup. + * + * @return true si aucun coup n’est possible + */ @Override public boolean isGameOver() { if (gameOver) return true; @@ -67,6 +147,12 @@ public class AvalamBoard extends AbstractBoard { return true; } + /** + * Retourne le résultat si la partie est terminée. + * Règle utilisée ici : comparaison du nombre de tours contrôlées par chaque couleur. + * + * @return WIN / LOSS / DRAW ou null si partie non terminée + */ @Override public Result getResult() { if (!isGameOver()) return null; @@ -91,6 +177,19 @@ public class AvalamBoard extends AbstractBoard { return result; } + /** + * Teste si un coup est légal selon les règles implémentées : + * - coup de type AvalamPly + * - source/destination dans le plateau et différentes + * - source et destination non null + * - la tour source appartient au joueur courant (couleur du sommet) + * - cases adjacentes + * - couleurs différentes entre source et destination (règle de ce projet) + * - hauteur finale <= MAX_HEIGHT + * + * @param c coup à tester + * @return true si le coup est légal + */ @Override public boolean isLegal(AbstractPly c) { if (!(c instanceof AvalamPly)) return false; @@ -114,6 +213,14 @@ public class AvalamBoard extends AbstractBoard { return true; } + /** + * Applique un coup légal : + * - fusion de la tour source sur la destination + * - la case source devient vide + * - passage au joueur suivant via super.doPly + * + * @param c coup à jouer + */ @Override public void doPly(AbstractPly c) { if (!isLegal(c)) throw new IllegalArgumentException("Coup illégal : " + c); @@ -135,6 +242,12 @@ public class AvalamBoard extends AbstractBoard { result = null; } + /** + * Retourne un itérateur sur tous les coups légaux du joueur courant. + * Génération brute : pour chaque case et chaque voisin (8 directions), on teste isLegal(). + * + * @return itérateur de coups possibles (AbstractPly) + */ @Override public Iterator iterator() { java.util.List moves = new java.util.ArrayList<>(); @@ -159,6 +272,12 @@ public class AvalamBoard extends AbstractBoard { return moves.iterator(); } + /** + * Retourne une copie “sûre” de l’état du plateau. + * Ici, la grille est recopiée case par case (copie des références Tower). + * + * @return copie du plateau (IBoard) + */ @Override public IBoard safeCopy() { Tower[][] newGrid = new Tower[SIZE][SIZE]; diff --git a/fr/iut_fbleau/Avalam/AvalamPly.java b/fr/iut_fbleau/Avalam/AvalamPly.java index b337d31..80dfc4b 100644 --- a/fr/iut_fbleau/Avalam/AvalamPly.java +++ b/fr/iut_fbleau/Avalam/AvalamPly.java @@ -4,44 +4,43 @@ import fr.iut_fbleau.GameAPI.AbstractPly; import fr.iut_fbleau.GameAPI.Player; /** - * Représente un coup (ply) dans le jeu Avalam. - * - * Un coup est défini par : - * - * - * Ces coordonnées seront utilisées par AvalamBoard pour : - * - * - * Cette classe ne contient aucune logique de vérification : tout est délégué - * à AvalamBoard.isLegal() et AvalamBoard.doPly(). - */ +* La classe AvalamPly +* +* Représente un coup (ply) dans le jeu Avalam. +* Un coup est défini par : +* - un joueur (PLAYER1 ou PLAYER2) +* - une position source (xFrom, yFrom) +* - une position destination (xTo, yTo) +* +* Cette classe ne vérifie pas la légalité : tout est délégué à AvalamBoard. +*/ public class AvalamPly extends AbstractPly { - /** Coordonnées source */ + //Attributs + + /** Coordonnée ligne de la case source. */ private final int xFrom; + + /** Coordonnée colonne de la case source. */ private final int yFrom; - /** Coordonnées destination */ + /** Coordonnée ligne de la case destination. */ private final int xTo; + + /** Coordonnée colonne de la case destination. */ private final int yTo; + //Constructeur + /** - * Constructeur principal. - * - * @param player joueur qui joue le coup - * @param xFrom ligne d'origine - * @param yFrom colonne d'origine - * @param xTo ligne de destination - * @param yTo colonne de destination - */ + * Construit un coup Avalam. + * + * @param player joueur qui joue le coup + * @param xFrom ligne d'origine + * @param yFrom colonne d'origine + * @param xTo ligne de destination + * @param yTo colonne de destination + */ public AvalamPly(Player player, int xFrom, int yFrom, int xTo, int yTo) { super(player); this.xFrom = xFrom; @@ -50,26 +49,51 @@ public class AvalamPly extends AbstractPly { this.yTo = yTo; } - /** Ligne d'origine */ + //Méthodes + + /** + * Retourne la ligne d'origine. + * + * @return ligne source + */ public int getXFrom() { return xFrom; } - /** Colonne d'origine */ + /** + * Retourne la colonne d'origine. + * + * @return colonne source + */ public int getYFrom() { return yFrom; } - /** Ligne de destination */ + /** + * Retourne la ligne de destination. + * + * @return ligne destination + */ public int getXTo() { return xTo; } - /** Colonne de destination */ + /** + * Retourne la colonne de destination. + * + * @return colonne destination + */ public int getYTo() { return yTo; } + //Affichage + + /** + * Retourne une représentation textuelle du coup. + * + * @return chaîne décrivant le coup + */ @Override public String toString() { return "AvalamPly{" + diff --git a/fr/iut_fbleau/Avalam/AvalamWindow.java b/fr/iut_fbleau/Avalam/AvalamWindow.java index 6e85649..36492e5 100644 --- a/fr/iut_fbleau/Avalam/AvalamWindow.java +++ b/fr/iut_fbleau/Avalam/AvalamWindow.java @@ -1,9 +1,5 @@ package fr.iut_fbleau.Avalam; -import fr.iut_fbleau.Avalam.logic.BoardLoader; -import fr.iut_fbleau.Avalam.ui.BoardView; -import fr.iut_fbleau.Avalam.ui.ScoreView; -import fr.iut_fbleau.Avalam.ui.TurnView; import fr.iut_fbleau.GameAPI.Player; import fr.iut_fbleau.GameAPI.Result; @@ -11,41 +7,53 @@ import javax.swing.*; import java.awt.*; /** - * Fenêtre principale du jeu Avalam. - * - * Elle contient : - * - le plateau (BoardView) - * - l'affichage du score - * - l'affichage du joueur courant - * - * Elle interagit directement avec AvalamBoard (moteur du jeu). - */ +* La classe AvalamWindow +* +* Fenêtre principale (interface graphique) du jeu Avalam. +* Elle contient : +* - le plateau (BoardView) +* - l'affichage du score (ScoreView) +* - l'affichage du joueur courant (TurnView) +* +* Elle pilote un objet AvalamBoard (moteur du jeu). +*/ public class AvalamWindow extends JFrame { - /** Moteur du jeu (API GameAPI) */ + //Attributs + + /** Moteur du jeu (état + règles). */ private AvalamBoard board; - /** Vues graphiques */ + /** Vue affichant le score des deux couleurs. */ private ScoreView scoreView; + + /** Vue affichant le joueur dont c'est le tour. */ private TurnView turnView; + + /** Vue affichant le plateau et gérant les interactions de jeu. */ private BoardView boardView; + //Constructeur + + /** + * Construit la fenêtre et initialise l’interface : + * - charge le plateau initial depuis Plateau.txt + * - construit les vues (score, tour, plateau) + * - affiche la fenêtre + */ public AvalamWindow() { super("Avalam"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new BorderLayout()); - // ---------------------------------------------------------- // Chargement du plateau initial depuis Plateau.txt - // ---------------------------------------------------------- Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt"); - board = new AvalamBoard(initialGrid); // PLAYER1 commence + // Initialisation du moteur (PLAYER1 commence) + board = new AvalamBoard(initialGrid); - // ---------------------------------------------------------- - // PANNEAU SCORE + TOUR - // ---------------------------------------------------------- + // Création du panneau supérieur (score + tour) JPanel topPanel = new JPanel(new GridLayout(2, 1)); topPanel.setBackground(new java.awt.Color(200, 200, 200)); @@ -61,11 +69,8 @@ public class AvalamWindow extends JFrame { add(topPanel, BorderLayout.NORTH); - // ---------------------------------------------------------- - // PLATEAU (BoardView) - // ---------------------------------------------------------- + // Création de la vue plateau (avec callback de mise à jour) boardView = new BoardView(board, this::onBoardUpdated); - add(boardView, BorderLayout.CENTER); pack(); @@ -74,49 +79,63 @@ public class AvalamWindow extends JFrame { setVisible(true); } - /* ================================================================ - * MISES À JOUR D’APRÈS LE MOTEUR - * ================================================================ */ + //Méthodes /** - * Appelé automatiquement après chaque coup via BoardView → controller → board. - */ + * Méthode appelée automatiquement après chaque coup (via BoardView). + * Elle rafraîchit : + * - les scores + * - le joueur courant + * et affiche un message si la partie est terminée. + */ public void onBoardUpdated() { - // Mise à jour du score et du joueur courant + // Mise à jour du score scoreView.updateScores( computeScore(Color.YELLOW), computeScore(Color.RED) ); + // Mise à jour du joueur courant turnView.setTurn(turnMessage()); - // Détection de fin de partie + // Détection de fin de partie if (board.isGameOver()) { Result res = board.getResult(); String msg; + // Correction : ajout des "break" pour éviter le fall-through. switch (res) { - case WIN : msg = "Le joueur jaune a gagné !"; - case LOSS : msg = "Le joueur rouge a gagné !"; - case DRAW : msg = "Égalité !"; - default : msg = "Fin de partie."; + case WIN: + msg = "Le joueur jaune a gagné !"; + break; + case LOSS: + msg = "Le joueur rouge a gagné !"; + break; + case DRAW: + msg = "Égalité !"; + break; + default: + msg = "Fin de partie."; + break; } - JOptionPane.showMessageDialog(this, msg, "Partie terminée", - JOptionPane.INFORMATION_MESSAGE); + JOptionPane.showMessageDialog( + this, + msg, + "Partie terminée", + JOptionPane.INFORMATION_MESSAGE + ); } } - - /* ================================================================ - * OUTILS - * ================================================================ */ - /** - * Calcule le score d'une couleur : nombre de tours contrôlées. - */ + * Calcule le score d'une couleur : nombre de tours contrôlées (sommet de la tour). + * + * @param c couleur à compter + * @return nombre de tours appartenant à la couleur c + */ private int computeScore(Color c) { int score = 0; for (int r = 0; r < AvalamBoard.SIZE; r++) { @@ -131,10 +150,12 @@ public class AvalamWindow extends JFrame { } /** - * Message du joueur dont c'est le tour. - */ + * Retourne le message correspondant au joueur dont c'est le tour. + * + * @return message d’affichage du tour + */ private String turnMessage() { - return "Tour du joueur : " + + return "Tour du joueur : " + (board.getCurrentPlayer() == Player.PLAYER1 ? "Jaune" : "Rouge"); } } diff --git a/fr/iut_fbleau/Avalam/logic/BoardLoader.java b/fr/iut_fbleau/Avalam/BoardLoader.java similarity index 64% rename from fr/iut_fbleau/Avalam/logic/BoardLoader.java rename to fr/iut_fbleau/Avalam/BoardLoader.java index d6f1f52..a022013 100644 --- a/fr/iut_fbleau/Avalam/logic/BoardLoader.java +++ b/fr/iut_fbleau/Avalam/BoardLoader.java @@ -1,4 +1,4 @@ -package fr.iut_fbleau.Avalam.logic; +package fr.iut_fbleau.Avalam; import fr.iut_fbleau.Avalam.Color; import fr.iut_fbleau.Avalam.Tower; @@ -8,8 +8,32 @@ import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; +/** +* La classe BoardLoader +* +* Permet de charger un plateau Avalam à partir d’un fichier texte. +* Le fichier contient une grille 9x9 de valeurs numériques : +* - 0 : case vide +* - 1 : tour jaune +* - 2 : tour rouge +* +* Cette classe fournit une méthode statique pour construire +* une grille de tours (Tower[][]) à partir d’une ressource. +*/ public class BoardLoader { + //Attributs + + //Constructeur + + //Méthodes + + /** + * Charge un plateau Avalam depuis un fichier de ressources. + * + * @param resourcePath chemin du fichier de plateau (dans les ressources) + * @return une grille 9x9 de tours (Tower) ou null pour les cases vides + */ public static Tower[][] loadFromFile(String resourcePath) { Tower[][] grid = new Tower[9][9]; @@ -17,7 +41,7 @@ public class BoardLoader { InputStream in = BoardLoader.class.getResourceAsStream("/" + resourcePath); if (in == null) { - System.err.println("❌ Ressource introuvable : /" + resourcePath); + System.err.println("Ressource introuvable : /" + resourcePath); return grid; } @@ -28,7 +52,7 @@ public class BoardLoader { while ((line = reader.readLine()) != null && row < 9) { - // 🔥 Accepte SOIT les espaces, SOIT les virgules + // Accepte SOIT les espaces, SOIT les virgules line = line.replace(",", " "); String[] parts = line.trim().split("\\s+"); diff --git a/fr/iut_fbleau/Avalam/ui/BoardView.java b/fr/iut_fbleau/Avalam/BoardView.java similarity index 63% rename from fr/iut_fbleau/Avalam/ui/BoardView.java rename to fr/iut_fbleau/Avalam/BoardView.java index 7918eeb..208f79b 100644 --- a/fr/iut_fbleau/Avalam/ui/BoardView.java +++ b/fr/iut_fbleau/Avalam/BoardView.java @@ -1,4 +1,4 @@ -package fr.iut_fbleau.Avalam.ui; +package fr.iut_fbleau.Avalam; import fr.iut_fbleau.Avalam.AvalamBoard; import fr.iut_fbleau.Avalam.Tower; @@ -7,43 +7,59 @@ import javax.swing.*; import java.awt.*; /** - * BoardView est la vue principale du plateau Avalam. - * - * Elle gère : - * - l’affichage des tours (PieceLayer) - * - l’affichage des coups possibles (HighlightLayer) - * - un fond graphique personnalisé - * - les clics via InteractionController - */ +* La classe BoardView +* +* Représente la vue principale du plateau Avalam. +* Elle gère : +* - l’affichage des tours (PieceLayer) +* - l’affichage des coups possibles (HighlightLayer) +* - l’affichage du fond graphique +* - la gestion des interactions via InteractionController +* +* Cette classe ne contient aucune logique de jeu. +*/ public class BoardView extends JLayeredPane { - /** Référence au moteur Avalam */ + //Attributs + + /** Référence au moteur du jeu Avalam. */ private AvalamBoard board; - /** Couche d’affichage du fond */ + /** Couche graphique du fond du plateau. */ private BackgroundLayer backgroundLayer; - /** Couche d’affichage des rond verts */ + /** Couche graphique des déplacements possibles. */ private HighlightLayer highlightLayer; - /** Couche d’affichage des pièces */ + /** Couche graphique des pièces (tours). */ private PieceLayer pieceLayer; - /** Contrôleur des interactions */ + /** Contrôleur des interactions utilisateur. */ private InteractionController controller; - /** Décalages et dimensions pour l'affichage */ + /** Taille d’un pion en pixels. */ private final int size = 50; + + /** Espacement entre deux cases du plateau. */ private final int spacing = 70; + + /** Décalage horizontal du plateau. */ private final int xBase = 60; + + /** Décalage vertical du plateau. */ private final int yBase = 60; - /** Callback vers AvalamWindow pour mises à jour (score, tour, fin) */ + /** Callback vers AvalamWindow pour mettre à jour l’interface (score, tour, fin). */ private Runnable boardUpdateCallback; + //Constructeur + /** - * Constructeur. - */ + * Construit la vue du plateau Avalam. + * + * @param board moteur du jeu Avalam + * @param boardUpdateCallback fonction de rappel après un coup + */ public BoardView(AvalamBoard board, Runnable boardUpdateCallback) { this.board = board; this.boardUpdateCallback = boardUpdateCallback; @@ -71,9 +87,11 @@ public class BoardView extends JLayeredPane { refresh(); } + //Méthodes + /** - * Appelé par le contrôleur après un coup. - */ + * Appelé par le contrôleur après un coup. + */ public void onBoardUpdated() { if (boardUpdateCallback != null) { boardUpdateCallback.run(); @@ -81,8 +99,8 @@ public class BoardView extends JLayeredPane { } /** - * Rafraîchit les couches visuelles. - */ + * Rafraîchit l’affichage du plateau. + */ public void refresh() { pieceLayer.displayGrid( @@ -100,8 +118,10 @@ public class BoardView extends JLayeredPane { } /** - * Récupère la grille depuis le moteur. - */ + * Récupère la grille actuelle du moteur de jeu. + * + * @return grille 9x9 de tours + */ private Tower[][] boardGrid() { Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE]; @@ -113,18 +133,28 @@ public class BoardView extends JLayeredPane { return grid; } + //Affichage + /** - * Composant affichant l’image de fond. - */ + * Classe interne représentant la couche graphique du fond. + */ private static class BackgroundLayer extends JComponent { private Image img; + /** + * Construit une couche de fond à partir d’une image. + * + * @param resourcePath chemin de l’image + */ public BackgroundLayer(String resourcePath) { img = Toolkit.getDefaultToolkit().getImage( getClass().getClassLoader().getResource(resourcePath) ); } + /** + * Dessine l’image de fond. + */ @Override protected void paintComponent(Graphics g) { super.paintComponent(g); diff --git a/fr/iut_fbleau/Avalam/Color.java b/fr/iut_fbleau/Avalam/Color.java index 5eedab1..061a9d0 100644 --- a/fr/iut_fbleau/Avalam/Color.java +++ b/fr/iut_fbleau/Avalam/Color.java @@ -1,20 +1,57 @@ package fr.iut_fbleau.Avalam; +/** +* L'énumération Color +* +* Représente les deux couleurs utilisées dans Avalam : +* - YELLOW (jaune) +* - RED (rouge) +* +* Chaque valeur est associée à une couleur Swing (java.awt.Color) +* pour l’affichage graphique et peut être convertie en Player (GameAPI). +*/ public enum Color { + //Attributs + + /** Couleur jaune (associée à PLAYER1). */ YELLOW(255, 220, 0), + + /** Couleur rouge (associée à PLAYER2). */ RED(200, 40, 40); + /** Couleur Swing utilisée pour l'affichage dans l'interface graphique. */ private final java.awt.Color swingColor; + //Constructeur + + /** + * Construit une couleur Avalam en initialisant sa couleur Swing associée. + * + * @param r composante rouge [0..255] + * @param g composante verte [0..255] + * @param b composante bleue [0..255] + */ Color(int r, int g, int b) { this.swingColor = new java.awt.Color(r, g, b); } + //Méthodes + + /** + * Retourne la couleur Swing associée (pour l'affichage). + * + * @return java.awt.Color + */ public java.awt.Color getSwingColor() { return swingColor; } + /** + * Convertit la couleur Avalam en joueur GameAPI. + * + * @return PLAYER1 si YELLOW, sinon PLAYER2 + */ public fr.iut_fbleau.GameAPI.Player toPlayer() { return (this == YELLOW ? fr.iut_fbleau.GameAPI.Player.PLAYER1 : diff --git a/fr/iut_fbleau/Avalam/HighlightLayer.java b/fr/iut_fbleau/Avalam/HighlightLayer.java new file mode 100644 index 0000000..f08fb92 --- /dev/null +++ b/fr/iut_fbleau/Avalam/HighlightLayer.java @@ -0,0 +1,94 @@ +package fr.iut_fbleau.Avalam; + +import javax.swing.*; +import java.awt.*; +import java.util.List; + +/** +* La classe HighlightLayer +* +* Gère l'affichage graphique des cases jouables sur le plateau Avalam. +* Les cases autorisées sont représentées par des cercles verts semi-transparents. +* +* Cette classe ne contient aucune logique de jeu. +*/ +public class HighlightLayer extends JPanel { + + //Attributs + + /** Position X de base du plateau. */ + private int xBase; + + /** Position Y de base du plateau. */ + private int yBase; + + /** Espacement entre les cases du plateau. */ + private int spacing; + + /** Taille d’un pion en pixels. */ + private int size; + + /** Liste des positions jouables (cases en vert). */ + private List legalMoves; + + //Constructeur + + /** + * Construit la couche d'affichage des coups légaux. + * + * @param xBase position X de base du plateau + * @param yBase position Y de base du plateau + * @param spacing espacement entre cases + * @param size taille des pions + */ + public HighlightLayer(int xBase, int yBase, int spacing, int size) { + this.xBase = xBase; + this.yBase = yBase; + this.spacing = spacing; + this.size = size; + + setOpaque(false); + setBounds(0, 0, 800, 800); + } + + //Méthodes + + /** + * Définit la liste des cases légales à afficher. + * + * @param moves liste des positions jouables + */ + public void setLegalMoves(List moves) { + this.legalMoves = moves; + repaint(); + } + + //Affichage + + /** + * Dessine les cercles verts autour des cases autorisées. + * + * @param g contexte graphique + */ + @Override + protected void paintComponent(Graphics g) { + super.paintComponent(g); + + if (legalMoves == null) return; + + Graphics2D g2 = (Graphics2D) g; + g2.setColor(new java.awt.Color(0, 255, 0, 120)); + + for (Point p : legalMoves) { + + int r = p.x; + int c = p.y; + + int x = xBase + c * spacing; + int y = yBase + r * spacing; + + int highlight = size + 20; // Cercle plus grand que le pion + g2.fillOval(x - 10, y - 10, highlight, highlight); + } + } +} diff --git a/fr/iut_fbleau/Avalam/ui/InteractionController.java b/fr/iut_fbleau/Avalam/InteractionController.java similarity index 62% rename from fr/iut_fbleau/Avalam/ui/InteractionController.java rename to fr/iut_fbleau/Avalam/InteractionController.java index 42c7436..8d74e80 100644 --- a/fr/iut_fbleau/Avalam/ui/InteractionController.java +++ b/fr/iut_fbleau/Avalam/InteractionController.java @@ -1,8 +1,4 @@ -package fr.iut_fbleau.Avalam.ui; - -import fr.iut_fbleau.Avalam.AvalamBoard; -import fr.iut_fbleau.Avalam.AvalamPly; -import fr.iut_fbleau.Avalam.Tower; +package fr.iut_fbleau.Avalam; import fr.iut_fbleau.GameAPI.AbstractPly; import fr.iut_fbleau.GameAPI.Player; @@ -13,48 +9,71 @@ import java.util.Iterator; import java.util.List; /** - * Le contrôleur gère toute l'interaction entre l'utilisateur et le moteur Avalam. - * - * Son rôle : - * - gérer la sélection d’une tour - * - générer les coups légaux via l’API (iterator) - * - valider un déplacement (isLegal) - * - appliquer un coup (doPly) - * - mettre à jour le plateau (via refresh demandé au BoardView) - * - * IMPORTANT : ce contrôleur n’affiche rien. Il envoie les infos à BoardView. - */ +* La classe InteractionController +* +* Gère l'interaction entre l'utilisateur et le moteur du jeu Avalam. +* Elle permet : +* - la sélection d'une tour +* - le calcul des coups légaux +* - la validation d'un déplacement +* - l'application d'un coup +* - la mise à jour de l'affichage via BoardView +* +* Cette classe ne réalise aucun affichage direct. +*/ public class InteractionController { + //Attributs + + /** Référence au moteur du jeu Avalam. */ private AvalamBoard board; - /** Position sélectionnée (-1 si aucune) */ + /** Ligne de la tour sélectionnée (-1 si aucune). */ private int selectedRow = -1; + + /** Colonne de la tour sélectionnée (-1 si aucune). */ private int selectedCol = -1; - /** Liste des coups légaux (en Point) autour de la sélection */ + /** Liste des coups légaux (sous forme de points). */ private List legalMoves = new ArrayList<>(); - /** Référence à la vue pour la rafraîchir après déplacements */ + /** Référence à la vue du plateau pour rafraîchir l'affichage. */ private BoardView view; + //Constructeur + + /** + * Construit le contrôleur d'interactions. + * + * @param board moteur du jeu Avalam + * @param view vue du plateau + */ public InteractionController(AvalamBoard board, BoardView view) { this.board = board; this.view = view; } - /** Retourne les cases jouables (pour HighlightLayer). */ + //Méthodes + + /** + * Retourne la liste des cases jouables. + * + * @return liste des coups légaux + */ public List getLegalMoves() { return legalMoves; } /** - * Appelé lorsqu’un pion est cliqué dans BoardView. - * Gère : - * - sélection d’une tour - * - désélection - * - tentative de déplacement (si clique sur un highlight) - */ + * Appelé lorsqu’un pion est cliqué dans BoardView. + * Gère : + * - la sélection d’une tour + * - la désélection + * - la tentative de déplacement + * + * @param r ligne cliquée + * @param c colonne cliquée + */ public void onPieceClicked(int r, int c) { // Si on clique la même case ⇒ désélection @@ -79,16 +98,21 @@ public class InteractionController { } } - /* ------------------------------------------------------------------------- - * SÉLECTION D’UNE TOUR - * ---------------------------------------------------------------------- */ - + /** + * Sélectionne une tour à la position (r,c). + * + * @param r ligne + * @param c colonne + */ private void selectTower(int r, int c) { selectedRow = r; selectedCol = c; computeLegalMoves(); } + /** + * Annule la sélection actuelle. + */ private void clearSelection() { selectedRow = -1; selectedCol = -1; @@ -96,9 +120,9 @@ public class InteractionController { } /** - * Identifie les destinations possibles depuis la tour sélectionnée. - * Utilise l’API officielle : board.iterator() - */ + * Calcule les coups légaux à partir de la tour sélectionnée. + * Utilise l'itérateur fourni par AvalamBoard. + */ private void computeLegalMoves() { legalMoves.clear(); @@ -117,13 +141,12 @@ public class InteractionController { } } - /* ------------------------------------------------------------------------- - * TENTATIVE DE DÉPLACEMENT - * ---------------------------------------------------------------------- */ - /** - * Tente d’exécuter un déplacement vers (r,c) si c’est un coup légal. - */ + * Tente d’exécuter un déplacement vers la case (r,c). + * + * @param r ligne de destination + * @param c colonne de destination + */ private void tryMove(int r, int c) { // Vérifier si (r,c) est une destination légale boolean isLegalDest = false; @@ -152,11 +175,11 @@ public class InteractionController { // Réinitialiser la sélection clearSelection(); - // Recalcul du score + joueur courant + fin de partie (handled in window) + // Mise à jour de l'interface view.onBoardUpdated(); } else { - // Coup impossible (rare, mais pour sécurité) + // Coup impossible clearSelection(); } diff --git a/fr/iut_fbleau/Avalam/Main.java b/fr/iut_fbleau/Avalam/Main.java index 822dfdd..4257f02 100644 --- a/fr/iut_fbleau/Avalam/Main.java +++ b/fr/iut_fbleau/Avalam/Main.java @@ -1,6 +1,27 @@ package fr.iut_fbleau.Avalam; +/** +* La classe Main +* +* Point d’entrée du programme. +* Lance l’interface graphique principale (AvalamWindow). +*/ public class Main { + + //Attributs + + //Constructeur + public Main() { + + } + + //Méthodes + + /** + * Méthode principale : démarre l’application. + * + * @param args arguments de la ligne de commande (non utilisés) + */ public static void main(String[] args) { new AvalamWindow(); } diff --git a/fr/iut_fbleau/Avalam/ui/PieceButton.java b/fr/iut_fbleau/Avalam/PieceButton.java similarity index 58% rename from fr/iut_fbleau/Avalam/ui/PieceButton.java rename to fr/iut_fbleau/Avalam/PieceButton.java index c0ef110..7fedbaa 100644 --- a/fr/iut_fbleau/Avalam/ui/PieceButton.java +++ b/fr/iut_fbleau/Avalam/PieceButton.java @@ -1,40 +1,47 @@ -package fr.iut_fbleau.Avalam.ui; - +package fr.iut_fbleau.Avalam; import javax.swing.*; import java.awt.*; /** - * La classe PieceButton représente graphiquement une tour Avalam. - * Il s'agit d'un bouton rond : - * - *
    - *
  • coloré selon le joueur
    • - *
  • affichant sa hauteur
    • - *
  • avec un effet de survol visuel
    • - *
- * - * Ce composant sert d'interaction principale pour cliquer les pions. - * - * @author - * @version 1.0 - */ +* La classe PieceButton +* +* Représente graphiquement une tour Avalam sous forme d’un bouton rond. +* Chaque bouton : +* - possède une couleur correspondant au joueur, +* - affiche la hauteur de la tour, +* - réagit au survol de la souris. +* +* Ce composant permet l’interaction avec les pièces du plateau. +*/ public class PieceButton extends JButton { - private Color color; + //Attributs + + /** Couleur graphique du pion. */ + private java.awt.Color color; + + /** Hauteur de la tour affichée. */ private int height; + + /** Indique si la souris survole le bouton. */ private boolean hover = false; - /** Position de la tour sur la grille. */ - public final int row, col; + /** Position de la tour sur la grille (ligne). */ + public final int row; + + /** Position de la tour sur la grille (colonne). */ + public final int col; + + //Constructeur /** - * Constructeur. - * - * @param c couleur graphique du pion - * @param height hauteur de la tour - * @param row ligne du pion - * @param col colonne du pion - */ + * Construit un bouton représentant une tour Avalam. + * + * @param c couleur graphique du pion + * @param height hauteur de la tour + * @param row ligne du pion + * @param col colonne du pion + */ public PieceButton(java.awt.Color c, int height, int row, int col) { this.color = c; this.height = height; @@ -52,9 +59,13 @@ public class PieceButton extends JButton { }); } + //Méthodes + /** - * Dessine le pion rond ainsi que son chiffre au centre. - */ + * Dessine le pion rond ainsi que sa hauteur au centre. + * + * @param g contexte graphique + */ @Override protected void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g.create(); @@ -78,9 +89,15 @@ public class PieceButton extends JButton { g2.dispose(); } + //Affichage + /** - * Rend le bouton réellement rond (zone cliquable circulaire). - */ + * Rend le bouton réellement rond (zone cliquable circulaire). + * + * @param x coordonnée X + * @param y coordonnée Y + * @return true si le point est dans le cercle + */ @Override public boolean contains(int x, int y) { double dx = x - getWidth()/2.0; diff --git a/fr/iut_fbleau/Avalam/ui/PieceLayer.java b/fr/iut_fbleau/Avalam/PieceLayer.java similarity index 55% rename from fr/iut_fbleau/Avalam/ui/PieceLayer.java rename to fr/iut_fbleau/Avalam/PieceLayer.java index 0c69076..3c0276b 100644 --- a/fr/iut_fbleau/Avalam/ui/PieceLayer.java +++ b/fr/iut_fbleau/Avalam/PieceLayer.java @@ -1,48 +1,44 @@ -package fr.iut_fbleau.Avalam.ui; - -import fr.iut_fbleau.Avalam.Tower; +package fr.iut_fbleau.Avalam; import javax.swing.*; import java.awt.*; /** - * La classe PieceLayer gère l'affichage des pions - * (sous forme de PieceButton) sur la grille. - * - * Elle s'occupe uniquement : - *
    - *
  • d'afficher les pièces
    • - *
  • de positionner correctement les boutons
    • - *
  • d'attacher un callback à chaque clic
    • - *
- * - * Aucune logique de jeu n'est réalisée ici. - * - * @author - * @version 1.0 - */ +* La classe PieceLayer +* +* Gère l'affichage des tours du plateau Avalam sous forme de boutons. +* Elle : +* - affiche les pièces, +* - positionne les boutons sur la grille, +* - associe une action de clic à chaque pièce. +* +* Aucune logique de jeu n'est implémentée ici. +*/ public class PieceLayer extends JPanel { + //Constructeur + /** - * Constructeur. - * Initialise un panneau transparent prêt à recevoir des pions. - */ + * Construit la couche graphique des pièces. + */ public PieceLayer() { setLayout(null); setOpaque(false); setBounds(0, 0, 800, 800); } + //Méthodes + /** - * Affiche la grille de tours sous forme de boutons. - * - * @param grid grille 9×9 des tours - * @param xBase offset X du plateau - * @param yBase offset Y du plateau - * @param spacing espacement entre cases - * @param size taille d'un pion - * @param clickCallback fonction appelée lors d’un clic sur un pion - */ + * Affiche la grille de tours sous forme de boutons interactifs. + * + * @param grid grille 9×9 des tours + * @param xBase décalage horizontal du plateau + * @param yBase décalage vertical du plateau + * @param spacing espacement entre cases + * @param size taille d'un pion + * @param clickCallback fonction appelée lors d’un clic sur un pion + */ public void displayGrid(Tower[][] grid, int xBase, int yBase, int spacing, int size, java.util.function.BiConsumer clickCallback) { diff --git a/fr/iut_fbleau/Avalam/ScoreView.java b/fr/iut_fbleau/Avalam/ScoreView.java new file mode 100644 index 0000000..2a548ea --- /dev/null +++ b/fr/iut_fbleau/Avalam/ScoreView.java @@ -0,0 +1,57 @@ +package fr.iut_fbleau.Avalam; + +import javax.swing.*; +import java.awt.*; + +/** +* La classe ScoreView +* +* Affiche les scores des deux joueurs du jeu Avalam. +* Cette classe est purement graphique : elle ne calcule pas les scores. +*/ +public class ScoreView extends JPanel { + + //Attributs + + /** Label affichant le score du joueur jaune. */ + private JLabel scoreY; + + /** Label affichant le score du joueur rouge. */ + private JLabel scoreR; + + //Constructeur + + /** + * Construit la vue des scores. + * + * @param y score initial du joueur jaune + * @param r score initial du joueur rouge + */ + public ScoreView(int y, int r) { + setBackground(new java.awt.Color(200,200,200)); + setLayout(new FlowLayout()); + + scoreY = new JLabel("Score Jaune : " + y); + scoreR = new JLabel("Score Rouge : " + r); + + scoreY.setFont(new Font("Arial", Font.BOLD, 18)); + scoreR.setFont(new Font("Arial", Font.BOLD, 18)); + + add(scoreY); + add(new JLabel(" | ")); + add(scoreR); + } + + //Méthodes + + /** + * Met à jour l'affichage des scores. + * + * @param y nouveau score du joueur jaune + * @param r nouveau score du joueur rouge + */ + public void updateScores(int y, int r) { + scoreY.setText("Score Jaune : " + y); + scoreR.setText("Score Rouge : " + r); + } +} diff --git a/fr/iut_fbleau/Avalam/Tower.java b/fr/iut_fbleau/Avalam/Tower.java index a160bc3..6dcd39c 100644 --- a/fr/iut_fbleau/Avalam/Tower.java +++ b/fr/iut_fbleau/Avalam/Tower.java @@ -1,48 +1,99 @@ package fr.iut_fbleau.Avalam; /** - * Représente une tour dans le jeu Avalam. - * - * Une tour possède : - * - la couleur de son sommet - * - sa hauteur (nombre de pions) - */ +* La classe Tower +* +* Représente une tour dans le jeu Avalam. +* Une tour est caractérisée par : +* - une couleur (couleur du sommet) +* - une hauteur (nombre de pions empilés) +* +* Cette version est volontairement compatible avec le reste du projet : +* - constructeur Tower(Color) utilisé par BoardLoader +* - constructeur Tower(int, Color) utilisé dans d'autres parties possibles +* - méthode mergeTower(Tower) utilisée par AvalamBoard +* - méthode merge(Tower) conservée (si elle est utilisée ailleurs) +*/ public class Tower { - private Color color; + //Attributs + + /** Hauteur de la tour (nombre de pions empilés). */ private int height; - /** Nouvelle tour de hauteur 1 */ + /** Couleur du sommet de la tour (propriétaire actuel). */ + private Color color; + + //Constructeur + + /** + * Construit une tour de hauteur 1 avec la couleur donnée. + * (Constructeur attendu par BoardLoader dans ton projet.) + * + * @param color couleur du sommet + */ public Tower(Color color) { - this.color = color; - this.height = 1; + this(1, color); } - /** Tour avec couleur et hauteur existantes */ - public Tower(Color color, int height) { - this.color = color; + /** + * Construit une tour avec une hauteur et une couleur données. + * + * @param height hauteur initiale + * @param color couleur du sommet + */ + public Tower(int height, Color color) { this.height = height; + this.color = color; } - public Color getColor() { - return color; - } + //Méthodes + /** + * Retourne la hauteur de la tour. + * + * @return hauteur + */ public int getHeight() { return height; } /** - * Fusionne this (destination) avec src (source). - * La source monte sur la destination → - * - la couleur du sommet devient celle de src - * - la hauteur s’additionne - */ - public void mergeTower(Tower src) { - this.color = src.color; - this.height = this.height + src.height; + * Retourne la couleur du sommet. + * + * @return couleur + */ + public Color getColor() { + return color; } + /** + * Fusionne la tour src sur la tour courante (destination). + * La couleur du sommet devient celle de src. + * + * @param src tour source empilée sur la destination + */ + public void merge(Tower src) { + this.height += src.height; + this.color = src.color; + } + + /** + * Alias de merge() pour compatibilité avec d'autres classes. + * + * @param src tour source empilée sur la destination + */ + public void mergeTower(Tower src) { + merge(src); + } + + //Affichage + + /** + * Représentation textuelle de la tour. + * + * @return chaîne représentant la tour + */ @Override public String toString() { return color + "(" + height + ")"; diff --git a/fr/iut_fbleau/Avalam/TurnView.java b/fr/iut_fbleau/Avalam/TurnView.java new file mode 100644 index 0000000..246440c --- /dev/null +++ b/fr/iut_fbleau/Avalam/TurnView.java @@ -0,0 +1,45 @@ +package fr.iut_fbleau.Avalam; + +import javax.swing.*; +import java.awt.*; + +/** +* La classe TurnView +* +* Affiche le joueur dont c'est le tour dans le jeu Avalam. +* Cette classe est uniquement graphique. +*/ +public class TurnView extends JPanel { + + //Attributs + + /** Label affichant le joueur courant. */ + private JLabel text; + + //Constructeur + + /** + * Construit la vue du tour de jeu. + * + * @param initial message initial à afficher + */ + public TurnView(String initial) { + setBackground(new java.awt.Color(220,220,220)); + + text = new JLabel(initial); + text.setFont(new Font("Arial", Font.BOLD, 20)); + + add(text); + } + + //Méthodes + + /** + * Met à jour le texte affichant le joueur courant. + * + * @param s message à afficher + */ + public void setTurn(String s) { + text.setText(s); + } +} diff --git a/fr/iut_fbleau/Avalam/ui/HighlightLayer.java b/fr/iut_fbleau/Avalam/ui/HighlightLayer.java deleted file mode 100644 index 81513bd..0000000 --- a/fr/iut_fbleau/Avalam/ui/HighlightLayer.java +++ /dev/null @@ -1,74 +0,0 @@ -package fr.iut_fbleau.Avalam.ui; - -import javax.swing.*; -import java.awt.*; -import java.util.List; - -/** - * La classe HighlightLayer est responsable de l'affichage des - * cases de déplacement autorisées sous forme de cercles verts. - * - * Elle n'interagit pas directement avec les pièces, mais se contente - * de dessiner en arrière-plan selon une liste de positions légales. - * - * @author - * @version 1.0 - */ -public class HighlightLayer extends JPanel { - - private int xBase, yBase, spacing, size; - - /** Liste des positions jouables (cases en vert). */ - private List legalMoves; - - /** - * Constructeur. - * - * @param xBase position X de base du plateau - * @param yBase position Y de base du plateau - * @param spacing espacement entre cases - * @param size taille des pions - */ - public HighlightLayer(int xBase, int yBase, int spacing, int size) { - this.xBase = xBase; - this.yBase = yBase; - this.spacing = spacing; - this.size = size; - - setOpaque(false); - setBounds(0, 0, 800, 800); - } - - /** - * Définit la liste des cases légales à afficher. - */ - public void setLegalMoves(List moves) { - this.legalMoves = moves; - repaint(); - } - - /** - * Dessine les cercles verts autour des cases autorisées. - */ - @Override - protected void paintComponent(Graphics g) { - super.paintComponent(g); - - if (legalMoves == null) return; - - Graphics2D g2 = (Graphics2D) g; - g2.setColor(new Color(0, 255, 0, 120)); - - for (Point p : legalMoves) { - - int r = p.x; - int c = p.y; - - int x = xBase + c * spacing; - int y = yBase + r * spacing; - - int highlight = size + 20; // Cercle plus grand que le pion - g2.fillOval(x - 10, y - 10, highlight, highlight); - } - } -} diff --git a/fr/iut_fbleau/Avalam/ui/ScoreView.java b/fr/iut_fbleau/Avalam/ui/ScoreView.java deleted file mode 100644 index 494d33f..0000000 --- a/fr/iut_fbleau/Avalam/ui/ScoreView.java +++ /dev/null @@ -1,46 +0,0 @@ -package fr.iut_fbleau.Avalam.ui; - -import javax.swing.*; -import java.awt.*; - -/** - * La classe ScoreView affiche les scores actuels des deux joueurs. - * - * Elle est purement graphique : aucune logique de calcul n'est présente. - * - * @author - * @version 1.0 - */ -public class ScoreView extends JPanel { - - private JLabel scoreY, scoreR; - - /** - * Constructeur. - * - * @param y score initial du joueur jaune - * @param r score initial du joueur rouge - */ - public ScoreView(int y, int r) { - setBackground(new Color(200,200,200)); - setLayout(new FlowLayout()); - - scoreY = new JLabel("Score Jaune : " + y); - scoreR = new JLabel("Score Rouge : " + r); - - scoreY.setFont(new Font("Arial", Font.BOLD, 18)); - scoreR.setFont(new Font("Arial", Font.BOLD, 18)); - - add(scoreY); - add(new JLabel(" | ")); - add(scoreR); - } - - /** - * Met à jour l'affichage des scores. - */ - public void updateScores(int y, int r) { - scoreY.setText("Score Jaune : " + y); - scoreR.setText("Score Rouge : " + r); - } -} diff --git a/fr/iut_fbleau/Avalam/ui/TurnView.java b/fr/iut_fbleau/Avalam/ui/TurnView.java deleted file mode 100644 index 5b28c90..0000000 --- a/fr/iut_fbleau/Avalam/ui/TurnView.java +++ /dev/null @@ -1,41 +0,0 @@ -package fr.iut_fbleau.Avalam.ui; - -import javax.swing.*; -import java.awt.*; - -/** - * La classe TurnView affiche le joueur à qui c'est le tour. - * - * Elle agit comme une simple bannière d’information, - * mise à jour par la logique du jeu. - * - * @author - * @version 1.0 - */ -public class TurnView extends JPanel { - - private JLabel text; - - /** - * Constructeur. - * - * @param initial message initial à afficher - */ - public TurnView(String initial) { - setBackground(new Color(220,220,220)); - - text = new JLabel(initial); - text.setFont(new Font("Arial", Font.BOLD, 20)); - - add(text); - } - - /** - * Met à jour le texte affichant le joueur courant. - * - * @param s message à afficher - */ - public void setTurn(String s) { - text.setText(s); - } -}