erreur de création dans l'arène

Reviewed-on: #25

Makefile

@@ -1,5 +1,7 @@
 # === Environnements ===
-TEST_ENV = "bin:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
+JUNIT_JAR = /usr/share/java/junit.jar
+HAMCREST_JAR = /usr/share/java/hamcrest-core.jar
+TEST_ENV = "bin:$(JUNIT_JAR):$(HAMCREST_JAR)"
 
 # === Répertoires ===
 SRC_DIR = fr
@@ -9,8 +11,11 @@ BIN_DIR = bin
 RES_SRC = fr/iut_fbleau/Res
 RES_BIN = bin/fr/iut_fbleau/Res
 
-# === Recherche automatique des fichiers .java dans tous les sous-dossiers ===
+# === Recherche automatique des fichiers .java ===
-SOURCES := $(shell find $(SRC_DIR) -name "*.java")
+# SOURCES : uniquement le code de l'application (sans les fichiers de tests)
+SOURCES := $(shell find $(SRC_DIR) -name "*.java" -not -path "$(SRC_DIR)/iut_fbleau/Tests/*")
+# TEST_SOURCES : uniquement les fichiers de tests
+TEST_SOURCES := $(shell find $(SRC_DIR)/iut_fbleau/Tests -name "*.java" 2>/dev/null)
 
 # === Classe principale ===
 MAIN_CLASS = fr.iut_fbleau.Avalam.Main
@@ -20,7 +25,10 @@ TEST_CLASS = fr.iut_fbleau.Tests.AvalamBoardTest
 
 # === Commandes Java ===
 JC = javac
-JCFLAGS = -d $(BIN_DIR) -cp $(TEST_ENV)
+# Compilation normale (application uniquement)
+JCFLAGS = -d $(BIN_DIR)
+# Compilation des tests (application + JUnit)
+JCFLAGS_TESTS = -d $(BIN_DIR) -cp $(TEST_ENV)
 
 JAVA = java
 JAVAFLAGS = -cp $(BIN_DIR)
@@ -38,6 +46,35 @@ compile:
 	@mkdir -p $(BIN_DIR)
 	@$(JC) $(JCFLAGS) $(SOURCES)
 
+compile_tests: compile
+	@echo "===> Compilation des tests..."
+	@mkdir -p $(BIN_DIR)
+ifneq ($(TEST_SOURCES),)
+	@$(JC) $(JCFLAGS_TESTS) $(TEST_SOURCES)
+else
+	@echo "Aucun fichier de test trouvé dans $(SRC_DIR)/iut_fbleau/Tests"
+endif
+
+# === Vérification / installation des dépendances de tests ===
+check_test_deps:
+	@echo "===> Vérification des dépendances de tests (JUnit / Hamcrest)..."
+	@if [ ! -f "$(JUNIT_JAR)" ] || [ ! -f "$(HAMCREST_JAR)" ]; then \
+		echo "    JUnit ou Hamcrest manquant, tentative d'installation (sudo requis)..."; \
+		if command -v sudo >/dev/null 2>&1; then \
+			sudo apt-get update && sudo apt-get install -y junit4 libhamcrest-java; \
+		else \
+			apt-get update && apt-get install -y junit4 libhamcrest-java; \
+		fi; \
+		if [ ! -f "$(JUNIT_JAR)" ] || [ ! -f "$(HAMCREST_JAR)" ]; then \
+			echo "✖ Impossible de trouver/installer $(JUNIT_JAR) ou $(HAMCREST_JAR). Vérifiez manuellement vos paquets JUnit/Hamcrest."; \
+			exit 1; \
+		else \
+			echo "✔ Dépendances de tests installées."; \
+		fi; \
+	else \
+		echo "✔ JUnit et Hamcrest trouvés."; \
+	fi
+
 # === Copie des ressources (.txt) dans bin ===
 resources:
 	@echo "===> Copie des ressources..."
@@ -51,7 +88,7 @@ run:
 	@$(JAVA) $(JAVAFLAGS) $(MAIN_CLASS)
 
 # === Tests ===
-test:
+test: check_test_deps compile_tests
 	@echo "===> Lancement des tests..."
 	@$(JAVA) $(JAVAFLAGS_TESTS) org.junit.runner.JUnitCore $(TEST_CLASS)
 	@echo "... Fin des tests."

README.md

@@ -12,37 +12,55 @@ Dans un second temps, nous développerons des bots les plus efficaces possible,
 
 Le jeu de notre groupe est **Avalam**.
 
-## Compilation et exécution
+## Compilation, exécution et tests
 
-### Compilation
+### Compilation (sans tests)
 ```bash
 make build
 ```
-
+ou simplement :
-### Tests
 ```bash
-make test
+make
 ```
+Cette commande :
+- compile uniquement le code de l'application (sans les fichiers du dossier `fr/iut_fbleau/Tests`) ;
+- copie les ressources dans `bin/`.
 
-### Exécution
+### Exécution du jeu
 ```bash
 make run
 ```
+Lance la fenêtre de jeu Avalam après compilation.
+
+### Lancer les tests
+```bash
+make test
+```
+Cette commande :
+- vérifie d'abord la présence de **JUnit** et **Hamcrest** dans `/usr/share/java` ;
+- si nécessaire, tente de les installer automatiquement via `apt-get` (sudo requis sur Debian/Ubuntu) ;
+- compile ensuite les fichiers de tests (`fr/iut_fbleau/Tests`) ;
+- lance enfin la suite de tests JUnit (`AvalamBoardTest`).
+
+Si l'installation automatique échoue (autre OS, pas de droits sudo, pas d'accès réseau, etc.), un message l'indiquera et il faudra installer JUnit/Hamcrest manuellement.
 
 ### Nettoyage
 ```bash
 make clean
 ```
