Ajout de la commande de test au ReadMe + légères corrections de langue

Makefile

@@ -1,3 +1,6 @@
+# === Environnements ===
+TEST_ENV = "bin:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
+
 # === Répertoires ===
 SRC_DIR = fr
 BIN_DIR = bin
@@ -12,12 +15,16 @@ SOURCES := $(shell find $(SRC_DIR) -name "*.java")
 # === Classe principale ===
 MAIN_CLASS = fr.iut_fbleau.Avalam.Main
 
+# === Classe de test ===
+TEST_CLASS = fr.iut_fbleau.Tests.AvalamBoardTest
+
 # === Commandes Java ===
 JC = javac
-JCFLAGS = -d $(BIN_DIR)
+JCFLAGS = -d $(BIN_DIR) -cp $(TEST_ENV)
 
 JAVA = java
 JAVAFLAGS = -cp $(BIN_DIR)
+JAVAFLAGS_TESTS = -cp $(TEST_ENV)
 
 # === Règle par défaut ===
 all: build
@@ -43,6 +50,12 @@ run:
 	@echo "===> Lancement du jeu Avalam..."
 	@$(JAVA) $(JAVAFLAGS) $(MAIN_CLASS)
 
+# === Tests ===
+test:
+	@echo "===> Lancement des tests..."
+	@$(JAVA) $(JAVAFLAGS_TESTS) org.junit.runner.JUnitCore $(TEST_CLASS)
+	@echo "... Fin des tests."
+
 # === Nettoyage ===
 clean:
 	@echo "===> Suppression des fichiers compilés..."

README.md

@@ -4,9 +4,11 @@
 
 Date de création : 16/10/25
 
-Le but est de mettre en oeuvre des jeux plus intéressants que le jeu de Nim, toujours en suivant l'API.
+Date de rendu : 06/02/26
 
-Dans un second temps, on fera des bots le plus efficace possible (probablement un alpha beta avec cut-off plus fonction d'évaluation qui peut être faite à la main ou par MonteCarlo).
+Le but est de mettre en oeuvre un jeu plus intéressants que le jeu de Nim, en suivant l'API de Florent Madelaine.
+
+Dans un second temps, nous développerons des bots les plus efficaces possible, probablement en utilisant un algorithme alpha-bêta avec cut-off et une fonction d'évaluation réalisé à la main ou par MonteCarlo.
 
 Le jeu de notre groupe est **Avalam**.
 
@@ -17,6 +19,11 @@ Le jeu de notre groupe est **Avalam**.
 make build
 ```
 
+### Tests
+```bash
+make test
+```
+
 ### Exécution
 ```bash
 make run
@@ -78,13 +85,13 @@ Le plateau est représenté par une grille 9x9 où chaque case contient :
 
 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 :
+### Règles officielles :
 **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** \
+**Déplacements** \
 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)** \

fr/iut_fbleau/Avalam/BackgroundLayer.java

@@ -0,0 +1,37 @@
+package fr.iut_fbleau.Avalam;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+* La classe <code>BackgroundLayer</code>
+* 
+* Sous composant de BoardView affichant l’image de fond.
+*/
+public class BackgroundLayer extends JComponent {
+    private Image img;
+
+    /**
+    * Construit une couche de fond.
+    *
+    * @param resourcePath chemin de l'image de fond
+    */
+    public BackgroundLayer(String resourcePath) {
+        img = Toolkit.getDefaultToolkit().getImage(
+                getClass().getClassLoader().getResource(resourcePath)
+        );
+    }
+
+    /**
+    * Dessine l'image de fond.
+    *
+    * @param g contexte graphique
+    */
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        if (img != null) {
+            g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
+        }
+    }
+}

fr/iut_fbleau/Avalam/BoardView.java

