Makefile

@@ -1,41 +1,40 @@
-# Répertoires
+# === Répertoires ===
-SRC_DIR = .
+SRC_DIR = fr
 BIN_DIR = bin
 
-# Trouve tous les fichiers .java
+# === Recherche automatique des fichiers .java dans tous les sous-dossiers ===
 SOURCES := $(shell find $(SRC_DIR) -name "*.java")
 
-# Classe principale
+# === Classe principale ===
-MAIN = fr.iut_fbleau.Avalam.Main
+MAIN_CLASS = fr.iut_fbleau.Avalam.Main
 
-# Options javac
+# === Commandes Java ===
 JC = javac
 JCFLAGS = -d $(BIN_DIR)
 
-# Options java
 JAVA = java
 JAVAFLAGS = -cp $(BIN_DIR)
 
-# Règle par défaut
+# === Règle par défaut ===
 all: build
 
-# Compilation
+# === Compilation ===
 build:
-	@echo "Compilation du projet..."
+	@echo "===> Compilation du projet Avalam..."
 	@mkdir -p $(BIN_DIR)
 	@$(JC) $(JCFLAGS) $(SOURCES)
-	@echo "✔ Compilation terminée !"
+	@echo "✔ Compilation terminée."
 
-# Exécution
+# === Exécution ===
 run:
-	@echo "Lancement du jeu Avalam..."
+	@echo "===> Lancement du jeu Avalam..."
-	@$(JAVA) $(JAVAFLAGS) $(MAIN)
+	@$(JAVA) $(JAVAFLAGS) $(MAIN_CLASS)
 
-# Nettoyage des .class
+# === Nettoyage ===
 clean:
-	@echo "Suppression des fichiers compilés..."
+	@echo "===> Suppression des fichiers compilés..."
 	@rm -rf $(BIN_DIR)
-	@echo "✔ Nettoyage terminé !"
+	@echo "✔ Nettoyage complet."
 
-# Recompile + run
+# === Recompile + run ===
-re: clean all run
+re: clean build run

README.md

@@ -21,7 +21,7 @@ Le but du jeu est de constituer un maximum de tours de 1 à 5 pions, jamais plus
 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 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.

fr/iut_fbleau/Avalam/AvalamPanel.java

@@ -1,184 +0,0 @@
-package fr.iut_fbleau.Avalam;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.*;
-import java.io.*;
-
-/**
- * La classe <code>AvalamPanel</code> gère l'affichage graphique du plateau Avalam.
- *
- * Elle a pour rôle :
- *  - de charger la configuration initiale du plateau depuis le fichier Plateau.txt
- *  - d'afficher les pions sous forme de boutons ronds cliquables
- *  - de gérer leur positionnement visuel sur une fenêtre Swing
- *
- * À ce stade, les clics ne modifient pas le modèle (aucune règle appliquée),
- * ils servent seulement à confirmer que la sélection fonctionne.
- *
- * @version 1.0
- * @author ---
- */
-public class AvalamPanel extends JPanel {
-
-    /** Grille du plateau contenant des objets Tower ou null (case vide). */
-    private Tower[][] grid = new Tower[9][9];
-
-    /** Taille visuelle d’un pion. */
-    private final int pionTaille = 50;
-
-    /** Distance entre deux pions. */
-    private final int pas = 70;
-
-    /** Décalage horizontal pour centrer le plateau. */
-    private final int xBase = 60;
-
-    /** Décalage vertical pour centrer le plateau. */
-    private final int yBase = 60;
-
-    /**
-     * Constructeur.
-     * Initialise le layout, charge le plateau et affiche les pions.
-     */
-    public AvalamPanel() {
-        setLayout(null);
-        chargerPlateau();
-        afficherPions();
-    }
-
-    /**
-     * Charge la grille du plateau depuis le fichier Plateau.txt (matrice du plateau).
-     *
-     * 0 → case vide
-     * 1 → pion du joueur 1 (couleur YELLOW)
-     * 2 → pion du joueur 2 (couleur RED)
-     */
-    private void chargerPlateau() {
-        try {
-            File f = new File("fr/iut_fbleau/Res/Plateau.txt");
-            BufferedReader br = new BufferedReader(new FileReader(f));
-
-            String line;
-            int row = 0;
-
-            while ((line = br.readLine()) != null && row < 9) {
-                String[] parts = line.split(",");
-                for (int col = 0; col < 9; col++) {
-                    int valeur = Integer.parseInt(parts[col]);
-
-                    if (valeur == 1) grid[row][col] = new Tower(Color.YELLOW);
-                    else if (valeur == 2) grid[row][col] = new Tower(Color.RED);
-                    else grid[row][col] = null;
-                }
-                row++;
-            }
-
-            br.close();
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * Ajoute graphiquement les pions sur le plateau.
-     * Chaque pion est représenté par un bouton rond Swing.
-     */
-    private void afficherPions() {
-        for (int i = 0; i < 9; i++) {
-            for (int j = 0; j < 9; j++) {
-                Tower t = grid[i][j];
-
-                if (t != null) {
-
-                    // Conversion couleur Avalam → couleur Swing
-                    java.awt.Color swingColor = t.getColor().getSwingColor();
-
-                    JButton pion = creerBoutonRond(swingColor);
-
-                    int x = xBase + j * pas;
-                    int y = yBase + i * pas;
-                    pion.setBounds(x, y, pionTaille, pionTaille);
-
-                    int finalI = i;
-                    int finalJ = j;
-
-                    // !!!TEMPORAIRE!!! permet de voir quel endroit cliqué
-                    pion.addActionListener(e ->
-                        JOptionPane.showMessageDialog(null,
-                                "Tu as cliqué sur (" + finalI + ", " + finalJ + ")")
-                    );
-
-                    add(pion);
-                }
-            }
-        }
-    }
-
-    /**
-     * Crée un bouton rond représentant un pion.
-     *
-     * Un effet d'assombrissement est appliqué au survol pour un meilleur feedback visuel.
-     *
-     * @param couleurSwing la couleur Swing du pion
-     * @return un bouton circulaire
-     */
-    private JButton creerBoutonRond(java.awt.Color couleurSwing) {
-
-        JButton bouton = new JButton() {
-
-            /** Indique si la souris survole le bouton. */
-            private boolean hover = false;
-
-            {
-                setBorderPainted(false);
-                setContentAreaFilled(false);
-                setFocusPainted(false);
-                setOpaque(false);
-
-                // Gestion du survol
-                addMouseListener(new MouseAdapter() {
-                    @Override
-                    public void mouseEntered(MouseEvent e) {
-                        hover = true;
-                        repaint();
-                    }
-
-                    @Override
-                    public void mouseExited(MouseEvent e) {
-                        hover = false;
-                        repaint();
-                    }
-                });
-            }
-
-            /**
-             * Dessine le pion sous forme de cercle.
-             */
-            @Override
-            protected void paintComponent(Graphics g) {
-                Graphics2D g2 = (Graphics2D) g.create();
-                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                                    RenderingHints.VALUE_ANTIALIAS_ON);
-
-                g2.setColor(hover ? couleurSwing.darker() : couleurSwing);
-                g2.fillOval(0, 0, getWidth(), getHeight());
-
-                g2.dispose();
-            }
-
-            /**
-             * Rend le clique précis au cercle (pas carré).
-             */
-            @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);
-            }
-        };
-
-        bouton.setPreferredSize(new Dimension(pionTaille, pionTaille));
-        return bouton;
-    }
-}

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -1,29 +1,41 @@
 package fr.iut_fbleau.Avalam;
 
