Update README.md

Reviewed-on: #10
Reviewed-by: Alistair VAISSE <alistair.vaisse@etu.u-pec.fr>
Reviewed-by: Clemence DUCREUX <clemence.ducreux@etu.u-pec.fr>

README.md

@@ -1,4 +1,4 @@
-# Instructions pour une bonne developer experience
+# 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
@@ -21,18 +21,6 @@ La description doit fournir une explication légèrement détaillée des tâches
 
     Comportement attendu une fois la tâche accomplie
 
-### Assigner une personne au ticket 
-
-L'assignement d'une eprsonne est essentielle pour savoir qui travaille sur quoi. Si plusieurs personnes ont participé dans le ticket, vous pouvez le modifier.
-
-    Aller dans assignements ou assignees et choisissez les developers
-
-### Assigner une deadline (optionnel)
-
-Le mieux serait d'ajouter une deadline pour les tâches pour savoir à peu près quand vous pensez avoir fini votre travail. ce n'est pas grave si vous n'en mettez pas mais si vous êtes sûr de quand vous allez à peu près le finir, cela peut-être intéressant de le savoir. C'est particulièrement intéressant pour les grosses tâches. 
-
-
-### Note : vous pouvez créer des tickets pour d'autres personnes si vous avez des recommandations 
 
 ## 2. Création de la Branche
 
@@ -96,48 +84,6 @@ Remplissez les informations nécessaires :
 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.
 
 
