Diagramme Avalam (simplifié)

Reviewed-on: #28

Diagrammes/Diagramme_Bot.mmd

@@ -24,9 +24,10 @@ classDiagram
         +DivineBot(Player p, int maxDepth)
         +giveYourMove(IBoard board) : AbstractPly
         -alphaBeta(IBoard board, int depth, int alpha, int beta) : int
-        -terminalValue(IBoard board): int
         -evaluate(IBoard board) : int
-        -listMoves(IBoard board): List<AbstractPly>
+        -isIsolated(AvalamBoard b, int r, int c) : boolean
+        -isVulnerable(AvalamBoard b, int r, int c, Color enemyColor) : boolean
+        -listMoves(IBoard board) : List~AbstractPly~
     }
 
     class IdiotBot{

README.md

@@ -123,3 +123,8 @@ Tans qu'un joueur peut effectuer un mouvement il a l'obligation de jouer, la par
 On compte alors combien de pions de chaque couleur occupent le sommet des tours restantes, le vainqueur étant évidemment celui qui en totalise le plus.
 Attention! Qu'une tour comporte 1,2,... ou 5 pions, elle vaut toujours UN point.
 
+## Arène de bots
+Dans ce mode de jeu, deux bots s'affrontent pour certains nombre de partie choisit, afin de voir quel bot gagne le plus.
+
+### Lancer parties
+Lancer parties permet de faire fonctionner l'arène. On choisit le premier bot pour le joueur1, et le deuxième pour le joueur deux. On choisit la profondeurs de recherches pour les bots intelligent, puis enfin le nombre de partie que doivent effectués les bots. Enfin il suffit pour voir l'entièreté des résultats, si y a beaucoup de parties, sinon, on peut voir les parties se déroulé pendant la session.

fr/iut_fbleau/Avalam/ArenaWindow.java

@@ -192,24 +192,55 @@ public class ArenaWindow extends JFrame {
      * @param nbParties nombre de parties à jouer
      */
     private void runArena(String bot1Type, String bot2Type, int depth, int nbParties) {
-        // Créer les bots
-        AbstractGamePlayer bot1 = createBot(bot1Type, Player.PLAYER1, depth);
-        AbstractGamePlayer bot2 = createBot(bot2Type, Player.PLAYER2, depth);
-
-        if (bot1 == null || bot2 == null) {
-            JOptionPane.showMessageDialog(this, "Erreur lors de la création des bots.");
-            return;
-        }
-
         // Vider le tableau
         tableModel.setRowCount(0);
         results.clear();
 
-        // Charger le plateau initial
-        Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
+        // 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;
 
-        // Lancer les parties
             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);
 
@@ -217,28 +248,64 @@ public class ArenaWindow extends JFrame {
                     Result result = game.run();
                     String winner = getWinnerName(result, bot1Type, bot2Type);
                     
-                // Ajouter au tableau
+                    // 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 " + i,
+                                "Partie " + partieNum,
                                 bot1Type,
                                 bot2Type,
                                 winner
                         });
+                    });
                 } catch (Exception e) {
+                    errors++;
+                    SwingUtilities.invokeLater(() -> {
                         tableModel.addRow(new Object[]{
-                        "Partie " + i,
+                                "Partie " + partieNum,
                                 bot1Type,
                                 bot2Type,
                                 "Erreur: " + e.getMessage()
                         });
+                    });
                 }
             }
             
-        // Afficher un message de fin avec possibilité de quitter directement
+            // 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,
-                "Toutes les parties sont terminées !",
+                        statsMessage,
                         "Arène terminée",
                         JOptionPane.DEFAULT_OPTION,
                         JOptionPane.INFORMATION_MESSAGE,
@@ -250,6 +317,10 @@ public class ArenaWindow extends JFrame {
                 if (choice == 1) {
                     System.exit(0);
                 }
+            });
+        });
+
+        arenaThread.start();
     }
 
     /**

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++)
-                this.grid[r][c] = initialGrid[r][c];
+            for (int c = 0; c < SIZE; 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());
+                }
+            }
     }
 
     /**

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -233,7 +233,6 @@ 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());
         }
 

fr/iut_fbleau/Bot/DivineBot.java

@@ -2,74 +2,53 @@ package fr.iut_fbleau.Bot;
 
 import fr.iut_fbleau.Avalam.*;
 import fr.iut_fbleau.GameAPI.*;
-
 import java.util.*;
 
 /**
- * Bot "Divin" (alpha-beta + évaluateur pondéré).
- * * Idée :
- * - Utilise l'algorithme Alpha-Beta pour anticiper les coups.
- * - Évalue les plateaux non terminaux en accordant plus d'importance aux tours hautes.
+ * Bot expert pour le jeu Avalam utilisant l'algorithme Alpha-Beta.
+ * * Ce bot évalue le plateau en fonction du contrôle des tours, 
+ * de leur isolation (points sécurisés) et de leur vulnérabilité.
  */
 public class DivineBot extends AbstractGamePlayer {
 
-    // Attributs
-
-    /** Joueur contrôlé par ce bot (PLAYER1 ou PLAYER2). */
+    /** Joueur contrôlé par le bot. */
     private final Player me;
 
-    /** Profondeur maximale de recherche avant évaluation. */
+    /** Profondeur de recherche dans l'arbre des coups. */
     private final int maxDepth;
 
-    /** Générateur aléatoire pour choisir parmi les meilleurs coups équivalents. */
+    /** Générateur aléatoire pour choisir entre des coups d'égale valeur. */
     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
+     * Constructeur du DivineBot.
+     * @param p le joueur (P1 ou P2).
+     * @param maxDepth la profondeur d'anticipation.
      */
     public DivineBot(Player p, int maxDepth) {
         super(p);
         this.me = p;
-        this.maxDepth = Math.max(1, maxDepth);
+        this.maxDepth = 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)
+     * Calcule et retourne le meilleur coup possible.
+     * @param board l'état actuel du jeu.
+     * @return le coup sélectionné.
      */
     @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;
+        int bestValue = Integer.MIN_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);
+            int value = alphaBeta(next, maxDepth - 1, Integer.MIN_VALUE, Integer.MAX_VALUE);
 
