nettoyage + lisibilité code + changement structure

fr/iut_fbleau/Avalam/InteractionController.java

@@ -0,0 +1,188 @@
+package fr.iut_fbleau.Avalam;
+
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.Player;
+
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+* La classe <code>InteractionController</code>
+*
+* Gère l'interaction entre l'utilisateur et le moteur du jeu Avalam.
+* Elle permet :
+* - la sélection d'une tour
+* - le calcul des coups légaux
+* - la validation d'un déplacement
+* - l'application d'un coup
+* - la mise à jour de l'affichage via BoardView
+*
+* Cette classe ne réalise aucun affichage direct.
+*/
+public class InteractionController {
+
+    //Attributs
+
+    /** Référence au moteur du jeu Avalam. */
+    private AvalamBoard board;
+
+    /** Ligne de la tour sélectionnée (-1 si aucune). */
+    private int selectedRow = -1;
+
+    /** Colonne de la tour sélectionnée (-1 si aucune). */
+    private int selectedCol = -1;
+
+    /** Liste des coups légaux (sous forme de points). */
+    private List<Point> legalMoves = new ArrayList<>();
+
+    /** Référence à la vue du plateau pour rafraîchir l'affichage. */
+    private BoardView view;
+
+    //Constructeur
+
+    /**
+    * Construit le contrôleur d'interactions.
+    *
+    * @param board moteur du jeu Avalam
+    * @param view vue du plateau
+    */
+    public InteractionController(AvalamBoard board, BoardView view) {
+        this.board = board;
+        this.view = view;
+    }
+
+    //Méthodes
+
+    /**
+    * Retourne la liste des cases jouables.
+    *
+    * @return liste des coups légaux
+    */
+    public List<Point> getLegalMoves() {
+        return legalMoves;
+    }
+
+    /**
+    * Appelé lorsqu’un pion est cliqué dans BoardView.
+    * Gère :
+    * - la sélection d’une tour
+    * - la désélection
+    * - la tentative de déplacement
+    *
+    * @param r ligne cliquée
+    * @param c colonne cliquée
+    */
+    public void onPieceClicked(int r, int c) {
+
+        // Si on clique la même case ⇒ désélection
+        if (r == selectedRow && c == selectedCol) {
+            clearSelection();
+            view.refresh();
+            return;
+        }
+
+        // Si aucune sélection : on sélectionne un pion appartenant au joueur courant
+        Tower t = board.getTowerAt(r, c);
+
+        if (t != null && t.getColor().toPlayer() == board.getCurrentPlayer()) {
+            selectTower(r, c);
+            view.refresh();
+            return;
+        }
+
+        // Sinon : tentons de jouer un coup (déplacement)
+        if (selectedRow != -1 && selectedCol != -1) {
+            tryMove(r, c);
+        }
+    }
+
+    /**
+    * Sélectionne une tour à la position (r,c).
+    *
+    * @param r ligne
+    * @param c colonne
+    */
+    private void selectTower(int r, int c) {
+        selectedRow = r;
+        selectedCol = c;
+        computeLegalMoves();
+    }
+
+    /**
+    * Annule la sélection actuelle.
+    */
+    private void clearSelection() {
+        selectedRow = -1;
+        selectedCol = -1;
+        legalMoves.clear();
+    }
+
+    /**
+    * Calcule les coups légaux à partir de la tour sélectionnée.
+    * Utilise l'itérateur fourni par AvalamBoard.
+    */
+    private void computeLegalMoves() {
+        legalMoves.clear();
+
+        Iterator<AbstractPly> it = board.iterator();
+
+        while (it.hasNext()) {
+            AbstractPly p = it.next();
+
+            if (!(p instanceof AvalamPly)) continue;
+            AvalamPly ap = (AvalamPly) p;
+
+            // On ne garde que les coups dont la source correspond à la sélection
+            if (ap.getXFrom() == selectedRow && ap.getYFrom() == selectedCol) {
+                legalMoves.add(new Point(ap.getXTo(), ap.getYTo()));
+            }
+        }
+    }
+
+    /**
+    * Tente d’exécuter un déplacement vers la case (r,c).
+    *
+    * @param r ligne de destination
+    * @param c colonne de destination
+    */
+    private void tryMove(int r, int c) {
+        // Vérifier si (r,c) est une destination légale
+        boolean isLegalDest = false;
+        for (Point p : legalMoves) {
+            if (p.x == r && p.y == c) {
+                isLegalDest = true;
+                break;
+            }
+        }
+        if (!isLegalDest) {
+            clearSelection(); // clic ailleurs = désélection
+            view.refresh();
+            return;
+        }
+
+        // Construire le coup
+        Player cur = board.getCurrentPlayer();
+        AvalamPly ply = new AvalamPly(cur, selectedRow, selectedCol, r, c);
+
+        // Vérifier via l’API
+        if (board.isLegal(ply)) {
+
+            // Appliquer via l’API
+            board.doPly(ply);
+
+            // Réinitialiser la sélection
+            clearSelection();
+
+            // Mise à jour de l'interface
+            view.onBoardUpdated();
+
+        } else {
+            // Coup impossible
+            clearSelection();
+        }
+
+        view.refresh();
+    }
+}