+Supprime le répertoire `bin/` (classes compilées et ressources copiées).
 
-### Recompiler et exécuter
+### Recompiler puis exécuter
 ```bash
 make re
 ```
+Équivaut à `make clean` puis `make build` puis `make run`.
 
 ### Générer la Javadoc
 ```bash
 make javadoc
 ```
+Génère la documentation dans le dossier `doc/`.
 
 ## Architecture du projet
 

fr/iut_fbleau/Avalam/ArenaGame.java

@@ -0,0 +1,44 @@
+package fr.iut_fbleau.Avalam;
+
+import fr.iut_fbleau.GameAPI.AbstractGame;
+import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
+import fr.iut_fbleau.GameAPI.IBoard;
+import fr.iut_fbleau.GameAPI.Player;
+
+import java.util.EnumMap;
+
+/**
+ * Classe pour jouer une partie entre deux bots sans interface graphique.
+ * Utilisée dans le mode Arène.
+ * 
+ * @version 1.0
+ */
+public class ArenaGame extends AbstractGame {
+
+    /**
+     * Construit une partie Arène entre deux bots.
+     *
+     * @param board plateau initial
+     * @param bot1 bot pour PLAYER1
+     * @param bot2 bot pour PLAYER2
+     */
+    public ArenaGame(IBoard board, AbstractGamePlayer bot1, AbstractGamePlayer bot2) {
+        super(board, createPlayerMap(bot1, bot2));
+    }
+
+    /**
+     * Crée la map des joueurs pour AbstractGame.
+     *
+     * @param bot1 bot pour PLAYER1
+     * @param bot2 bot pour PLAYER2
+     * @return une EnumMap associant chaque Player à son bot
+     */
+    private static EnumMap<Player, AbstractGamePlayer> createPlayerMap(
+            AbstractGamePlayer bot1, AbstractGamePlayer bot2) {
+        EnumMap<Player, AbstractGamePlayer> map = new EnumMap<>(Player.class);
+        map.put(Player.PLAYER1, bot1);
+        map.put(Player.PLAYER2, bot2);
+        return map;
+    }
+}
+

fr/iut_fbleau/Avalam/ArenaWindow.java

