src/main/java/app/SimulatorApplication.java

@@ -17,8 +17,10 @@ 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;
+  public static final int INITIAL_CLOUD_COUNT = 5;
+
 
   private Stage primaryStage;
   private Parent view;
@@ -44,7 +46,7 @@ public class SimulatorApplication extends javafx.application.Application {
     view = loader.load();
     Controller controller = loader.getController();
     controller.initialize(BOX_WIDTH, BOX_HEIGHT, COLUMN_COUNT, ROW_COUNT,
-            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT);
+            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT,INITIAL_CLOUD_COUNT);
   }
 
   private void showScene() {

src/main/java/controller/Controller.java

@@ -88,9 +88,13 @@ public class Controller {
     if (squareState.contains(ModelElement.FIRE)) {
       return ViewElement.FIRE;
     }
+    if (squareState.contains(ModelElement.CLOUD)) {  // Assurez-vous que le modèle inclut bien le nuage
+      return ViewElement.CLOUD;
+    }
     return ViewElement.EMPTY;
   }
 
+
   private void initializeTimeline() {
     Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);
     EventHandler<ActionEvent> eventHandler =
@@ -124,9 +128,9 @@ public class Controller {
   }
 
   public void initialize(int squareWidth, int squareHeight, int columnCount,
-                                int rowCount, int initialFireCount, int initialFirefighterCount) {
+                                int rowCount, int initialFireCount, int initialFirefighterCount,int initialCloudCount) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
+    this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount,initialCloudCount));
     repaintGrid();
   }
 

src/main/java/model/Cloud.java

+package model;
+
+import util.Position;
+
+public class Cloud {
+
+    private Position position;
+
+    public Cloud(Position position) {
+        this.position = position;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+
+}

src/main/java/model/Fire.java

+package model;
+
+import util.Position;
+
+
+
+public class Fire {
+
+    private Position position;
+
+
+    public Fire(Position position){
+        this.position = position;
+    }
+
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+
+
+
+
+
+}
\ No newline at end of file

src/main/java/model/FireFighter.java

+package model;
+
+import util.Position;
+
+
+public class FireFighter {
+
+    private Position position;
+
+
+    public FireFighter(Position position){
+        this.position = position;
+    }
+
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+
+
+
+
+}
\ No newline at end of file

src/main/java/model/FirefighterBoard.java

 package model;
 
 import util.Position;
+import util.TargetStrategy;
 
 import java.util.*;
 
@@ -10,59 +11,110 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   private final int rowCount;
   private final int initialFireCount;
   private final int initialFirefighterCount;
+  private final int initialCloudCount;
   private final TargetStrategy targetStrategy = new TargetStrategy();
-  private List<Position> firefighterPositions;
-  private Set<Position> firePositions;
-  private Map<Position, List<Position>> neighbors = new HashMap();
+  private List<FireFighter> firefighters;
+  private Map<Position, Fire> fires = new HashMap<>();
+  private List<Cloud> clouds;
+  private final Map<Position, List<Position>> neighbors = new HashMap<>();
   private final Position[][] positions;
   private int step = 0;
   private final Random randomGenerator = new Random();
 
-  public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
+  public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount,int initialCloudCount) {
     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++)
