ajout de la logique des règles de coups

Logique des pions et "tour"

Makefile

@@ -0,0 +1,48 @@
+# === Répertoires ===
+SRC_DIR = fr
+BIN_DIR = bin
+
+# === Recherche automatique des fichiers .java dans tous les sous-dossiers ===
+SOURCES := $(shell find $(SRC_DIR) -name "*.java")
+
+# === Classe principale ===
+MAIN_CLASS = fr.iut_fbleau.Avalam.Main
+
+# === Commandes Java ===
+JC = javac
+JCFLAGS = -d $(BIN_DIR)
+
+JAVA = java
+JAVAFLAGS = -cp $(BIN_DIR)
+
+# === Règle par défaut ===
+all: build
+
+# === Compilation ===
+build:
+	@echo "===> Compilation du projet Avalam..."
+	@mkdir -p $(BIN_DIR)
+	@$(JC) $(JCFLAGS) $(SOURCES)
+	@echo "✔ Compilation terminée."
+
+# === Exécution ===
+run:
+	@echo "===> Lancement du jeu Avalam..."
+	@$(JAVA) $(JAVAFLAGS) $(MAIN_CLASS)
+
+# === Nettoyage ===
+clean:
+	@echo "===> Suppression des fichiers compilés..."
+	@rm -rf $(BIN_DIR)
+	@echo "✔ Nettoyage complet."
+
+# === Recompile + run ===
+re: clean build run
+
+# === Génération de la Javadoc ===
+DOC_DIR = doc
+javadoc:
+	@echo "===> Génération de la Javadoc..."
+	@mkdir -p $(DOC_DIR)
+	@javadoc -d $(DOC_DIR) -sourcepath $(SRC_DIR) -subpackages fr.iut_fbleau.Avalam
+	@echo "✔ Javadoc générée dans $(DOC_DIR)/"

README.md

@@ -1,6 +1,6 @@
 # BUT3 Projet Jeu Groupe
 
-*Auteurs : AMARY Aurelien, DICK Adrien, FELIX-VIMALARATNAM Patrick, RABN Hugo*
+*Auteurs : AMARY Aurelien, DICK Adrien, FELIX-VIMALARATNAM Patrick, RABAN Hugo*
 
 Date de création : 16/10/25
 
