Debug commit

nbproject/private/private.properties

@@ -11,5 +11,5 @@ do.depend=false
 do.jar=true
 javac.debug=true
 javadoc.preview=true
-user.properties.file=C:\\Users\\senda\\AppData\\Roaming\\NetBeans\\8.0.2\\build.properties
+user.properties.file=C:\\Users\\timot\\AppData\\Roaming\\NetBeans\\11.2\\build.properties
 >>>>>>> 4dd14568c244c833d17b679f8f3b340f997c8d04

nbproject/private/private.xml

@@ -3,7 +3,10 @@
     <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="0"/>
     <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2">
         <group>
-            <file>file:/home/louis/Documents/IMT/ProjetInfo/src/tictactoecodingame/Player.java</file>
+            <file>file:/C:/Users/timot/OneDrive/Desktop/2019-2020/Projet-Informatique/tmp/src/tictactoecodingame/Fraction.java</file>
+            <file>file:/C:/Users/timot/OneDrive/Desktop/2019-2020/Projet-Informatique/tmp/src/tictactoecodingame/Node.java</file>
+            <file>file:/C:/Users/timot/OneDrive/Desktop/2019-2020/Projet-Informatique/tmp/src/tictactoecodingame/Arbre.java</file>
+            <file>file:/C:/Users/timot/OneDrive/Desktop/2019-2020/Projet-Informatique/tmp/src/tictactoecodingame/AlgoRechercheMCTS.java</file>
         </group>
     </open-files>
 </project-private>

src/tictactoecodingame/AlgoRechercheMCTS.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Random;
+
+/**
+ *
+ * @author timot
+ */
+public class AlgoRechercheMCTS extends AlgoRecherche {
+    Arbre search;
+    
+    public AlgoRechercheMCTS(Joueur player, Joueur opponent){
+        search = new Arbre(player, opponent);
+    }
+    
+    @Override
+    public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean _ponder) {
+        search = new Arbre(search.root().player(), search.root().opponent());
+        Node root = search.root();
+        root.board((new Node(_plateau)).board());
+        int iterations = 0;
+        Random seed = new Random();
+        while(iterations < 1){
+            iterations++;
+            Node nextNode = selection(root);
+            if(!nextNode.board().partieTerminee()){
+                expansion(nextNode);
+            }
+            if(!nextNode.children().isEmpty()){
+                nextNode = nextNode.children().get(seed.nextInt(nextNode.children().size()));
+            }
+            Joueur winner = simulate(nextNode);
+            update(winner, nextNode);
+        }
+        
+        Node nextPlay = root.nextPlay();
+        search.root(nextPlay);
+        return nextPlay.board().getDernierCoup();
+    }
+    
+    private Node selection(Node root){
+        Node currentNode = root;
+        while(!(currentNode.children().isEmpty())){
+            currentNode = Fraction.bestChild(currentNode);
+        }
+        return currentNode;
+    }
+    
+    private void expansion(Node leaf){
+        ArrayList<Coup> coups = leaf.getCoups();
+        Iterator<Coup> coup = coups.iterator();
+        Plateau leafPlateau = (new Node(leaf.board(), null, null, null)).board();
+        Coup currentCoup;
+        while(coup.hasNext()){
+            currentCoup = coup.next();
+            leafPlateau.joueCoup(currentCoup);
+            Node newLeaf = new Node(leafPlateau, leaf.opponent(), leaf.player(), leaf);
+            leafPlateau.annuleDernierCoup();
+            leaf.children().add(newLeaf);
+        }
+    }
+    
+    private Joueur simulate(Node node){
+        Node tmp = new Node(node.board(), node.player(), node.opponent(), node.parent());
+        Plateau board = tmp.board();
+        Joueur p1 = node.player();Joueur p2 = node.opponent();
+        Joueur currentPlayer = node.player();
+        Random seed = new Random();
+        while(!board.partieTerminee()){
+            ArrayList<Coup> coups = board.getListeCoups(currentPlayer);
+            Coup coup = coups.get(seed.nextInt(coups.size()));
+            board.joueCoup(coup);
+            if(currentPlayer.equals(p1)){
+                currentPlayer = p2;
+            }else{
+                currentPlayer = p1;
+            }
+        }
+        return board.vainqueur();
+    }
+    
+    private void update(Joueur winner, Node node){
+        Node currentNode = node;
+        while(currentNode != null){
+            currentNode.addVisit();
+            if(currentNode.player() == winner){
+                currentNode.addWin();
+            }
+            currentNode = currentNode.parent();
+        }
+    }
+    
+}

