From 4b2b37a04a7c0613ac0cb965649a1a0285af7fed Mon Sep 17 00:00:00 2001
From: vaisse <alistair@vaisse.etu.u-pec.fr>
Date: Tue, 3 Feb 2026 11:54:49 +0100
Subject: [PATCH] =?UTF-8?q?j'ai=20=C3=A9crit=20des=20trucs,=20mais=20il=20?=
 =?UTF-8?q?faut=20encore=20tester?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 javaAPI/fr/iut_fbleau/HexGame/Simulation.java | 136 +++++++++++++++++-
 1 file changed, 131 insertions(+), 5 deletions(-)

diff --git a/javaAPI/fr/iut_fbleau/HexGame/Simulation.java b/javaAPI/fr/iut_fbleau/HexGame/Simulation.java
index bf58cf0..49c34ca 100644
--- a/javaAPI/fr/iut_fbleau/HexGame/Simulation.java
+++ b/javaAPI/fr/iut_fbleau/HexGame/Simulation.java
@@ -10,7 +10,8 @@ public class Simulation extends AbstractGame {
     //ATTRIBUTS
     private HexPly bestmove;
     private float bestoutcome;
-    private int MAXDEPTH = 6;
+    private int MAXDEPTH = 9;
+    private int EVALDEPTH = 10;
     private LinkedList<Integer[]> taken = new LinkedList<Integer[]>();
 
     //ATTRIBUTS QUE JE NE VOUDRAIS PAS CRÉER IDÉALEMENT
@@ -25,13 +26,47 @@ public class Simulation extends AbstractGame {
     }
 
     //METHODES
+    /*Le jeu de Hex ne peut jamais finir avec le résultat null. En utilisant cette propriété, on peut avoir cet algorithme simplifié du monte-carlo*/
+    private float MonteCarlo(HexBoard position){
+        RandomBot simplay = new RandomBot();
+        HexBoard simpos = position.safeCopy(); 
+        LinkedList<Integer[]> ctaken = taken;
+        HexPly testmove;
+        float wins = 0;
+        float losses = 0;
+
+        for(int i=0; i<EVALDEPTH; i++){
+            while(!simpos.isGameOver()){
+                testmove = (HexPly) simplay.giveYourMove(simpos);
+                if(!ctaken.contains(t) && simpos.isLegal(testmove)){
+                    ctaken.add(new Integer[]{testmove.getRow(), testmove.getCol()});
+                    simpos.doPly(testmove);
+                    if(simpos.getResult()==Result.LOSS){
+                        losses++;
+                    } else if(simpos.getResult()==Result.WIN){
+                        wins++;
+                    }
+                }
+            }
+            simpos = position.safeCopy();
+            ctaken = taken;
+        }
+
+        if(wins>=losses){
+            return losses/wins;
+        } else {
+            return -(wins/losses);
+        }
+
+    }
+
     private float explMAX(HexBoard position, int depth){
         if (position.getResult()==Result.LOSS) {
             return -1.0f;
         } else if (position.getResult()==Result.WIN){
             return 1.0f;
         } else if (depth==MAXDEPTH) {
-            return 0f;
+            return MonteCarlo(position);
         } else {
                 float bestcase = -1.0f;
                 HexPly bestcasemove;
@@ -73,7 +108,7 @@ public class Simulation extends AbstractGame {
         } else if (position.getResult()==Result.WIN){
             return 1.0f;
         } else if (depth==MAXDEPTH) {
-            return 0f;
+            return MonteCarlo(position);
         } else {
                 float bestcase = 1.0f;
                 HexPly bestcasemove;
@@ -109,6 +144,97 @@ public class Simulation extends AbstractGame {
         }
     }
 
+    private float explMAXAB(HexBoard position, int depth, float A, float B){
+        if (position.getResult()==Result.LOSS) {
+            return -1.0f;
+        } else if (position.getResult()==Result.WIN){
+            return 1.0f;
+        } else if (depth==MAXDEPTH) {
+            return MonteCarlo(position);
+        } else {
+                float bestcase = A;
+                HexPly bestcasemove;
+                HexPly testmove;
+                for (int i=0; i<position.getSize(); i++) {
+                        for (int j=0; j<position.getSize(); j++) {
+                                if(depth==0){
+                                    //System.out.println("MAX New Line :");
+                                }
+                                Integer[] t = new Integer[]{i, j}; 
+                                testmove = new HexPly(Player.PLAYER1, i, j);
+                                if(!taken.contains(t) && position.isLegal(testmove)){
+                                        //System.out.println("  MAX test move : "+Integer.toString(i)+","+Integer.toString(j));
+                                        taken.add(t);
+                                        position.doPly(testmove);
+                                        float val = explMINAB(position, depth+1, bestcase, B);  
+                                        if (val >= bestcase) {
+                                                //System.out.println("     MAX new best case");
+                                                bestcase = val;
+                                                bestcasemove = testmove;
+                                                if (depth==0) {
+                                                    this.bestoutcome = bestcase;
+                                                    this.bestmove = bestcasemove;
+                                                }
+                                                if(bestcase>=B){
+                                                    return bestcase;
+                                                }
+                                        }
+                                        position.undoPly();
+                                        taken.remove(t);
+                                }
+                        }
+                }
+                return bestcase;
+        }
+    }
+
+    private float explMINAB(HexBoard position, int depth, A, B){
+        if (position.getResult()==Result.LOSS) {
+            return -1.0f;
+        } else if (position.getResult()==Result.WIN){
+            return 1.0f;
+        } else if (depth==MAXDEPTH) {
+            return MonteCarlo(position);
+        } else {
+                float bestcase = B;
+                HexPly bestcasemove;
+                HexPly testmove;
+                for (int i=0; i<position.getSize(); i++) {
+                        for (int j=0; j<position.getSize(); j++) {
+                                if(depth==0){
+                                    //System.out.println("MIN New Line :");
+                                }
+                                Integer[] t = new Integer[]{i, j}; 
+                                testmove = new HexPly(Player.PLAYER2, i, j);
+                                if(!taken.contains(t) && position.isLegal(testmove)){
+                                        //System.out.println("  MIN test move : "+Integer.toString(i)+","+Integer.toString(j));
+                                        taken.add(t);
+                                        position.doPly(testmove);
+                                        float val = explMAXAB(position, depth+1, A, bestcase);  
+                                        if (val <= bestcase) {
+                                                //System.out.println("     MIN new best case");
+                                                bestcase = val;
+                                                bestcasemove = testmove;
+                                                if (depth==0) {
+                                                    this.bestoutcome = bestcase;
+                                                    this.bestmove = bestcasemove;
+                                                }
+                                                if(bestcase<=A){
+                                                    return bestcase;
+                                                }
+                                        }
+                                        
+                                        position.undoPly();
+                                        taken.remove(t);
+                                }
+                        }
+                }
+                return bestcase;
+        }
+    }
+       
+
+
     private AbstractPly GiveBestMove(IBoard board) {
         if (!(board instanceof HexBoard)) {
             throw new IllegalArgumentException("Ce joueur attend un HexBoard.");
@@ -116,9 +242,9 @@ public class Simulation extends AbstractGame {
         HexBoard hb = (HexBoard) board;
         float bestcase;
         if(hb.getCurrentPlayer()==Player.PLAYER1){
-            bestcase = explMAX(hb, 0);
+            bestcase = explMAXAB(hb, 0, -1.0f, 1.0f);
         } else {
-            bestcase = explMIN(hb, 0);
+            bestcase = explMINAB(hb, 0, -1.0f, 1.0f);
         }
         return this.bestmove;
     }