@@ -1,192 +1,159 @@
-package fr.iut_fbleau.Avalam;
+package fr.iut_fbleau.Avalam;
-
+
-import javax.swing.*;
+import javax.swing.*;
-import java.awt.*;
+import java.awt.*;
-
+
-/**
+/**
-* La classe <code>BoardView</code>
+* La classe <code>BoardView</code>
-*
+*
-* Représente la vue principale du plateau Avalam.
+* Représente la vue principale du plateau Avalam.
-* Elle gère :
+* Elle gère :
-* - l’affichage des tours (PieceLayer)
+* - l’affichage des tours (PieceLayer)
-* - l’affichage des coups possibles (HighlightLayer)
+* - l’affichage des coups possibles (HighlightLayer)
-* - l’affichage du fond graphique
+* - l’affichage du fond graphique (BackgroundLayer)
-* - les clics via InteractionController
+* - les clics via InteractionController
-*
+*
-* Cette classe ne contient aucune logique de règles du jeu.
+* Cette classe ne contient aucune logique de règles du jeu.
-*
+*
-* @version 1.0
+* @version 1.0
-* Date :
+* Date :
-* Licence :
+* Licence :
-*/
+*/
-public class BoardView extends JLayeredPane {
+public class BoardView extends JLayeredPane {
-
+
-    //Attributs
+    //Attributs
-
+
-    /** Référence au moteur Avalam. */
+    /** Référence au moteur Avalam. */
-    private AvalamBoard board;
+    private AvalamBoard board;
-
+
-    /** Couche d’affichage du fond. */
+    /** Couche d’affichage du fond. */
-    private BackgroundLayer backgroundLayer;
+    private BackgroundLayer backgroundLayer;
-
+
-    /** Couche d’affichage des coups possibles. */
+    /** Couche d’affichage des coups possibles. */
-    private HighlightLayer highlightLayer;
+    private HighlightLayer highlightLayer;
-
+
-    /** Couche d’affichage des pièces. */
+    /** Couche d’affichage des pièces. */
-    private PieceLayer pieceLayer;
+    private PieceLayer pieceLayer;
-
+
-    /** Contrôleur des interactions. */
+    /** Contrôleur des interactions. */
-    private InteractionController controller;
+    private InteractionController controller;
-
+
-    /** Taille d’un pion en pixels. */
+    /** Taille d’un pion en pixels. */
-    private final int size = 50;
+    private final int size = 50;
-
+
-    /** Espacement entre les cases. */
+    /** Espacement entre les cases. */
-    private final int spacing = 70;
+    private final int spacing = 70;
-
+
-    /** Décalage horizontal du plateau. */
+    /** Décalage horizontal du plateau. */
-    private final int xBase = 60;
+    private final int xBase = 60;
-
+
-    /** Décalage vertical du plateau. */
+    /** Décalage vertical du plateau. */
-    private final int yBase = 60;
+    private final int yBase = 60;
-
+
-    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
+    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
-    private Runnable boardUpdateCallback;
+    private Runnable boardUpdateCallback;
-
+
-    //Constructeur
+    //Constructeur
-
+
-    /**
+    /**
-    * Construit la vue du plateau.
+    * Construit la vue du plateau.
-    *
+    *
-    * @param board moteur du jeu
+    * @param board moteur du jeu
-    * @param boardUpdateCallback callback à appeler après un coup
+    * @param boardUpdateCallback callback à appeler après un coup
-    */
+    */
-    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
+    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
-        this.board = board;
+        this.board = board;
-        this.boardUpdateCallback = boardUpdateCallback;
+        this.boardUpdateCallback = boardUpdateCallback;
-
+
-        setLayout(null);
+        setLayout(null);
-
+
-        // Contrôleur
+        // Contrôleur
-        this.controller = new InteractionController(board, this);
+        this.controller = new InteractionController(board, this);
-
+
-        // Couche fond
+        // Couche fond
-        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
+        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
-        backgroundLayer.setBounds(0, 0, 725, 725);
+        backgroundLayer.setBounds(0, 0, 725, 725);
-        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);
+        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);
-
+
-        // Couche highlight
+        // Couche highlight
-        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
+        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
-        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
+        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
-
+
-        // Couche pièces
+        // Couche pièces
-        pieceLayer = new PieceLayer();
+        pieceLayer = new PieceLayer();
-        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
+        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
-
+
-        setPreferredSize(new Dimension(725, 725));
+        setPreferredSize(new Dimension(725, 725));
-
+
-        refresh();
+        refresh();
-    }
+    }
-
+
-    //Méthodes
+    //Méthodes
-
+
-    /**
+    /**
-    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
+    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
-    *
+    *
-    * @return contrôleur
+    * @return contrôleur
-    */
+    */
-    public InteractionController getController() {
+    public InteractionController getController() {
-        return controller;
+        return controller;
-    }
+    }
-
+
-    /**
+    /**
-    * Active/désactive les interactions utilisateur sur le plateau.
+    * Active/désactive les interactions utilisateur sur le plateau.
-    * Utile pendant l'animation du bot pour éviter des clics concurrents.
+    * Utile pendant l'animation du bot pour éviter des clics concurrents.
-    *
+    *
-    * @param enabled true pour activer, false pour désactiver
+    * @param enabled true pour activer, false pour désactiver
-    */
+    */
-    public void setInteractionEnabled(boolean enabled) {
+    public void setInteractionEnabled(boolean enabled) {
-        // Désactive la couche des pièces (boutons) principalement
+        // Désactive la couche des pièces (boutons) principalement
-        pieceLayer.setEnabled(enabled);
+        pieceLayer.setEnabled(enabled);
-        for (Component c : pieceLayer.getComponents()) {
+        for (Component c : pieceLayer.getComponents()) {
-            c.setEnabled(enabled);
+            c.setEnabled(enabled);
-        }
+        }
-    }
+    }
-
+
-    /**
+    /**
-    * Appelé par le contrôleur après un coup.
+    * Appelé par le contrôleur après un coup.
-    */
+    */
-    public void onBoardUpdated() {
+    public void onBoardUpdated() {
-        if (boardUpdateCallback != null) {
+        if (boardUpdateCallback != null) {
-            boardUpdateCallback.run();
+            boardUpdateCallback.run();
-        }
+        }
-    }
+    }
-
+
-    /**
+    /**
-    * Rafraîchit les couches visuelles.
+    * Rafraîchit les couches visuelles.
-    */
+    */
-    public void refresh() {
+    public void refresh() {
-
+
-        pieceLayer.displayGrid(
+        pieceLayer.displayGrid(
-                boardGrid(),
+                boardGrid(),
-                xBase, yBase, spacing, size,
+                xBase, yBase, spacing, size,
-                (r, c) -> controller.onPieceClicked(r, c)
+                (r, c) -> controller.onPieceClicked(r, c)
-        );
+        );
-
+
-        highlightLayer.setLegalMoves(controller.getLegalMoves());
+        highlightLayer.setLegalMoves(controller.getLegalMoves());
-
+
-        backgroundLayer.repaint();
+        backgroundLayer.repaint();
-        highlightLayer.repaint();
+        highlightLayer.repaint();
-        pieceLayer.repaint();
+        pieceLayer.repaint();
-        repaint();
+        repaint();
-    }
+    }
-
+
-    /**
+    /**
-    * Récupère la grille depuis le moteur.
+    * Récupère la grille depuis le moteur.
-    *
+    *
-    * @return grille 9x9 de tours
+    * @return grille 9x9 de tours
-    */
+    */
-    private Tower[][] boardGrid() {
+    private Tower[][] boardGrid() {
-        Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
+        Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
-
+
-        for (int r = 0; r < AvalamBoard.SIZE; r++) {
+        for (int r = 0; r < AvalamBoard.SIZE; r++) {
-            for (int c = 0; c < AvalamBoard.SIZE; c++) {
+            for (int c = 0; c < AvalamBoard.SIZE; c++) {
-                grid[r][c] = board.getTowerAt(r, c);
+                grid[r][c] = board.getTowerAt(r, c);
-            }
+            }
-        }
+        }
-        return grid;
+        return grid;
-    }
+    }
-
+}
-    //Affichage
-
-    /**
-    * Composant affichant l’image de fond.
-    */
-    private static class BackgroundLayer extends JComponent {
-        private Image img;
-
-        /**
-        * Construit une couche de fond.
-        *
-        * @param resourcePath chemin de l'image de fond
-        */
-        public BackgroundLayer(String resourcePath) {
-            img = Toolkit.getDefaultToolkit().getImage(
-                    getClass().getClassLoader().getResource(resourcePath)
-            );
-        }
-
-        /**
-        * Dessine l'image de fond.
-        *
-        * @param g contexte graphique
-        */
-        @Override
-        protected void paintComponent(Graphics g) {
-            super.paintComponent(g);
-            if (img != null) {
-                g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
-            }
-        }
-    }
-}

