[Ajout] Logique de déplacement et d'extinction de feu des pompiers

src/main/java/controller/Controller.java

@@ -74,7 +74,6 @@ public class Controller {
     int columnCount = board.columnCount();
     int rowCount = board.rowCount();
     ViewElement[][] viewElements = new ViewElement[rowCount][columnCount];
-    System.out.println("columnsCOunt : " + columnCount + " rowCount : " + rowCount);
     for(int column = 0; column < columnCount; column++)
       for(int row = 0; row < rowCount; row++)
         viewElements[row][column] = getViewElement(board.getState(new Position(row, column)));

src/main/java/model/Board.java

@@ -67,5 +67,9 @@ public interface Board<S> {
   public void setState(Entity state, Position position, boolean replaceStates);
 
   public boolean doesPositionExist(Position position);
+
+  public void clearCase(Position position);
+
+  public Position getNearestEntity(Position fromPos, Class<?> entityType);
 }
 

src/main/java/model/EmptySquare.java

@@ -10,8 +10,14 @@ public class EmptySquare implements Entity{
 
     private Position position;
     private final Color viewColor = Color.WHITE;
+    private int age;
     public EmptySquare(Position p){
         this.position = p;
+        this.age = -999;
+    }
+    public EmptySquare(Position p, int age){
+        this.position = p;
+        this.age = age;
     }
     @Override
     public List<Position> nextTurn(Board<Entity> board) {
@@ -33,11 +39,11 @@ public class EmptySquare implements Entity{
     }
     @Override
     public int getAge() {
-        return -999;
+        return this.age;
     }
 
     @Override
     public void incrementAge() {
-        return;
+        age = age + 1;
     }
 }

src/main/java/model/Entity.java

@@ -6,7 +6,12 @@ import javafx.scene.paint.Color;
 import util.Position;
 
 public interface Entity {
-    // Calcule ce que l'entité va faire au prochain tour, et retourne la liste des positions affectés
+        /**
+     * Exécute un tour de jeu, en vérifiant les cases adjacentes pour des instances de Fire.
+     *
+     * @param b Le plateau de jeu contenant des entités.
+     * @return Une liste de positions affectées durant le tour (que la vue doit mettre à jour).
+     */
     public List<Position> nextTurn(Board<Entity> board);
     public Position getPosition();
     public void setPosition(Position p);

src/main/java/model/Fire.java

 package model;
+import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import javafx.scene.paint.Color;
 import util.Position;
+import util.PositionUtil;
 
 public class Fire implements Entity{
     Board<Entity> b;
@@ -24,10 +24,14 @@ public class Fire implements Entity{
 
     @Override
     public List<Position> nextTurn(Board<Entity> board) {
-        age = age +1;
-        List<Position> positions = generateAdjacentPosition();
+        if(board.getStepNumber() % 2 == 0)return new ArrayList<Position>();
+        List<Position> positions = PositionUtil.generateAdjacentPositions(position, board);
         for(Position p : positions){
+            if(b.getState(p) instanceof EmptySquare){
+                if(b.getState(p).getAge() < b.getStepNumber()){
                     board.setState(new Fire(p, board), p);
+                }
+            }
             if(!b.doesPositionExist(p)){
                 positions.remove(p);
             }
@@ -35,19 +39,7 @@ public class Fire implements Entity{
         return positions;
     }
     
-    private List<Position> generateAdjacentPosition(){
-        int x = position.x();
-        int y = position.y();
 
-        return Stream.of(
-                new Position(x, y + 1),
-                new Position(x + 1, y),
-                new Position(x, y - 1),
-                new Position(x - 1, y)
-            )
-            .filter(p -> b.doesPositionExist(p))
-            .collect(Collectors.toList());
-    }
 
     
     @Override

src/main/java/model/FireFighter.java

@@ -4,6 +4,7 @@ import java.util.List;
 
 import javafx.scene.paint.Color;
 import util.Position;
+import util.PositionUtil;
 
 public class FireFighter implements Entity{
     private int age;
@@ -23,18 +24,91 @@ public class FireFighter implements Entity{
     }
     
     public List<Position> nextTurn(Board<Entity> b) {
-        age++;
-        List<Position> positions = new ArrayList<Position>();
-        positions.add(position);
+        List<Position> positions = new ArrayList<>();
+    
+        // Générer les positions adjacentes
+        List<Position> adjacentPositions = PositionUtil.generateAdjacentPositions(position, b);
+    
+        // Vérifier s'il y a du feu dans une des positions adjacentes
+        boolean hasFire = adjacentPositions.stream()
+                                           .anyMatch(p -> b.getState(p) instanceof Fire);
+    
+        if (hasFire) {
+            // Si du feu est trouvé, on éteint les feux adjacents
+            positions.addAll(extinguish(adjacentPositions, b));
+        } else {
+            // Chercher la position du feu le plus proche
+            Position nearestFirePos = b.getNearestEntity(position, Fire.class);
+    
+            if (nearestFirePos != null && !nearestFirePos.equals(position)) {
+                // Trouver la meilleure position pour se rapprocher du feu
+                Position nextPos = getNextPositionTowards(position, nearestFirePos, b);
+    
+                if (nextPos != null) {
+                    // Mettre à jour la position du pompier
+                    b.clearCase(position); // Vider l'ancienne case
+                    positions.add(new Position(position.x(), position.y()));
+                    this.position = nextPos;
+                    b.setState(this, nextPos); // Mettre à jour la nouvelle case
+                    positions.add(nextPos);
+                    adjacentPositions = PositionUtil.generateAdjacentPositions(nextPos, b);
+                    positions.addAll(extinguish(adjacentPositions, b));
+                } 
+                // Aucun déplacement possible = le pompier reste sur place
+            }
+        }
+    
         return positions;
-        // Récupérer la position
-        //Si un feu est à proximité : éteindre les feux à x + 1 y, x y+1, x+1 y-1, x-1 y+1 
-        //Sinon
-        //Se déplacer vers le feu le plus proche
-        //Si un feu est à proximité : éteindre les feux à x + 1 y, x y+1, x+1 y-1, x-1 y+1 
-        // Ajouter un feu à x + 1 y, x y+1, x-1 y, x y-1 
     }
     
+    private List<Position> extinguish(List<Position> adjacentPositions, Board<Entity> b) {
+        List<Position> extinguishedPositions = new ArrayList<>();
+        for (Position p : adjacentPositions) {
+            if (b.getState(p) instanceof Fire) {
+                b.clearCase(p);
+                extinguishedPositions.add(p); // Ajouter la position où le feu a été éteint
+            }
+        }
+        return extinguishedPositions;
+    }
+    
+    private Position getNextPositionTowards(Position currentPos, Position targetPos, Board<Entity> b) {
+        // Générer les 8 positions adjacentes possibles
+        List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(currentPos, b);
+    
+        // Filtrer les positions qui sont libres
+        possibleMoves.removeIf(p -> !(b.getState(p) instanceof EmptySquare));
+    
+        // Si aucune position libre n'est disponible, retourner null
+        if (possibleMoves.isEmpty()) {
+            return null;
+        }
+    
+        // Calculer la distance actuelle vers la cible
+        int currentDistance = PositionUtil.getManhattanDistance(currentPos, targetPos);
+    
+        // Choisir la position libre qui réduit le plus la distance vers le feu
+        Position bestMove = null;
+        int minDistance = currentDistance;
+        for (Position move : possibleMoves) {
+            int distance = PositionUtil.getManhattanDistance(move, targetPos);
+            if (distance < minDistance) {
+                minDistance = distance;
+                bestMove = move;
+            }
+        }
+    
+        // Si aucun déplacement ne réduit la distance, annuler le déplacement
+        if (bestMove == null) {
+            return null;
+        }
+        System.out.println("moving from " + position.toString() + " to " + bestMove.toString());
+        return bestMove;
+    }
+    
+    
+    
+
     @Override
     public void setPosition(Position p) {
         this.position = p;

src/main/java/model/FireFighterScenario.java

@@ -15,8 +15,12 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
   private Matrix<Entity> matrix;
   private int step;
 
+  private int initialFireCount;
+  private int initialFireFightersCount;
   public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount) {
     this.matrix = new Matrix<Entity>(columns, rows);
+    this.initialFireCount = initialFireCount;
+    this.initialFireFightersCount = initialFireFightersCount;
     initScenario(matrix);
     placeInitialActors(initialFireCount, initialFireFightersCount);
     this.step = 0;
@@ -95,6 +99,10 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
   public int columnCount() {
     return matrix.getColumns();
   }
+  @Override
+  public void clearCase(Position position){
+    setState(new EmptySquare(position, step+1), position, true);
+  }
 
   public List<Position> updateToNextGeneration() {
     ArrayList<Position> changedPositions = new ArrayList<>();
@@ -103,15 +111,18 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
       Entity e = iterator.next();
       if (e instanceof EmptySquare)
         continue;
-      System.out.println("found age : " + e.getAge() + " current age : " + step);
       if (e.getAge() == 0) {
         e.incrementAge();
         continue;
       }
-      ;
+      if(e.getAge() == step+1){
+        continue;
+      }
       List<Position> entityUpdatedPositions = e.nextTurn(this);
+      e.incrementAge();
       changedPositions.addAll(entityUpdatedPositions);
     }
+    matrix.displayMatrix();
     return changedPositions;
   }
 
@@ -142,7 +153,10 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
 
 
   public void reset() {
+    step = 0;
     matrix.clear();
+    initScenario(matrix);
+    placeInitialActors(initialFireCount, initialFireFightersCount);
   }
 
   public int stepNumber() {

src/main/java/util/Matrix.java

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
+import model.Fire;
+import model.FireFighter;
+
 public class Matrix<E> implements Iterable<E> {
     private ArrayList<ArrayList<E>> matrix;
     private final int rows;
@@ -36,9 +39,11 @@ public class Matrix<E> implements Iterable<E> {
     }
 
     public void clear() {
-        this.matrix.clear();
+        this.matrix = new ArrayList<>(rows);
+        // Initialiser chaque ligne de la matrice
         for (int i = 0; i < rows; i++) {
             ArrayList<E> row = new ArrayList<>(columns);
+            // Initialiser chaque colonne avec des valeurs nulles
             for (int j = 0; j < columns; j++) {
                 row.add(null);
             }
@@ -56,7 +61,7 @@ public class Matrix<E> implements Iterable<E> {
     public int getRows(){
         return this.rows;
     }
-    /*
+
 
     public void displayMatrix() {
         System.out.print("  ");
@@ -69,7 +74,15 @@ public class Matrix<E> implements Iterable<E> {
             System.out.print("| ");
             for (int j = 0; j < columns; j++) {
                 if (matrix.get(i).get(j) != null) {
-                    System.out.print(" x | ");
+                    if(matrix.get(i).get(j) instanceof Fire){
+                        System.out.print(" F | ");
+                    }   
+                    else if(matrix.get(i).get(j) instanceof FireFighter){
+                        System.out.print(" ff | ");
+                    }else{
+                        System.out.print("  | ");
+                    }
+                    
                 } else {
                     System.out.print("   | ");
                 }
@@ -82,7 +95,7 @@ public class Matrix<E> implements Iterable<E> {
             System.out.println();
         }
     }
-        */
+
 
     private void validateIndex(int x, int y) {
         if (x < 0 || x >= rows || y < 0 || y >= columns) {

src/main/java/util/PositionUtil.java

@@ -2,8 +2,31 @@ package util;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import model.Board;
+import model.Entity;
 
 public class PositionUtil {
+    /**
+     * Calcule et retourne une liste de positions situées à une distance de
+     * Manhattan spécifique à partir d'une position donnée.
+     * La distance de Manhattan entre deux points (x1, y1) et (x2, y2) est donnée
+     * par |x1 - x2| + |y1 - y2|.
+     * Cette méthode génère toutes les positions possibles à cette distance dans une
+     * grille de taille spécifiée.
+     *
+     * @param fromPos  la position de départ à partir de laquelle la distance est
+     *                 calculée.
+     * @param distance la distance de Manhattan à utiliser pour trouver les
+     *                 positions.
+     * @param rows     le nombre de lignes dans la grille.
+     * @param cols     le nombre de colonnes dans la grille.
+     * @return une liste de positions à la distance de Manhattan spécifiée de la
+     *         position initiale, qui se trouvent également dans les limites de la
+     *         grille.
+     */
     public static List<Position> getPositionsAtManhattanDistance(Position fromPos, int distance, int rows, int cols) {
         List<Position> positions = new ArrayList<>();
         int x0 = fromPos.x();
@@ -27,4 +50,64 @@ public class PositionUtil {
 
         return positions;
     }
+
+    /**
+     * Génère une liste de positions adjacentes à une position donnée, en vérifiant
+     * si chaque position est valide dans le contexte du jeu.
+     *
+     * @param position la position de départ pour laquelle générer les positions
+     *                 adjacentes.
+     * @param board    l'objet représentant le plateau de jeu qui permet de vérifier
+     *                 si une position existe.
+     * @return une liste des positions adjacentes valides.
+     */
+    public static List<Position> generateAdjacentPositions(Position position, Board<Entity> board) {
+        int x = position.x();
+        int y = position.y();
+
+        return Stream.of(
+                new Position(x, y + 1),
+                new Position(x + 1, y),
+                new Position(x, y - 1),
+                new Position(x - 1, y))
+                .filter(p -> board.doesPositionExist(p))
+                .collect(Collectors.toList());
+    }
+
+    // Méthode pour générer toutes les positions adjacentes (y compris les
+    // diagonales)
+    public static List<Position> generateAllAdjacentPositions(Position position, Board<Entity> board) {
+        int x = position.x();
+        int y = position.y();
+
+        List<Position> positions = new ArrayList<>();
+
+        // Liste des 8 déplacements possibles
+        int[][] deltas = {
+                { 1, 0 }, // x+1, y
+                { -1, 0 }, // x-1, y
+                { 0, 1 }, // x, y+1
+                { 0, -1 }, // x, y-1
+                { 1, 1 }, // x+1, y+1
+                { -1, -1 }, // x-1, y-1
+                { 1, -1 }, // x+1, y-1
+                { -1, 1 } // x-1, y+1
+        };
+
+        for (int[] delta : deltas) {
+            int newX = x + delta[0];
+            int newY = y + delta[1];
+            Position p = new Position(newX, newY);
+            if (board.doesPositionExist(p)) {
+                positions.add(p);
+            }
+        }
+
+        return positions;
+    }
+
+    public static int getManhattanDistance(Position p1, Position p2) {
+        return Math.abs(p1.x() - p2.x()) + Math.abs(p1.y() - p2.y());
+    }
+
 }
\ No newline at end of file