Update README.md

README.md

@@ -1,56 +1,171 @@
-# BUT3 – Projet Jeu : Hex
+# Instructions de Travail sur les Tickets
+
+Ce document présente la procédure à suivre lors de la création et de la gestion des tickets de développement. Veuillez suivre chaque étape avec attention.
+## 1. Création du Ticket
+
+### Titre du Ticket
+
+Le titre doit décrire de manière générale la tâche à réaliser. Soyez précis, mais sans entrer dans les détails techniques. Par exemple :
+
+    Ajout d'une nouvelle fonctionnalité de recherche dans l'application
+
+    Correction du bug d'affichage sur la page d'accueil
+
+### Description du Ticket
+
+La description doit fournir une explication légèrement détaillée des tâches à réaliser. Elle doit inclure les éléments suivants :
+
+    Objectif global de la tâche
+
+    Étapes spécifiques ou parties du projet concernées
+
+    Comportement attendu une fois la tâche accomplie
 
 
-Il s’agit d’une implémentation du jeu **Hex** en Java, développée à partir de l’API fournie par le Monsieur Madelaine.  
-Le projet comprend un moteur de jeu fonctionnel, un affichage console pour le debug, ainsi que des bots permettant de jouer automatiquement.
+## 2. Création de la Branche
 
+Lorsque vous commencez à travailler sur un ticket, créez une nouvelle branche avec un nom particulier qui reflète le ticket en cours. Le format de la branche doit être :
 
-## Compilation
+    nom-de-la-feature-#numeroduticket
 
-Depuis la racine du projet, compiler l’ensemble des fichiers Java avec la commande suivante :
+### Pour créer une branche : 
 