+
+    initializePositionsAndNeighbors();
+
+    this.initialFireCount = initialFireCount;
+    this.initialFirefighterCount = initialFirefighterCount;
+    this.initialCloudCount = initialCloudCount;
+    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 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]);
-        neighbors.put(positions[row][column], list);
-      }
-    this.initialFireCount = initialFireCount;
-    this.initialFirefighterCount = initialFirefighterCount;
-    initializeElements();
+    return list;
   }
 
   public void initializeElements() {
-    firefighterPositions = new ArrayList<>();
-    firePositions = new HashSet<>();
-    for (int index = 0; index < initialFireCount; index++)
-      firePositions.add(randomPosition());
-    for (int index = 0; index < initialFirefighterCount; index++)
-      firefighterPositions.add(randomPosition());
+    firefighters = new ArrayList<>();
+    clouds = new ArrayList<>();
+    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()));
+    }
+    for (int index = 0; index < initialCloudCount; index++) {
+      clouds.add(new Cloud(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 (Position firefighterPosition : firefighterPositions)
-      if (firefighterPosition.equals(position))
-        result.add(ModelElement.FIREFIGHTER);
-    if (firePositions.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);
+
+    for (Cloud cloud : clouds) {
+      if (cloud.getPosition().equals(position)) result.add(ModelElement.CLOUD);
+    }
     return result;
   }
 
+  private List<Position> updateClouds() {
+    List<Position> modifiedPositions = new ArrayList<>();
+    for (Cloud cloud : clouds) {
+      Position currentPosition = cloud.getPosition();
+      Position newPosition = randomNeighbor(currentPosition);
+      cloud.setPosition(newPosition);
+      modifiedPositions.add(currentPosition);
+      modifiedPositions.add(newPosition);
+
+
+      extinguish(newPosition);
+    }
+    return modifiedPositions;
+  }
+  private Position randomNeighbor(Position position) {
+    List<Position> neighborPositions = neighbors.get(position);
+    return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
+  }
+
+
   @Override
   public int rowCount() {
     return rowCount;
@@ -75,50 +127,57 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
   public List<Position> updateToNextGeneration() {
     List<Position> modifiedPositions = updateFirefighters();
+    modifiedPositions.addAll(updateClouds());
     modifiedPositions.addAll(updateFires());
     step++;
     return modifiedPositions;
   }
 
+
   private List<Position> updateFires() {
     List<Position> modifiedPositions = new ArrayList<>();
     if (step % 2 == 0) {
-      List<Position> newFirePositions = new ArrayList<>();
-      for (Position fire : firePositions) {
+      Set<Position> newFirePositions = new HashSet<>();
+      for (Position fire : new HashSet<>(fires.keySet())) {
         newFirePositions.addAll(neighbors.get(fire));
       }
-      firePositions.addAll(newFirePositions);
-      modifiedPositions.addAll(newFirePositions);
+      for (Position position : newFirePositions) {
+        if (!fires.containsKey(position)) {
+          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 : firefighterPositions) {
-      Position newFirefighterPosition =
-              targetStrategy.neighborClosestToFire(firefighterPosition,
-                      firePositions, neighbors);
-      firefighterNewPositions.add(newFirefighterPosition);
-      extinguish(newFirefighterPosition);
-      modifiedPosition.add(firefighterPosition);
-      modifiedPosition.add(newFirefighterPosition);
-      List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
-              .filter(firePositions::contains).toList();
-      for (Position firePosition : neighborFirePositions)
-        extinguish(firePosition);
-      modifiedPosition.addAll(neighborFirePositions);
-    }
-    firefighterPositions = firefighterNewPositions;
-    return modifiedPosition;
+    List<Position> modifiedPositions = new ArrayList<>();
+    for (FireFighter firefighter : firefighters) {
+      Position currentPosition = firefighter.getPosition();
+      Position newPosition = targetStrategy.neighborClosestToFire(currentPosition, fires.keySet(), neighbors);
+
+      firefighter.setPosition(newPosition);
+      modifiedPositions.add(currentPosition);
+      modifiedPositions.add(newPosition);
+
+      extinguish(newPosition);
+
+      for (Position neighbor : neighbors.get(newPosition)) {
+        extinguish(neighbor);
+        modifiedPositions.add(neighbor);
+      }
     }
+    return modifiedPositions;
+  }
+
 
   @Override
   public void reset() {
@@ -127,20 +186,21 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   }
 
   private void extinguish(Position position) {
-    firePositions.remove(position);
+    if (fires.containsKey(position)) {
+      fires.remove(position);
+    }
   }
 
 
   @Override
   public void setState(List<ModelElement> state, Position position) {
-    firePositions.remove(position);
-    for (; ; ) {
-      if (!firefighterPositions.remove(position)) break;
-    }
+    extinguish(position);
+    firefighters.removeIf(firefighter -> firefighter.getPosition().equals(position));
+
     for (ModelElement element : state) {
       switch (element) {
-        case FIRE -> firePositions.add(position);
-        case FIREFIGHTER -> firefighterPositions.add(position);
+        case FIRE -> fires.put(position, new Fire(position));
+        case FIREFIGHTER -> firefighters.add(new FireFighter(position));
       }
     }
   }

src/main/java/model/ModelElement.java

 package model;
 
 public enum ModelElement {
-  FIREFIGHTER, FIRE
+  FIREFIGHTER,
+  FIRE,
+  CLOUD;
 }
+

src/main/java/model/Road.java

+package model;
+
+import util.Position;
+
+public class Road {
+
+    private final Position position;
+
+
+    public Road(Position position){
+        this.position = position;
+    }
+
+    public Position getPosition(){
+        return this.position;
+    }
+
+
+
+
+
+}

src/main/java/module-info.java

@@ -4,5 +4,6 @@ module firefighter {
   requires javafx.graphics;
   opens controller to javafx.fxml;
   exports app;
+  exports view;
   opens app to javafx.fxml;
 }

src/main/java/util/TargetStrategy.java

-package model;
+package util;
 
 import util.Position;
 
@@ -12,7 +12,7 @@ public class TargetStrategy {
      * @param targets positions that are targeted.
      * @return the position next to the current position that is on the path to the closest target.
      */
-    Position neighborClosestToFire(Position position, Collection<Position> targets,
+    public Position neighborClosestToFire(Position position, Collection<Position> targets,
                                    Map<Position,List<Position>>neighbors) {
         Set<Position> seen = new HashSet<Position>();
         HashMap<Position, Position> firstMove = new HashMap<Position, Position>();

src/main/java/view/FirefighterGrid.java

@@ -10,8 +10,10 @@ import java.util.List;
 public class FirefighterGrid extends Canvas implements Grid<ViewElement>{
 
     private void paintElementAtPosition(ViewElement element, Position position) {
+        System.out.println("Painting " + element + " at " + position);
         paintBox(position.row(), position.column(), element.color);
     }
+
     private int boxWidth;
     private int boxHeight;
     private int columnCount;

src/main/java/view/ViewElement.java

@@ -3,7 +3,7 @@ package view;
 import javafx.scene.paint.Color;
 
 public enum ViewElement {
-  FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE);
+  FIREFIGHTER(Color.BLUE), FIRE(Color.RED),CLOUD(Color.LIGHTSKYBLUE), EMPTY(Color.WHITE);
   final Color color;
   ViewElement(Color color) {
     this.color = color;

src/test/java/model/FirefighterBoardTest.java

@@ -10,17 +10,17 @@ import static org.assertj.core.api.Assertions.*;
 public class FirefighterBoardTest {
   @Test
   void testColumnCount(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3,1);
     assertThat(board.columnCount()).isEqualTo(20);
   }
   @Test
   void testRowCount(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3,1);
     assertThat(board.rowCount()).isEqualTo(10);
   }
   @Test
   void testStepNumber(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3,1);
     for(int index = 0; index < 10; index++){
       assertThat(board.stepNumber()).isEqualTo(index);
       board.updateToNextGeneration();
@@ -29,7 +29,7 @@ public class FirefighterBoardTest {
   }
   @Test
   void testGetState_afterSet(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 0, 0);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 0, 0,1);
     Position position = new Position(1,2);
     assertThat(board.getState(position)).isEmpty();
     board.setState(List.of(ModelElement.FIRE), position);