fr/iut_fbleau/Tests/AvalamBoardTest.java

@@ -0,0 +1,123 @@
+package fr.iut_fbleau.Tests;
+
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.Player;
+
+import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.AvalamPly;
+import fr.iut_fbleau.Avalam.Tower;
+import fr.iut_fbleau.Avalam.Color;
+
+import org.junit.Before;
+import org.junit.Test;
+//import org.mockito.Mockito;  //Mockito absent
+
+import static org.junit.Assert.*;
+
+/**
+* La classe <code>AvalamBoardTest</code> test si la méthode isLegal() fonctionne comme prévu.
+*/
+public class AvalamBoardTest {
+
+    private Tower[][] grid;
+    private AvalamBoard board;
+
+    @Before
+    public void setUp() {
+        grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
+
+        //Création des tours de tests
+        /* Motif
+        1,0,2 | 2,0,3
+        2,1,0 | 2,3,0
+        0,2,1 | 0,1,1
+        */
+        grid[4][2] = new Tower(2, Color.YELLOW);
+        grid[6][2] = new Tower(3, Color.RED);
+
+        grid[4][3] = new Tower(2, Color.RED);
+        grid[5][3] = new Tower(3, Color.YELLOW);
+
+        grid[5][4] = new Tower(1, Color.RED);
+        grid[6][4] = new Tower(1, Color.YELLOW);
+
+        //Joueur courant initialisé à 1, soit jaune
+        board = new AvalamBoard(grid);  //AvalamBoard copie la grille
+    }
+
+    /*
+    @Test  //Mockito absent
+    public void nonAvalamPly_returnsFalse() {
+        //Vérifie si l'instance est bien AvalamPly
+        AbstractPly fake = Mockito.mock(AbstractPly.class);  //Crée une instance non-AvalamPly
+        assertFalse(board.isLegal(fake));
+    }*/
+
+    @Test
+    public void outOfBounds_returnsFalse() {
+        //Source "out of box"
+        AvalamPly p = new AvalamPly(Player.PLAYER1, -1, 2, 4, 2);
+        assertFalse(board.isLegal(p));
+
+        //Destination "out of box"
+        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 6, 4, 9, 4);
+        assertFalse(board.isLegal(p2));
+    }
+
+    @Test
+    public void sameCell_returnsFalse() {
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 4, 5, 4);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void emptySourceOrDest_returnsFalse() {
+        //Source null
+        AvalamPly p1 = new AvalamPly(Player.PLAYER1, 5, 5, 5, 4);
+        assertFalse(board.isLegal(p1));
+
+        //Destination null
+        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 6, 4, 6, 3);
+        assertFalse(board.isLegal(p2));
+    }
+
+    @Test
+    public void sourceNotOwned_returnsFalse() {
+        //Le joueur courant n'est pas rouge
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 4, 6, 4);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void notAdjacent_returnsFalse() {
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 2, 6, 2);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void sameColor_returnsFalse() {
+        //La couleur des tours est identique
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 2, 5, 3);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void tooTallAfterMerge_returnsFalse() {
+        //Hauteur maximale dépassé : 3+3 = 6 > MAX_HEIGHT (5)
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 3, 6, 2);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void validMove_returnsTrue() {
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 3, 4, 3);  //Hauteur limite à 5
+        assertTrue(board.isLegal(p));
+    }
+
+    @Test  //À vérifier
+    public void currentPlayerMismatchInPlyDoesNotAffectOwnershipCheck() {
+        //Si le coup est construit avec le mauvais joueur
+        AvalamPly p = new AvalamPly(Player.PLAYER2, 4, 2, 4, 3);
+        assertFalse(board.isLegal(p));
+    }
+}