Upload New File

src/MCTS/MCTS.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 mcts;
+
+import java.util.ArrayList;
+import java.util.Random;
+import tictactoecodingame.Coup;
+import tictactoecodingame.Joueur;
+import tictactoecodingame.Plateau;
+
+/**
+ *
+ * @author Lloyd
+ */
+public class MCTS {
+    
+    Plateau plateau;
+    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, int nbIteration) {
+        this.plateau = plateau;
+        this.joueur = joueur;
+        this.adversaire = adversaire;
+        this.nbIteration = nbIteration;
+        
+        plateau.sauvegardePosition(0);
+        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() {
+        for (int i=0; i < nbIteration; i++) {
+            selection();
+            if (plateau.partieTerminee()) {
+                propagationArriere();
+            }
+            else {
+                expansion();
+                simulation();
+                propagationArriere();
+            }
+        }
+        return MeilleurCoup.getMeilleurCoupUCT(noeud);
+    }
+    
+    //4 PHASE DU MCTS
+    
+    /**
+     * 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());
+        }
+    }
+    
+    /**
+     * 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;
+        Joueur joueurTemp = Util.swapJoueur(noeud.getEtat().getJoueur(), joueur, adversaire);
+        
+        Etat newEtat;
+        Noeud newNoeud;
+        for (Coup coup : coupsPossibles) {
+            newEtat = new Etat();
+            newEtat.setJoueur(joueurTemp);
+            newEtat.setDernierCoup(coup);
+            newEtat.setProfondeur(newProfondeur);
+
+            newNoeud = new Noeud(newEtat, noeud);
+            noeudsPossibles.add(newNoeud);
+        }
+        
+        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 void simulation() {
+        Joueur joueurTemp = noeud.getEtat().getJoueur();
+        int randomIndex;
+        Coup randomCoup;
+
+        while (!plateau.partieTerminee()) {
+            randomIndex = r.nextInt(plateau.getListeCoups(joueurTemp).size());
+            randomCoup = plateau.getListeCoups(joueurTemp).get(randomIndex);
+            plateau.joueCoup(randomCoup);
+            joueurTemp = Util.swapJoueur(joueurTemp, joueur, adversaire);
+        }
+    }
+    
+    /**
+     * 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.
+     */
+    
+    public void propagationArriere() {
+        while (noeud != null) {
+            noeud.getEtat().updateNbVisite();
+            if (plateau.vainqueur() == null) {
+                noeud.getEtat().updateNbVictoire(0.5);
+            }
+            if (plateau.vainqueur() != null && noeud.getEtat().getJoueur() != plateau.vainqueur()) {
+                noeud.getEtat().updateNbVictoire(1);
+            }
+            noeud = noeud.getParent();
+        }
+        noeud = racine;
+        plateau.restaurePosition(0);
+    }
+}
+