Merge remote-tracking branch 'origin/main'

# Conflicts:
#	src/main/java/model/FirefighterBoard.java
#	src/main/java/model/Initializer.java
#	src/main/java/model/ModelElement.java

src/main/java/model/CloudStrategy.java

+package model;
+
+import util.Position;
+import util.TargetStrategy;
+
+import java.util.*;
+
+public class CloudStrategy implements Strategy {
+    private final TargetStrategy targetStrategy = new TargetStrategy();
+    private List<Position> cloudPositions;
+    private final Set<Position> firePositions;
+    private final Map<Position, List<Position>> neighbors;
+    private final Random random = new Random();
+    private final int maxRows;
+    private final int maxCols;
+
+    public CloudStrategy(List<Position> cloudPositions, Set<Position> firePositions, Map<Position, List<Position>> neighbors, int maxRows, int maxCols) {
+
+        this.cloudPositions = cloudPositions;
+        this.firePositions = firePositions;
+        this.neighbors = neighbors;
+        this.maxRows = maxRows;
+        this.maxCols = maxCols;
+    }
+
+    @Override
+    public List<Position> update() {
+        List<Position> modifiedCloudPositions = new ArrayList<>();
+        List<Position> newCloudPositions = new ArrayList<>();
+
+        for (Position cloudPosition : cloudPositions) {
+            Position newCloudPosition = randomPos(cloudPosition);
+            newCloudPositions.add(newCloudPosition);
+            modifiedCloudPositions.add(cloudPosition);
+            modifiedCloudPositions.add(newCloudPosition);
+            extinguishFiures(newCloudPosition, modifiedCloudPositions);
+        }
+        cloudPositions = newCloudPositions;
+        return modifiedCloudPositions;
+    }
+
+    @Override
+    public List<Position> getModelPositions() {
+        return cloudPositions;
+    }
+
+    @Override
+    public Set<Position> getFirePositions() {
+        return firePositions;
+    }
+    private void extinguishFiures(Position position, List<Position> modifiedCloudPositions) {
+        List<Position> positions = new ArrayList<>(neighbors.getOrDefault(position, Collections.emptyList()));
+        positions.add(position);
+        List<Position> firePos = positions.stream().filter(firePositions :: contains).toList();
+        firePositions.removeAll(firePos);
+        modifiedCloudPositions.addAll(firePos);
+    }
+    private Position randomPos(Position cloudPosition) {
+        int row = random.nextInt(3)-1;
+        int col = random.nextInt(3)-1;
+        int newRow = cloudPosition.getRow() + row;
+        int newCol = cloudPosition.getCol() + col;
+        if (newRow>=0 && newRow<maxRows && newCol>=0 && newCol<maxCols) {
+            return new Position(newRow, newCol);
+        }
+        return cloudPosition;
+    }
+}

src/main/java/model/FirefighterBoard.java

@@ -4,34 +4,34 @@ import util.Position;
 import javafx.util.Pair;
 import java.util.*;
 
+import static model.ModelElement.CLOUD;
+
 public class FirefighterBoard implements Board<List<ModelElement>> {
     private final int columnCount;
     private final int rowCount;
     private final int initialFireCount;
     private final int initialFirefighterCount;
-    private final int initialRoadCount;
 
     private List<Position> firefighterPositions;
     private Set<Position> firePositions;
-    private List<Position> RoadPositions;
     private final Map<Position, List<Position>> neighbors;
     private final Position[][] positions;
+    private List<Position> cloudPositions;
 
     private int step = 0;
 
     // Constructor for FirefighterBoard
-    public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount, int initialRoadCount) {
+    public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
         this.columnCount = columnCount;
         this.rowCount = rowCount;
         this.initialFireCount = initialFireCount;
         this.initialFirefighterCount = initialFirefighterCount;
-        this.initialRoadCount = initialRoadCount;
 
         this.positions = new Position[rowCount][columnCount];
         this.firefighterPositions = new ArrayList<>();
         this.firePositions = new HashSet<>();
-        this.RoadPositions = new ArrayList<>();
         this.neighbors = new HashMap<>();
+        this.cloudPositions = new ArrayList<>();
 
         initializeBoard();
     }
@@ -48,11 +48,6 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
         for (int i = 0; i < initialFirefighterCount; i++) {
             firefighterPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
         }
-        // Initialize Road positions
-        for (int i = 0; i < initialRoadCount; i++) {
-            RoadPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
-        }
-
 
         // Initialize neighbors map
         for (int row = 0; row < rowCount; row++) {
@@ -87,9 +82,9 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
                         result.add(ModelElement.FIREFIGHTER);
                     }
                 }