@@ -10,20 +10,85 @@ Dans un second temps, on fera des bots le plus efficace possible (probablement u
 
 Le jeu de notre groupe est **Avalam**.
 
-## Présentation Avalam
-Sur un plateau de jeu, les joueurs dispose de 24 pions chacun. Le but est de créer des petites tours avec son pions de couleur au dessus. Pour ce faire chaque joueur déplace son pion sur une tour ou déplace une tour sur un autre pion. La personne avec le plus de pions sur le dessus de chaque tour gagne.
+## Compilation et exécution
+
+### Compilation
+```bash
+make build
+```
+
+### Exécution
+```bash
+make run
+```
+
+### Nettoyage
+```bash
+make clean
+```
+
+### Recompiler et exécuter
+```bash
+make re
+```
+
+### Générer la Javadoc
+```bash
+make javadoc
+```
+
+## Architecture du projet
+
+### Structure des classes principales
+
+- **`AvalamBoard`** : Implémentation du plateau de jeu conforme à l'API `AbstractBoard`
+  - Gère l'état du plateau (grille 9x9)
+  - Valide les règles d'Avalam
+  - Applique et annule les coups
+  - Détecte la fin de partie et calcule le résultat
+
+- **`AvalamPly`** : Représente un coup dans le jeu
+  - Stocke les coordonnées de départ et d'arrivée
+  - Stocke la hauteur de la tour source (pour l'annulation)
+
+- **`Tower`** : Représente une tour de pions
+  - Stocke la couleur du sommet et la hauteur
+
+- **`Color`** : Énumération des couleurs des joueurs
+  - COLOR1 (Jaune) et COLOR2 (Rouge)
+
+### Logique du jeu
+
+Le plateau est représenté par une grille 9x9 où chaque case contient :
+- `null` : case vide (trou)
+- `ArrayList<Integer>` : tour de pions (chaque Integer = 1 pour PLAYER1, 2 pour PLAYER2)
+
+### Règles implémentées
+
+- ✅ Validation des limites du plateau
+- ✅ Vérification que la case source n'est pas vide
+- ✅ Vérification que la case destination n'est pas vide (pas de trou)
+- ✅ Vérification que la destination est voisine (horizontal, vertical ou diagonal)
+- ✅ Vérification que la hauteur totale après déplacement ≤ 5
+- ✅ Déplacement de toute la pile (pas partiel)
+- ✅ Détection de fin de partie (plus aucun coup possible)
+- ✅ Calcul du résultat (nombre de tours possédées par chaque joueur)
+
+## Présentation [Avalam](https://escaleajeux.fr/?principal=/jeu/avaxl?)
+
+Sur un plateau de jeu, les joueurs disposent de 24 pions chacun. Le but est de créer de petites tours avec son pion de couleur au-dessus. Pour ce faire, chaque joueur déplace son pion sur une tour ou déplace une tour sur un autre pion. La personne ayant le plus de pions sur le dessus des tours gagne.
 
 ### Régles officiel :
-**Regle de base** \
+**Régle de base** \
 Chaque joueur choisit sa couleur.
 Le but du jeu est de constituer un maximum de tours de 1 à 5 pions, jamais plus, surmontées par un pion de sa couleur.
 Un joueur est le propriétaire d'une tour lorsqu'un pion de sa couleur en occupe le sommet. Un pion isolé constitue également une tour. 
 
 **Deplacements** \
-Chaque joueur en effectue un seul, dans n'importe quel sens (horizontal, vertical, diagonal) avec n'importe quel pion (ou pile de pions), quelle qu'en soit la couleur. Ce mouvement consiste à empiler le ou les pions déplacés sur un trou directement voisin déjà occupé par un ou plusieurs pions.
+Chaque joueur en effectue un seul mouvement, dans n'importe quel sens (horizontal, vertical, diagonal) avec n'importe quel pion (ou pile de pions), quelle qu'en soit la couleur. Ce mouvement consiste à empiler le ou les pions déplacés sur un trou directement voisin déjà occupé par un ou plusieurs pions.
 
 **Mouvement interdit (1)** \
-On déplace obligatoirement toute la pile se trouvant sur un troue (elle peut évidemment n'être constituée que d'un seul pion). Autrement dit, une pile de pions ne peut qu'augmenter, jamais diminuer.
+On déplace obligatoirement toute la pile se trouvant sur un trou (elle peut évidemment n'être constituée que d'un seul pion). Autrement dit, une pile de pions ne peut qu'augmenter, jamais diminuer.
 
 **Mouvement interdit (2)** \
 On ne peut jamais poser de pions sur un trou inoccupé: il le reste donc définitivement. Un pion (ou une tour) isolé de tous les cotés ne pourra donc plus changer de propriétaire.
@@ -32,3 +97,4 @@ On ne peut jamais poser de pions sur un trou inoccupé: il le reste donc défini
 Tans qu'un joueur peut effectuer un mouvement il a l'obligation de jouer, la partie ne s'achevant que lorque plus aucun déplacement n'est possible.
 On compte alors combien de pions de chaque couleur occupent le sommet des tours restantes, le vainqueur étant évidemment celui qui en totalise le plus.
 Attention! Qu'une tour comporte 1,2,... ou 5 pions, elle vaut toujours UN point.
+

fr/iut_fbleau/Avalam/AvalamPly.java

@@ -0,0 +1,129 @@
+package fr.iut_fbleau.Avalam;
+
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.Player;
+
+/**
+ * Représente un coup dans le jeu Avalam.
+ * Un coup consiste à déplacer une tour de la position (xFrom, yFrom) 
+ * vers la position (xTo, yTo).
+ * 
+ * @author AMARY Aurelien, DICK Adrien, FELIX-VIMALARATNAM Patrick, RABAN Hugo
+ * @version 1.0
+ */
+public class AvalamPly extends AbstractPly {
+    /** Coordonnée X de la case source */
+    private int xFrom;
+    /** Coordonnée Y de la case source */
+    private int yFrom;
+    /** Coordonnée X de la case destination */
+    private int xTo;
+    /** Coordonnée Y de la case destination */
+    private int yTo;
+    /** Hauteur de la tour source (utilisée pour l'annulation de coup) */
+    private int sourceHeight;
+
+    /**
+     * Constructeur par défaut d'un coup Avalam.
+     * La hauteur de la source sera définie automatiquement lors de l'application du coup.
+     * 
+     * @param joueur Le joueur qui effectue le coup
+     * @param xFrom Coordonnée X de la case source
+     * @param yFrom Coordonnée Y de la case source
+     * @param xTo Coordonnée X de la case destination
+     * @param yTo Coordonnée Y de la case destination
+     */
+    public AvalamPly(Player joueur, int xFrom, int yFrom, int xTo, int yTo) {
+        super(joueur);
+        this.xFrom = xFrom;
+        this.yFrom = yFrom;
+        this.xTo = xTo;
+        this.yTo = yTo;
+        this.sourceHeight = -1; // Sera défini lors du doPly
+    }
+
+    /**
+     * Constructeur avec hauteur de la source spécifiée.
+     * Utilisé principalement pour l'annulation de coups.
+     * 
+     * @param joueur Le joueur qui effectue le coup
+     * @param xFrom Coordonnée X de la case source
+     * @param yFrom Coordonnée Y de la case source
+     * @param xTo Coordonnée X de la case destination
+     * @param yTo Coordonnée Y de la case destination
+     * @param sourceHeight Hauteur de la tour source avant le déplacement
+     */
+    public AvalamPly(Player joueur, int xFrom, int yFrom, int xTo, int yTo, int sourceHeight) {
+        super(joueur);
+        this.xFrom = xFrom;
+        this.yFrom = yFrom;
+        this.xTo = xTo;
+        this.yTo = yTo;
+        this.sourceHeight = sourceHeight;
+    }
+
+    /**
+     * Retourne la coordonnée X de la case source.
+     * 
+     * @return La coordonnée X de la case source
+     */
+    public int getXFrom() {
+        return xFrom;
+    }
+
+    /**
+     * Retourne la coordonnée Y de la case source.
+     * 
+     * @return La coordonnée Y de la case source
+     */
+    public int getYFrom() {
+        return yFrom;
+    }
+
+    /**
+     * Retourne la coordonnée X de la case destination.
+     * 
+     * @return La coordonnée X de la case destination
+     */
+    public int getXTo() {
+        return xTo;
+    }
+
+    /**
+     * Retourne la coordonnée Y de la case destination.
+     * 
+     * @return La coordonnée Y de la case destination
+     */
+    public int getYTo() {
+        return yTo;
+    }
+
+    /**
+     * Retourne la hauteur de la tour source.
+     * 
+     * @return La hauteur de la tour source, ou -1 si non définie
+     */
+    public int getSourceHeight() {
+        return sourceHeight;
+    }
+
+    /**
+     * Définit la hauteur de la tour source.
+     * Cette méthode est appelée automatiquement lors de l'application du coup.
+     * 
+     * @param height La hauteur de la tour source
+     */
+    public void setSourceHeight(int height) {
+        this.sourceHeight = height;
+    }
+
+    @Override
+    public String toString() {
+        return "AvalamPly{" +
+                "joueur=" + getPlayer() +
+                ", from=(" + xFrom + "," + yFrom + ")" +
+                ", to=(" + xTo + "," + yTo + ")" +
+                '}';
+    }
+}
+

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -0,0 +1,42 @@
+package fr.iut_fbleau.Avalam;
+
+import fr.iut_fbleau.Avalam.logic.*;
+import fr.iut_fbleau.Avalam.ui.*;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Fenêtre principale du jeu Avalam.
+ */
+public class AvalamWindow extends JFrame {
+
+    public AvalamWindow() {
+        super("Avalam - Plateau Graphique");
+
+        setSize(750, 800);
+        setLocationRelativeTo(null);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+        Tower[][] grid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
+        GameState gs = new GameState(grid);
+        ScoreManager sm = new ScoreManager();
+
+        int y = sm.count(Color.COLOR1, grid);
+        int r = sm.count(Color.COLOR2, grid);
+
+        ScoreView scoreView = new ScoreView(y, r);
+        TurnView turnView = new TurnView("Tour du joueur : Jaune");
+
+        BoardView boardView = new BoardView(gs);
+
+        JPanel top = new JPanel(new GridLayout(2,1));
+        top.add(scoreView);
+        top.add(turnView);
+
+        add(top, BorderLayout.NORTH);
+        add(boardView, BorderLayout.CENTER);
+
+        setVisible(true);
+    }
+}

fr/iut_fbleau/Avalam/Color.java

@@ -1,6 +1,28 @@
 package fr.iut_fbleau.Avalam;
 
+/**
+ * L'énumération <code>Color</code> représente la couleur du sommet d'une tour Avalam.
+ *
+ * COLOR1 : couleur du Joueur Jaune
+ * COLOR2 : couleur du Joueur Rouge
+ *
+ * Les couleurs Swing associées peuvent être modifiées ici pour changer tout le jeu.
+ *
+ * @version 3.0
+ */
 public enum Color {
-    RED,
-    YELLOW
+
+    COLOR1(java.awt.Color.YELLOW), // Joueur Jaune
+    COLOR2(java.awt.Color.RED);    // Joueur Rouge
+
+    /** Couleur Swing associée */
+    private final java.awt.Color swingColor;
+
+    Color(java.awt.Color col) {
+        this.swingColor = col;
+    }
+
+    public java.awt.Color getSwingColor() {
+        return this.swingColor;
+    }
 }

fr/iut_fbleau/Avalam/Main.java

@@ -0,0 +1,7 @@
+package fr.iut_fbleau.Avalam;
+
+public class Main {
+    public static void main(String[] args) {
+        new AvalamWindow();
+    }
+}

fr/iut_fbleau/Avalam/Tower.java

@@ -5,8 +5,6 @@ package fr.iut_fbleau.Avalam ;
 *
 * @version 1.0
 * @author Aurélien
-* Date : 16-10-25 ; 16-10-25
-* Licence :
 */
 public class Tower {
    //Attributs
@@ -17,10 +15,12 @@ public class Tower {
    public Tower(Color color) {
       this.color = color ;
    }
+
    //Méthodes
    public Color getColor() {
       return this.color ;
    }
+
    public byte getHeight() {
       return this.height ;
    }
@@ -34,7 +34,7 @@ public class Tower {
       this.height += tower.getHeight();
    }
 
-   //Affichage
+   @Override
    public String toString() {
       return "" ;
    }

fr/iut_fbleau/Avalam/logic/BoardLoader.java

@@ -0,0 +1,60 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+import java.io.*;
+
+/**
+ * La classe <code>BoardLoader</code> est responsable du chargement d'un plateau Avalam
+ * depuis un fichier texte externe (généralement Plateau.txt).
+ *
+ * Le fichier doit contenir une matrice 9×9 de valeurs numériques séparées par des virgules :
+ * - 0 : case vide (trou)
+ * - 1 : pion appartenant au joueur COLOR1 (Jaune)
+ * - 2 : pion appartenant au joueur COLOR2 (Rouge)
+ *
+ * Aucun contrôle de cohérence avancé n'est effectué, le chargeur se contente
+ * d’interpréter les valeurs comme demandé.
+ *
+ * @author 
+ * @version 1.0
+ */
+public class BoardLoader {
+
+    /**
+     * Charge un plateau Avalam depuis un fichier.
+     *
+     * @param path chemin du fichier plateau.
+     * @return un tableau 9×9 contenant des objets <code>Tower</code> ou <code>null</code>.
+     */
+    public static Tower[][] loadFromFile(String path) {
+
+        Tower[][] grid = new Tower[9][9];
+
+        try (BufferedReader br = new BufferedReader(new FileReader(new File(path)))) {
+
+            String line;
+            int row = 0;
+
+            while ((line = br.readLine()) != null && row < 9) {
+
+                String[] parts = line.split(",");
+
+                for (int col = 0; col < 9; col++) {
+                    int v = Integer.parseInt(parts[col]);
+
+                    // Interprétation des valeurs
+                    if (v == 1) grid[row][col] = new Tower(Color.COLOR1);
+                    else if (v == 2) grid[row][col] = new Tower(Color.COLOR2);
+                    else grid[row][col] = null; // Case vide
+                }
+                row++;
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return grid;
+    }
+}

fr/iut_fbleau/Avalam/logic/GameState.java

@@ -0,0 +1,70 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+
+/**
+ * La classe <code>GameState</code> représente l'état courant du jeu Avalam :
+ * - la grille 9×9
+ * - le joueur dont c'est le tour
+ *
+ * Elle ne contient aucune logique de déplacement ni de vérification des règles ;
+ * son rôle est uniquement de stocker et de fournir l'état du jeu.
+ *
+ * @author
+ * @version 1.0
+ */
+public class GameState {
+
+    /** Grille du plateau : 9×9 tours ou cases vides. */
+    private Tower[][] grid;
+
+    /** Joueur dont c’est le tour (COLOR1 ou COLOR2). */
+    private Color currentPlayer = Color.COLOR1;
+
+    /**
+     * Constructeur.
+     *
+     * @param grid la grille initiale du plateau.
+     */
+    public GameState(Tower[][] grid) {
+        this.grid = grid;
+    }
+
+    /**
+     * Retourne la tour présente à la position (r,c), ou null.
+     */
+    public Tower get(int r, int c) {
+        return grid[r][c];
+    }
+
+    /**
+     * Retourne la grille complète.
+     */
+    public Tower[][] getGrid() {
+        return grid;
+    }
+
+    /**
+     * Retourne le joueur dont c'est le tour.
+     */
+    public Color getCurrentPlayer() {
+        return currentPlayer;
+    }
+
+    /**
+     * Change le joueur courant : COLOR1 → COLOR2 → COLOR1.
+     */
+    public void switchPlayer() {
+        currentPlayer = (currentPlayer == Color.COLOR1) ? Color.COLOR2 : Color.COLOR1;
+    }
+
+    /**
+     * Vérifie si une position (r,c) est dans les limites du plateau.
+     *
+     * @return vrai si la position est comprise dans un plateau 9×9.
+     */
+    public boolean isInside(int r, int c) {
+        return r >= 0 && r < 9 && c >= 0 && c < 9;
+    }
+}

fr/iut_fbleau/Avalam/logic/ScoreManager.java

@@ -0,0 +1,37 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+
+/**
+ * La classe <code>ScoreManager</code> gère le calcul des scores
+ * selon les règles officielles d’Avalam :
+ *
+ * Un joueur gagne 1 point par tour dont le sommet (couleur) lui appartient,
+ * indépendamment de la hauteur de la tour.
+ *
+ * Cette classe n’a aucune responsabilité autre que compter.
+ *
+ * @author
+ * @version 1.0
+ */
+public class ScoreManager {
+
+    /**
+     * Compte le nombre de tours dont le sommet appartient à la couleur donnée.
+     *
+     * @param c     couleur du joueur (COLOR1 ou COLOR2)
+     * @param grid  grille 9×9 contenant des tours ou null
+     * @return score du joueur
+     */
+    public static int count(Color c, Tower[][] grid) {
+        int score = 0;
+
+        for (int i = 0; i < 9; i++)
+            for (int j = 0; j < 9; j++)
+                if (grid[i][j] != null && grid[i][j].getColor() == c)
+                    score++;
+
+        return score;
+    }
+}

fr/iut_fbleau/Avalam/logic/TurnManager.java

@@ -0,0 +1,35 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+
+/**
+ * La classe <code>TurnManager</code> gère le déroulement des tours d’Avalam.
+ *
+ * Son rôle est simple :
+ * - identifier le joueur dont c’est le tour
+ * - passer au joueur suivant
+ *
+ * Elle ne contient pas de logique de mouvement, ni de validation.
+ *
+ * @author
+ * @version 1.0
+ */
+public class TurnManager {
+
+    /** Joueur dont c'est le tour (COLOR1 commence la partie). */
+    private Color current = Color.COLOR1;
+
+    /**
+     * Retourne le joueur actuel.
+     */
+    public Color getPlayer() {
+        return current;
+    }
+
+    /**
+     * Passe au joueur suivant.
+     */
+    public void next() {
+        current = (current == Color.COLOR1) ? Color.COLOR2 : Color.COLOR1;
+    }
+}

fr/iut_fbleau/Avalam/ui/BoardView.java

@@ -0,0 +1,84 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import fr.iut_fbleau.Avalam.logic.GameState;
+
+import javax.swing.*;
+
+/**
+ * La classe <code>BoardView</code> représente l'affichage complet du plateau Avalam.
+ * Elle s’appuie sur une architecture en couches (layered pane) pour séparer proprement :
+ *
+ * <ul>
+ *     <li><b>HighlightLayer</b> : les cases jouables mises en surbrillance</li>
+ *     <li><b>PieceLayer</b> : les pions affichés sous forme de boutons ronds</li>
+ * </ul>
+ *
+ * La vue ne contient pas la logique de jeu : elle la délègue entièrement
+ * à un <code>InteractionController</code>.
+ *
+ * @author
+ * @version 1.0
+ */
+public class BoardView extends JLayeredPane {
+
+    /** Taille des pions affichés. */
+    private final int size = 50;
+
+    /** Distance entre deux cases de la grille. */
+    private final int spacing = 70;
+
+    /** Décalages pour centrer l'affichage. */
+    private final int xBase = 60, yBase = 60;
+
+    /** Accès à l'état du jeu. */
+    private GameState state;
+
+    /** Couche d'affichage des ronds verts. */
+    private HighlightLayer highlightLayer;
+
+    /** Couche d'affichage des pions. */
+    private PieceLayer pieceLayer;
+
+    /** Gestionnaire d'interactions utilisateur. */
+    private InteractionController controller;
+
+    /**
+     * Constructeur de la vue du plateau.
+     *
+     * @param state l'état du jeu Avalam
+     */
+    public BoardView(GameState state) {
+        this.state = state;
+        setLayout(null);
+
+        controller = new InteractionController(state);
+
+        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
+        pieceLayer = new PieceLayer();
+
+        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
+        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
+
+        refresh();
+    }
+
+    /**
+     * Met à jour l'affichage des couches en fonction de l'état actuel du jeu.
+     */
+    public void refresh() {
+
+        pieceLayer.displayGrid(
+            state.getGrid(),
+            xBase, yBase, spacing, size,
+
+            // Callback appelé lorsqu’un pion est cliqué
+            (r, c) -> {
+                controller.onPieceClicked(r, c);
+                highlightLayer.setLegalMoves(controller.getLegalMoves());
+                highlightLayer.repaint();
+            }
+        );
+
+        highlightLayer.repaint();
+    }
+}

fr/iut_fbleau/Avalam/ui/HighlightLayer.java

@@ -0,0 +1,74 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.List;
+
+/**
+ * La classe <code>HighlightLayer</code> 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<Point> 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<Point> 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);
+        }
+    }
+}

fr/iut_fbleau/Avalam/ui/InteractionController.java

@@ -0,0 +1,116 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import fr.iut_fbleau.Avalam.Tower;
+import fr.iut_fbleau.Avalam.logic.GameState;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * La classe <code>InteractionController</code> gère entièrement
+ * la logique d'interaction de l'utilisateur :
+ *
+ * <ul>
+ *     <li>Sélection d'un pion</li>
+ *     <li>Annulation de la sélection</li>
+ *     <li>Calcul des cases de déplacement légales</li>
+ * </ul>
+ *
+ * Aucun affichage n'est réalisé ici ; la vue (BoardView) récupère
+ * simplement les données calculées pour les afficher.
+ *
+ * @author
+ * @version 1.0
+ */
+public class InteractionController {
+
+    private GameState state;
+
+    /** Position du pion sélectionné (ou -1 s'il n'y en a pas). */
+    private int selectedRow = -1, selectedCol = -1;
+
+    /** Liste des déplacements possibles depuis la sélection. */
+    private List<Point> legalMoves = new ArrayList<>();
+
+    /**
+     * Constructeur.
+     *
+     * @param state état du jeu à manipuler
+     */
+    public InteractionController(GameState state) {
+        this.state = state;
+    }
+
+    /**
+     * Retourne les cases jouables calculées.
+     */
+    public List<Point> getLegalMoves() {
+        return legalMoves;
+    }
+
+    /**
+     * Gère le clic sur un pion donné.
+     *
+     * @param r ligne de la case cliquée
+     * @param c colonne de la case cliquée
+     */
+    public void onPieceClicked(int r, int c) {
+
+        Tower t = state.get(r, c);
+        if (t == null) return;
+
+        // Annulation si on reclique la sélection
+        if (r == selectedRow && c == selectedCol) {
+            selectedRow = -1;
+            selectedCol = -1;
+            legalMoves.clear();
+            return;
+        }
+
+        // Interdiction de jouer le pion adverse
+        if (t.getColor() != state.getCurrentPlayer()) {
+            selectedRow = -1;
+            selectedCol = -1;
+            legalMoves.clear();
+            return;
+        }
+
+        selectedRow = r;
+        selectedCol = c;
+
+        computeLegalMoves();
+    }
+
+    /**
+     * Calcule toutes les cases accessibles à partir du pion sélectionné.
+     */
+    private void computeLegalMoves() {
+
+        legalMoves.clear();
+
+        Tower[][] grid = state.getGrid();
+        Tower src = grid[selectedRow][selectedCol];
+        int h = src.getHeight();
+
+        int[] d = {-1, 0, 1};
+
+        for (int dr : d) {
+            for (int dc : d) {
+
+                if (dr == 0 && dc == 0) continue;
+
+                int nr = selectedRow + dr;
+                int nc = selectedCol + dc;
+
+                if (!state.isInside(nr, nc)) continue;
+
+                Tower dest = grid[nr][nc];
+                if (dest == null) continue;
+                if (h + dest.getHeight() > 5) continue;
+
+                legalMoves.add(new Point(nr, nc));
+            }
+        }
+    }
+}

fr/iut_fbleau/Avalam/ui/PieceButton.java

@@ -0,0 +1,90 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * La classe <code>PieceButton</code> représente graphiquement une tour Avalam.
+ * Il s'agit d'un bouton rond :
+ *
+ * <ul>
+ *     <li>coloré selon le joueur</li>
+ *     <li>affichant sa hauteur</li>
+ *     <li>avec un effet de survol visuel</li>
+ * </ul>
+ *
+ * Ce composant sert d'interaction principale pour cliquer les pions.
+ *
+ * @author
+ * @version 1.0
+ */
+public class PieceButton extends JButton {
+
+    private Color color;
+    private int height;
+    private boolean hover = false;
+
+    /** Position de la tour sur la grille. */
+    public final int row, col;
+
+    /**
+     * Constructeur.
+     *
+     * @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;
+        this.row = row;
+        this.col = col;
+
+        setBorderPainted(false);
+        setContentAreaFilled(false);
+        setFocusPainted(false);
+        setOpaque(false);
+
+        addMouseListener(new java.awt.event.MouseAdapter() {
+            @Override public void mouseEntered(java.awt.event.MouseEvent e) { hover = true; repaint(); }
+            @Override public void mouseExited (java.awt.event.MouseEvent e) { hover = false; repaint(); }
+        });
+    }
+
+    /**
+     * Dessine le pion rond ainsi que son chiffre au centre.
+     */
+    @Override
+    protected void paintComponent(Graphics g) {
+        Graphics2D g2 = (Graphics2D) g.create();
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        // Couleur foncée lorsque survolé
+        g2.setColor(hover ? color.darker() : color);
+        g2.fillOval(0, 0, getWidth(), getHeight());
+
+        // Hauteur affichée au centre
+        g2.setColor(java.awt.Color.BLACK);
+        g2.setFont(new Font("Arial", Font.BOLD, 18));
+
+        String txt = String.valueOf(height);
+        FontMetrics fm = g2.getFontMetrics();
+
+        int x = (getWidth() - fm.stringWidth(txt)) / 2;
+        int y = (getHeight() + fm.getAscent()) / 2 - 3;
+
+        g2.drawString(txt, x, y);
+        g2.dispose();
+    }
+
+    /**
+     * Rend le bouton réellement rond (zone cliquable circulaire).
+     */
+    @Override
+    public boolean contains(int x, int y) {
+        double dx = x - getWidth()/2.0;
+        double dy = y - getHeight()/2.0;
+        return dx*dx + dy*dy <= (getWidth()/2.0)*(getWidth()/2.0);
+    }
+}

fr/iut_fbleau/Avalam/ui/PieceLayer.java

@@ -0,0 +1,77 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import fr.iut_fbleau.Avalam.Tower;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * La classe <code>PieceLayer</code> gère l'affichage des pions
+ * (sous forme de <code>PieceButton</code>) sur la grille.
+ *
+ * Elle s'occupe uniquement :
+ * <ul>
+ *     <li>d'afficher les pièces</li>
+ *     <li>de positionner correctement les boutons</li>
+ *     <li>d'attacher un callback à chaque clic</li>
+ * </ul>
+ *
+ * Aucune logique de jeu n'est réalisée ici.
+ *
+ * @author
+ * @version 1.0
+ */
+public class PieceLayer extends JPanel {
+
+    /**
+     * Constructeur.
+     * Initialise un panneau transparent prêt à recevoir des pions.
+     */
+    public PieceLayer() {
+        setLayout(null);
+        setOpaque(false);
+        setBounds(0, 0, 800, 800);
+    }
+
+    /**
+     * 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
+     */
+    public void displayGrid(Tower[][] grid, int xBase, int yBase,
+                            int spacing, int size,
+                            java.util.function.BiConsumer<Integer, Integer> clickCallback) {
+
+        removeAll();
+
+        for (int r = 0; r < 9; r++) {
+            for (int c = 0; c < 9; c++) {
+
+                Tower t = grid[r][c];
+                if (t != null) {
+
+                    PieceButton pb = new PieceButton(
+                        t.getColor().getSwingColor(),
+                        t.getHeight(),
+                        r, c
+                    );
+
+                    pb.setBounds(xBase + c * spacing, yBase + r * spacing, size, size);
+
+                    int fr = r, fc = c;
+                    pb.addActionListener(e -> clickCallback.accept(fr, fc));
+
+                    add(pb);
+                }
+            }
+        }
+
+        revalidate();
+        repaint();
+    }
+}

fr/iut_fbleau/Avalam/ui/ScoreView.java

@@ -0,0 +1,46 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * La classe <code>ScoreView</code> 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);
+    }
+}

fr/iut_fbleau/Avalam/ui/TurnView.java

@@ -0,0 +1,41 @@
+package fr.iut_fbleau.Avalam.ui;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * La classe <code>TurnView</code> 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);
+    }
+}

