Plateau graphique v2 *score,tourJoueur,tailleTour,selection* + maj makefile,readme

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.
- *
- * 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
+ * Fenêtre principale du jeu Avalam.
  */
 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
-        add(new AvalamPanel());
+        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

@@ -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,
- * ce qui évite les conversions dans le code graphique.
+ * COLOR1 : couleur du Joueur Jaune
+ * 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),
-    YELLOW(java.awt.Color.YELLOW);
+    COLOR1(java.awt.Color.YELLOW), // Joueur Jaune
+    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);
+    }
+}