-                case ROAD -> {
-                    if (RoadPositions.contains(position)) {
-                        result.add(ModelElement.ROAD);
+                case CLOUD -> {
+                    if (cloudPositions.contains(position)) {
+                        result.add(ModelElement.CLOUD);
                     }
                 }
                 default ->{
@@ -117,11 +112,20 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     @Override
     public void reset() {
         step = 0;
-        firefighterPositions.clear();
-        firePositions.clear();
+        Initializer initializer = new Initializer(columnCount,rowCount,initialFireCount,initialFirefighterCount);
+        resetPos(firePositions,initializer.getFirePositions());
+        resetPos(firefighterPositions,initializer.getFirefighterPositions());
+        resetPos(cloudPositions,initializer.getCloudPositions());
+
+        neighbors.clear();
+        neighbors.putAll(initializer.getNeighbors());
 
         initializeBoard();
     }
+    private <S> void resetPos(Collection<S> currentPositions, Collection<S> newPositions) {
+        currentPositions.clear();
+        currentPositions.addAll(newPositions);
+  }
 
     @Override
     public void setState(List<ModelElement> state, Position position) {
@@ -132,7 +136,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
             switch (element) {
                 case FIRE -> firePositions.add(position);
                 case FIREFIGHTER -> firefighterPositions.add(position);
-                case ROAD -> RoadPositions.add(position);
+                case CLOUD -> cloudPositions.add(position);
             }
         }
     }
@@ -141,7 +145,8 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     public List<Position> updateToNextGeneration() {
         List<ModelElement> elements = List.of(
                 ModelElement.FIRE,
-                ModelElement.FIREFIGHTER
+                ModelElement.FIREFIGHTER,
+                ModelElement.CLOUD
         );
         List<Position> modifiedPositions = new ArrayList<>();
 
@@ -149,6 +154,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
             Strategy strategy = switch(element) {
                 case FIRE -> new SimpleFireSpreadStrategy(firePositions, neighbors,step);
                 case FIREFIGHTER -> new FirefighterMovementStrategy(firefighterPositions,firePositions,neighbors);
+                case CLOUD -> new CloudStrategy(cloudPositions,firePositions,neighbors,rowCount,columnCount);
                 default -> throw new IllegalStateException("Type de modèle inconnu : " + element);
             };
             modifiedPositions.addAll(strategy.update());
@@ -156,6 +162,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
             switch (element) {
                 case FIRE -> firePositions = strategy.getFirePositions();
                 case FIREFIGHTER -> firefighterPositions = strategy.getModelPositions();
+                case CLOUD -> cloudPositions = strategy.getModelPositions();
             }
         }
         step++;
@@ -165,11 +172,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     private Set<Position> spreadFire() {
         Set<Position> newFirePositions = new HashSet<>();
         for (Position firePosition : firePositions) {
-            for (Position neighbor : neighbors.get(firePosition)) {
-                if (!RoadPositions.contains(neighbor)) {
-                    newFirePositions.add(neighbor);
-                }
-            }
+            newFirePositions.addAll(neighbors.get(firePosition));  // Spread fire to neighbors
         }
         return newFirePositions;
     }
@@ -198,10 +201,6 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
         for (Position firefighterPosition : firefighterPositions) {
             updatedElements.add(new Pair<>(firefighterPosition, ModelElement.FIREFIGHTER));
         }
-        // Add Road positions
-        for (Position roadPosition : RoadPositions) {
-            updatedElements.add(new Pair<>(roadPosition, ModelElement.ROAD));
-        }
 
         return updatedElements;
     }

src/main/java/model/Initializer.java

@@ -16,10 +16,14 @@ public class Initializer {
     private List<Position> RoadPositions;
     private final List<Position> firefighterPositions;
     private final Set<Position> firePositions;
+    private final List<Position> cloudPositions;
     private int step = 0;
 
     private final Random randomGenerator = new Random();
 
+    private static final int cloudCount = 3;
+
+
     public Initializer(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount, int initialRoadCount) {
         this.columnCount = columnCount;
         this.rowCount = rowCount;
@@ -32,10 +36,8 @@ public class Initializer {
         this.firePositions = new HashSet<>();
         this.firefighterPositions = new ArrayList<>();
         this.RoadPositions = new ArrayList<>();
+        this.cloudPositions = new ArrayList<>();
 
-        initializePositions();
-        initializeNeighbors();
-        initializeElements();
     }
     private void initializePositions() {
         for (int row = 0; row < rowCount; row++) {
@@ -60,6 +62,7 @@ public class Initializer {
         initializeFirePositions();
         initializeFirefighters();
         initializeRoadPositions();
+
     }
     private void initializeFirePositions() {
         addRandomPositions(firePositions, initialFireCount);
@@ -68,6 +71,9 @@ public class Initializer {
             addRandomPositions(firefighterPositions, initialFirefighterCount);
     }
     private void initializeRoadPositions() {addRandomPositions(RoadPositions, initialRoadCount);}
+    private void initializeCloudsPositions() {
+        addRandomPositions(cloudPositions, cloudCount);
+    }
 
     private void addRandomPositions(Collection<Position> targetCollection, int count) {
         while (targetCollection.size() < count) {
@@ -115,6 +121,7 @@ public class Initializer {
     public Set<Position> getFirePositions() {
         return firePositions;
     }
+    public List<Position> getCloudPositions() {return cloudPositions;}
     public int getStep() {return step;}
 
 }

src/main/java/model/ModelElement.java

@@ -2,7 +2,7 @@ package model;
 
 
 public enum ModelElement {
-  ROAD("Gris"), FIREFIGHTER("blue"), FIRE("red");
+  FIREFIGHTER("blue"), FIRE("red"), CLOUD("darkgrey");
 
   private final String color;