Debug Commit 2

src/tictactoecodingame/AlgoRechercheMCTS.java

@@ -14,31 +14,55 @@ import java.util.Random;
  * @author timot
  */
 public class AlgoRechercheMCTS extends AlgoRecherche {
-    ArbreMCTS search;
-    int maxIterations;
+    private final ArbreMCTS search;
+    private final int maxIterations;
+    private final Random seed;
+    private ArrayList<Integer> chemin;
+    private final double coeff;
     
-    public AlgoRechercheMCTS(Joueur player, Joueur opponent, int m){
+    public AlgoRechercheMCTS(Joueur player, Joueur opponent, int m, double c){
         search = new ArbreMCTS(player, opponent);
         maxIterations = m;
+        seed = new Random();
+        coeff = c;
     }
     
     @Override
     public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean _ponder) {
+
+        Coup lastPlayed = _plateau.getDernierCoup();
+        if(search.root().coup() == null){
+            search.root().coup(lastPlayed);
+            expansion(search.root(), _plateau);
+        }
+        Node tmp = null;
+        Iterator<Node> children = search.root().children().iterator();
+        if(lastPlayed != null){
+            while(children.hasNext()){
+                tmp = children.next();
+                if(tmp.coup().equals(lastPlayed)){
+                    search.root(tmp);
+                }
+            }
+        }
         Node root = search.root();
         _plateau.sauvegardePosition(0);
         int iterations = 0;
-        Random seed = new Random();
+        int trivial = 0;
         while(iterations < maxIterations){
             iterations++;
-            Node nextNode = selection(root);
+            chemin = new ArrayList<>();
+            Node nextNode = selection(root, _plateau);
             if(!_plateau.partieTerminee()){
                 expansion(nextNode, _plateau);
+                trivial++;
             }
             if(!nextNode.children().isEmpty()){
                 nextNode = nextNode.children().get(seed.nextInt(nextNode.children().size()));
+                _plateau.joueCoup(nextNode.coup());
             }
             Joueur winner = simulate(nextNode, _plateau);
-            update(winner, nextNode);
+            backPropagation(root, winner);
             _plateau.restaurePosition(0);
         }
         Node nextPlay = root.nextPlay();
@@ -46,12 +70,32 @@ public class AlgoRechercheMCTS extends AlgoRecherche {
         return nextPlay.coup();
     }
     
-    private Node selection(Node root){
-        Node currentNode = root;
-        while(!(currentNode.children().isEmpty())){
-            currentNode = Fraction.bestChild(currentNode);
+    public Node selection(Node n, Plateau pl){
+        if (n.children().isEmpty()){
+	    return n;
         }
-        return currentNode;
+        else {
+            double valMax=Double.NEGATIVE_INFINITY;
+            int indiceSelection=0;
+            ArrayList<Node> f = n.children();
+            double val;
+            for(int i = 0; i < f.size(); i++){
+                Node nf = f.get(i);
+                if(nf.visits() == 0){
+                    val = Double.MAX_VALUE;
+                }else{
+                    val = (nf.wins()/nf.visits())+coeff*Math.sqrt(Math.log(n.visits())/nf.visits());
+                }
+                if (val>valMax){
+                    indiceSelection=i;
+                    valMax=val;
+                }
+            }
+            Node noeudSelectionne=f.get(indiceSelection);
+	    pl.joueCoup(noeudSelectionne.coup());
+            chemin.add(indiceSelection);
+            return selection(noeudSelectionne, pl);
+        }       
     }
     
     private void expansion(Node leaf, Plateau leafPlateau){
@@ -68,7 +112,6 @@ public class AlgoRechercheMCTS extends AlgoRecherche {
     private Joueur simulate(Node node, Plateau board){
         Joueur p1 = node.player();Joueur p2 = node.opponent();
         Joueur currentPlayer = node.player();
-        Random seed = new Random();
         Coup coup;
         ArrayList<Coup> coups;
         while(!board.partieTerminee()){
@@ -84,14 +127,19 @@ public class AlgoRechercheMCTS extends AlgoRecherche {
         return board.vainqueur();
     }
     
-    private void update(Joueur winner, Node node){
-        Node currentNode = node;
-        while(currentNode != null){
+    public void backPropagation(Node n, Joueur gagnant){
+        Node currentNode = n; int index = 0;
+        do{
             currentNode.addVisit();
-            if(currentNode.player().equals(winner)){
+            if (currentNode.player().equals(gagnant)){
                 currentNode.addWin();
             }
-            currentNode = currentNode.parent();
+            currentNode = currentNode.children().get(chemin.get(index));
+            index++;
+        }while(index < chemin.size());
+        currentNode.addVisit();
+        if (currentNode.player().equals(gagnant)){
+            currentNode.addWin();
         }
     }
     

src/tictactoecodingame/ArbreMCTS.java

@@ -10,7 +10,7 @@ package tictactoecodingame;
  * @author timot
  */
 public class ArbreMCTS {
-    Node root;
+    private Node root;
     
     public ArbreMCTS(Joueur pl, Joueur o){
         root = new Node(null, pl, o);

src/tictactoecodingame/Node.java

@@ -12,12 +12,12 @@ import java.util.Iterator;
  * @author timot
  */
 public class Node {
-    Coup coup;
-    Joueur player;
-    Joueur opponent;
-    int visits = 0;
-    int wins = 0;
-    ArrayList<Node> children;
+    private Coup coup;
+    private final Joueur player;
+    private final Joueur opponent;
+    private int visits = 0;
+    private int wins = 0;
+    private final ArrayList<Node> children;
     
     public Node(Coup c, Joueur pl, Joueur o){
         coup = c;
@@ -46,9 +46,13 @@ public class Node {
         return children;
     }
 
-        public Coup coup(){
+    public Coup coup(){
         return coup;
     }
+    
+    public void coup(Coup c){
+        coup = c;
+    }
        
     public void addVisit(){
         visits++;
@@ -57,20 +61,24 @@ public class Node {
     public void addWin(){
         wins++;
     }
+    
+    public double winrate(){
+        if(visits == 0){
+            return 0;
+        }else{
+            return wins/visits;
+        }
+    }
      
     public Node nextPlay(){
         Node bestNode = null;
-        double winrate = 0;
+        double winrate = Double.NEGATIVE_INFINITY;
         Iterator<Node> child = children.iterator();
         Node currentNode; double currentWinrate;
         while(child.hasNext()){
             currentNode = child.next();
-            if(currentNode.visits == 0 ){
-                currentWinrate = 0;
-            }else{
-                currentWinrate = currentNode.wins() / currentNode.visits();
-            }
-            if( currentWinrate > winrate){
+            currentWinrate = currentNode.winrate();
+            if(currentWinrate > winrate){
                 winrate = currentWinrate;
                 bestNode = currentNode;
             }

src/tictactoecodingame/Player.java

@@ -18,7 +18,7 @@ public class Player {
         
         // Remplacer ici l'algorithme aléatoire par votre algorithme. 
         // Créer une nouvelle classe qui hérite de la class AlgoRecherche
-        AlgoRechercheMCTS alea  = new AlgoRechercheMCTS(joueurOrdi, humain, 100);   // L'ordinateur joue au hasard
+        AlgoRechercheMCTS alea  = new AlgoRechercheMCTS(joueurOrdi, humain, 1000,0.1);
         joueurOrdi.setAlgoRecherche(alea);                              
              
         GrilleTicTacToe3x3 grille = new GrilleTicTacToe3x3();