Correct errors

src/main/java/app/SimulatorApplication.java

@@ -17,7 +17,7 @@ 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_FIRE_COUNT = 4;
   public static final int INITIAL_FIREFIGHTER_COUNT = 3;
   public static final int INITIAL_CLOUD_COUNT = 3;
   public static final int INITIAL_MOTORIZED_COUNT = 3;

src/main/java/model/BoardFireFighterBehavior.java

@@ -65,35 +65,68 @@ public class BoardFireFighterBehavior implements BoardBehavior{
         List<Position> modifiedPositions = new ArrayList<>();
         if (step % 2 == 0) {
             List<Position> newFirePositions = new ArrayList<>();
+
+            // Pour chaque feu existant, vérifier ses voisins
             for (Position fire : firePositions) {
-                newFirePositions.addAll(neighbors.get(fire));
+                // Si la position voisine est libre (non occupée par un feu ou un pompier), le feu peut se propager
+                for (Position neighbor : neighbors.get(fire)) {
+                    // Vérifier si le feu peut se propager à cette position (pas de feu déjà là et pas un terrain bloqué)
+                    if (canMoveTo(neighbor, firePositions, firefighterPositions) && !firePositions.contains(neighbor)) {
+                        newFirePositions.add(neighbor);
+                    }
+                }
             }
+
+            // Ajouter les nouvelles positions de feu à la liste des feux existants
             firePositions.addAll(newFirePositions);
             modifiedPositions.addAll(newFirePositions);
         }
         return modifiedPositions;
     }
 
+
     public List<Position> updateFirefighters() {
         List<Position> modifiedPositions = new ArrayList<>();
         List<Position> newFirefighterPositions = new ArrayList<>();
+
         for (Position firefighterPosition : firefighterPositions) {
+            // Calcul de la position vers laquelle le pompier devrait se déplacer
             Position newFirefighterPosition = targetStrategy.neighborClosestToTarget(firefighterPosition, firePositions, neighbors);
-            newFirefighterPositions.add(newFirefighterPosition);
-            extinguish(newFirefighterPosition);
-            modifiedPositions.add(firefighterPosition);
-            modifiedPositions.add(newFirefighterPosition);
-
-            List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
-                    .filter(firePositions::contains).toList();
-            for (Position firePosition : neighborFirePositions) {
-                extinguish(firePosition);
+
+            // Vérification si la position cible est valide pour le mouvement
+            if (canMoveTo(newFirefighterPosition, firePositions, firefighterPositions)) {
+                // Si le déplacement est valide, on met à jour la position du pompier
+                newFirefighterPositions.add(newFirefighterPosition);
+
+                // Éteindre le feu à la nouvelle position
+                extinguish(newFirefighterPosition);
+                modifiedPositions.add(firefighterPosition);
+                modifiedPositions.add(newFirefighterPosition);
+
+                // Vérification des voisins et extinction des feux voisins
+                List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
+                        .filter(firePositions::contains).toList();
+
+                // Log pour débogage
+                System.out.println("Pompiers se déplacent de " + firefighterPosition + " vers " + newFirefighterPosition);
+
+                // Éteindre les feux voisins
+                for (Position firePosition : neighborFirePositions) {
+                    extinguish(firePosition);
+                    modifiedPositions.add(firePosition);  // Ajout des feux éteints dans la liste des positions modifiées
+                }
+            } else {
+                // Si la position n'est pas valide, le pompier reste sur place
+                newFirefighterPositions.add(firefighterPosition);
+                System.out.println("Pompier ne peut pas se déplacer à " + newFirefighterPosition + ", il reste à " + firefighterPosition);
             }
-            modifiedPositions.addAll(neighborFirePositions);
         }
+
+        // Mettre à jour la liste des positions des pompiers
         firefighterPositions = newFirefighterPositions;
         return modifiedPositions;
     }
+
     public List<Position> updateMotorized() {
         List<Position> modifiedPositions = new ArrayList<>();
         List<Position> newPositions = new ArrayList<>();
@@ -201,18 +234,30 @@ public class BoardFireFighterBehavior implements BoardBehavior{
             // Déplacement aléatoire
             List<Position> possibleMoves = neighbors.get(cloudPosition);
             Position newCloudPosition = possibleMoves.get(new Random().nextInt(possibleMoves.size()));
+
+            // Vérification que le nuage ne se déplace pas vers une montagne
+            if (!canMoveTo(newCloudPosition, firePositions, firefighterPositions)) {
+                continue;  // Si la position est invalide ou une montagne, le nuage reste sur place
+            }
+
             newCloudPositions.add(newCloudPosition);
 
-            // Éteindre le feu à la position du nuage
-            extinguish(newCloudPosition);
-            modifiedPositions.add(cloudPosition);
-            modifiedPositions.add(newCloudPosition);
+            // Éteindre le feu à la position du nuage (le nuage mange le feu)
+            if (firePositions.contains(newCloudPosition)) {
+                extinguish(newCloudPosition);  // Supprimer le feu
+                modifiedPositions.add(newCloudPosition);  // Ajouter la position du feu éteint aux positions modifiées
+                System.out.println("Feu éteint par nuage à : " + newCloudPosition);
+            }
+
+            modifiedPositions.add(cloudPosition);  // Ajouter l'ancienne position du nuage
+            modifiedPositions.add(newCloudPosition);  // Ajouter la nouvelle position du nuage
         }
 
         cloudPositions = newCloudPositions;
         return modifiedPositions;
     }
 
+
     public List<Position> getCloudPositions() {
         return cloudPositions;
     }
@@ -264,5 +309,32 @@ public class BoardFireFighterBehavior implements BoardBehavior{
     public Map<Position, Terrain> getTerrainMap() {
         return terrainMap;
     }
+    public boolean canMoveTo(Position position, Set<Position> firePositions, List<Position> firefighterPositions) {
+        // Vérifie si la position est hors des limites (par exemple, en dehors de la grille ou inaccessible)
+        if (!neighbors.containsKey(position)) {
+            return false;
+        }
+
+        // Si la position est occupée par un feu et que le terrain n'est pas traversable par le feu
+        if (firePositions.contains(position)) {
+            return false;  // Impossible de traverser une case contenant un feu
+        }
+
+        // Si la position est occupée par un pompier et que le pompier ne peut pas franchir
+        if (firefighterPositions.contains(position)) {
+            return false;  // Impossible de se déplacer sur la position d'un autre pompier
+        }
+
+        // Si la position est une montagne, aucun élément ne peut la franchir sauf les nuages
+        if (terrainMap.get(position) != null && !cloudPositions.contains(position)) {
+            return false;  // Impossible de franchir une montagne, sauf pour un nuage
+        }
+
+        return true;  // La position est traversable
+    }
+
+
+
+
 
 }