Bot Divin (plus performant)

fr/iut_fbleau/Bot/DivineBot.java

@@ -4,46 +4,18 @@ import fr.iut_fbleau.Avalam.*;
 import fr.iut_fbleau.GameAPI.*;
 import java.util.*;
 
-/**
- * Bot expert utilisant l'algorithme Alpha-Beta pour le jeu Avalam.
- * * Idée :
- * - Explore l'arbre des coups possibles jusqu'à une profondeur donnée.
- * - Utilise l'élagage Alpha-Beta pour optimiser la recherche.
- * - Évalue les positions selon le contrôle des tours et leur hauteur.
- */
 public class DivineBot extends AbstractGamePlayer {
 
-    // Attributs
-
-    /** Joueur contrôlé par ce bot (PLAYER1 ou PLAYER2). */
     private final Player me;
-
-    /** Profondeur maximale de recherche (cut-off). */
     private final int maxDepth;
-
-    /** Générateur aléatoire pour départager les coups de même valeur. */
     private final Random rng = new Random();
 
-    // Constructeur
-
-    /**
-     * Construit un bot DivineBot.
-     * * @param p joueur contrôlé par ce bot
-     * @param maxDepth profondeur maximale de recherche
-     */
     public DivineBot(Player p, int maxDepth) {
         super(p);
         this.me = p;
         this.maxDepth = maxDepth; 
     }
 
-    // Méthodes
-
-    /**
-     * Méthode appelée par GameAPI : le bot doit choisir le meilleur coup possible.
-     * * @param board copie sûre de l'état de jeu (IBoard)
-     * @return le coup choisi (AbstractPly) ou null si aucun coup n'est possible
-     */
     @Override
     public AbstractPly giveYourMove(IBoard board) {
         if (board == null || board.isGameOver()) return null;
@@ -55,7 +27,7 @@ public class DivineBot extends AbstractGamePlayer {
         for (AbstractPly m : moves) {
             IBoard next = board.safeCopy();
             next.doPly(m);
-            // On calcule la valeur du plateau après ce coup
+            // On regarde l'avenir
             int value = alphaBeta(next, maxDepth - 1, Integer.MIN_VALUE, Integer.MAX_VALUE);
 
             if (value > bestValue) {
@@ -69,27 +41,18 @@ public class DivineBot extends AbstractGamePlayer {
         return bestMoves.get(rng.nextInt(bestMoves.size()));
     }
 
-    /**
-     * Fonction récursive Alpha-Beta pour évaluer l'arbre de décision.
-     * * @param board état actuel du plateau
-     * @param depth profondeur restante à explorer
-     * @param alpha borne inférieure
-     * @param beta borne supérieure
-     * @return la valeur de l'évaluation
-     */
     private int alphaBeta(IBoard board, int depth, int alpha, int beta) {
         if (board.isGameOver()) {
             Result r = board.getResult();
             if (r == Result.DRAW) return 0;
-            
+            // On vérifie strictement si MON joueur a gagné
-            boolean p1Wins = (r == Result.WIN);
+            boolean winP1 = (r == Result.WIN);
             boolean amIP1 = (me == Player.PLAYER1);
-            return (p1Wins == amIP1) ? 10000 : -10000;
+            return (winP1 == amIP1) ? 1000000 : -1000000;
         }
         
         if (depth == 0) return evaluate(board);
 
-        // Si c'est à moi de jouer, je maximise. Sinon, je minimise.
         boolean isMax = (board.getCurrentPlayer() == me);
         int best = isMax ? Integer.MIN_VALUE : Integer.MAX_VALUE;
 
@@ -110,18 +73,13 @@ public class DivineBot extends AbstractGamePlayer {
         return best;
     }
 
-    /**
-     * Heuristique spécifique à Avalam.
-     * Valorise le contrôle des tours, avec un bonus pour les tours de hauteur 5 (verrouillées).
-     * * @param board plateau à évaluer
-     * @return score numérique de la position (positif si avantageux)
-     */
     private int evaluate(IBoard board) {
         if (!(board instanceof AvalamBoard)) return 0;
         AvalamBoard b = (AvalamBoard) board;
-
+        
-        // Configuration des couleurs
+        // On définit clairement les couleurs
         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++) {
@@ -129,30 +87,66 @@ public class DivineBot extends AbstractGamePlayer {
                 Tower t = b.getTowerAt(r, c);
                 if (t == null || t.getHeight() == 0) continue;
 
-                // Une tour de 5 vaut beaucoup plus car elle est "verrouillée".
+                int h = t.getHeight();
-                int val = (t.getHeight() == 5) ? 10 : 1;
+                int weight = 0;
-                
+
-                if (t.getColor() == myColor) {
+                // Étape 1 : Est-ce que cette tour est "finie" ou isolée ?
-                    score += val;
+                if (h == 5 || isIsolated(b, r, c)) {
+                    weight = 1000; // Point sécurisé
                 } else {
-                    score -= val;
+                    // Étape 2 : Si la tour est prenable par l'ennemi
+                    if (isVulnerable(b, r, c, oppColor)) {
+                        // Si c'est ma tour, c'est un danger (-200)
+                        // Si c'est la sienne, c'est une opportunité (+50)
+                        weight = -200; 
+                    } else {
+                        // Étape 3 : Barème de progression sécurisée
+                        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 += weight;
+                else score -= weight;
             }
         }
         return score;
     }
 
-    /**
+    private boolean isIsolated(AvalamBoard b, int r, int c) {
-     * Récupère la liste de tous les coups légaux disponibles sur le plateau.
+        for (int dr = -1; dr <= 1; dr++) {
-     * * @param board plateau actuel
+            for (int dc = -1; dc <= 1; dc++) {
-     * @return liste des coups possibles
+                if (dr == 0 && dc == 0) continue;
-     */
+                Tower n = b.getTowerAt(r + dr, c + dc);
+                if (n != null && n.getHeight() > 0) return false;
+            }
+        }
+        return true;
+    }
+
+    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);
+                // Si un ennemi peut sauter dessus pour faire une tour <= 5
+                if (n != null && n.getColor() == enemyColor && (n.getHeight() + myHeight <= 5)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     private List<AbstractPly> listMoves(IBoard board) {
         List<AbstractPly> moves = new ArrayList<>();
         Iterator<AbstractPly> it = board.iterator();
-        while (it.hasNext()) {
+        while (it.hasNext()) moves.add(it.next());
-            moves.add(it.next());
-        }
         return moves;
     }
 }