Final commit 1

src/tictactoecodingame/AlgoRechercheMinMax.java

@@ -51,11 +51,7 @@ public class AlgoRechercheMinMax extends AlgoRecherche{
         return depth;
     }
     
-    public Joueur[] getPlayers(Joueur joueur1, Joueur joueur2){
-        Joueur[] players = {target, opponent};
-        return players;
-    }
-    
+    @Override
     public Coup meilleurCoup( Plateau _plateau , Joueur _joueur , boolean _ponder ){
         //On part du principe que la partie n'est pas terminée donc qu'il reste au moins un coup
         plateau = _plateau;
@@ -92,7 +88,6 @@ public class AlgoRechercheMinMax extends AlgoRecherche{
             plateau.sauvegardePosition(currentDepth);
         }
         //On crée les nouveau noeuds à partir des coups disponible du point de vue du joueur à ce niveau de l'arbre
-        ArrayList<Coup> coups = plateau.getListeCoups(currentJoueur);
         if(plateau.partieTerminee()){
             Joueur winner = plateau.vainqueur();
             if(winner == target){
@@ -110,7 +105,8 @@ public class AlgoRechercheMinMax extends AlgoRecherche{
             t.setvalue(c);
         }
         else{
-            ArrayList<ArbreMinMax> fils = new ArrayList<ArbreMinMax>();
+            ArrayList<Coup> coups = plateau.getListeCoups(currentJoueur);
+            ArrayList<ArbreMinMax> fils = new ArrayList<>();
             for(int i=0; i<coups.size();i++){
                 ArbreMinMax a = new ArbreMinMax(coups.get(i));
                 if(currentJoueur == target){

src/tictactoecodingame/ArbreMCTS.java

@@ -5,111 +5,27 @@
  */
 package tictactoecodingame;
 
-import java.util.ArrayList;
-
 /**
  *
- * @author senda
+ * <div>Cette classe englobe la structure de noeud en un arbre, et permets d'agir sur sa racine.</div>
  */
 public class ArbreMCTS {
+    private Node root;
     
-    private Fraction value;
-    private ArrayList<Coup> coups;
-    private ArrayList<ArbreMCTS> fils;
-    
-    // Les constructeurs :
-    public ArbreMCTS (Fraction value, ArrayList coups, ArrayList fils){
-        this.value = value;
-        this.fils = fils;
-        this.coups = coups;
-    }
-    
-
-    public ArbreMCTS (int den, int num, ArrayList coups, ArrayList fils){
-        this.value.den = den;
-        this.value.num = num;
-        this.fils = fils;
-        this.coups = coups;
-    }
-    
-    public ArbreMCTS (Fraction value, Plateau _plateau, Joueur _joueur){
-        this.value = value;
-        this.coups = _plateau.getListeCoups(_joueur) ;
-        int a = coups.size();
-        fils = new ArrayList();
-        for(int i = 0; i < a ; i++){
-            ArbreMCTS Arbre_i = new ArbreMCTS(new Fraction()); // Attention ! Ce constructeur initialise donc avec des valeurs nulles en racine !
-            fils.add(Arbre_i);
-        }
-        
-    }
-    
-    public ArbreMCTS (Fraction value){
-        this.value = value;
-    }
-    
-
-    public ArbreMCTS (int den, int num){
-        this.value.den = den;
-        this.value.num = num;
-    }
-    
-    // Les accesseurs :
-    public Fraction getFraction(){
-        return value;
-    }
-    
-    public double getvalue(){
-        return(value.getNote());
-    }
-    
-    public ArrayList<ArbreMCTS> getfils(){
-        return(fils);
-    }
-       
-    public ArrayList<Coup> getcoups(){
-        return(coups);
-    }
-    
-    public Fraction getFrac(){
-        return(this.value);
-    }
-    
-    //Des choses sans nom :
-    public void setvalue(Fraction value){
-        this.value = value;
-    }
-    
-    public void setfils(ArrayList fils){
-        this.fils = fils;
-    }
-    
-    public void setcoups(ArrayList coups){
-        this.coups = coups;
-    }
-    
-    //Fonctions auxiliaires :
-    public boolean estFeuille(){
-        return(fils == null);
+    /**
+     * <div>Initialisation d'un arbre : La racine représente un plateau vide.</div>
+     * @param pl Le joueur qui va jouer.
+     * @param o  Le joueur qui vient de jouer.
+     */
+    public ArbreMCTS(Joueur pl, Joueur o){
+        root = new Node(null, pl, o);
     }
     
-    public boolean estNoeud(){
-        return(fils != null);
+    public Node root(){
+        return root;
     }
     
-    public int hauteur(){
-        if(this.estFeuille()){
-            return 1;
-        }
-        else{
-            int a = this.fils.size();
-            ArbreMCTS fils0 = this.fils.get(0);
-            int maxfils = fils0.hauteur();
-            for (int i = 1; i < a; i++){
-                ArbreMCTS next = this.fils.get(i);
-                maxfils = Math.max(next.hauteur(),maxfils);
-            }
-            return(1 + maxfils);   
-        }
+    public void root(Node r){
+        root = r;
     }
 }

src/tictactoecodingame/ArbreMinMax.java

@@ -6,7 +6,6 @@
 package tictactoecodingame;
 
 import java.util.ArrayList;
-import static tictactoecodingame.Generator.random_tests;
 
 /**
  *

src/tictactoecodingame/GrilleTicTacToe9x9.java

@@ -21,9 +21,10 @@ public class GrilleTicTacToe9x9 extends Plateau {
     int nbPostionSauvegarde;
 
     CoupTicTacToe dernierCoup;
-    CoupTicTacToe dernierCoupSav;
+    CoupTicTacToe[] dernierCoupSav = new CoupTicTacToe[100];
     Joueur vainqueur;
-    boolean grilleGagnee , grilleGagneeSav;  // vrai si dernier coup gagne une grille
+    boolean grilleGagnee ;
+    boolean[] grilleGagneeSav = new boolean[100];  // vrai si dernier coup gagne une grille
 
     @Override
     public void init() {
@@ -296,8 +297,8 @@ public class GrilleTicTacToe9x9 extends Plateau {
                 grille3x3Sav[_index][c][l] = grille3x3[c][l];
             }
         }
-        dernierCoupSav = dernierCoup;
-        grilleGagneeSav = grilleGagnee;
+        dernierCoupSav[_index] = dernierCoup;
+        grilleGagneeSav[_index] = grilleGagnee;
        
 
     }
@@ -317,8 +318,8 @@ public class GrilleTicTacToe9x9 extends Plateau {
             }
         }
         vainqueur = null;
-        dernierCoup = dernierCoupSav;
-        grilleGagnee = grilleGagneeSav;
+        dernierCoup = dernierCoupSav[_index];
+        grilleGagnee = grilleGagneeSav[_index];
     }
 
     private boolean isGrillePleine() {

src/tictactoecodingame/Joueur.java

@@ -30,6 +30,7 @@ public abstract class Joueur {
 	}
 	abstract public Coup joue( Plateau p_plateau );
 	
+        @Override
 	public String toString() {
 		return nom;
 	}

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;
+/**
+ *
+ * <div>Cette classe instancie les noeuds d'un arbre. Chaque noeud contient un certain nombre d'informations :</div>
+ * <ul>
+ * <li>Un coup : Ce coup représente le coup qui <strong>vient</strong> d'être joué.</li>
+ * <li>Deux joueurs : Ces joueurs représentent respectivement le joueur qui va jouer, et son adversaire, soit le joueur qui vient
+ * de jouer.</li> 
+ * <li>Trois entiers : Ces entiers comptent le nombre de victoires, égalités et nombre total de parties jouées passant par ce noeud.
+ * Les victoires sont comptées pour le joueur qui vient de jouer, c'est à dire opponent, étant donné que ces valeurs sont uniquement
+ * lues depuis le contexte de leur parent dans l'arbre, où opponent devient player.</li>
+ * <li>Une liste de Node : Cette liste représente simplement les enfants du noeud.</li>
+ * <li>Un booléen : Ce booléen indique si le noeud est résolu. Un noeud résolu est un noeud représentant une partie terminée, ou un
+ * noeud dont tous les fils sont résolus.</li>
+ * </ul>
+ */
+public class Node {
+    private final Coup coup;
+    private final Joueur player;
+    private final Joueur opponent;
+    private int visits = 0;
+    private int wins = 0;
+    private int draws = 0;
+    private final ArrayList<Node> children;
+    private boolean solved = false;
+    
+    /**
+     * <div>Initialisation standard d'un Node</div>
+     * @param c Le coup qui vient d'être joué.
+     * @param pl Le joueur qui va jouer le prochain coup.
+     * @param o Le joueur qui vient de jouer le coup c.
+     */
+    public Node(Coup c, Joueur pl, Joueur o){
+        coup = c;
+        player = pl;
+        opponent = o;
+        children = new ArrayList<>();
+    }
+    
+    //Les accesseurs et modifieurs nécessaires
+    public int visits(){
+        return visits;
+    }
+    
+    public int wins(){
+        return wins;
+    }
+    
+    public int draws(){
+        return draws;
+    }
+    
+    public Joueur player(){
+        return player;
+    }
+    
+    public Joueur opponent(){
+        return opponent;
+    }
+    
+    public ArrayList<Node> children(){
+        return children;
+    }
+
+    public Coup coup(){
+        return coup;
+    }
+    
+    public boolean solved(){
+        return solved;
+    }
+    
+    public void solved(boolean s){
+        solved = s;
+    }
+    
+    //Les fonctions permettant d'incrémenter le nombre de visites, victoires et égalités.
+    public void addVisit(){
+        visits++;
+    }
+    
+    public void addWin(){
+        wins ++;
+    }
+    
+    public void addDraw(){
+        draws++;
+    }
+
+    /** <div>Une fonction permettant de calculer le taux de victoire d'un noeud.Ce taux peut prendre en compte les égalités, en fonction
+    du coefficient rentré.</div>
+    @return Le taux de victoire.
+    */
+    public double winrate(){
+        if(visits == 0){
+            return 0;
+        }else{
+            return (wins + 0.3*draws)/visits;
+        }
+    }
+    
+    /** <div>Une fonction permettant de trouver le Node fils avec le meilleur taux de victoire.</div>
+     * @return Le Node avec le meilleur taux de victoire de tous les fils de son père.
+     */
+    public Node nextPlay(){
+        Node bestNode = null;
+        double winrate = Double.NEGATIVE_INFINITY;
+        Iterator<Node> child = children.iterator();
+        Node currentNode; double currentWinrate;
+        while(child.hasNext()){
+            currentNode = child.next();
+            currentWinrate = currentNode.winrate();
+            if(currentWinrate > winrate){
+                winrate = currentWinrate;
+                bestNode = currentNode;
+            }
+        }
+        return bestNode;
+    }
+    
+    //Une méthode permettant de visualiser les informations d'un noeud. Surtout utile pendant le débogage.
+    @Override
+    public String toString(){
+        return coup.toString() + "  " + visits + "  " + winrate() * 100;
+    }
+}

src/tictactoecodingame/Player.java

@@ -16,14 +16,15 @@ public class Player {
         JoueurOrdi joueurOrdi1 = new JoueurOrdi("Ordi1");
         JoueurOrdi joueurOrdi2 = new JoueurOrdi("Ordi2");
         //Il faut deux joueurs car l'id fixe le jeton
-       
         
+        GrilleTicTacToe9x9 grille = new GrilleTicTacToe9x9();
 
         AlgoRechercheMinMax minmax  = new AlgoRechercheMinMax(3, 10, joueurOrdi1, joueurOrdi2);
+        AlgoRechercheMCTS mcts1000 = new AlgoRechercheMCTS(joueurOrdi2, joueurOrdi1, 1000, Math.sqrt(2), grille.getNbLignes(), grille.getNbColonnes(), false);
+        
         joueurOrdi1.setAlgoRecherche(minmax);
-        joueurOrdi2.setAlgoRecherche(minmax);
+        joueurOrdi2.setAlgoRecherche(mcts1000);
              
-        GrilleTicTacToe9x9 grille = new GrilleTicTacToe9x9();
          
 
         Arbitre a = new Arbitre(grille, joueurOrdi1 , joueurOrdi2);

src/tictactoecodingame/Selection.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;
-
-/**
- *
- * @author louis
- */
-public class Selection {
-    ArrayList<Integer> chemin;
-    
-    public Selection(){
-        chemin=new ArrayList<>();
-    }
-    
-    
-    public Selection(double c, ArbreMCTS a){
-        Selection s=new Selection();
-        chemin=SelectionAux(c, a, s, 0).chemin;
-    }
-    
-    private Selection SelectionAux(double c, ArbreMCTS a, Selection s, int nbSimulPere){
-        if (a.estFeuille()){
-            return s;
-        }
-        else {
-            double coefMax=0;
-            int indiceSelection=0;
-            ArrayList<ArbreMCTS> f=a.getfils();
-            for(int i=0;i<f.size();i++){
-                ArbreMCTS arbreTeste = f.get(i);
-                double coef =arbreTeste.getvalue()+c*Math.sqrt(Math.log(nbSimulPere)/arbreTeste.getFraction().getDenominateur());
-                if (coef>coefMax){
-                    indiceSelection=i;
-                    coefMax=coef;
-                }
-            }
-            ArbreMCTS arbreSelectionne=f.get(indiceSelection);
-            int nbSimulPereNew=arbreSelectionne.getFraction().getDenominateur();
-            s.chemin.add(indiceSelection);
-            return SelectionAux(c,arbreSelectionne,s,nbSimulPereNew);
-        }       
-    }
-}