@@ -0,0 +1,363 @@
+package fr.iut_fbleau.Avalam;
+
+import fr.iut_fbleau.Bot.AlphaBetaBot;
+import fr.iut_fbleau.Bot.DivineBot;
+import fr.iut_fbleau.Bot.IdiotBot;
+import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
+import fr.iut_fbleau.GameAPI.Player;
+import fr.iut_fbleau.GameAPI.Result;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Fenêtre pour le mode Arène (bots vs bots).
+ *
+ * Elle permet :
+ * - de sélectionner deux bots parmi Idiot, Alpha-Beta et Divin ;
+ * - de configurer la profondeur de recherche pour les bots intelligents ;
+ * - de choisir le nombre de parties à jouer ;
+ * - d’afficher, dans un tableau, le résultat de chaque partie (gagnant ou erreur) ;
+ * - de revenir au menu principal ou de quitter entièrement le jeu.
+ */
+public class ArenaWindow extends JFrame {
+
+    /** Tableau affichant les résultats des parties. */
+    private JTable resultsTable;
+    
+    /** Modèle de données pour le tableau des résultats. */
+    private DefaultTableModel tableModel;
+    
+    /** Liste des résultats des parties (non utilisée actuellement). */
+    private List<String> results;
+
+    /**
+     * Construit la fenêtre Arène.
+     */
+    public ArenaWindow() {
+        super("Arène - Bot vs Bot");
+        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        setLayout(new BorderLayout());
+
+        results = new ArrayList<>();
+
+        // Panneau de configuration
+        JPanel configPanel = createConfigPanel();
+        add(configPanel, BorderLayout.NORTH);
+
+        // Tableau des résultats
+        createResultsTable();
+        JScrollPane scrollPane = new JScrollPane(resultsTable);
+        add(scrollPane, BorderLayout.CENTER);
+
+        // Panneau des boutons
+        JPanel buttonPanel = new JPanel(new FlowLayout());
+        JButton startButton = new JButton("Lancer les parties");
+        startButton.addActionListener(e -> showConfigDialog());
+        buttonPanel.add(startButton);
+
+        JButton backButton = new JButton("Retour au menu");
+        backButton.addActionListener(e -> {
+            dispose(); // Ferme la fenêtre Arène
+            Main.showModeSelection(); // Affiche le menu principal
+        });
+        buttonPanel.add(backButton);
+
+        // Nouveau bouton pour quitter entièrement le jeu
+        JButton quitButton = new JButton("Quitter");
+        quitButton.addActionListener(e -> System.exit(0));
+        buttonPanel.add(quitButton);
+
+        add(buttonPanel, BorderLayout.SOUTH);
+
+        pack();
+        setSize(600, 400);
+        setLocationRelativeTo(null);
+        setVisible(true);
+    }
+
+    /**
+     * Crée le panneau de configuration (pour l'instant vide, sera rempli par le dialogue).
+     *
+     * @return un JPanel contenant les informations de configuration
+     */
+    private JPanel createConfigPanel() {
+        JPanel panel = new JPanel();
+        panel.setBorder(BorderFactory.createTitledBorder("Configuration"));
+        panel.add(new JLabel("Utilisez le bouton 'Lancer les parties' pour configurer et démarrer."));
+        return panel;
+    }
+
+    /**
+     * Crée le tableau des résultats avec les colonnes : Partie, Bot 1, Bot 2, Gagnant.
+     */
+    private void createResultsTable() {
+        String[] columnNames = {"Partie", "Bot 1", "Bot 2", "Gagnant"};
+        tableModel = new DefaultTableModel(columnNames, 0) {
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                return false;
+            }
+        };
+        resultsTable = new JTable(tableModel);
+        resultsTable.setFillsViewportHeight(true);
+    }
+
+    /**
+     * Affiche le dialogue de configuration et lance les parties.
+     */
+    private void showConfigDialog() {
+        // Choix du bot 1
+        String[] botTypes = {"Bot Idiot", "Bot Alpha-Beta", "Bot Divin"};
+        String bot1Choice = (String) JOptionPane.showInputDialog(
+                this,
+                "Choisissez le Bot 1 (Joueur 1) :",
+                "Configuration Arène - Bot 1",
+                JOptionPane.QUESTION_MESSAGE,
+                null,
+                botTypes,
+                botTypes[0]
+        );
+
+        if (bot1Choice == null) return;
+
+        // Choix du bot 2
+        String bot2Choice = (String) JOptionPane.showInputDialog(
+                this,
+                "Choisissez le Bot 2 (Joueur 2) :",
+                "Configuration Arène - Bot 2",
+                JOptionPane.QUESTION_MESSAGE,
+                null,
+                botTypes,
+                botTypes[0]
+        );
+
+        if (bot2Choice == null) return;
+
+        // Profondeur pour Alpha-Beta et Divin
+        int depth = 4;
+        if (bot1Choice.contains("Alpha") || bot1Choice.contains("Divin") ||
+            bot2Choice.contains("Alpha") || bot2Choice.contains("Divin")) {
+            String depthStr = JOptionPane.showInputDialog(
+                    this,
+                    "Profondeur de recherche pour les bots Alpha-Beta/Divin ?\n(Conseil: 4)",
+                    "Profondeur",
+                    JOptionPane.QUESTION_MESSAGE
+            );
+            if (depthStr != null) {
+                try {
+                    depth = Integer.parseInt(depthStr.trim());
+                    if (depth < 1) depth = 1;
+                } catch (Exception e) {
+                    depth = 4;
+                }
+            }
+        }
+
+        // Nombre de parties
+        String nbPartiesStr = JOptionPane.showInputDialog(
+                this,
+                "Combien de parties voulez-vous jouer ?",
+                "Nombre de parties",
+                JOptionPane.QUESTION_MESSAGE
+        );
+
+        if (nbPartiesStr == null) return;
+
+        int nbParties;
+        try {
+            nbParties = Integer.parseInt(nbPartiesStr.trim());
+            if (nbParties < 1) {
+                JOptionPane.showMessageDialog(this, "Le nombre de parties doit être au moins 1.");
+                return;
+            }
+        } catch (Exception e) {
+            JOptionPane.showMessageDialog(this, "Nombre invalide.");
+            return;
+        }
+
+        // Lancer les parties
+        runArena(bot1Choice, bot2Choice, depth, nbParties);
+    }
+
+    /**
+     * Lance les parties entre les deux bots.
+     * 
+     * @param bot1Type type du bot 1 (Joueur 1)
+     * @param bot2Type type du bot 2 (Joueur 2)
+     * @param depth profondeur de recherche pour les bots Alpha-Beta/Divin
+     * @param nbParties nombre de parties à jouer
+     */
+    private void runArena(String bot1Type, String bot2Type, int depth, int nbParties) {
+        // Vider le tableau
+        tableModel.setRowCount(0);
+        results.clear();
+
+        // Créer un dialogue de progression
+        JDialog progressDialog = new JDialog(this, "Parties en cours...", true);
+        JLabel progressLabel = new JLabel("Préparation des parties...", JLabel.CENTER);
+        progressLabel.setBorder(BorderFactory.createEmptyBorder(20, 40, 20, 40));
+        progressDialog.add(progressLabel);
+        progressDialog.setSize(300, 100);
+        progressDialog.setLocationRelativeTo(this);
+        progressDialog.setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
+
+        // Exécuter les parties dans un thread séparé pour ne pas bloquer l'interface
+        Thread arenaThread = new Thread(() -> {
+            SwingUtilities.invokeLater(() -> progressDialog.setVisible(true));
+
+            // Statistiques pour déboguer
+            int bot1Wins = 0;
+            int bot2Wins = 0;
+            int draws = 0;
+            int errors = 0;
+
+            for (int i = 1; i <= nbParties; i++) {
+                final int partieNum = i;
+                SwingUtilities.invokeLater(() -> {
+                    progressLabel.setText("Partie " + partieNum + " / " + nbParties + " en cours...");
+                });
+
+                // Recréer les bots à chaque partie pour garantir l'indépendance complète
+                // (notamment pour réinitialiser les générateurs aléatoires)
+                AbstractGamePlayer bot1 = createBot(bot1Type, Player.PLAYER1, depth);
+                AbstractGamePlayer bot2 = createBot(bot2Type, Player.PLAYER2, depth);
+
+                if (bot1 == null || bot2 == null) {
+                    errors++;
+                    SwingUtilities.invokeLater(() -> {
+                        tableModel.addRow(new Object[]{
+                                "Partie " + partieNum,
+                                bot1Type,
+                                bot2Type,
+                                "Erreur: Impossible de créer les bots"
+                        });
+                    });
+                    continue;
+                }
+
+                // Recharger le plateau à chaque partie pour garantir l'indépendance complète
+                Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
+                AvalamBoard board = new AvalamBoard(initialGrid, Player.PLAYER1);
+                ArenaGame game = new ArenaGame(board, bot1, bot2);
+
+                try {
+                    Result result = game.run();
+                    String winner = getWinnerName(result, bot1Type, bot2Type);
+                    
+                    // Mettre à jour les statistiques
+                    if (result == Result.WIN) {
+                        bot1Wins++;
+                    } else if (result == Result.LOSS) {
+                        bot2Wins++;
+                    } else if (result == Result.DRAW) {
+                        draws++;
+                    }
+                    
+                    // Ajouter au tableau dans le thread EDT
+                    SwingUtilities.invokeLater(() -> {
+                        tableModel.addRow(new Object[]{
+                                "Partie " + partieNum,
+                                bot1Type,
+                                bot2Type,
+                                winner
+                        });
+                    });
+                } catch (Exception e) {
+                    errors++;
+                    SwingUtilities.invokeLater(() -> {
+                        tableModel.addRow(new Object[]{
+                                "Partie " + partieNum,
+                                bot1Type,
+                                bot2Type,
+                                "Erreur: " + e.getMessage()
+                        });
+                    });
+                }
+            }
+            
+            // Afficher les statistiques finales
+            final int finalBot1Wins = bot1Wins;
+            final int finalBot2Wins = bot2Wins;
+            final int finalDraws = draws;
+            final int finalErrors = errors;
+
+            // Fermer le dialogue et afficher le message de fin avec statistiques
+            SwingUtilities.invokeLater(() -> {
+                progressDialog.dispose();
+                
+                String statsMessage = String.format(
+                    "Toutes les parties sont terminées !\n\n" +
+                    "Statistiques :\n" +
+                    "- %s (Bot 1) : %d victoires\n" +
+                    "- %s (Bot 2) : %d victoires\n" +
+                    "- Matchs nuls : %d\n" +
+                    "- Erreurs : %d",
+                    bot1Type, finalBot1Wins,
+                    bot2Type, finalBot2Wins,
+                    finalDraws,
+                    finalErrors
+                );
+                
+                Object[] options = {"OK", "Quitter le jeu"};
+                int choice = JOptionPane.showOptionDialog(
+                        this,
+                        statsMessage,
+                        "Arène terminée",
+                        JOptionPane.DEFAULT_OPTION,
+                        JOptionPane.INFORMATION_MESSAGE,
+                        null,
+                        options,
+                        options[0]
+                );
+
+                if (choice == 1) {
+                    System.exit(0);
+                }
+            });
+        });
+
+        arenaThread.start();
+    }
+
+    /**
+     * Crée un bot selon son type.
+     *
+     * @param botType type de bot ("Bot Idiot", "Bot Alpha-Beta", "Bot Divin")
+     * @param player joueur contrôlé par ce bot (PLAYER1 ou PLAYER2)
+     * @param depth profondeur de recherche pour Alpha-Beta/Divin
+     * @return une instance de AbstractGamePlayer correspondant au type, ou null si le type est invalide
+     */
+    private AbstractGamePlayer createBot(String botType, Player player, int depth) {
+        if (botType.equals("Bot Idiot")) {
+            return new IdiotBot(player);
+        } else if (botType.equals("Bot Alpha-Beta")) {
+            return new AlphaBetaBot(player, depth);
+        } else if (botType.equals("Bot Divin")) {
+            return new DivineBot(player, depth);
+        }
+        return null;
+    }
+
+    /**
+     * Détermine le nom du gagnant selon le résultat.
+     * 
+     * @param result résultat de la partie (WIN, LOSS, ou DRAW du point de vue de PLAYER1)
+     * @param bot1Type nom du bot 1
+     * @param bot2Type nom du bot 2
+     * @return une chaîne indiquant le gagnant ou "Match nul"
+     */
+    private String getWinnerName(Result result, String bot1Type, String bot2Type) {
+        if (result == Result.WIN) {
+            return bot1Type + " (Joueur 1)";
+        } else if (result == Result.LOSS) {
+            return bot2Type + " (Joueur 2)";
+        } else {
+            return "Match nul";
+        }
+    }
+}
+