-```bash
-javac -d build $(find javaAPI -name "*.java")
+    git checkout -b feature-recherche-#123
+
+## 3. Commit des Changements
+
+Les commits doivent suivre la convention suivante :
+
+- Le message de commit doit décrire brièvement le changement effectué.
+
+- À la fin du message de commit, vous devez toujours ajouter le numéro du ticket pour faciliter le suivi des tâches.
+
+Exemple de message de commit :
+
+    Ajout du champ de recherche sur la page d'accueil #123
+
+## 4. Push de la Branche
+
+Après avoir effectué vos changements et effectué vos commits, vous devrez pousser la branche sur le dépôt distant. Lors de votre premier git push, vous recevrez un message pour définir l'upstream de la branche.
+
+Exemple de message affiché :
+
+``` 
+fatal: The upstream branch 'origin/feature-recherche-#123' does not exist
+To push the branch and set the upstream, use the following command:
+git push --set-upstream origin nom-de-la-feature-#numero 
 ```
 
-Les fichiers compilés (`.class`) sont générés dans le dossier `bin`.
+
+Vous devez copier et coller la commande dans votre terminal pour effectuer le push. Une fois cette commande exécutée, votre branche sera poussée vers le dépôt distant.
+
+## 5. Création d'une Pull Request (PR)
+
+Une fois que vous avez poussé votre branche sur Gitea, vous devez ouvrir une pull request pour demander la révision de votre code.
+
+Voici les étapes pour créer une pull request correctement :
+
+- Allez sur Gitea et naviguez vers le projet concerné.
+
+- Cliquez sur "Branches" et vous devriez voir la branche que vous venez de pousser.
+
+- Cliquez sur le bouton "Create Pull Request" à côté de votre branche.
+
+Remplissez les informations nécessaires :
+
+- Titre de la PR : Utilisez le même titre que celui du ticket.
+
+- Description de la PR : Décrivez brièvement ce que votre PR accomplit. Vous pouvez vous baser sur la description du ticket.
+
+- Revues : Assurez-vous de demander une révision par deux membres de l’équipe.
+
+- Cliquez sur "Create Pull Request" pour soumettre.
+
+Une fois la PR ouverte, vous devrez attendre la révision et l’approbation de l’équipe avant de pouvoir fusionner la branche dans main ou develop selon le flux de travail de votre projet.
 
 
-## Lancer une démonstration
+# Résumé des Commandes Git :
 
-### Partie automatique (bot)
+Voici un récapitulatif des commandes Git que vous utiliserez fréquemment :
 
-```bash
-java -cp build fr.iut_fbleau.HexGame.HexMain 3 autoplay
-```
+## 1. Créer une branche 
 
-Ce mode permet de lancer une partie entièrement automatique en utilisant le bot implémenté dans la classe `Simulation`.
-
-### Partie interactive (joueur humain)
-
-```bash
-java -cp build fr.iut_fbleau.HexGame.HexMain
-```
-
-Le plateau s’affiche dans le terminal et les coups sont entrés sous forme de coordonnées.
+    git checkout -b feature-recherche-#123
 
 
-## Tests et validation
+## 2. Ajouter les fichiers modifiés : 
 
-Les tests sont réalisés sous forme de **tests fonctionnels** via des méthodes `main` et des modes de démonstration :
-- vérification de la validité des coups,
-- alternance correcte des joueurs,
-- détection des conditions de fin de partie,
-- exécution de parties complètes en mode automatique.
-
-L’affichage console du plateau, fourni par la méthode `HexBoard.toString()`, est utilisé comme outil de debug pour visualiser l’état du jeu à chaque tour.
+    git add .
+    git add *
+    git add <nom_du_fichier>
 
 
-## Organisation du projet
+## 3. Commit des changements :
 
-- `HexBoard` : représentation du plateau et gestion des règles du jeu  
-- `HexPly` : représentation d’un coup  
-- `Simulation` : bot basé sur une recherche Minimax à profondeur limitée  
-- `HexMain` : point d’entrée du programme  
+    git commit -m "Ajout de [...] #numeroticket"
 
-Les classes principales sont documentées à l’aide de **Javadoc**.
+
+## 4. Pousser la branche
+
+    git push -set-upstream origin <nom-de-la-branche-#numeroticket>
+
+
+## 5. Supprimer une branche 
+
+    git branch -d <nom_de_la_branche>
+
+
+## Comment fonctionne l’algorithme de victoire (idée générale)
+
+Dans Hex, un joueur gagne s’il existe un chemin continu de ses pions connectant ses deux bords :
+
+PLAYER1 : relier gauche → droite
+
+PLAYER2 : relier haut → bas
+
+Un “chemin” = une suite de cases adjacentes sur la grille hexagonale (6 voisins possibles) appartenant au joueur.
+
+Ce que fait l’algo (principe)
+
+L’algo fait un parcours de graphe (DFS avec une pile, ou BFS avec une file c’est pareil pour le résultat) :
+
+On prend toutes les cases du bord de départ du joueur (ex: bord gauche pour PLAYER1).
+
+On ne garde que celles qui contiennent un pion du joueur.
+
+À partir de ces cases, on explore toutes les cases voisines contenant aussi un pion du joueur, et ainsi de suite.
+
+Si pendant l’exploration on atteint l’autre bord, alors il existe un chemin → victoire.
+
+Pourquoi ça marche ?
+
+Parce que ça revient à demander :
+
+“Est-ce qu’il existe une composante connexe de pions du joueur qui touche les deux bords ?”
+
+Le DFS/BFS explore exactement la composante connexe.
+
+Les 6 voisins en Hex (grille hexagonale)
+
+Dans ton code, tu as :
+
+private static final int[][] NEIGHBORS = {
+  {-1,  0}, {+1,  0},
+  { 0, -1}, { 0, +1},
+  {-1, +1}, {+1, -1}
+};
+
+
+Ça signifie qu’une case (r,c) a jusqu’à 6 voisins :
+'''
+(r-1,c), (r+1,c) : “haut/bas”
+
+(r,c-1), (r,c+1) : “gauche/droite”
+
+(r-1,c+1) et (r+1,c-1) : les 2 diagonales propres au pavage hexagonal
+'''
+Complexité
+
+Au pire, on visite chaque case une seule fois → O(N²) pour un plateau N×N.
+
+Très correct pour Hex.

javaAPI/fr/iut_fbleau/GameAPI/AbstractGame.java

@@ -34,8 +34,8 @@ public abstract class AbstractGame {
     
     // constructeur à appeler dans le constructeur d'un fils concret avec super.
     public AbstractGame(IBoard b, EnumMap<Player,AbstractGamePlayer> m){
-        this.currentBoard=b;
-        this.mapPlayers=m;
+	this.currentBoard=b;
+	this.mapPlayers=m;
     }
 
     /**

javaAPI/fr/iut_fbleau/HexGame/HexBoard.java

@@ -1,154 +1,63 @@
 package fr.iut_fbleau.HexGame;
 
 import fr.iut_fbleau.GameAPI.*;
-
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.List;
+import java.util.*;
 
 /**
- * Représente le plateau du jeu de Hex.
+ * Plateau du jeu de Hex.
  *
- * <h2>Rappel des conditions de victoire</h2>
- * <ul>
- *   <li>{@link Player#PLAYER1} gagne s'il existe un chemin de pions connectés
- *       reliant le bord gauche au bord droit.</li>
- *   <li>{@link Player#PLAYER2} gagne s'il existe un chemin de pions connectés
- *       reliant le bord haut au bord bas.</li>
- * </ul>
- *
- * <h2>Idée de l'algorithme de détection de victoire</h2>
- * On modélise le plateau comme un graphe :
- * <ul>
- *   <li>Chaque case est un sommet</li>
- *   <li>Deux cases sont connectées si elles sont voisines sur la grille hexagonale (6 voisins)</li>
- * </ul>
- *
- * Pour tester la victoire d'un joueur, on lance un parcours (DFS/BFS) :
- * <ol>
- *   <li>On part de toutes les cases du bord de départ qui contiennent un pion du joueur.</li>
- *   <li>On explore tous les pions du joueur connectés à ces cases.</li>
- *   <li>Si on atteint le bord opposé, il existe un chemin : le joueur gagne.</li>
- * </ol>
- *
- * Complexité : O(N²) au pire (on visite chaque case au plus une fois).
+ * Joueur 1 relie la gauche et la droite.
+ * Joueur 2 relie le haut et le bas.
  */
 public class HexBoard extends AbstractBoard {
 
-    /** Taille du plateau : size x size. */
     private final int size;
+    private Player[][] cells;
+    private Deque<AbstractPly> historyLocal;
 
-    /**
-     * Grille des cases.
-     * Une case vaut :
-     * <ul>
-     *   <li>null : case vide</li>
-     *   <li>PLAYER1 : pion du joueur 1</li>
-     *   <li>PLAYER2 : pion du joueur 2</li>
-     * </ul>
-     */
-    private final Player[][] cells;
-
-    /**
-     * Offsets des 6 voisins d'une case dans une grille hexagonale.
-     *
-     * Pour une case (r,c), les voisins potentiels sont :
-     * (r-1,c), (r+1,c), (r,c-1), (r,c+1), (r-1,c+1), (r+1,c-1).
-     */
     private static final int[][] NEIGHBORS = {
-            {-1,  0}, {+1,  0},
-            { 0, -1}, { 0, +1},
-            {-1, +1}, {+1, -1}
+        {-1,  0}, {+1,  0},
+        { 0, -1}, { 0, +1},
+        {-1, +1}, {+1, -1}
     };
 
-    /** Crée un plateau vide avec {@link Player#PLAYER1} qui commence. */
     public HexBoard(int size) {
-        this(size, Player.PLAYER1);
-    }
-
-    /**
-     * Constructeur interne, utile pour {@link #safeCopy()}.
-     * @param size taille du plateau
-     * @param current joueur courant
-     */
-    private HexBoard(int size, Player current) {
-        super(current, new ArrayDeque<>());
-        if (size <= 0) throw new IllegalArgumentException("size must be > 0");
+        super();
         this.size = size;
         this.cells = new Player[size][size];
+        this.historyLocal = new ArrayDeque<>();
+        this.currentPlayer = Player.PLAYER1;
     }
 
-    /** @return la taille du plateau. */
-    public int getSize() {
-        return size;
-    }
-
-    /**
-     * Vérifie si (r,c) est dans le plateau.
-     * @param r ligne (0..size-1)
-     * @param c colonne (0..size-1)
-     */
     private boolean inBounds(int r, int c) {
         return r >= 0 && r < size && c >= 0 && c < size;
     }
 
-    /** @return le contenu d'une case (null si vide). */
     private Player getCell(int r, int c) {
         return cells[r][c];
     }
 
-    /** Modifie une case (utilisé par doPly/undoPly). */
     private void setCell(int r, int c, Player p) {
         cells[r][c] = p;
     }
 
-    /**
-     * Teste la victoire de PLAYER1 (gauche -> droite).
-     *
-     * <h3>Détails de l'algorithme</h3>
-     * <ol>
-     *   <li>On initialise une structure "visited" pour ne pas revisiter les cases.</li>
-     *   <li>On met dans une pile toutes les cases du bord gauche (colonne 0)
-     *       qui contiennent un pion PLAYER1.</li>
-     *   <li>On effectue un DFS :
-     *       <ul>
-     *         <li>on dépile une case</li>
-     *         <li>si elle est sur la colonne size-1 : on a touché le bord droit -> victoire</li>
-     *         <li>sinon, on empile tous ses voisins qui sont des pions PLAYER1 et pas encore visités</li>
-     *       </ul>
-     *   </li>
-     * </ol>
-     *
-     * @return true si PLAYER1 a un chemin gauche->droite, false sinon
-     */
     private boolean hasPlayer1Won() {
         boolean[][] visited = new boolean[size][size];
         Deque<int[]> stack = new ArrayDeque<>();
-
-        // 1) points de départ : bord gauche
         for (int r = 0; r < size; r++) {
             if (getCell(r, 0) == Player.PLAYER1) {
                 visited[r][0] = true;
                 stack.push(new int[]{r, 0});
             }
         }
-
-        // 2) DFS
         while (!stack.isEmpty()) {
             int[] cur = stack.pop();
-            int cr = cur[0], cc = cur[1];
-
-            // condition d'arrivée : bord droit
+            int cr = cur[0];
+            int cc = cur[1];
             if (cc == size - 1) return true;
-
-            // explore les 6 voisins
             for (int[] d : NEIGHBORS) {
                 int nr = cr + d[0], nc = cc + d[1];
-                if (inBounds(nr, nc)
-                        && !visited[nr][nc]
-                        && getCell(nr, nc) == Player.PLAYER1) {
+                if (inBounds(nr, nc) && !visited[nr][nc] && getCell(nr, nc) == Player.PLAYER1) {
                     visited[nr][nc] = true;
                     stack.push(new int[]{nr, nc});
                 }
@@ -157,42 +66,23 @@ public class HexBoard extends AbstractBoard {
         return false;
     }
 
-    /**
-     * Teste la victoire de PLAYER2 (haut -> bas).
-     *
-     * Même principe que {@link #hasPlayer1Won()} mais :
-     * <ul>
-     *   <li>Départ : bord haut (ligne 0)</li>
-     *   <li>Arrivée : bord bas (ligne size-1)</li>
-     * </ul>
-     *
-     * @return true si PLAYER2 a un chemin haut->bas, false sinon
-     */
     private boolean hasPlayer2Won() {
         boolean[][] visited = new boolean[size][size];
         Deque<int[]> stack = new ArrayDeque<>();
-
-        // points de départ : bord haut
         for (int c = 0; c < size; c++) {
             if (getCell(0, c) == Player.PLAYER2) {
                 visited[0][c] = true;
                 stack.push(new int[]{0, c});
             }
         }
-
-        // DFS
         while (!stack.isEmpty()) {
             int[] cur = stack.pop();
-            int cr = cur[0], cc = cur[1];
-
-            // condition d'arrivée : bord bas
+            int cr = cur[0];
+            int cc = cur[1];
             if (cr == size - 1) return true;
-
             for (int[] d : NEIGHBORS) {
                 int nr = cr + d[0], nc = cc + d[1];
-                if (inBounds(nr, nc)
-                        && !visited[nr][nc]
-                        && getCell(nr, nc) == Player.PLAYER2) {
+                if (inBounds(nr, nc) && !visited[nr][nc] && getCell(nr, nc) == Player.PLAYER2) {
                     visited[nr][nc] = true;
                     stack.push(new int[]{nr, nc});
                 }
@@ -208,50 +98,18 @@ public class HexBoard extends AbstractBoard {
         int r = hp.getRow(), c = hp.getCol();
         return inBounds(r, c)
                 && getCell(r, c) == null
-                && hp.getPlayer() == getCurrentPlayer();
-    }
-
-    /**
-     * Teste si un coup est immédiatement gagnant.
-     *
-     * On joue le coup, on teste la victoire, puis on annule le coup.
-     * Cela permet d'évaluer un coup sans modifier définitivement l'état du plateau.
-     *
-     * @param move coup à tester
-     * @return true si après ce coup le joueur a gagné, false sinon
-     */
-    public boolean isWinningMove(AbstractPly move) {
-        if (!isLegal(move)) return false;
-        Player p = move.getPlayer();
-
-        doPly(move);
-        boolean winNow = (p == Player.PLAYER1) ? hasPlayer1Won() : hasPlayer2Won();
-        undoPly();
-
-        return winNow;
+                && hp.getPlayer() == this.getCurrentPlayer();
     }
 
     @Override
     public void doPly(AbstractPly move) {
-        if (!(move instanceof HexPly)) {
+        if (!(move instanceof HexPly))
             throw new IllegalArgumentException("Coup invalide: " + move);
-        }
-        if (!isLegal(move)) {
-            throw new IllegalStateException("Coup illégal: " + move);
-        }
-
         HexPly hp = (HexPly) move;
+        if (!isLegal(hp))
+            throw new IllegalStateException("Coup illégal: " + hp);
         setCell(hp.getRow(), hp.getCol(), hp.getPlayer());
-        addPlyToHistory(move);
-        setNextPlayer();
-    }
-
-    @Override
-    public void undoPly() {
-        AbstractPly last = removePlyFromHistory();
-        HexPly hp = (HexPly) last;
-
-        setCell(hp.getRow(), hp.getCol(), null);
+        historyLocal.push(hp);
         setNextPlayer();
     }
 
@@ -262,32 +120,46 @@ public class HexBoard extends AbstractBoard {
 
     @Override
     public Result getResult() {
-        if (!isGameOver()) return null;
-        if (hasPlayer1Won()) return Result.WIN;   // du point de vue PLAYER1
-        return Result.LOSS;
+        if (hasPlayer1Won()) return Result.WIN;
+        if (hasPlayer2Won()) return Result.LOSS;
+        return Result.DRAW;
     }
 
     @Override
-    public Iterator<AbstractPly> iterator() {
-        Player me = getCurrentPlayer();
+    public Iterator<AbstractPly> getPlies() {
+        Player me = this.getCurrentPlayer();
         List<AbstractPly> moves = new ArrayList<>();
-
         for (int r = 0; r < size; r++) {
             for (int c = 0; c < size; c++) {
-                if (getCell(r, c) == null) {
-                    moves.add(new HexPly(me, r, c));
-                }
+                if (getCell(r, c) == null) moves.add(new HexPly(me, r, c));
             }
         }
         return moves.iterator();
     }
 
+    @Override
+    public Iterator<AbstractPly> getHistory() {
+        return historyLocal.iterator();
+    }
+
+    @Override
+    public void undoLastPly() {
+        if (historyLocal.isEmpty()) return;
+        HexPly last = (HexPly) historyLocal.pop();
+        setCell(last.getRow(), last.getCol(), null);
+        this.currentPlayer = last.getPlayer();
+    }
+
     @Override
     public IBoard safeCopy() {
-        HexBoard copy = new HexBoard(this.size, this.getCurrentPlayer());
+        HexBoard copy = new HexBoard(this.size);
+        copy.currentPlayer = this.currentPlayer;
         for (int r = 0; r < size; r++) {
-            System.arraycopy(this.cells[r], 0, copy.cells[r], 0, size);
+            for (int c = 0; c < size; c++) {
+                copy.cells[r][c] = this.cells[r][c];
+            }
         }
+        copy.historyLocal = new ArrayDeque<>(this.historyLocal);
         return copy;
     }
 
@@ -308,4 +180,8 @@ public class HexBoard extends AbstractBoard {
         sb.append("Current player: ").append(getCurrentPlayer()).append("\n");
         return sb.toString();
     }
+
+    public int getSize() {
+        return size;
+    }
 }

javaAPI/fr/iut_fbleau/HexGame/HexMain.java

@@ -1,40 +0,0 @@
-package fr.iut_fbleau.HexGame;
-
-import fr.iut_fbleau.GameAPI.*;
-import java.util.EnumMap;
-import java.util.Scanner;
-
-/**
- * Lancement d'une partie de Hex en console.
- */
-public class HexMain {
-
-    public static void main(String[] args) {
-        int size = 7;
-        if (args.length >= 1) {
-            try { size = Integer.parseInt(args[0]); } catch (NumberFormatException ignored) {}
-        }
-
-        HexBoard board = new HexBoard(size);
-
-        Scanner sc = new Scanner(System.in);
-        Result res;
-        EnumMap<Player, AbstractGamePlayer> players = new EnumMap<>(Player.class);
-        players.put(Player.PLAYER1, new HumanConsolePlayer(Player.PLAYER1, sc));
-        players.put(Player.PLAYER2, new HumanConsolePlayer(Player.PLAYER2, sc));
-
-
-        if (args.length>=2 && args[1].equals("autoplay")) {
-            Simulation sim = new Simulation(board, players);
-            res = sim.run(); 
-        } else {
-            AbstractGame game = new AbstractGame(board, players) {};
-            res = game.run();
-        }
-
-        System.out.println(board);
-        System.out.println("Résultat (du point de vue de PLAYER1) : " + res);
-
-        sc.close();
-    }
-}

javaAPI/fr/iut_fbleau/HexGame/HumanConsolePlayer.java

@@ -1,68 +0,0 @@
-package fr.iut_fbleau.HexGame;
-
-import fr.iut_fbleau.GameAPI.*;
-
-import java.util.Scanner;
-
-/**
- * Joueur humain en console.
- *
- * Format attendu : "row col" (indices à partir de 0).
- */
-public class HumanConsolePlayer extends AbstractGamePlayer {
-
-    private final Scanner in;
-
-    public HumanConsolePlayer(Player me, Scanner in) {
-        super(me);
-        this.in = in;
-    }
-
-    @Override
-    public AbstractPly giveYourMove(IBoard board) {
-        if (!(board instanceof HexBoard)) {
-            throw new IllegalArgumentException("Ce joueur attend un HexBoard.");
-        }
-        HexBoard hb = (HexBoard) board;
-
-        while (true) {
-            System.out.println(hb);
-            System.out.print("Joueur " + board.getCurrentPlayer() + " - entrez un coup (row col) : ");
-
-            String line = in.nextLine().trim();
-            if (line.equalsIgnoreCase("quit") || line.equalsIgnoreCase("exit")) {
-                throw new IllegalStateException("Partie interrompue par l'utilisateur.");
-            }
-            if (line.equalsIgnoreCase("help")) {
-                System.out.println("Entrez deux entiers : row col (0 <= row,col < " + hb.getSize() + ")");
-                System.out.println("Commandes: help, quit");
-                continue;
-            }
-
-            String[] parts = line.split("\\s+");
-            if (parts.length != 2) {
-                System.out.println("Format invalide. Exemple: 3 4");
-                continue;
-            }
-
-            try {
-                int r = Integer.parseInt(parts[0]);
-                int c = Integer.parseInt(parts[1]);
-                HexPly ply = new HexPly(board.getCurrentPlayer(), r, c);
-
-                if (!hb.isLegal(ply)) {
-                    System.out.println("Coup illégal (case occupée / hors plateau / mauvais joueur). Réessayez.");
-                    continue;
-                }
-
-                if (hb.isWinningMove(ply)) {
-                    System.out.println("Coup gagnant !");
-                }
-
-                return ply;
-            } catch (NumberFormatException e) {
-                System.out.println("Veuillez entrer deux entiers.");
-            }
-        }
-    }
-}

javaAPI/fr/iut_fbleau/HexGame/Simulation.java

@@ -1,145 +0,0 @@
-package fr.iut_fbleau.HexGame;
-
-import fr.iut_fbleau.GameAPI.*;
-import java.util.EnumMap;
-import java.util.LinkedList;
-
-
-public class Simulation extends AbstractGame {
-
-    //ATTRIBUTS
-    private HexPly bestmove;
-    private float bestoutcome;
-    private int MAXDEPTH = 6;
-    private LinkedList<Integer[]> taken = new LinkedList<Integer[]>();
-
-    //ATTRIBUTS QUE JE NE VOUDRAIS PAS CRÉER IDÉALEMENT
-    private IBoard simCurrentBoard;
-    private EnumMap<Player, AbstractGamePlayer> simmapPlayers;
-
-    //CONSTRUCTEUR
-    public Simulation(IBoard b, EnumMap<Player,AbstractGamePlayer> m){
-        super(b, m);
-        simCurrentBoard = b;
-        simmapPlayers = m;
-    }
-
-    //METHODES
-    private float explMAX(HexBoard position, int depth){
-        if (position.getResult()==Result.LOSS) {
-            return -1.0f;
-        } else if (position.getResult()==Result.WIN){
-            return 1.0f;
-        } else if (depth==MAXDEPTH) {
-            return 0f;
-        } else {
-                float bestcase = -1.0f;
-                HexPly bestcasemove;
-                HexPly testmove;
-                for (int i=0; i<position.getSize(); i++) {
-                        for (int j=0; j<position.getSize(); j++) {
-                                if(depth==0){
-                                    //System.out.println("MAX New Line :");
-                                }
-                                Integer[] t = new Integer[]{i, j}; 
-                                testmove = new HexPly(Player.PLAYER1, i, j);
-                                if(!taken.contains(t) && position.isLegal(testmove)){
-                                        //System.out.println("  MAX test move : "+Integer.toString(i)+","+Integer.toString(j));
-                                        taken.add(t);
-                                        position.doPly(testmove);
-                                        float val = explMIN(position, depth+1);  
-                                        if (val >= bestcase) {
-                                                //System.out.println("     MAX new best case");
-                                                bestcase = val;
-                                                bestcasemove = testmove;
-                                                if (depth==0) {
-                                                    this.bestoutcome = bestcase;
-                                                    this.bestmove = bestcasemove;
-                                                }
-                                        }
-                                        position.undoPly();
-                                        taken.remove(t);
-                                }
-                        }
-                }
-                return bestcase;
-        }
-    }
-
-
-    private float explMIN(HexBoard position, int depth){
-        if (position.getResult()==Result.LOSS) {
-            return -1.0f;
-        } else if (position.getResult()==Result.WIN){
-            return 1.0f;
-        } else if (depth==MAXDEPTH) {
-            return 0f;
-        } else {
-                float bestcase = 1.0f;
-                HexPly bestcasemove;
-                HexPly testmove;
-                for (int i=0; i<position.getSize(); i++) {
-                        for (int j=0; j<position.getSize(); j++) {
-                                if(depth==0){
-                                    //System.out.println("MIN New Line :");
-                                }
-                                Integer[] t = new Integer[]{i, j}; 
-                                testmove = new HexPly(Player.PLAYER2, i, j);
-                                if(!taken.contains(t) && position.isLegal(testmove)){
-                                        //System.out.println("  MIN test move : "+Integer.toString(i)+","+Integer.toString(j));
-                                        taken.add(t);
-                                        position.doPly(testmove);
-                                        float val = explMAX(position, depth+1);  
-                                        if (val <= bestcase) {
-                                                //System.out.println("     MIN new best case");
-                                                bestcase = val;
-                                                bestcasemove = testmove;
-                                                if (depth==0) {
-                                                    this.bestoutcome = bestcase;
-                                                    this.bestmove = bestcasemove;
-                                                }
-                                        }
-                                        
-                                        position.undoPly();
-                                        taken.remove(t);
-                                }
-                        }
-                }
-                return bestcase;
-        }
-    }
-
-    private AbstractPly GiveBestMove(IBoard board) {
-        if (!(board instanceof HexBoard)) {
-            throw new IllegalArgumentException("Ce joueur attend un HexBoard.");
-        }
-        HexBoard hb = (HexBoard) board;
-        float bestcase;
-        if(hb.getCurrentPlayer()==Player.PLAYER1){
-            bestcase = explMAX(hb, 0);
-        } else {
-            bestcase = explMIN(hb, 0);
-        }
-        return this.bestmove;
-    }
-
-    @Override
-    public Result run(){
-        while(!simCurrentBoard.isGameOver()) {
-            AbstractGamePlayer player = simmapPlayers.get(simCurrentBoard.getCurrentPlayer());
-            IBoard board = simCurrentBoard.safeCopy();
-            AbstractPly ply = GiveBestMove(board);
-            HexPly concretePly = (HexPly) ply;
-
-            if (simCurrentBoard.isLegal(ply)) {
-                simCurrentBoard.doPly(ply);
-                taken.add(new Integer[]{concretePly.getRow(), concretePly.getCol()});
-                System.out.println("Player "+player+" goes ("+concretePly.getRow()+","+concretePly.getCol()+")");
-            }
-            else throw new IllegalStateException("Player "+ player + " is a bloody cheat. He tried playing : "+concretePly.getRow()+","+concretePly.getCol()+" I give up.");
-        }
-	    return simCurrentBoard.getResult();
-    }
-
-    
-}