le programme maintenant marche tout les feux s'eteingent et ils se propagent...

le programme maintenant marche tout les feux s'eteingent et ils se propagent aussi et les firefighters font leurs travail complet jusqu'a la fin on est tres contents

src/main/java/app/SimulatorApplication.java

@@ -17,8 +17,8 @@ public class SimulatorApplication extends javafx.application.Application {
   private static final int COLUMN_COUNT = 20;
   private static final int BOX_WIDTH = 50;
   private static final int BOX_HEIGHT = 50;
-  public static final int INITIAL_FIRE_COUNT = 3;
-  public static final int INITIAL_FIREFIGHTER_COUNT = 6;
+  public static final int INITIAL_FIRE_COUNT = 15;
+  public static final int INITIAL_FIREFIGHTER_COUNT = 10;
 
   private Stage primaryStage;
   private Parent view;

src/main/java/model/FirefighterBoard.java

@@ -13,8 +13,8 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   private final int initialFirefighterCount;
   private final TargetStrategy targetStrategy = new TargetStrategy();
   private List<FireFighter> firefighters;
-  private Set<Fire> fires;
-  private Map<Position, List<Position>> neighbors = new HashMap();
+  private Map<Position, Fire> fires = new HashMap<>();
+  private final Map<Position, List<Position>> neighbors = new HashMap<>();
   private final Position[][] positions;
   private int step = 0;
   private final Random randomGenerator = new Random();
@@ -23,46 +23,63 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     this.columnCount = columnCount;
     this.rowCount = rowCount;
     this.positions = new Position[rowCount][columnCount];
-    for (int column = 0; column < columnCount; column++)
-      for (int row = 0; row < rowCount; row++)
-        positions[row][column] = new Position(row, column);
-    for (int column = 0; column < columnCount; column++)
-      for (int row = 0; row < rowCount; row++) {
-        List<Position> list = new ArrayList<>();
-        if (row > 0) list.add(positions[row - 1][column]);
-        if (column > 0) list.add(positions[row][column - 1]);
-        if (row < rowCount - 1) list.add(positions[row + 1][column]);
-        if (column < columnCount - 1) list.add(positions[row][column + 1]);
-        neighbors.put(positions[row][column], list);
-      }
+
+    // Initialize positions and neighbors
+    initializePositionsAndNeighbors();
+
     this.initialFireCount = initialFireCount;
     this.initialFirefighterCount = initialFirefighterCount;
     initializeElements();
   }
 
+  private void initializePositionsAndNeighbors() {
+    for (int column = 0; column < columnCount; column++) {
+      for (int row = 0; row < rowCount; row++) {
+        positions[row][column] = new Position(row, column);
+      }
+    }
+
+    for (int column = 0; column < columnCount; column++) {
+      for (int row = 0; row < rowCount; row++) {
+        neighbors.put(positions[row][column], calculateNeighbors(row, column));
+      }
+    }
+  }
+
+  private List<Position> calculateNeighbors(int row, int column) {
+    List<Position> list = new ArrayList<>();
+    if (row > 0) list.add(positions[row - 1][column]);
+    if (column > 0) list.add(positions[row][column - 1]);
+    if (row < rowCount - 1) list.add(positions[row + 1][column]);
+    if (column < columnCount - 1) list.add(positions[row][column + 1]);
+    return list;
+  }
+
   public void initializeElements() {
     firefighters = new ArrayList<>();
-    fires = new HashSet<>();
-    for (int index = 0; index < initialFireCount; index++)
-      fires.add(new Fire(randomPosition()));
-    for (int index = 0; index < initialFirefighterCount; index++)
+    fires.clear();
+
+    for (int index = 0; index < initialFireCount; index++) {
+      Position position = randomPosition();
+      fires.put(position, new Fire(position));
+    }
+
+    for (int index = 0; index < initialFirefighterCount; index++) {
       firefighters.add(new FireFighter(randomPosition()));
+    }
   }
 
   private Position randomPosition() {
-    return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+    return positions[randomGenerator.nextInt(rowCount)][randomGenerator.nextInt(columnCount)];
   }
 
   @Override
   public List<ModelElement> getState(Position position) {
     List<ModelElement> result = new ArrayList<>();
-    for (FireFighter firefighter : firefighters)
-      if (firefighter.getPosition().equals(position))
-        result.add(ModelElement.FIREFIGHTER);
-
-    if (this.getFirePositions(fires).contains(position))
-      result.add(ModelElement.FIRE);
-
+    for (FireFighter firefighter : firefighters) {
+      if (firefighter.getPosition().equals(position)) result.add(ModelElement.FIREFIGHTER);
+    }
+    if (fires.containsKey(position)) result.add(ModelElement.FIRE);
     return result;
   }
 
