Merge branch 'Bruce' of http://gvipers.imt-lille-douai.fr/louis.bahrman/groupe3-tictactoe

Project-monitoring.md

-#Project Monitoring : TicTacToe groupe 3
+#Project Monitoring :
+=====================
 
+Projet : TicTacToe
+
+N° Groupe : 3
+
+Groupe : Louis Bahrman, Bruce Hersemeule, Timothy Laird, Théo Delbecq
 
 #Briques fonctionelles
+----------------------
 
-|Nom		|Description	|Séance		|Responsable	|Commit
-|:---	 	|:---		|:---		|:---		|:---
-|Fraction	|Structure de fraction pour les arbres MCTS|20/04/2020|Louis|f159fbc27aafe0f3e7fd85a7e53024dbe748e191
-|Arbre générique|Structure d'arbre commune aux 2 algorithmes|20/04/2020|Bruce|3415d259df15dea293f5d45a6541a75b5c690c27
-|Arbre MCTS	|
-|Arbre MinMax	|Structure d'arbre pour MinMax|21/04/2020|Bruce|b599e9988c324c551aa4e4cdb9a95cd327db1b99
+|Nom		|Description	|Séance		|Responsable	|Commit |Etat |Commentaires
+|:---	 	|:---		|:---		|:---		|:--- |:--- |:---
+|Prise en main	 	|Formation du groupe, choix du projet, lecture des documents, installation des environnements java requis, découverte du code fourni et tests de ses fonctionnalités		|30/03/2020		|Tous		| |Fini |
+|Mise en place du dépôt	 	|Création du dépôt, clonage en local et création de branches individuelles		|30/03/2020		|Louis		|7b8fed5436e8048c51c02041374defd4c5022e32 |Fini |[url du dépôt](https://gvipers.imt-lille-douai.fr/louis.bahrman/groupe3-tictactoe/tree/master)
+|Apprentissage git	 	|Apprentissage des commandes et des méthodes d'utilisation de git		|31/03/2020		|Tous		| |En cours |
+|Fraction	|Structure de fraction pour les arbres MCTS|20/04/2020|Louis|f159fbc27aafe0f3e7fd85a7e53024dbe748e191  |Fini |
\ No newline at end of file
+|Arbre générique|Structure d'arbre commune aux 2 algorithmes|20/04/2020|Bruce|3415d259df15dea293f5d45a6541a75b5c690c27  |Fini |
+|Arbre MCTS	|Structure d'abre et méthodes spécifiques à l'algo MCTS |20/04/2020 |Louis, Timothy | |En cours |
+|Generator |Générateur de fin de partie aléatoire permettant d'estimer la valeur d'un coup par estimation statistique		|20/04/2020		|Théo		|ad4f63446c6a351028d7fd923a379fc4dc327715  |Fini |
+|Arbre MinMax	|Structure d'arbre pour MinMax et algo de remontée|21/04/2020|Bruce|b599e9988c324c551aa4e4cdb9a95cd327db1b99  |Fini |
+|AlgoRechercheMinMax	 	|Algo de recherche créant un arbre des coups de la profondeur souhaitée pour un joueur et attribuant une valeur à chaque coup selon l'algo du MinMax	|21/04/2020	|Théo		|60b5f5a77e617c392e1c855ffaa64c557606c6a0 |A tester |
+|AlgoRechercheMCTS |Algo de création et parcours d'arbre des coups et recherche selon l'algo de Monte-Carlo |21/04/2020 |Louis, Timothy | |En cours |
+|Monitoring	 	|Création du monitoring, plannification et enregistrement des briques fonctionnelles du projet dans le fichier monitoring		|21/04/2020		|Tous		|22e9f32af8ad851db7a0deedb1c0299fe471ecfd |En cours |
+|Tests locaux et correction |Tests des performances des différents algo en local et correction en commun |27/04/2020 |Tous | |A venir |
+|Mise en place CodinGame |Conversion du code et mise en place des tests sur la plateforme CodinGame |27/04/2020 |Tous | |A venir |
\ No newline at end of file

src/tictactoecodingame/AlgoRecherMinMax1.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 senda
- 
-public class AlgoRecherMinMax1 extends AlgoRecherche {
-    ArrayList ListCoup;
-    
-    /*public AlgoRecherMinMax1() {
-              
-    }
-    
-    @Override
-    public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean _ponder) {
-        ListCoup = _plateau.getListeCoups(_joueur);
-        
-        
-        return ;
-    }
-}*/
-
-/* L'idée c'est :
-- Créer un arbre de coups :
-    On récupère les coups dispo
-    On fait toutes les possibilités d'enchaînement de coups (<N, <MaxCoupsRestants)
-- On applique MinMax
-- On rend le meilleur coup selon notre algorythme
-*/
\ No newline at end of file

src/tictactoecodingame/AlgoRechercheMinMax.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 Théo
+ */
+public class AlgoRechercheMinMax extends AlgoRecherche{
+    
+    /*La profondeur de recherche demandée doit être supérieure à 1 et inférieure
+    à 98 (On commence à 0 et l'emplacement 99 est utilisée par le générateur), 
+    en pratique la croissance est factorielle en mémoire donc en ne dépassera pas 10*/
+    private int depth;
+    private Plateau plateau;
+    private Joueur target;
+    private Joueur opponent;
+    private int d_gen;
+    
+    public AlgoRechercheMinMax(int depth, int d_gen, Joueur joueur1, Joueur joueur2){
+        this.depth = depth;
+        this.d_gen = d_gen;
+        //Cet algo ne marche qu'avec des jeux à deux joueurs
+        target = joueur1;
+        opponent = joueur2;
+    }
+    
+    public void setRandGenDepth(int d_gen){
+        this.d_gen = d_gen;
+    }
+    
+    public void setDepth(int depth){
+        this.depth = depth;
+    }
+    
+    public void setPlayers(Joueur joueur1, Joueur joueur2){
+        target = joueur1;
+        opponent = joueur2;
+    }
+    
+    public int getRandGenDepth(int d_gen){
+        return d_gen;
+    }
+    
+    public int getDepth(int depth){
+        return depth;
+    }
+    
+    public Joueur[] getPlayers(Joueur joueur1, Joueur joueur2){
+        Joueur[] players = {target, opponent};
+        return players;
+    }
+    
+    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;
+        plateau.sauvegardePosition(0);
+        if(target != _joueur){
+        opponent = target;
+        target = _joueur;
+        }
+        ArbreMinMax explore = new ArbreMinMax();
+        builder(explore, target, 0);
+        explore.MinMax(0);
+        int m = Integer.MIN_VALUE;
+        Coup c = null;
+        for(int i = 0; i < explore.getfils().size() ; i++){
+            int n = explore.getfils().get(i).getvalue();
+            if(n > m){
+                m = n;
+                c = explore.getfils().get(i).getcoup();
+            }
+        }
+        plateau.restaurePosition(0);
+        return c;
+    }
+    
+    //Fonction auxiliaire récursive de création de l'arbre des coups possibles
+    private void builder(ArbreMinMax t,Joueur currentJoueur, int currentDepth){
+        //On commence par mettre le plateau à jour en fonction du coup théorique joué
+        if(currentDepth == 0){
+            plateau.restaurePosition(0);
+        }
+        else{
+            plateau.restaurePosition(currentDepth-1);
+            plateau.joueCoup(t.getcoup());
+            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){
+                t.setvalue(1);
+            }
+            else if(winner == opponent){
+                t.setvalue(-1);
+            }
+            else {
+                t.setvalue(0);
+            }
+        }
+        else if (currentDepth == depth){
+            int c = Generator.random_tests(plateau, d_gen, target);
+            t.setvalue(c);
+        }
+        else{
+            ArrayList<ArbreMinMax> fils = new ArrayList<ArbreMinMax>();
+            for(int i=0; i<coups.size();i++){
+                ArbreMinMax a = new ArbreMinMax(coups.get(i));
+                if(currentJoueur == target){
+                    builder(a, opponent,currentDepth + 1);
+                }
+                else {
+                    builder(a, target,currentDepth + 1);
+                }
+                fils.add(a);
+            }
+            t.setfils(fils);
+        }
+    }
+}