-            // 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();
@@ -77,73 +56,48 @@ public class DivineBot extends AbstractGamePlayer {
             } 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.
+     * Algorithme Alpha-Beta pour optimiser la recherche du meilleur score.
      */
     private int alphaBeta(IBoard board, int depth, int alpha, int beta) {
+        if (board.isGameOver()) {
+            Result r = board.getResult();
+            if (r == Result.DRAW) return 0;
+            return (r == Result.WIN == (me == Player.PLAYER1)) ? 1000000 : -1000000;
+        }
         
-        // 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;
+        boolean isMax = (board.getCurrentPlayer() == me);
+        int best = isMax ? Integer.MIN_VALUE : Integer.MAX_VALUE;
 
         for (AbstractPly m : listMoves(board)) {
             IBoard next = board.safeCopy();
             next.doPly(m);
-
             int val = alphaBeta(next, depth - 1, alpha, beta);
 
             if (isMax) {
-                alpha = Math.max(alpha, val);
-                if (alpha >= beta) break; // Coupure Beta
+                best = Math.max(best, val);
+                alpha = Math.max(alpha, best);
             } else {
-                beta = Math.min(beta, val);
-                if (alpha >= beta) break; // Coupure Alpha
+                best = Math.min(best, val);
+                beta = Math.min(beta, best);
             }
+            if (alpha >= beta) break;
         }
-
-        return isMax ? alpha : beta;
+        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.
+     * Analyse la situation actuelle et attribue un score au plateau.
+     * @param board le plateau à analyser.
+     * @return le score (positif si avantageux pour le bot).
      */
     private int evaluate(IBoard board) {
-
         if (!(board instanceof AvalamBoard)) return 0;
         AvalamBoard b = (AvalamBoard) board;
         
@@ -151,35 +105,76 @@ public class DivineBot extends AbstractGamePlayer {
         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;
+                if (t == null || t.getHeight() == 0) continue;
 
                 int h = t.getHeight();
+                int weight = 0;
 
-                // Pondération selon la hauteur (heuristique "Divine")
-                int value =
-                        (h == 5) ? 1000 :
-                        (h == 4) ? 300 :
-                        (h == 3) ? 120 :
-                        (h == 2) ? 40 : 10;
+                // Points sécurisés (isolation ou hauteur max)
+                if (h == 5 || isIsolated(b, r, c)) {
+                    weight = 1000; 
+                } else {
+                    // Gestion de la vulnérabilité face à l'ennemi
+                    if (isVulnerable(b, r, c, oppColor)) {
+                        weight = -200; 
+                    } else {
+                        switch (h) {
+                            case 4: weight = 400; break; 
+                            case 3: weight = 150; break;
+                            case 2: weight = 60;  break;
+                            default: weight = 10; break;
+                        }
+                    }
+                }
                 
-                if (t.getColor() == myColor) score += value;
-                else score -= value;
+                if (t.getColor() == myColor) score += weight;
+                else score -= weight;
             }
         }
         return score;
     }
 
     /**
-     * Génère la liste de tous les coups possibles sur le plateau donné.
+     * Vérifie si une tour n'a plus de voisins (point bloqué).
+     */
+    private boolean isIsolated(AvalamBoard b, int r, int c) {
+        for (int dr = -1; dr <= 1; dr++) {
+            for (int dc = -1; dc <= 1; dc++) {
+                if (dr == 0 && dc == 0) continue;
+                Tower n = b.getTowerAt(r + dr, c + dc);
+                if (n != null && n.getHeight() > 0) return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Vérifie si l'adversaire peut capturer la tour au prochain coup.
+     */
+    private boolean isVulnerable(AvalamBoard b, int r, int c, Color enemyColor) {
+        int myHeight = b.getTowerAt(r, c).getHeight();
+        for (int dr = -1; dr <= 1; dr++) {
+            for (int dc = -1; dc <= 1; dc++) {
+                if (dr == 0 && dc == 0) continue;
+                Tower n = b.getTowerAt(r + dr, c + dc);
+                if (n != null && n.getColor() == enemyColor && (n.getHeight() + myHeight <= 5)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Liste tous les coups possibles sur le plateau actuel.
      */
     private List<AbstractPly> listMoves(IBoard board) {
         List<AbstractPly> moves = new ArrayList<>();
-        board.iterator().forEachRemaining(moves::add);
+        Iterator<AbstractPly> it = board.iterator();
+        while (it.hasNext()) moves.add(it.next());
         return moves;
     }
 }