Plateau graphique v2 *score,tourJoueur,tailleTour,selection* + maj makefile,readme

fr/iut_fbleau/Avalam/logic/BoardLoader.java

@@ -0,0 +1,60 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+import java.io.*;
+
+/**
+ * La classe <code>BoardLoader</code> est responsable du chargement d'un plateau Avalam
+ * depuis un fichier texte externe (généralement Plateau.txt).
+ *
+ * Le fichier doit contenir une matrice 9×9 de valeurs numériques séparées par des virgules :
+ * - 0 : case vide (trou)
+ * - 1 : pion appartenant au joueur COLOR1 (Jaune)
+ * - 2 : pion appartenant au joueur COLOR2 (Rouge)
+ *
+ * Aucun contrôle de cohérence avancé n'est effectué, le chargeur se contente
+ * d’interpréter les valeurs comme demandé.
+ *
+ * @author 
+ * @version 1.0
+ */
+public class BoardLoader {
+
+    /**
+     * Charge un plateau Avalam depuis un fichier.
+     *
+     * @param path chemin du fichier plateau.
+     * @return un tableau 9×9 contenant des objets <code>Tower</code> ou <code>null</code>.
+     */
+    public static Tower[][] loadFromFile(String path) {
+
+        Tower[][] grid = new Tower[9][9];
+
+        try (BufferedReader br = new BufferedReader(new FileReader(new File(path)))) {
+
+            String line;
+            int row = 0;
+
+            while ((line = br.readLine()) != null && row < 9) {
+
+                String[] parts = line.split(",");
+
+                for (int col = 0; col < 9; col++) {
+                    int v = Integer.parseInt(parts[col]);
+
+                    // Interprétation des valeurs
+                    if (v == 1) grid[row][col] = new Tower(Color.COLOR1);
+                    else if (v == 2) grid[row][col] = new Tower(Color.COLOR2);
+                    else grid[row][col] = null; // Case vide
+                }
+                row++;
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return grid;
+    }
+}

fr/iut_fbleau/Avalam/logic/GameState.java

@@ -0,0 +1,70 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+
+/**
+ * La classe <code>GameState</code> représente l'état courant du jeu Avalam :
+ * - la grille 9×9
+ * - le joueur dont c'est le tour
+ *
+ * Elle ne contient aucune logique de déplacement ni de vérification des règles ;
+ * son rôle est uniquement de stocker et de fournir l'état du jeu.
+ *
+ * @author
+ * @version 1.0
+ */
+public class GameState {
+
+    /** Grille du plateau : 9×9 tours ou cases vides. */
+    private Tower[][] grid;
+
+    /** Joueur dont c’est le tour (COLOR1 ou COLOR2). */
+    private Color currentPlayer = Color.COLOR1;
+
+    /**
+     * Constructeur.
+     *
+     * @param grid la grille initiale du plateau.
+     */
+    public GameState(Tower[][] grid) {
+        this.grid = grid;
+    }
+
+    /**
+     * Retourne la tour présente à la position (r,c), ou null.
+     */
+    public Tower get(int r, int c) {
+        return grid[r][c];
+    }
+
+    /**
+     * Retourne la grille complète.
+     */
+    public Tower[][] getGrid() {
+        return grid;
+    }
+
+    /**
+     * Retourne le joueur dont c'est le tour.
+     */
+    public Color getCurrentPlayer() {
+        return currentPlayer;
+    }
+
+    /**
+     * Change le joueur courant : COLOR1 → COLOR2 → COLOR1.
+     */
+    public void switchPlayer() {
+        currentPlayer = (currentPlayer == Color.COLOR1) ? Color.COLOR2 : Color.COLOR1;
+    }
+
+    /**
+     * Vérifie si une position (r,c) est dans les limites du plateau.
+     *
+     * @return vrai si la position est comprise dans un plateau 9×9.
+     */
+    public boolean isInside(int r, int c) {
+        return r >= 0 && r < 9 && c >= 0 && c < 9;
+    }
+}

fr/iut_fbleau/Avalam/logic/ScoreManager.java

@@ -0,0 +1,37 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+
+/**
+ * La classe <code>ScoreManager</code> gère le calcul des scores
+ * selon les règles officielles d’Avalam :
+ *
+ * Un joueur gagne 1 point par tour dont le sommet (couleur) lui appartient,
+ * indépendamment de la hauteur de la tour.
+ *
+ * Cette classe n’a aucune responsabilité autre que compter.
+ *
+ * @author
+ * @version 1.0
+ */
+public class ScoreManager {
+
+    /**
+     * Compte le nombre de tours dont le sommet appartient à la couleur donnée.
+     *
+     * @param c     couleur du joueur (COLOR1 ou COLOR2)
+     * @param grid  grille 9×9 contenant des tours ou null
+     * @return score du joueur
+     */
+    public static int count(Color c, Tower[][] grid) {
+        int score = 0;
+
+        for (int i = 0; i < 9; i++)
+            for (int j = 0; j < 9; j++)
+                if (grid[i][j] != null && grid[i][j].getColor() == c)
+                    score++;
+
+        return score;
+    }
+}

fr/iut_fbleau/Avalam/logic/TurnManager.java

@@ -0,0 +1,35 @@
+package fr.iut_fbleau.Avalam.logic;
+
+import fr.iut_fbleau.Avalam.Color;
+
+/**
+ * La classe <code>TurnManager</code> gère le déroulement des tours d’Avalam.
+ *
+ * Son rôle est simple :
+ * - identifier le joueur dont c’est le tour
+ * - passer au joueur suivant
+ *
+ * Elle ne contient pas de logique de mouvement, ni de validation.
+ *
+ * @author
+ * @version 1.0
+ */
+public class TurnManager {
+
+    /** Joueur dont c'est le tour (COLOR1 commence la partie). */
+    private Color current = Color.COLOR1;
+
+    /**
+     * Retourne le joueur actuel.
+     */
+    public Color getPlayer() {
+        return current;
+    }
+
+    /**
+     * Passe au joueur suivant.
+     */
+    public void next() {
+        current = (current == Color.COLOR1) ? Color.COLOR2 : Color.COLOR1;
+    }
+}