@@ -86,47 +103,50 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   private List<Position> updateFires() {
     List<Position> modifiedPositions = new ArrayList<>();
     if (step % 2 == 0) {
-      List<Position> newFirePositions = new ArrayList<>();
-      for (Position fire : getFirePositions(this.fires)) {
+      Set<Position> newFirePositions = new HashSet<>();
+      for (Position fire : new HashSet<>(fires.keySet())) { // Utilisez une copie de la clé
         newFirePositions.addAll(neighbors.get(fire));
       }
-      this.getFirePositions(fires).addAll(newFirePositions);
-      modifiedPositions.addAll(newFirePositions);
+      for (Position position : newFirePositions) {
+        if (!fires.containsKey(position)) { // Vérifiez si le feu est nouveau
+          fires.put(position, new Fire(position));
+          modifiedPositions.add(position);
+        }
+      }
     }
     return modifiedPositions;
-
   }
 
+
   @Override
   public int stepNumber() {
     return step;
   }
 
   private List<Position> updateFirefighters() {
-    List<Position> modifiedPosition = new ArrayList<>();
-    List<Position> firefighterNewPositions = new ArrayList<>();
-    for (Position firefighterPosition : this.getFireFighterPositions(this.firefighters)) {
-      Position newFirefighterPosition =
-              targetStrategy.neighborClosestToFire(firefighterPosition,
-                      this.getFirePositions(fires), neighbors);
-      firefighterNewPositions.add(newFirefighterPosition);
-      extinguish(newFirefighterPosition);
-      modifiedPosition.add(firefighterPosition);
-      modifiedPosition.add(newFirefighterPosition);
-      List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
-              .filter(this.getFirePositions(fires)::contains).toList();
-      for (Position firePosition : neighborFirePositions)
-        extinguish(firePosition);
-      modifiedPosition.addAll(neighborFirePositions);
-    }
-    ArrayList<FireFighter> newFireFighters = new ArrayList<>();
-    for(Position position : firefighterNewPositions){
-      newFireFighters.add(new FireFighter(position));
+    List<Position> modifiedPositions = new ArrayList<>();
+    for (FireFighter firefighter : firefighters) {
+      Position currentPosition = firefighter.getPosition();
+      Position newPosition = targetStrategy.neighborClosestToFire(currentPosition, fires.keySet(), neighbors);
+
+      // Déplacement du pompier
+      firefighter.setPosition(newPosition);
+      modifiedPositions.add(currentPosition);
+      modifiedPositions.add(newPosition);
+
+      // Éteindre le feu à la nouvelle position
+      extinguish(newPosition);
+
+      // Éteindre les feux voisins
+      for (Position neighbor : neighbors.get(newPosition)) {
+        extinguish(neighbor);
+        modifiedPositions.add(neighbor);
+      }
     }
-    firefighters = newFireFighters;
-    return modifiedPosition;
+    return modifiedPositions;
   }
 
+
   @Override
   public void reset() {
     step = 0;
@@ -134,10 +154,8 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   }
 
   private void extinguish(Position position) {
-    for(Fire fire: fires){
-      if(fire.getPosition().equals(position)){
-        fires.remove(fire);
-      }
+    if (fires.containsKey(position)) {
+      fires.remove(position);
     }
   }
 
@@ -145,39 +163,13 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   @Override
   public void setState(List<ModelElement> state, Position position) {
     extinguish(position);
-    for (; ; ) {
-      if (!getFireFighterPositions(this.firefighters).remove(position)) break;
-    }
+    firefighters.removeIf(firefighter -> firefighter.getPosition().equals(position));
+
     for (ModelElement element : state) {
       switch (element) {
-        case FIRE -> fires.add(new Fire(position));
+        case FIRE -> fires.put(position, new Fire(position));
         case FIREFIGHTER -> firefighters.add(new FireFighter(position));
       }
     }
   }
-
-
-
-
-  public Set<Position> getFirePositions(Set<Fire> fireSet){
-    Set<Position> firePositions = new HashSet<>();
-    for(Fire fire : fireSet){
-      firePositions.add(fire.getPosition());
-    }
-    return firePositions;
-  }
-
-
-  public ArrayList<Position> getFireFighterPositions(List<FireFighter> fireFighterList){
-    ArrayList<Position> fireFighterPositions = new ArrayList<>();
-    for(FireFighter fireFighter : fireFighterList){
-      fireFighterPositions.add(fireFighter.getPosition());
-    }
-    return fireFighterPositions;
-  }
-
-
-
-
-
-}
\ No newline at end of file
+}