+import fr.iut_fbleau.Avalam.logic.*;
+import fr.iut_fbleau.Avalam.ui.*;
+
 import javax.swing.*;
+import java.awt.*;
 
 /**
- * La classe <code>AvalamWindow</code> représente la fenêtre principale du jeu Avalam.
+ * Fenêtre principale du jeu Avalam.
- *
- * Elle crée une fenêtre Swing, lui donne une taille, un titre,
- * puis y ajoute un <code>AvalamPanel</code> qui contient l'affichage réel du plateau.
- *
- * @version 1.0
  */
 public class AvalamWindow extends JFrame {
 
-    /**
-     * Constructeur : initialise la fenêtre du jeu.
-     */
     public AvalamWindow() {
         super("Avalam - Plateau Graphique");
 
-        setSize(750, 750);
+        setSize(750, 800);
         setLocationRelativeTo(null);
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
-        // Ajout du panneau contenant le plateau
+        Tower[][] grid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
-        add(new AvalamPanel());
+        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

@@ -3,30 +3,25 @@ package fr.iut_fbleau.Avalam;
 /**
  * L'énumération <code>Color</code> représente la couleur du sommet d'une tour Avalam.
  *
- * Chaque valeur contient directement sa couleur Swing associée,
+ * COLOR1 : couleur du Joueur Jaune
- * ce qui évite les conversions dans le code graphique.
+ * COLOR2 : couleur du Joueur Rouge
  *
- * @version 2.0
+ * Les couleurs Swing associées peuvent être modifiées ici pour changer tout le jeu.
+ *
+ * @version 3.0
  */
 public enum Color {
 
-    RED(java.awt.Color.RED),
+    COLOR1(java.awt.Color.YELLOW), // Joueur Jaune
-    YELLOW(java.awt.Color.YELLOW);
+    COLOR2(java.awt.Color.RED);    // Joueur Rouge
 
-    /** Couleur Swing associée à la couleur Avalam. */
+    /** Couleur Swing associée */
     private final java.awt.Color swingColor;
 
-    /**
-     * Constructeur interne de l’énumération.
-     * @param col couleur Swing associée.
-     */
     Color(java.awt.Color col) {
         this.swingColor = col;
     }
 
-    /**
-     * Retourne la couleur Swing (java.awt.Color) associée.
-     */
     public java.awt.Color getSwingColor() {
         return this.swingColor;
     }

fr/iut_fbleau/Avalam/Main.java

@@ -1,15 +1,5 @@
 package fr.iut_fbleau.Avalam;
 
-import fr.iut_fbleau.Avalam.AvalamWindow;
-
-/**
- * Classe principale lançant le programme Avalam.
- *
- * Le point d'entrée du programme crée simplement une fenêtre AvalamWindow,
- * qui initialise l'affichage du jeu.
- *
- * @version 1.0
- */
 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());
-   }
-}