fr/iut_fbleau/AvalamTests/TestTower.java

@@ -1,28 +0,0 @@
-package fr.iut_fbleau.AvalamTests ;
-
-import fr.iut_fbleau.Avalam.Tower ;
-import fr.iut_fbleau.Avalam.Color ;
-
-/**
-* La classe <code>TestPion</code>
-*
-* @version 1.0
-* @author Aurélien
-* Date :  16-10-25 ; 16-10-25
-* Licence :
-*/
-public class TestTower {
-   public static void main(String[] args){
-      Tower t1 = new Tower(Color.RED);
-      Tower t2 = new Tower(Color.YELLOW);
-
-      System.out.println("Vérification données :");
-      System.out.println("RED = " + t1.getColor());
-      System.out.println("1 = " + t1.getHeight());
-
-      System.out.println("\nVérification empilement :");
-      t1.mergeTower(t2);
-      System.out.println("YELLOW = " + t1.getColor());
-      System.out.println("2 = " + t1.getHeight());
-   }
-}

fr/iut_fbleau/Res/Plateau.txt

@@ -0,0 +1,9 @@
+0,0,1,2,0,0,0,0,0
+0,1,2,1,2,0,0,0,0
+0,2,1,2,1,2,1,0,0
+0,1,2,1,2,1,2,1,2
+1,2,1,2,0,2,1,2,1
+2,1,2,1,2,1,2,1,0
+0,0,1,2,1,2,1,2,0
+0,0,0,0,2,1,2,1,0
+0,0,0,0,0,2,1,0,0