Replace MCTS.java

src/mcts/MCTS.java

@@ -18,89 +18,76 @@ import tictactoecodingame.Plateau;
 public class MCTS {
     
     Plateau plateau;
-    Noeud racine;
     double coefficientUCT;
     Joueur joueur;
     Joueur adversaire;
     Random r;
+    int nbIteration; //Nombre d'itérations des 4 phases du MCTS
+    Noeud racine; //Racine de l'arbre
+    Noeud noeud; //Noeud pour parcourir l'arbre
     
     //CONSTRUCTEUR
-    public MCTS(Plateau plateau, Joueur joueur, Joueur adversaire) {
+    
+    public MCTS(Plateau plateau, Joueur joueur, Joueur adversaire, int nbIteration) {
         this.plateau = plateau;
         this.joueur = joueur;
         this.adversaire = adversaire;
+        this.nbIteration = nbIteration;
         
         plateau.sauvegardePosition(0);
-        //coefficientUCT = 0.8;
         coefficientUCT = Math.sqrt(2);
         r = new Random(System.currentTimeMillis());
         
-        
         Etat etat = new Etat();
         etat.setJoueur(joueur);
         racine = new Noeud();
         racine.setEtat(etat);
+        this.noeud = racine;
     }
     
-    
     //Obtenir le meilleurCoup grâce au MCTS
-    public Coup meilleurCoup() {
-        //double endTime = System.currentTimeMillis() + 1000; // temps en milliseconde
-        Noeud noeudPrometteur;
-        Noeud noeudSimulation;
-        Joueur gagnantSimulation;
-        ArrayList<Coup> coupsPossibles;
-        
-        //while (System.currentTimeMillis() < endTime) {
-        for (int i=0; i < 2000; i++) {    //nombre d'itérations variable
-            noeudPrometteur = selection();
     
+    public Coup meilleurCoup() {
+        for (int i=0; i < nbIteration; i++) {
+            selection();
             if (plateau.partieTerminee()) {
-                propagationArriere(noeudPrometteur, plateau.vainqueur());
+                propagationArriere();
             }
             else {
-                coupsPossibles = plateau.getListeCoups(noeudPrometteur.getEtat().getJoueur());
-                noeudSimulation = expansion(noeudPrometteur, coupsPossibles);
-                gagnantSimulation = simulation(noeudSimulation);
-                propagationArriere(noeudSimulation, gagnantSimulation);
-            }
-            
-            /* //TESTS
-            if (!racine.getListeEnfant().isEmpty()) {
-                for (Noeud enfant : racine.getListeEnfant()) {
-                    System.out.print(enfant.getEtat().getScoreVictoire() + " / " + enfant.getEtat().getNbVisite() + " " + enfant.getEtat().getDernierCoup().toString() + " | ");
+                expansion();
+                simulation();
+                propagationArriere();
             }
         }
-            System.out.println();
-            System.out.println(racine.getEtat().getScoreVictoire() + "/" + racine.getEtat().getNbVisite());
-            */
-            
-        }
-        plateau.restaurePosition(0);
-        return Util.getMeilleurCoup(racine);
+        return MeilleurCoup.getMeilleurCoupUCT(noeud);
     }
     
     //4 PHASE DU MCTS
     
-    //Selectionne le noeud "prometteur" grâce à UCT.
-    public Noeud selection() {
-        Noeud noeudPrometteur = racine;
-        while (!noeudPrometteur.getListeEnfant().isEmpty()) {
-            noeudPrometteur = UCT.trouverNoeudPrometteur(noeudPrometteur, coefficientUCT);
-            plateau.joueCoup(noeudPrometteur.getEtat().getDernierCoup());
+    /**
+     * Selectionne le noeud "prometteur" grâce à UCT (Upper Confidence Bound 1 applied to Trees).
+     * Tant que le noeud selectionné possède des noeuds enfants, on choisit l'enfant le plus prometteur.
+     */
+    
+    public void selection() {
+        while (!noeud.getListeEnfant().isEmpty()) {
+            noeud = UCT.trouverNoeudPrometteurUCT(noeud, coefficientUCT);
+            plateau.joueCoup(noeud.getEtat().getDernierCoup());
         }
-        return noeudPrometteur;
     }
     
-    //Une fois le meilleur noeud trouvé, on créé tous les noeuds enfant possible, et on en choisit un au hasard.
-    public Noeud expansion(Noeud noeud, ArrayList<Coup> coupsPossibles) {
-        Joueur joueurTemp = Util.swapJoueur(noeud.getEtat().getJoueur(), joueur, adversaire);
+    /**
+     * Une fois le neoud prometteur trouvé, on créé tous les noeuds enfant possible, et on en choisit un au hasard.
+    */
+    
+    public void expansion() {
+        ArrayList<Coup> coupsPossibles = plateau.getListeCoups(noeud.getEtat().getJoueur());
+        ArrayList<Noeud> noeudsPossibles = noeud.getListeEnfant();
         int newProfondeur = noeud.getEtat().getProfondeur() + 1;
-        int randomIndex;
+        Joueur joueurTemp = Util.swapJoueur(noeud.getEtat().getJoueur(), joueur, adversaire);
+        
         Etat newEtat;
-        Noeud randomNoeud;
         Noeud newNoeud;
-        
         for (Coup coup : coupsPossibles) {
             newEtat = new Etat();
             newEtat.setJoueur(joueurTemp);
@@ -108,47 +95,50 @@ public class MCTS {
             newEtat.setProfondeur(newProfondeur);
 
             newNoeud = new Noeud(newEtat, noeud);
-            noeud.getListeEnfant().add(newNoeud);
+            noeudsPossibles.add(newNoeud);
         }
         
-        
-        ArrayList<Noeud> noeudsPossibles = noeud.getListeEnfant();
-        randomIndex = r.nextInt(noeudsPossibles.size());
-        randomNoeud = noeudsPossibles.get(randomIndex);
-        plateau.joueCoup(randomNoeud.getEtat().getDernierCoup());
-        return randomNoeud;
+        noeud = noeudsPossibles.get(r.nextInt(noeudsPossibles.size()));
+        plateau.joueCoup(noeud.getEtat().getDernierCoup());
     }
     
-    //A partir du nouveau noeud choisi durant l'expansion, on simule une partie de coup aléatoire jusqu'à terminer la partie.
-    public Joueur simulation(Noeud noeud) {
+    /**
+     * A partir du nouveau noeud choisi durant l'expansion, on simule une partie de coup aléatoire jusqu'à terminer la partie.
+     */
+    
+    public void simulation() {
         Joueur joueurTemp = noeud.getEtat().getJoueur();
+        int randomIndex;
+        Coup randomCoup;
 
         while (!plateau.partieTerminee()) {
-            int randomIndex = r.nextInt(plateau.getListeCoups(joueurTemp).size());
-            Coup randomCoup = plateau.getListeCoups(joueurTemp).get(randomIndex);
+            randomIndex = r.nextInt(plateau.getListeCoups(joueurTemp).size());
+            randomCoup = plateau.getListeCoups(joueurTemp).get(randomIndex);
             plateau.joueCoup(randomCoup);
             joueurTemp = Util.swapJoueur(joueurTemp, joueur, adversaire);
         }
-        
-        joueurTemp = plateau.vainqueur();
-        return joueurTemp;
     }
     
-    //Une fois la simulation terminée, on met à jour l'arbre.
-    public void propagationArriere(Noeud noeud, Joueur gagnant) {
-        plateau.restaurePosition(0);
-        Noeud parent = noeud;
+    /**
+     * Une fois la simulation terminée, on met à jour l'arbre comme suit : 
+     * On remonte dans l'arbre de parent en parent jusqu'à atteindre la racine, 
+     * en mettant à jour le nombre de visite de chaque noeud, 
+     * et le score des noeud dont le joueur est soit le perdant, soit le joueur null.
+     */
     
-        while (parent != null) {
-            parent.getEtat().updateNbVisite();
-            if (gagnant == null) {
-                parent.getEtat().updateNbVictoire(0.5);
+    public void propagationArriere() {
+        while (noeud != null) {
+            noeud.getEtat().updateNbVisite();
+            if (plateau.vainqueur() == null) {
+                noeud.getEtat().updateNbVictoire(0.5);
             }
-            if (gagnant != null && parent.getEtat().getJoueur() != gagnant) {
-                parent.getEtat().updateNbVictoire(1);
+            if (plateau.vainqueur() != null && noeud.getEtat().getJoueur() != plateau.vainqueur()) {
+                noeud.getEtat().updateNbVictoire(1);
             }
-            parent = parent.getParent();
+            noeud = noeud.getParent();
         }
+        noeud = racine;
+        plateau.restaurePosition(0);
     }
 }