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

Project-monitoring.md

@@ -3,9 +3,17 @@
 
 #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		| |Fini |
+|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 |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		|:---  |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		|:---  |A tester |
+|AlgoRechercheMCTS |Algo de création et parcours d'arbre des coups et recherche selon l'algo de Monte-Carlo |21/04/2020 |Timothy | |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

nbproject/private/private.properties

 <<<<<<< HEAD
 <<<<<<< HEAD
+<<<<<<< HEAD
 compile.on.save=true
 do.depend=false
 do.jar=true
@@ -31,3 +32,20 @@ javadoc.preview=true
 user.properties.file=/home/louis/.netbeans/11.3/build.properties
 >>>>>>> 4dd14568c244c833d17b679f8f3b340f997c8d04
 >>>>>>> 4f5ab9d710d3dfdc1fe71236031395a85db95bec
+=======
+<<<<<<< HEAD
+compile.on.save=true
+do.depend=false
+do.jar=true
+javac.debug=true
+javadoc.preview=true
+user.properties.file=C:\\Users\\timot\\AppData\\Roaming\\NetBeans\\11.2\\build.properties
+=======
+compile.on.save=true
+do.depend=false
+do.jar=true
+javac.debug=true
+javadoc.preview=true
+user.properties.file=C:\\Users\\theo\\AppData\\Roaming\\NetBeans\\11.3\\build.properties
+>>>>>>> 4dd14568c244c833d17b679f8f3b340f997c8d04
+>>>>>>> 94177790fa8a419aa9237d306f5420565be1ebd3

nbproject/private/private.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
+    <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/>
+    </open-files>
+</project-private>

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/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,21 +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(9, 100, joueurOrdi1, joueurOrdi2);
+        joueurOrdi1.setAlgoRecherche(minmax);
+        joueurOrdi2.setAlgoRecherche(minmax);
              
         GrilleTicTacToe3x3 grille = new GrilleTicTacToe3x3();
          
 
-        //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
        

src/tictactoecodingame/Selection.java

@@ -44,8 +44,6 @@ public class Selection {
             int nbSimulPereNew=arbreSelectionne.getFraction().getDenominateur();
             s.chemin.add(indiceSelection);
             return SelectionAux(c,arbreSelectionne,s,nbSimulPereNew);
-        }
-        
-        
+        }       
     }
 }