src/tictactoecodingame/Arbre.java → src/tictactoecodingame/ArbreMCTS.java

@@ -11,61 +11,63 @@ import java.util.ArrayList;
  *
  * @author senda
  */
-public class Arbre {
-    public static int N = 5;
-    protected Fraction value;
-    protected ArrayList<Coup> coups;
-    protected ArrayList<Arbre> fils;
+public class ArbreMCTS {
     
-    // Les constructeurs :
-    
-    public Arbre(){   
-    }
+    private Fraction value;
+    private ArrayList<Coup> coups;
+    private ArrayList<ArbreMCTS> fils;
     
-    public Arbre (Fraction value, ArrayList coups, ArrayList fils){
+    // Les constructeurs :
+    public ArbreMCTS (Fraction value, ArrayList coups, ArrayList fils){
         this.value = value;
         this.fils = fils;
         this.coups = coups;
     }
     
-    public Arbre (int num, int den, ArrayList coups, ArrayList fils){
+
+    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 Arbre (Fraction value, Plateau _plateau, Joueur _joueur){
+    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++){
-            Arbre Arbre_i = new Arbre(new Fraction()); // Attention ! Ce constructeur initialise donc avec des valeurs nulles en racine !
+            ArbreMCTS Arbre_i = new ArbreMCTS(new Fraction()); // Attention ! Ce constructeur initialise donc avec des valeurs nulles en racine !
             fils.add(Arbre_i);
         }
         
     }
     
-    public Arbre (Fraction value){
+    public ArbreMCTS (Fraction value){
         this.value = value;
     }
     
-    public Arbre (int num, int den){
+
+    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<Arbre> getfils(){
+    public ArrayList<ArbreMCTS> getfils(){
         return(fils);
     }
        
-    public ArrayList getcoups(){
+    public ArrayList<Coup> getcoups(){
         return(coups);
     }
     
@@ -101,10 +103,10 @@ public class Arbre {
         }
         else{
             int a = this.fils.size();
-            Arbre fils0 = this.fils.get(0);
+            ArbreMCTS fils0 = this.fils.get(0);
             int maxfils = fils0.hauteur();
             for (int i = 1; i < a; i++){
-                Arbre next = this.fils.get(i);
+                ArbreMCTS next = this.fils.get(i);
                 maxfils = Math.max(next.hauteur(),maxfils);
             }
             return(1 + maxfils);   

src/tictactoecodingame/ArbreMinMax.java

@@ -15,6 +15,8 @@ import static tictactoecodingame.Generator.random_tests;
 public class ArbreMinMax {
     
     protected int value;
+    //Coup théorique joué à ce noeud
+    protected Coup coup;
     protected ArrayList<Coup> coups;
     protected ArrayList<ArbreMinMax> fils;
     
@@ -23,6 +25,10 @@ public class ArbreMinMax {
     public ArbreMinMax(){   
     }
     
+    public ArbreMinMax(Coup coup){
+        this.coup = coup;
+    }
+    
     public ArbreMinMax(int value, ArrayList coups, ArrayList fils){
         this.value = value;
         this.fils = fils;
@@ -61,7 +67,11 @@ public class ArbreMinMax {
         }
     }
     
-    public ArrayList getcoups(){
+    public Coup getcoup(){
+        return coup;
+    }
+    
+    public ArrayList<Coup> getcoups(){
         return(coups);
     }
     
@@ -105,7 +115,7 @@ public class ArbreMinMax {
     }
     
     public int Min(){
-        int m = 2147483640;
+        int m = Integer.MAX_VALUE;
         int a = this.getfils().size();
         for(int i = 0; i < a ; i++){
             int n = this.getfils().get(i).getvalue();
@@ -117,7 +127,7 @@ public class ArbreMinMax {
     }
     
     public int Max(){
-        int m = 0;
+        int m = Integer.MIN_VALUE;
         int a = this.getfils().size();
         for(int i = 0; i < a ; i++){
             int n = this.getfils().get(i).getvalue();
@@ -132,23 +142,22 @@ public class ArbreMinMax {
         // c = compteur 
         // Le compteur doit être initialisé à 0 donc pair -> Max, impair -> Min
         
-        if(this.getfils() != null){
+        if(!this.estFeuille()){
             int a = this.getfils().size();
             for(int i = 0; i < a ; i++){
                  this.getfils().get(i).MinMax(c+1);
             }
-        }
-        
-        if(c%2 == 0){
-            //On attribue le Min
-            int m = this.Min();
-            this.setvalue(m);   
+            if(c%2 == 0){
+                //On attribue le max
+                int m = this.Max();
+                this.setvalue(m);   
             }
-        else{
-            //On attribue le max
-            int m = this.Max();
-            this.setvalue(m);
+            else{
+                //On attribue le min
+                int m = this.Min();
+                this.setvalue(m);
             }
         }
-        
     }
+    
+}

src/tictactoecodingame/Generator.java

@@ -10,7 +10,7 @@ package tictactoecodingame;
  * @author Théo
  */
 public class Generator {
-    public static int random_tests(Plateau plateau, int nb_tests) {
+    public static int random_tests(Plateau plateau, int nb_tests,Joueur target) {
         int c = 0;
         JoueurOrdi player = new JoueurOrdi("player");
         JoueurOrdi opponent = new JoueurOrdi("oppo");
@@ -23,7 +23,7 @@ public class Generator {
         opponent.forceId(i);
         
         Coup coup;
-        plateau.sauvegardePosition(0);
+        plateau.sauvegardePosition(99);
         for(i=0; i<nb_tests;i++){
             while (!plateau.partieTerminee()) {
                 coup = currentPlayer.joue(plateau);
@@ -39,11 +39,13 @@ public class Generator {
             }
 
             Joueur vainqueur = plateau.vainqueur();
-            if ( vainqueur == player )
-                c++;
-            else if ( vainqueur == player )
-                c--;
-            plateau.restaurePosition(0);
+            if(vainqueur != null){
+                if ( vainqueur.getIdJoueur() == target.getIdJoueur() )
+                    c++;
+                else if ( vainqueur.getIdJoueur() != target.getIdJoueur() )
+                    c--;
+            }
+            plateau.restaurePosition(99);
         }
         return c;
     }

src/tictactoecodingame/GrilleTicTacToe3x3.java

@@ -81,8 +81,7 @@ public class GrilleTicTacToe3x3 extends Plateau {
             return false;
         }
 
-        Joueur dernierJoueur = dernierCoup.getJeton()
-                .getJoueur();
+        Joueur dernierJoueur = dernierCoup.getJeton().getJoueur();
 
         /* Regarde si le dernier coup est gagnant */
         for (int d = 0; d < 4; d++) {

src/tictactoecodingame/Player.java

@@ -12,22 +12,23 @@ public class Player {
 
     public static void main(String args[]) {
         
-        JoueurHumain humain = new JoueurHumain("Humain");     
-        JoueurOrdi joueurOrdi = new JoueurOrdi("Ordi");
+
+        //JoueurHumain humain = new JoueurHumain("Humain");     
+        JoueurOrdi joueurOrdi1 = new JoueurOrdi("Ordi1");
+        JoueurOrdi joueurOrdi2 = new JoueurOrdi("Ordi2");
+        //Il faut deux joueurs car l'id fixe le jeton
        
-        
-        // Remplacer ici l'algorithme aléatoire par votre algorithme. 
-        // Créer une nouvelle classe qui hérite de la class AlgoRecherche
-        AlgoRechercheAleatoire alea  = new AlgoRechercheAleatoire( );   // L'ordinateur joue au hasard
-        joueurOrdi.setAlgoRecherche(alea);                              
+        AlgoRechercheMinMax minmax  = new AlgoRechercheMinMax(3, 10, joueurOrdi1, joueurOrdi2);
+        joueurOrdi1.setAlgoRecherche(minmax);
+        joueurOrdi2.setAlgoRecherche(minmax);
              
-        GrilleTicTacToe3x3 grille = new GrilleTicTacToe3x3();
+        GrilleTicTacToe9x9 grille = new GrilleTicTacToe9x9();
          
 
-        //Arbitre a = new Arbitre(grille, joueurOrdi , joueurOrdi );
+        Arbitre a = new Arbitre(grille, joueurOrdi1 , joueurOrdi2);
+
+        //Arbitre a = new Arbitre(grille, joueurOrdi , humain );
 
-        Arbitre a = new Arbitre(grille, joueurOrdi , humain );
-       
         a.startNewGame(true);    // Demarre une partie en affichant la grille du jeu
        
        // Pour lancer un tournooi de 100 parties en affichant la grille du jeu

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);
+        }       
+    }
+}