fr/iut_fbleau/Avalam/AvalamBoard.java

@@ -51,9 +51,16 @@ public class AvalamBoard extends AbstractBoard {
         super(startingPlayer, new ArrayDeque<>());
         this.grid = new Tower[SIZE][SIZE];
 
+        // Copie profonde : créer de nouvelles tours pour éviter que toutes les parties partagent les mêmes objets
         for (int r = 0; r < SIZE; r++)
-            for (int c = 0; c < SIZE; c++)
+            for (int c = 0; c < SIZE; c++) {
-                this.grid[r][c] = initialGrid[r][c];
+                Tower t = initialGrid[r][c];
+                if (t == null) {
+                    this.grid[r][c] = null;
+                } else {
+                    this.grid[r][c] = new Tower(t.getHeight(), t.getColor());
+                }
+            }
     }
 
     /**
@@ -205,6 +212,7 @@ public class AvalamBoard extends AbstractBoard {
         Tower dst = grid[xT][yT];
         if (src == null || dst == null) return false;
 
+        if (p.getPlayer() != getCurrentPlayer()) return false;
         if (src.getColor() != colorForPlayer(getCurrentPlayer())) return false;
         if (!areAdjacent(xF, yF, xT, yT)) return false;
         if (src.getColor() == dst.getColor()) return false;

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -1,8 +1,7 @@
 package fr.iut_fbleau.Avalam;
 
 import fr.iut_fbleau.Bot.AlphaBetaBot;
-// A FAIRE PLUS TARD (PVGOD)
+import fr.iut_fbleau.Bot.DivineBot;
-// import fr.iut_fbleau.Bot.DivineBot;
 import fr.iut_fbleau.Bot.IdiotBot;
 import fr.iut_fbleau.GameAPI.AbstractPly;
 import fr.iut_fbleau.GameAPI.Player;
@@ -14,22 +13,25 @@ import java.awt.*;
 /**
  * La classe <code>AvalamWindow</code>
  *
- * Fenêtre principale (interface graphique) du jeu Avalam.
+ * Fenêtre principale (interface graphique) du jeu Avalam pour tous les modes
- * Elle contient :
+ * hors Arène :
- * - le plateau (BoardView)
+ * - joueur vs joueur (PVP)
- * - l’affichage du score (ScoreView)
+ * - joueur vs bot idiot (PVBOT)
- * - l’affichage du joueur courant (TurnView)
+ * - joueur vs bot alpha (PVALPHA)
- *
- * Elle pilote un objet <code>AvalamBoard</code> (moteur du jeu).
- * Elle peut fonctionner en mode :
- * - joueur vs joueur
- * - joueur vs bot idiot (aléatoire)
- * - joueur vs bot alpha (cut-off)
  * - joueur vs bot divin (PVGOD)
  *
- * @version 1.0
+ * Elle contient :
- * Date :
+ * - le plateau (<code>BoardView</code>)
- * Licence :
+ * - l’affichage du score (<code>ScoreView</code>)
+ * - l’affichage du joueur courant (<code>TurnView</code>)
+ *
+ * Elle pilote un objet <code>AvalamBoard</code> (moteur du jeu) et,
+ * en fonction du {@link GameMode}, instancie le bot approprié
+ * (idiot, alpha-bêta ou divin).
+ *
+ * En fin de partie, elle ouvre une fenêtre de fin (<code>EndGameDialog</code>)
+ * affichant le gagnant, les scores et proposant les actions :
+ * « Rejouer », « Menu principal » ou « Quitter le jeu ».
  */
 public class AvalamWindow extends JFrame {
 
@@ -50,6 +52,9 @@ public class AvalamWindow extends JFrame {
     /** Mode de jeu sélectionné. */
     private final GameMode mode;
 
+    /** Profondeur de recherche utilisée (utile pour les modes avec bot intelligent et pour rejouer). */
+    private final int searchDepth;
+
     /** Joueur contrôlé par le bot (si actif). */
     private final Player botPlayer = Player.PLAYER2;
 
@@ -59,16 +64,8 @@ public class AvalamWindow extends JFrame {
     /** Bot Alpha-Beta (utilisé si mode PVALPHA). */
     private final AlphaBetaBot alphaBot;
 
-    // A FAIRE PLUS TARD (PVGOD)
+    /** Bot Divin (utilisé si mode PVGOD). */
-    // /** Bot Divin (utilisé si mode PVGOD). */
+    private final DivineBot divineBot;
-    // private final DivineBot divineBot;
-
-    /**
-     * A FAIRE PLUS TARD (PVGOD)
-     * On garde l'attribut à null pour ne pas casser la compilation,
-     * mais toute la logique PVGOD est désactivée/commentée.
-     */
-    private final Object divineBot = null;
 
     /** Indique si une animation de tour de bot est en cours. */
     private boolean botAnimating = false;
@@ -86,7 +83,7 @@ public class AvalamWindow extends JFrame {
      * Construit la fenêtre en fonction du mode choisi.
      * Pour PVALPHA/PVGOD, la profondeur par défaut est 4.
      *
-     * @param mode mode de jeu
+     * @param mode mode de jeu (PVP, PVBOT, PVALPHA ou PVGOD)
      */
     public AvalamWindow(GameMode mode) {
         this(mode, 4);
@@ -94,7 +91,8 @@ public class AvalamWindow extends JFrame {
 
     /**
      * Construit la fenêtre en fonction du mode choisi.
-     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off.
+     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off
+     * pour les bots Alpha-Beta et Divin.
      *
      * @param mode       mode de jeu
      * @param alphaDepth profondeur de recherche pour Alpha-Beta / Bot Divin
@@ -103,14 +101,14 @@ public class AvalamWindow extends JFrame {
         super("Avalam");
 
         this.mode = mode;
+        this.searchDepth = Math.max(1, alphaDepth);
 
         this.idiotBot = (mode == GameMode.PVBOT) ? new IdiotBot(botPlayer) : null;
 
-        int depth = Math.max(1, alphaDepth);
+        int depth = this.searchDepth;
         this.alphaBot = (mode == GameMode.PVALPHA) ? new AlphaBetaBot(botPlayer, depth) : null;
 
-        // A FAIRE PLUS TARD (PVGOD)
+        this.divineBot = (mode == GameMode.PVGOD) ? new DivineBot(botPlayer, depth) : null;
-        // this.divineBot = (mode == GameMode.PVGOD) ? new DivineBot(botPlayer, depth) : null;
 
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setLayout(new BorderLayout());
@@ -168,28 +166,30 @@ public class AvalamWindow extends JFrame {
         if (board.isGameOver()) {
             Result res = board.getResult();
 
-            String msg;
+            int scoreJaune = computeScore(Color.YELLOW);
-            switch (res) {
+            int scoreRouge = computeScore(Color.RED);
-                case WIN:
-                    msg = "Le joueur jaune a gagné !";
-                    break;
-                case LOSS:
-                    msg = "Le joueur rouge a gagné !";
-                    break;
-                case DRAW:
-                    msg = "Égalité !";
-                    break;
-                default:
-                    msg = "Fin de partie.";
-                    break;
-            }
 
-            JOptionPane.showMessageDialog(
+            EndGameDialog dialog = new EndGameDialog(
                     this,
-                    msg,
+                    res,
-                    "Partie terminée",
+                    scoreJaune,
-                    JOptionPane.INFORMATION_MESSAGE
+                    scoreRouge,
+                    mode,
+                    searchDepth,
+                    // Rejouer : on ferme la fenêtre actuelle et on relance une nouvelle partie avec le même mode/profondeur
+                    () -> SwingUtilities.invokeLater(() -> {
+                        dispose();
+                        new AvalamWindow(mode, searchDepth);
+                    }),
+                    // Menu principal : on ferme la fenêtre actuelle et on réaffiche le menu de mode de jeu
+                    () -> SwingUtilities.invokeLater(() -> {
+                        dispose();
+                        Main.showModeSelection();
+                    }),
+                    // Quitter complètement l'application
+                    () -> System.exit(0)
             );
+            dialog.setVisible(true);
             return;
         }
 
@@ -219,12 +219,7 @@ public class AvalamWindow extends JFrame {
         if (mode == GameMode.PVBOT && idiotBot == null) return;
         if (mode == GameMode.PVALPHA && alphaBot == null) return;
 
-        // A FAIRE PLUS TARD (PVGOD)
+        if (mode == GameMode.PVGOD && divineBot == null) return;
-        // if (mode == GameMode.PVGOD && divineBot == null) return;
-
-        // A FAIRE PLUS TARD (PVGOD)
-        // Pour l'instant, si PVGOD est sélectionné, on ne joue pas de coup bot.
-        if (mode == GameMode.PVGOD) return;
 
         botAnimating = true;
 
@@ -238,9 +233,7 @@ public class AvalamWindow extends JFrame {
         } else if (mode == GameMode.PVALPHA) {
             botMove = alphaBot.giveYourMove(board.safeCopy());
         } else {
-            // A FAIRE PLUS TARD (PVGOD)
+            botMove = divineBot.giveYourMove(board.safeCopy());
-            // botMove = divineBot.giveYourMove(board.safeCopy());
-            botMove = null;
         }
 
         if (botMove == null) {

fr/iut_fbleau/Avalam/EndGameDialog.java

@@ -0,0 +1,160 @@
+package fr.iut_fbleau.Avalam;
+
+import fr.iut_fbleau.GameAPI.Result;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Fenêtre de fin de partie.
+ *
+ * Elle est ouverte par {@link AvalamWindow} lorsque le moteur signale
+ * que la partie est terminée. Elle affiche :
+ * - le résultat (gagnant ou égalité) à partir du {@link Result} ;
+ * - le score détaillé (tours contrôlées par Jaune et Rouge) ;
+ * - le mode de jeu courant (PVP, PVBOT, PVALPHA, PVGOD, avec profondeur pour les bots intelligents).
+ *
+ * Elle propose également trois actions sous forme de boutons :
+ * - « Rejouer » : relancer une partie avec la même configuration ;
+ * - « Menu principal » : retourner au menu de sélection de mode ;
+ * - « Quitter » : fermer complètement l’application.
+ */
+public class EndGameDialog extends JDialog {
+
+    /**
+     * Construit la fenêtre de fin de partie.
+     *
+     * @param parent     fenêtre principale (généralement une {@link AvalamWindow})
+     * @param result     résultat de la partie (WIN / LOSS / DRAW du point de vue de PLAYER1 / Jaune)
+     * @param scoreJaune score du joueur jaune (nombre de tours contrôlées)
+     * @param scoreRouge score du joueur rouge (nombre de tours contrôlées)
+     * @param mode       mode de jeu courant (pour l’information et le « Rejouer »)
+     * @param depth      profondeur utilisée (pour les modes avec bot intelligent)
+     * @param onReplay   action à exécuter lorsque l’utilisateur clique sur « Rejouer »
+     * @param onMenu     action à exécuter lorsque l’utilisateur clique sur « Menu principal »
+     * @param onQuit     action à exécuter lorsque l’utilisateur clique sur « Quitter »
+     */
+    public EndGameDialog(
+            JFrame parent,
+            Result result,
+            int scoreJaune,
+            int scoreRouge,
+            GameMode mode,
+            int depth,
+            Runnable onReplay,
+            Runnable onMenu,
+            Runnable onQuit
+    ) {
+        super(parent, "Fin de partie", true);
+
+        setLayout(new BorderLayout(10, 10));
+
+        // Panel principal d'information
+        JPanel infoPanel = new JPanel();
+        infoPanel.setLayout(new BoxLayout(infoPanel, BoxLayout.Y_AXIS));
+        infoPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+        JLabel titre = new JLabel("Partie terminée");
+        titre.setFont(titre.getFont().deriveFont(Font.BOLD, 18f));
+        titre.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+        String gagnant;
+        switch (result) {
+            case WIN:
+                gagnant = "Le joueur JAUNE a gagné !";
+                break;
+            case LOSS:
+                gagnant = "Le joueur ROUGE a gagné !";
+                break;
+            case DRAW:
+                gagnant = "Égalité parfaite !";
+                break;
+            default:
+                gagnant = "Fin de partie.";
+        }
+
+        JLabel gagnantLabel = new JLabel(gagnant);
+        gagnantLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+        JLabel scoreLabel = new JLabel(
+                "Score - Jaune : " + scoreJaune + " | Rouge : " + scoreRouge
+        );
+        scoreLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+        JLabel modeLabel = new JLabel("Mode : " + modeToString(mode, depth));
+        modeLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+        infoPanel.add(titre);
+        infoPanel.add(Box.createVerticalStrut(10));
+        infoPanel.add(gagnantLabel);
+        infoPanel.add(Box.createVerticalStrut(5));
+        infoPanel.add(scoreLabel);
+        infoPanel.add(Box.createVerticalStrut(5));
+        infoPanel.add(modeLabel);
+
+        add(infoPanel, BorderLayout.CENTER);
+
+        // Panel des boutons d'action
+        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 15, 10));
+
+        JButton replayButton = new JButton("Rejouer");
+        replayButton.addActionListener(e -> {
+            if (onReplay != null) {
+                onReplay.run();
+            }
+            dispose();
+        });
+
+        JButton menuButton = new JButton("Menu principal");
+        menuButton.addActionListener(e -> {
+            if (onMenu != null) {
+                onMenu.run();
+            }
+            dispose();
+        });
+
+        JButton quitButton = new JButton("Quitter");
+        quitButton.addActionListener(e -> {
+            if (onQuit != null) {
+                onQuit.run();
+            }
+            dispose();
+        });
+
+        buttonPanel.add(replayButton);
+        buttonPanel.add(menuButton);
+        buttonPanel.add(quitButton);
+
+        add(buttonPanel, BorderLayout.SOUTH);
+
+        pack();
+        setResizable(false);
+        setLocationRelativeTo(parent);
+    }
+
+    /**
+     * Retourne une description lisible du mode de jeu courant.
+     *
+     * @param mode  mode de jeu
+     * @param depth profondeur (pour les bots intelligents)
+     * @return chaîne décrivant le mode
+     */
+    private String modeToString(GameMode mode, int depth) {
+        switch (mode) {
+            case PVP:
+                return "Joueur vs Joueur";
+            case PVBOT:
+                return "Joueur vs Bot idiot";
+            case PVALPHA:
+                return "Joueur vs Bot Alpha (profondeur " + depth + ")";
+            case PVGOD:
+                return "Joueur vs Bot Divin (profondeur " + depth + ")";
+            case ARENA:
+                return "Arène (bots)"; // normalement non utilisé ici
+            default:
+                return mode.name();
+        }
+    }
+}
+
+

fr/iut_fbleau/Avalam/GameMode.java

@@ -7,5 +7,6 @@ public enum GameMode {
     PVP,        // joueur vs joueur
     PVBOT,      // joueur vs bot idiot
     PVALPHA,     // joueur vs bot alpha
-    PVGOD       // joueur vs bot stratégique
+    PVGOD,       // joueur vs bot stratégique
+    ARENA       // bot vs bot (mode arène)
 }

fr/iut_fbleau/Avalam/Main.java

@@ -8,14 +8,22 @@ import javax.swing.*;
 public class Main {
 
     public static void main(String[] args) {
-
         SwingUtilities.invokeLater(() -> {
+            showModeSelection();
+        });
+    }
 
+    /**
+     * Affiche le menu de sélection du mode de jeu.
+     * Peut être appelé depuis d'autres fenêtres pour revenir au menu.
+     */
+    public static void showModeSelection() {
         String[] options = {
                 "joueur vs joueur",
                 "joueur vs botidiot",
                 "joueur vs bot alpha",
-                    "joueur vs bot divin (NON IMPLEMENTE)"
+                "joueur vs bot divin",
+                "Arène"
         };
 
         int choice = JOptionPane.showOptionDialog(
@@ -31,6 +39,12 @@ public class Main {
 
         if (choice == -1) System.exit(0);
 
+        // Mode Arène
+        if (choice == 4) {
+            new ArenaWindow();
+            return;
+        }
+
         GameMode mode;
         if (choice == 1) mode = GameMode.PVBOT;
         else if (choice == 2) mode = GameMode.PVALPHA;
@@ -64,6 +78,5 @@ public class Main {
         }
 
         new AvalamWindow(mode);
-        });
     }
 }

fr/iut_fbleau/Bot/DivineBot.java

@@ -1,22 +1,201 @@
 package fr.iut_fbleau.Bot;
 
-import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.*;
-import fr.iut_fbleau.Avalam.AvalamPly;
+import fr.iut_fbleau.GameAPI.*;
-import fr.iut_fbleau.Avalam.Color;
-import fr.iut_fbleau.Avalam.Tower;
-import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
-import fr.iut_fbleau.GameAPI.AbstractPly;
-import fr.iut_fbleau.GameAPI.IBoard;
-import fr.iut_fbleau.GameAPI.Player;
-import fr.iut_fbleau.GameAPI.Result;
 
 import java.util.*;
 
 /**
- * Bot "Divin" (fort) pour Avalam.
+ * Bot "Divin" (alpha-beta + évaluateur pondéré).
- *
+ * * Idée :
- *
+ * - Utilise l'algorithme Alpha-Beta pour anticiper les coups.
- * Objectif : trop fort. */
+ * - Évalue les plateaux non terminaux en accordant plus d'importance aux tours hautes.
-public class DivineBot{
+ */
+public class DivineBot extends AbstractGamePlayer {
 
+    // Attributs
+
+    /** Joueur contrôlé par ce bot (PLAYER1 ou PLAYER2). */
+    private final Player me;
+
+    /** Profondeur maximale de recherche avant évaluation. */
+    private final int maxDepth;
+
+    /** Générateur aléatoire pour choisir parmi les meilleurs coups équivalents. */
+    private final Random rng = new Random();
+
+    // Constructeur
+
+    /**
+     * Construit le bot Divine.
+     *
+     * @param p joueur contrôlé par ce bot
+     * @param maxDepth profondeur de l'arbre de recherche
+     */
+    public DivineBot(Player p, int maxDepth) {
+        super(p);
+        this.me = p;
+        this.maxDepth = Math.max(1, maxDepth);
+    }
+
+    // Méthodes
+
+    /**
+     * Méthode principale de décision du bot.
+     * Explore le premier niveau de l'arbre et lance les appels Alpha-Beta.
+     * * @param board état actuel du jeu
+     * @return le meilleur coup calculé (AbstractPly)
+     */
+    @Override
+    public AbstractPly giveYourMove(IBoard board) {
+
+        if (board == null || board.isGameOver()) return null;
+
+        List<AbstractPly> moves = listMoves(board);
+        if (moves.isEmpty()) return null;
+
+        boolean isMax = board.getCurrentPlayer() == me;
+
+        int bestValue = isMax ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+        List<AbstractPly> bestMoves = new ArrayList<>();
+
+        int alpha = Integer.MIN_VALUE;
+        int beta = Integer.MAX_VALUE;
+
+        for (AbstractPly m : moves) {
+            IBoard next = board.safeCopy();
+            next.doPly(m);
+
+            // Appel récursif pour évaluer la suite du coup
+            int value = alphaBeta(next, maxDepth - 1, alpha, beta);
+
+            if (isMax) {
+                if (value > bestValue) {
+                    bestValue = value;
+                    bestMoves.clear();
+                    bestMoves.add(m);
+                } else if (value == bestValue) {
+                    bestMoves.add(m);
+                }
+                alpha = Math.max(alpha, bestValue);
+            } else {
+                if (value < bestValue) {
+                    bestValue = value;
+                    bestMoves.clear();
+                    bestMoves.add(m);
+                } else if (value == bestValue) {
+                    bestMoves.add(m);
+                }
+                beta = Math.min(beta, bestValue);
+            }
+        }
+
+        // Retourne un coup au hasard parmi les meilleurs ex-aequo
+        return bestMoves.get(rng.nextInt(bestMoves.size()));
+    }
+
+    /**
+     * Algorithme récursif de recherche avec élagage Alpha-Beta.
+     */
+    private int alphaBeta(IBoard board, int depth, int alpha, int beta) {
+
+        // Cas de base : fin de partie ou limite de profondeur atteinte
+        if (board.isGameOver()) return terminalValue(board);
+        if (depth == 0) return evaluate(board);
+
+        boolean isMax = board.getCurrentPlayer() == me;
+
+        List<AbstractPly> moves = listMoves(board);
+        if (moves.isEmpty()) {
+            return evaluate(board);
+        }
+
+        if (isMax) {
+            int best = Integer.MIN_VALUE;
+            for (AbstractPly m : moves) {
+                IBoard next = board.safeCopy();
+                next.doPly(m);
+
+                int val = alphaBeta(next, depth - 1, alpha, beta);
+                best = Math.max(best, val);
+                alpha = Math.max(alpha, best);
+
+                if (alpha >= beta) break; // Coupure Beta
+            }
+            return best;
+        } else {
+            int best = Integer.MAX_VALUE;
+            for (AbstractPly m : moves) {
+                IBoard next = board.safeCopy();
+                next.doPly(m);
+
+                int val = alphaBeta(next, depth - 1, alpha, beta);
+                best = Math.min(best, val);
+                beta = Math.min(beta, best);
+
+                if (alpha >= beta) break; // Coupure Alpha
+            }
+            return best;
+        }
+    }
+
+    /**
+     * Calcule la valeur de l'état final (Victoire / Défaite).
+     */
+    private int terminalValue(IBoard board) {
+        Result r = board.getResult();
+        if (r == null) return 0;
+
+        if (r == Result.DRAW) return 0;
+
+        boolean botIsP1 = (me == Player.PLAYER1);
+        // Si le bot gagne, valeur positive élevée, sinon valeur négative
+        return ((r == Result.WIN) == botIsP1) ? 100000 : -100000;
+    }
+
+    /**
+     * Heuristique évoluée pour Avalam :
+     * Calcule un score basé sur le contrôle des tours et leur hauteur.
+     * Les tours de hauteur 5 sont prioritaires car elles sont bloquées.
+     */
+    private int evaluate(IBoard board) {
+
+        if (!(board instanceof AvalamBoard)) return 0;
+        AvalamBoard b = (AvalamBoard) board;
+
+        Color myColor = (me == Player.PLAYER1) ? Color.YELLOW : Color.RED;
+        Color oppColor = (myColor == Color.YELLOW) ? Color.RED : Color.YELLOW;
+
+        int score = 0;
+
+        for (int r = 0; r < AvalamBoard.SIZE; r++) {
+            for (int c = 0; c < AvalamBoard.SIZE; c++) {
+
+                Tower t = b.getTowerAt(r, c);
+                if (t == null) continue;
+
+                int h = t.getHeight();
+                
+                // Pondération selon la hauteur (heuristique "Divine")
+                int value =
+                        (h == 5) ? 1000 :
+                        (h == 4) ? 300 :
+                        (h == 3) ? 120 :
+                        (h == 2) ? 40 : 10;
+
+                if (t.getColor() == myColor) score += value;
+                else score -= value;
+            }
+        }
+        return score;
+    }
+
+    /**
+     * Génère la liste de tous les coups possibles sur le plateau donné.
+     */
+    private List<AbstractPly> listMoves(IBoard board) {
+        List<AbstractPly> moves = new ArrayList<>();
+        board.iterator().forEachRemaining(moves::add);
+        return moves;
+    }
 }