src/tictactoecodingame/Arbre.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+/**
+ *
+ * @author timot
+ */
+public class Arbre {
+    Node root;
+    
+    public Arbre(Joueur pl, Joueur o){
+        root = new Node(null, pl, o, null);
+    }
+    
+    public Node root(){
+        return root;
+    }
+    
+    public void root(Node r){
+        root = r;
+    }
+}

src/tictactoecodingame/Fraction.java

@@ -5,53 +5,35 @@
  */
 package tictactoecodingame;
 
+import java.util.ArrayList;
+
 /**
  *
  * @author louis
  */
 public class Fraction {
-    int num;
-    int den;
-    
-    public Fraction(int n, int d){
-        num=n;
-        den=d;
-    }
-    
-    public Fraction(){
-        num=0;
-        den=0;
-    }
-    
-    public Fraction(int n){
-        num=n;
-        den=1;
-    }
     
-    public int getScore(){
-        return num;
-    }
-            
-    public double getNote(){
-        try{
-            return num/den;
+    public static double frctValue(int parentVisit, int visits, int wins){
+        if(visits == 0){
+            return Integer.MAX_VALUE;
         }
-        catch(ArithmeticException e){return 1.;}
+        return (wins/visits) * 1.41 * Math.sqrt(Math.log(parentVisit) / visits);
     }
     
-    public int getNumerateur(){
-        return num;
-    }
-    
-    public int getDenominateur(){return den;}
-    
-    public void setDenominateur(int d){den=d;}
-    
-    public void setNumerateur(int n){
-        num=n;
+    public static Node bestChild(Node root){
+        int parentVisit = root.visits();
+        int maxIndex = 0;
+        double maxScore = 0;
+        ArrayList<Node> children = root.children();
+        double currentScore; Node currentNode;
+        for(int i = 0; i < children.size(); i++){
+            currentNode = children.get(i);
+            currentScore = frctValue(parentVisit, currentNode.visits(), currentNode.wins());
+            if(currentScore > maxScore){
+                maxScore = currentScore;
+                maxIndex = i;
+            }
+        }
+        return children.get(maxIndex);
     }
-    
-    public void incrementeNumerateur(){num+=1;}
-    
-    public void incrementeDenominateur(){den+=1;}
 }

src/tictactoecodingame/Node.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+/**
+ *
+ * @author timot
+ */
+public class Node {
+    Plateau board;
+    Joueur player;
+    Joueur opponent;
+    int visits = 0;
+    int wins = 0;
+    Node parent;
+    ArrayList<Node> children;
+    
+    public Node(Plateau b, Joueur pl, Joueur o, Node pr){
+        board = b;
+        player = pl;
+        opponent = o;
+        parent = pr;
+        children = new ArrayList<>();
+    }
+    
+    public Node(Plateau b){
+        board = b;
+    }
+    
+    public ArrayList<Coup> getCoups(){
+        return board.getListeCoups(player);
+    }
+    
+    public Node parent(){
+        return parent;
+    }
+    
+    public int visits(){
+        return visits;
+    }
+    
+    public int wins(){
+        return wins;
+    }
+    
+    public Plateau board(){
+        return board;
+    }
+    
+    public Joueur player(){
+        return player;
+    }
+    
+    public Joueur opponent(){
+        return opponent;
+    }
+    
+    public ArrayList<Node> children(){
+        return children;
+    }
+    
+    public void addVisit(){
+        visits++;
+    }
+    
+    public void addWin(){
+        wins++;
+    }
+    
+    public void board(Plateau p){
+        board = p;
+    }
+    
+    public Node nextPlay(){
+        Node bestNode = null;
+        double winrate = 0;
+        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){
+                winrate = currentWinrate;
+                bestNode = currentNode;
+            }
+        }
+        return bestNode;
+    }
+}