-## 6. Après la fusion accordée
-
-Une fois que la fusion de votre branche a été approuvée, vous devez supprimer cette branche localement. Pour se faire, recopiez cette commande : 
-
-    git branch -d <nom_de_la_branche>
-
-Lorsque vous avez supprimé votre branche et que vous souhaitez travailler à nouveau sur une nouvelle tâche, rebasez vous sur la branche master. Pour se faire suivez les instrucitons : 
-
-    git checkout master 
-
-Vérifiez que vous êtes bien sur la branche master : 
-
-    git branch
-
-Si vous êtes dessus, vous pouvez recommencer le rpocessus de création de ticket et de branche.
-
-
-## 7. Révisions 
-
- Si vous voyez qu'une pull request est en attente, n'hésitez pas à jetter un coup d'oeil au code et à le **TESTER** également ! Si vous avez des doutes sur le code contactez l'un des participants pour plus de détails.
-
-### Si vous souhaitez réviser le code 
-
-    Aller dans pull requests (ou demandes d'ajout) à côté des tickets (ou issues)
-
-Vous y verrez les demandes d'ajouts en cours et déjà mergées. Si vous souhaitez faire une révision : 
-
-    Cliquer sur celle qui vous intéresse et qui est open (ou ouverte)
-
-    Aller dans fichiers modifiés (ou files changed)
-
-    Vérifier et ajouter des commentaires si problèmes
-
-    Si problèmes refuser pull request et demander des changements
-
-    Si aucun problèmes en haut à droite cliquer sur évaluation (ou review)
-
-    Accepter les modifications et si vous êtes le deuxième à review, merger pull request
-
-### Note : 
-Une fois que tout ça est fait, supprimez la branche qui a été fusionnée, gitea le notifie juste après que vous ayez fusionner la branche dans l'historique de conversation de la pull request. 
-
 # Résumé des Commandes Git :
 
 Voici un récapitulatif des commandes Git que vous utiliserez fréquemment :
@@ -168,10 +114,58 @@ Voici un récapitulatif des commandes Git que vous utiliserez fréquemment :
 
     git branch -d <nom_de_la_branche>
 
-## 6. Vérifier la branche où l'on se trouve
 
-    git branch
+## Comment fonctionne l’algorithme de victoire (idée générale)
 
-## 7. Changer de branche 
+Dans Hex, un joueur gagne s’il existe un chemin continu de ses pions connectant ses deux bords :
 
-    git checkout <nom_de_la_branche>
+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/HexGame/HexBoard.java

@@ -0,0 +1,187 @@
+package fr.iut_fbleau.HexGame;
+
+import fr.iut_fbleau.GameAPI.*;
+import java.util.*;
+
+/**
+ * Plateau du jeu de Hex.
+ *
+ * Joueur 1 relie la gauche et la droite.
+ * Joueur 2 relie le haut et le bas.
+ */
+public class HexBoard extends AbstractBoard {
+
+    private final int size;
+    private Player[][] cells;
+    private Deque<AbstractPly> historyLocal;
+
+    private static final int[][] NEIGHBORS = {
+        {-1,  0}, {+1,  0},
+        { 0, -1}, { 0, +1},
+        {-1, +1}, {+1, -1}
+    };
+
+    public HexBoard(int size) {
+        super();
+        this.size = size;
+        this.cells = new Player[size][size];
+        this.historyLocal = new ArrayDeque<>();
+        this.currentPlayer = Player.PLAYER1;
+    }
+
+    private boolean inBounds(int r, int c) {
+        return r >= 0 && r < size && c >= 0 && c < size;
+    }
+
+    private Player getCell(int r, int c) {
+        return cells[r][c];
+    }
+
+    private void setCell(int r, int c, Player p) {
+        cells[r][c] = p;
+    }
+
+    private boolean hasPlayer1Won() {
+        boolean[][] visited = new boolean[size][size];
+        Deque<int[]> stack = new ArrayDeque<>();
+        for (int r = 0; r < size; r++) {
+            if (getCell(r, 0) == Player.PLAYER1) {
+                visited[r][0] = true;
+                stack.push(new int[]{r, 0});
+            }
+        }
+        while (!stack.isEmpty()) {
+            int[] cur = stack.pop();
+            int cr = cur[0];
+            int cc = cur[1];
+            if (cc == 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.PLAYER1) {
+                    visited[nr][nc] = true;
+                    stack.push(new int[]{nr, nc});
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean hasPlayer2Won() {
+        boolean[][] visited = new boolean[size][size];
+        Deque<int[]> stack = new ArrayDeque<>();
+        for (int c = 0; c < size; c++) {
+            if (getCell(0, c) == Player.PLAYER2) {
+                visited[0][c] = true;
+                stack.push(new int[]{0, c});
+            }
+        }
+        while (!stack.isEmpty()) {
+            int[] cur = stack.pop();
+            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) {
+                    visited[nr][nc] = true;
+                    stack.push(new int[]{nr, nc});
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isLegal(AbstractPly move) {
+        if (!(move instanceof HexPly)) return false;
+        HexPly hp = (HexPly) move;
+        int r = hp.getRow(), c = hp.getCol();
+        return inBounds(r, c)
+                && getCell(r, c) == null
+                && hp.getPlayer() == this.getCurrentPlayer();
+    }
+
+    @Override
+    public void doPly(AbstractPly move) {
+        if (!(move instanceof HexPly))
+            throw new IllegalArgumentException("Coup invalide: " + move);
+        HexPly hp = (HexPly) move;
+        if (!isLegal(hp))
+            throw new IllegalStateException("Coup illégal: " + hp);
+        setCell(hp.getRow(), hp.getCol(), hp.getPlayer());
+        historyLocal.push(hp);
+        setNextPlayer();
+    }
+
+    @Override
+    public boolean isGameOver() {
+        return hasPlayer1Won() || hasPlayer2Won();
+    }
+
+    @Override
+    public Result getResult() {
+        if (hasPlayer1Won()) return Result.WIN;
+        if (hasPlayer2Won()) return Result.LOSS;
+        return Result.DRAW;
+    }
+
+    @Override
+    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));
+            }
+        }
+        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);
+        copy.currentPlayer = this.currentPlayer;
+        for (int r = 0; r < size; r++) {
+            for (int c = 0; c < size; c++) {
+                copy.cells[r][c] = this.cells[r][c];
+            }
+        }
+        copy.historyLocal = new ArrayDeque<>(this.historyLocal);
+        return copy;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int r = 0; r < size; r++) {
+            for (int k = 0; k < r; k++) sb.append(" ");
+            for (int c = 0; c < size; c++) {
+                Player p = getCell(r, c);
+                char ch = '.';
+                if (p == Player.PLAYER1) ch = '1';
+                else if (p == Player.PLAYER2) ch = '2';
+                sb.append(ch).append(" ");
+            }
+            sb.append("\n");
+        }
+        sb.append("Current player: ").append(getCurrentPlayer()).append("\n");
+        return sb.toString();
+    }
+
+    public int getSize() {
+        return size;
+    }
+}

javaAPI/fr/iut_fbleau/HexGame/HexPly.java

@@ -0,0 +1,31 @@
+package fr.iut_fbleau.HexGame;
+
+import fr.iut_fbleau.GameAPI.*;
+
+/**
+ * Représente un coup dans le jeu de Hex.
+ */
+public class HexPly extends AbstractPly {
+
+    private final int row;
+    private final int col;
+
+    public HexPly(Player j, int row, int col) {
+        super(j);
+        this.row = row;
+        this.col = col;
+    }
+
+    public int getRow() {
+        return this.row;
+    }
+
+    public int getCol() {
+        return this.col;
+    }
+
+    @Override
+    public String toString() {
+        return "HexPly{player=" + getPlayer() + ", row=" + row + ", col=" + col + "}";
+    }
+}