Replace AlgoRechercheMinMax.java

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 static java.lang.Math.max;
-import static java.lang.Math.min;
-
-/**
- *
- * @author Alain
- */
-public class AlgoRechercheMinMax {
-    
-    String[][] grille = {{"","",""},{"","",""},{"","",""}};
-    int[] scores = {1,-1,0};
-
-    
-    public void meilleur_coup_minmax(){
-      double inf = Double.POSITIVE_INFINITY;
-      double bestScore = -1 * inf;
-      int[] meilleur_coup = new int[2] ;
-      
-      for (int i = 0; i < 3; i++){
-        for (int j = 0; j < 3; j++){
-            if (grille[i][j] == "" ) {
-                grille[i][j] = "X";}
-                int score = minimax(grille,0,false);
-                grille[i][j] = "" ;
-                if (score > bestScore){
-                    bestScore = score;
-                    meilleur_coup[0] = i;
-                    meilleur_coup[1] = j;
-                }
-                        
-            } 
-        }
-      grille[meilleur_coup[0]][meilleur_coup[1]] = "X";
-      // changer le tour du joueur ?
-    }
-    
-    public double minimax(String[][] grille,int profondeur,boolean isMaximizing){
-        Joueur gagnant = grille.vainqueur(); //Il faudrait connaitre le vainqueur
-        int resultat = gagnant.getIdJoueur();
-        if (resultat !== null) {
-            return scores[resultat];
-        }
-        
-        if (isMaximizing) {
-            double inf = Double.POSITIVE_INFINITY;
-      double bestScore = -1 * inf;
-      
-      for (int i = 0; i < 3; i++){
-        for (int j = 0; j < 3; j++){
-            if (grille[i][j] == "" ) {
-                grille[i][j] = "X";
-                double score = minimax(grille,profondeur + 1,false);
-                grille[i][j] = "" ;
-                bestScore = max(score,bestScore);
-        }
-        }
-      }
-      return bestScore;
-     }
-       else {
-            double inf = Double.POSITIVE_INFINITY;
-            double bestScore = inf;
-            for (int i = 0; i < 3; i++){
-        for (int j = 0; j < 3; j++){
-            if (grille[i][j] == "" ) {
-                grille[i][j] = "O";
-                double score = minimax(grille,profondeur + 1,true);
-                grille[i][j] = "" ;
-                bestScore = min(score,bestScore);
-        }
-            }
-            }
-            return bestScore;
-        }
-    }
-    
-
+/*
+ * 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 static java.lang.Math.max;
+import static java.lang.Math.min;
+import java.util.ArrayList;
+
+/**
+ *
+ * @author Alain
+ */
+public class AlgoRechercheMinMax extends AlgoRecherche {
+    
+    /* Le but de cet algorithme est d'implémenter la méthode MinMax au jeu TicTacToe. La fonction d'évaluation est ici assez simple elle retourne 1 sur le noeud si
+    l'ordi gagne la partie et -1 si l'ordi perd la partie. Cet algorithme est implémenté avec l'amélioration alpha beta.
+    */
+    
+    Joueur humain;
+    Joueur ordi;
+    public AlgoRechercheMinMax(Joueur _ordi1, Joueur _joueur1){
+        ordi = _ordi1;
+        humain = _joueur1;
+
+    }
+    
+    double[] scores = {-1,1,0}; // Score -1 si partie perdue, 1 si partie gagnée et 0 si égalité.
+
+    @Override
+    public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean ponder){
+        /* MeilleurCoup prend en paramètre un plateau, un joueur (non utilisé ici mais qui serait l'ordi) et un boolean ponder pour laisser l'ordi réfléchir.    
+        */
+        
+      double inf = Double.POSITIVE_INFINITY;
+      double bestScore = -1 * inf;
+      CoupTicTacToe meilleur_coup = null ;
+      double alpha = -1 * inf; // méthode alpha beta
+      double beta = inf;
+      ArrayList<Coup> coups = _plateau.getListeCoups(ordi);
+      
+      for (int i = 0; i < coups.size(); i++){
+        _plateau.sauvegardePosition(0); // Pour pouvoir revenir à cet état une fois les simulations finies et les scores calculés.
+        _plateau.joueCoup(coups.get(i));
+        double score = minimax(_plateau,humain,1,false,alpha,beta); //False car l'ordi a déjà placé son premier coup
+        Coup coup_provisoire = coups.get(i);
+        _plateau.restaurePosition(0); // Retour à la configuration initiale après calcul des scores.
+        if (score > bestScore){ // On modifie le bestScore si on en trouve un meilleur.
+            bestScore = score;
+            meilleur_coup = (CoupTicTacToe)coup_provisoire;
+                }
+            } 
+      return meilleur_coup;
+      // changer le tour du joueur 
+    }
+    
+    public double minimax(Plateau _plateau,Joueur _joueur,int profondeur,boolean isMaximizing, double alpha, double beta){
+        /* minimax prend en paramètre un plateau, le joueur qui va jouer, la profondeur, un boolean pour savoir si on doit maximiser ou minimiser et des doubles
+        alpha et beta pour implémenter la méthode alpha beta.
+        */
+        
+        if (_plateau.partieTerminee()){
+            if(_plateau.partieNulle()){
+                return 0;               
+            }
+            else{
+                Joueur gagnant = _plateau.vainqueur(); //Il faut connaitre le vainqueur
+                int resultat = gagnant.getIdJoueur();
+                return scores[resultat];}
+
+            
+        }      
+        if (isMaximizing) { //ordi qui joue
+      double inf = Double.POSITIVE_INFINITY;
+      double bestScore = -1 * inf;
+      ArrayList<Coup> coups = _plateau.getListeCoups(ordi);
+      for (int i = 0; i < coups.size(); i++){ // On suit le même principe que précédemment.
+        _plateau.sauvegardePosition(profondeur);
+        _plateau.joueCoup(coups.get(i));
+            double score = minimax(_plateau,humain,profondeur + 1,false, alpha, beta);
+            _plateau.restaurePosition(profondeur);
+            bestScore = max(score,bestScore);
+            alpha = max(alpha,score); // Méthode alpha beta
+            if (beta <= alpha){
+                break; // Ne vérifié pas les cas où on sait que les branches suivantes auront une évaluation inférieure à une déjà possible.
+            }
+        }
+      return bestScore;
+     }
+       else { // Humain ou autre ordi qui joue
+            double inf = Double.POSITIVE_INFINITY;
+            double bestScore = inf;
+            ArrayList<Coup> coups = _plateau.getListeCoups(humain);
+            for (int i = 0; i < coups.size(); i++){ // On suit le même principe que précédemment.
+                _plateau.sauvegardePosition(profondeur);
+                _plateau.joueCoup(coups.get(i)); 
+                double score = minimax(_plateau,ordi,profondeur + 1,true,alpha,beta);
+                _plateau.restaurePosition(profondeur);
+                bestScore = min(score,bestScore);
+                beta = min(beta,score);
+            if (beta <= alpha){
+                break; // Ne vérifié pas les cas où on sait que les branches suivantes auront une évaluation supérieure à une déjà possible.
+            }
+        }
+            
+            return bestScore;
+        }
+    }
+}
+    
+