diff --git a/.gradle/8.10.2/executionHistory/executionHistory.bin b/.gradle/8.10.2/executionHistory/executionHistory.bin
index 53225b6e1d3c27517a8449101ba24dd9d51f363a..1b04c929a7e6e8270dc77696abc06ecd9c56b77b 100644
Binary files a/.gradle/8.10.2/executionHistory/executionHistory.bin and b/.gradle/8.10.2/executionHistory/executionHistory.bin differ
diff --git a/.gradle/8.10.2/executionHistory/executionHistory.lock b/.gradle/8.10.2/executionHistory/executionHistory.lock
index 06f79ed17ebae12f4323b4883a00019d0c1c7d87..e20f18574181d8ff09e42dcf6caccef815f53ed2 100644
Binary files a/.gradle/8.10.2/executionHistory/executionHistory.lock and b/.gradle/8.10.2/executionHistory/executionHistory.lock differ
diff --git a/.gradle/8.10.2/fileHashes/fileHashes.bin b/.gradle/8.10.2/fileHashes/fileHashes.bin
index 8989656673bcca3b5670dd85268d4144e6b999ea..2b94c4ed959cc5773e8663685b0edf2ea4a98210 100644
Binary files a/.gradle/8.10.2/fileHashes/fileHashes.bin and b/.gradle/8.10.2/fileHashes/fileHashes.bin differ
diff --git a/.gradle/8.10.2/fileHashes/fileHashes.lock b/.gradle/8.10.2/fileHashes/fileHashes.lock
index 483570e1978f2c9f262de08186ad212fda1d7fc0..3f9302b190923d39bb00d07a94bc8a04cebe5f6b 100644
Binary files a/.gradle/8.10.2/fileHashes/fileHashes.lock and b/.gradle/8.10.2/fileHashes/fileHashes.lock differ
diff --git a/.gradle/8.10.2/fileHashes/resourceHashesCache.bin b/.gradle/8.10.2/fileHashes/resourceHashesCache.bin
index 7c7289b756a6949b1f985b0257f895dcb4ea896f..ca9f79172a257f13e1e007f6b1634f3278e887f2 100644
Binary files a/.gradle/8.10.2/fileHashes/resourceHashesCache.bin and b/.gradle/8.10.2/fileHashes/resourceHashesCache.bin differ
diff --git a/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/.gradle/buildOutputCleanup/buildOutputCleanup.lock
index f43397ebdd29301389a089397cd1646b4fe2561d..287af6e1ca757eb1c80330e74e2596b23a3cb115 100644
Binary files a/.gradle/buildOutputCleanup/buildOutputCleanup.lock and b/.gradle/buildOutputCleanup/buildOutputCleanup.lock differ
diff --git a/build/classes/java/main/app/SimulatorApplication.class b/build/classes/java/main/app/SimulatorApplication.class
index fca1aceeefd58a020e52c53c7a879dadb8f147ed..74b875251a0cde725bd7e353d53f8ef10d36b6c1 100644
Binary files a/build/classes/java/main/app/SimulatorApplication.class and b/build/classes/java/main/app/SimulatorApplication.class differ
diff --git a/build/classes/java/main/model/BoardFireFighterBehavior.class b/build/classes/java/main/model/BoardFireFighterBehavior.class
index 07204c3c3f123f9b13f3a54f72d36e3148c48a95..23937ecfb9fbe992d4ceb5471b0891d8bb9947ec 100644
Binary files a/build/classes/java/main/model/BoardFireFighterBehavior.class and b/build/classes/java/main/model/BoardFireFighterBehavior.class differ
diff --git a/build/classes/java/main/model/FireFactory.class b/build/classes/java/main/model/FireFactory.class
index 63ec280e55d1c3b09f0328944b6695f7f41db67e..cd2de694304566ad83e53b02f3ca95060dfe94dc 100644
Binary files a/build/classes/java/main/model/FireFactory.class and b/build/classes/java/main/model/FireFactory.class differ
diff --git a/build/classes/java/main/model/FirefighterBoard.class b/build/classes/java/main/model/FirefighterBoard.class
index dfcfecbdaae1ba217fa185d9de40690d2b2a8d44..e5546abb657938877a328311e38a6f60e909c7e5 100644
Binary files a/build/classes/java/main/model/FirefighterBoard.class and b/build/classes/java/main/model/FirefighterBoard.class differ
diff --git a/build/tmp/compileJava/previous-compilation-data.bin b/build/tmp/compileJava/previous-compilation-data.bin
index 33f51b6742b84ed99e02b091fc48257a19ed2a82..02f840310ffeae8d39057f746b3f0d133500205b 100644
Binary files a/build/tmp/compileJava/previous-compilation-data.bin and b/build/tmp/compileJava/previous-compilation-data.bin differ
diff --git a/src/main/java/app/SimulatorApplication.java b/src/main/java/app/SimulatorApplication.java
index 280ec62c05c645c8291c85f8ec2d7c08b8bc4da4..47b7017f062e4894a47716d4e45aabb8bd5387ad 100644
--- a/src/main/java/app/SimulatorApplication.java
+++ b/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 = 4;
+ public static final int INITIAL_FIRE_COUNT = 10;
public static final int INITIAL_FIREFIGHTER_COUNT = 3;
public static final int INITIAL_CLOUD_COUNT = 3;
public static final int INITIAL_MOTORIZED_COUNT = 3;
diff --git a/src/main/java/model/BoardFireFighterBehavior.java b/src/main/java/model/BoardFireFighterBehavior.java
index ccd6b9a2d245c0b596ba670e20b16a72557f4b39..53c01c6bcfe53673b99649da36049922bb7404c7 100644
--- a/src/main/java/model/BoardFireFighterBehavior.java
+++ b/src/main/java/model/BoardFireFighterBehavior.java
@@ -6,60 +6,36 @@ import util.TargetStrategy;
import java.util.*;
public class BoardFireFighterBehavior implements BoardBehavior{
- private final TargetStrategy targetStrategy = new TargetStrategy();
- private final Map<Position, List<Position>> neighbors;
- private List<Position> firefighterPositions;
- private List<Position> motorizedFighters;
- private List<Position> rocky;
- private Set<Position> firePositions;
- private final ElementFactory<FireFighter> firefighterFactory;
- private final ElementFactory<Fire> fireFactory;
- private final ElementFactory<Cloud> cloudFactory;
- private final ElementFactory<MotorizedFireFighter> motorizedFactory;
+ private static TargetStrategy targetStrategy = new TargetStrategy();
+ private static Map<Position, List<Position>> neighbors;
+
+ private static List<Position> rocky;
+
private ElementFactory<Rocky> rockyFactory;
- private List<Position> cloudPositions;
- private final Map<Position, Terrain> terrainMap = new HashMap<>();
- private int step;
+ private static Map<Position, Terrain> terrainMap = new HashMap<>();
+ private static int step;
+ static Movements fireMovements ;
+ static Movements fireFighterMovements;
+ static Movements cloudMovements;
+ static Movements motorizedMovements;
public BoardFireFighterBehavior(Map<Position, List<Position>> neighbors, ElementFactory<Fire> fireFactory ,ElementFactory<FireFighter> firefighterFactory,
ElementFactory<Cloud> cloudFactory,ElementFactory<MotorizedFireFighter> motorizedFactory,ElementFactory<Rocky> rockyFactory) {
this.step=0;
this.neighbors = neighbors;
- this.firefighterFactory = firefighterFactory;
- this.fireFactory = fireFactory;
- this.cloudFactory=cloudFactory;
- this.motorizedFactory=motorizedFactory;
this.rockyFactory=rockyFactory;
+ fireMovements=new FireMovements(fireFactory);
+ fireFighterMovements=new FireFighterMovements(firefighterFactory);
+ cloudMovements=new CloudMovements(cloudFactory);
+ motorizedMovements=new MotorizedMovements(motorizedFactory);
}
public void initializeElements(int rowCount, int columnCount) {
- // Feux
- firePositions = new HashSet<>();
- List<Fire> fires = fireFactory.createElements(rowCount, columnCount);
- for (Fire fire : fires) {
- firePositions.add(fire.getPosition());
- }
-
- // Pompiers
- firefighterPositions = new ArrayList<>();
- List<FireFighter> firefighters = firefighterFactory.createElements(rowCount, columnCount);
- for (FireFighter firefighter : firefighters) {
- firefighterPositions.add(firefighter.getPosition());
- }
-
-
- // Nuages
- cloudPositions = new ArrayList<>();
- List<Cloud> clouds = cloudFactory.createElements(rowCount, columnCount);
- for (Cloud cloud : clouds) {
- cloudPositions.add(cloud.getPosition());
- }
+ fireMovements.initializeElement(rowCount,columnCount);
+ fireFighterMovements.initializeElement(rowCount,columnCount);
+ cloudMovements.initializeElement(rowCount,columnCount);
// Pompiers motorisés
- motorizedFighters = new ArrayList<>();
- List<MotorizedFireFighter> motorizedFirefighters = motorizedFactory.createElements(rowCount, columnCount);
- for (MotorizedFireFighter motorizedFirefighter : motorizedFirefighters) {
- motorizedFighters.add(motorizedFirefighter.getPosition());
- }
+ motorizedMovements.initializeElement(rowCount,columnCount);
// Rocky
rocky = new ArrayList<>();
List<Rocky> rockies = rockyFactory.createElements(rowCount, columnCount);
@@ -73,146 +49,20 @@ public class BoardFireFighterBehavior implements BoardBehavior{
}
- public List<Position> updateFires() {
- 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) {
- // 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);
-
- // 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);
- }
- }
-
- // 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<>();
-
- for (Position currentPosition : motorizedFighters) {
- // Vérification de validité de la position actuelle
- if (!neighbors.containsKey(currentPosition)) {
- System.err.println("Position actuelle invalide : " + currentPosition);
- newPositions.add(currentPosition);
- continue;
- }
-
- // Étape 1 : Calcul du premier déplacement
- Position firstStep = targetStrategy.neighborClosestToTarget(currentPosition, firePositions, neighbors);
- if (firstStep == null || !neighbors.containsKey(firstStep)) {
- // Aucun déplacement possible, rester sur place
- System.out.println("Pas de première étape possible pour : " + currentPosition);
- newPositions.add(currentPosition);
- continue;
- }
-
- // Étape 2 : Calcul du deuxième déplacement
- Position secondStep = targetStrategy.neighborClosestToTarget(firstStep, firePositions, neighbors);
- Position finalPosition = (secondStep != null && neighbors.containsKey(secondStep)) ? secondStep : firstStep;
-
- // Ajout de la position finale aux nouvelles positions
- newPositions.add(finalPosition);
-
- // Mise à jour des positions modifiées
- modifiedPositions.add(currentPosition); // Ancienne position
- modifiedPositions.add(finalPosition); // Nouvelle position
-
- // Étape 3 : Éteindre les feux à la position finale
- extinguish(finalPosition);
- extinguishNearbyFires(finalPosition, modifiedPositions);
- }
-
- // Mettre à jour les positions globales
- motorizedFighters = newPositions;
- return modifiedPositions;
- }
-
- /**
- * Éteint les feux à proximité d'une position donnée.
- *
- * @param firefighterPosition La position actuelle du pompier.
- * @param modifiedPositions Les positions modifiées pendant ce tour.
- */
- private void extinguishNearbyFires(Position firefighterPosition, List<Position> modifiedPositions) {
- List<Position> nearbyFires = neighbors.getOrDefault(firefighterPosition, Collections.emptyList())
- .stream()
- .filter(firePositions::contains)
- .toList();
- for (Position fire : nearbyFires) {
- firePositions.remove(fire);
- modifiedPositions.add(fire);
- System.out.println("Feu éteint à : " + fire);
- }
- }
- private void extinguish(Position position) {
- firePositions.remove(position);
+ public static void extinguish(Position position) {
+ fireMovements.getPositions().remove(position);
}
public Set<Position> getFirePositions() {
- return firePositions;
+ return (Set<Position>) fireMovements.getPositions();
}
- public List<Position> getFirefighterPositions() {
- return firefighterPositions;
- }
+
public void incrementStep() {
step++;
@@ -226,10 +76,10 @@ public class BoardFireFighterBehavior implements BoardBehavior{
@Override
public List<Position> updateToNextGeneration() {
- List<Position> modifiedPositions = updateFirefighters();
- modifiedPositions.addAll(updateFires());
- modifiedPositions.addAll(updateClouds());
- modifiedPositions.addAll(updateMotorized());
+ List<Position> modifiedPositions = fireFighterMovements.updateElements();
+ modifiedPositions.addAll(fireMovements.updateElements());
+ modifiedPositions.addAll(cloudMovements.updateElements());
+ modifiedPositions.addAll(motorizedMovements.updateElements());
incrementStep();
return modifiedPositions;
}
@@ -237,45 +87,16 @@ public class BoardFireFighterBehavior implements BoardBehavior{
@Override
public void reset() {
this.step=0;
- }
- public List<Position> updateClouds() {
- List<Position> modifiedPositions = new ArrayList<>();
- List<Position> newCloudPositions = new ArrayList<>();
-
- for (Position cloudPosition : cloudPositions) {
- // 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 (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;
+ public Collection<Position> getCloudPositions() {
+ return cloudMovements.getPositions();
}
public List<Position> getMotorizedFighters() {
- return motorizedFighters;
+ return (List<Position>) motorizedMovements.getPositions();
}
private void generateMountainBlocks(int rowCount, int columnCount) {
Random random = new Random();
@@ -317,11 +138,28 @@ public class BoardFireFighterBehavior implements BoardBehavior{
}
}
}
+ /**
+ * Éteint les feux à proximité d'une position donnée.
+ *
+ * @param firefighterPosition La position actuelle du pompier.
+ * @param modifiedPositions Les positions modifiées pendant ce tour.
+ */
+ public static void extinguishNearbyFires(Position firefighterPosition, List<Position> modifiedPositions) {
+ List<Position> nearbyFires = getNeighbors().getOrDefault(firefighterPosition, Collections.emptyList())
+ .stream()
+ .filter(fireMovements.getPositions()::contains)
+ .toList();
+ for (Position fire : nearbyFires) {
+ fireMovements.getPositions().remove(fire);
+ modifiedPositions.add(fire);
+ System.out.println("Feu éteint à : " + fire);
+ }
+ }
public Map<Position, Terrain> getTerrainMap() {
return terrainMap;
}
- public boolean canMoveTo(Position position, Set<Position> firePositions, List<Position> firefighterPositions) {
+ public static 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;
@@ -338,7 +176,7 @@ public class BoardFireFighterBehavior implements BoardBehavior{
}
// Si la position est une montagne, aucun élément ne peut la franchir sauf les nuages
- if (terrainMap.get(position) != null && !cloudPositions.contains(position)) {
+ if (terrainMap.get(position) != null && !cloudMovements.getPositions().contains(position)) {
return false; // Impossible de franchir une montagne, sauf pour un nuage
}
if(rocky.contains(position))
@@ -389,7 +227,33 @@ public class BoardFireFighterBehavior implements BoardBehavior{
}
}
+
public List<Position> getRocky() {
return rocky;
}
+
+ public static int getStep() {
+ return step;
+ }
+
+ public static Map<Position, List<Position>> getNeighbors() {
+ return neighbors;
+ }
+
+ public static Movements getFireMovements() {
+ return fireMovements;
+ }
+
+ public static TargetStrategy getTargetStrategy() {
+ return targetStrategy;
+ }
+
+ public static Movements getFireFighterMovements() {
+ return fireFighterMovements;
+ }
+
+
+ public Collection<Position> getFirefighterPositions() {
+ return fireFighterMovements.getPositions();
+ }
}
diff --git a/src/main/java/model/CloudMovements.java b/src/main/java/model/CloudMovements.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e186aaebc89973da5229f2fa539cea959e6fa38
--- /dev/null
+++ b/src/main/java/model/CloudMovements.java
@@ -0,0 +1,67 @@
+package model;
+
+import util.Position;
+
+import java.util.*;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class CloudMovements implements Movements{
+ private List<Position> cloudPositions;
+ private final ElementFactory<Cloud> cloudFactory;
+ public CloudMovements(ElementFactory<Cloud> cloudFactory) {
+ this.cloudPositions = new ArrayList<>();
+ this.cloudFactory = cloudFactory;
+ }
+ @Override
+ public void initializeElement(int rowCount, int columnCount) {
+ // Nuages
+ cloudPositions = new ArrayList<>();
+ List<Cloud> clouds = cloudFactory.createElements(rowCount, columnCount);
+ for (Cloud cloud : clouds) {
+ cloudPositions.add(cloud.getPosition());
+ }
+ }
+
+
+ @Override
+ public List<Position> updateElements() {
+ List<Position> modifiedPositions = new ArrayList<>();
+ List<Position> newCloudPositions = new ArrayList<>();
+
+ for (Position cloudPosition : cloudPositions) {
+ // Déplacement aléatoire
+ List<Position> possibleMoves = getNeighbors().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, (Set<Position>) fireMovements.getPositions(), (List<Position>) fireFighterMovements.getPositions())) {
+ continue; // Si la position est invalide ou une montagne, le nuage reste sur place
+ }
+
+ newCloudPositions.add(newCloudPosition);
+
+ // Éteindre le feu à la position du nuage (le nuage mange le feu)
+ if (fireMovements.getPositions().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;
+ }
+
+
+
+
+
+ @Override
+ public Collection<Position> getPositions() {
+ return cloudPositions;
+ }
+}
diff --git a/src/main/java/model/ElementsUpdate.java b/src/main/java/model/ElementsUpdate.java
deleted file mode 100644
index d0e05e3e5cab80c00133c12fbf1a31885648c10d..0000000000000000000000000000000000000000
--- a/src/main/java/model/ElementsUpdate.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package model;
-
-import util.Position;
-
-import java.util.List;
-
-public interface ElementsUpdate {
- public List<Position> updateElements();
-}
diff --git a/src/main/java/model/FireFactory.java b/src/main/java/model/FireFactory.java
index 5b066af06cefbd9a6c91c5215bed2679f79ea43e..7bcd71402e0f3a98f416a1b558b394e102ceba91 100644
--- a/src/main/java/model/FireFactory.java
+++ b/src/main/java/model/FireFactory.java
@@ -29,6 +29,7 @@ public class FireFactory implements ElementFactory<Fire>,PositionGenerator{
Position randomPosition = generateRandomPosition(rowCount, columnCount);
boolean add = fires.add(new Fire(randomPosition));
}
+ System.out.println(fires.size());
return fires;
}
diff --git a/src/main/java/model/FireFighterMovements.java b/src/main/java/model/FireFighterMovements.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e1ded828c1572cde2a440e92f50659bd8e0412f
--- /dev/null
+++ b/src/main/java/model/FireFighterMovements.java
@@ -0,0 +1,79 @@
+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class FireFighterMovements implements Movements{
+ private final ElementFactory<FireFighter> firefighterFactory;
+ private List<Position> firefighterPositions;
+ public FireFighterMovements(ElementFactory<FireFighter> firefighterFactory) {
+ this.firefighterFactory = firefighterFactory;
+ this.firefighterPositions = new ArrayList<>();
+ }
+
+
+
+ @Override
+ public List<Position> updateElements() {
+ 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 =getTargetStrategy().neighborClosestToTarget(firefighterPosition, fireMovements.getPositions(), getNeighbors());
+
+ // Vérification si la position cible est valide pour le mouvement
+ if (canMoveTo(newFirefighterPosition, (Set<Position>) fireMovements.getPositions(), 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 = getNeighbors().get(newFirefighterPosition).stream()
+ .filter(fireMovements.getPositions()::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);
+ }
+ }
+
+ // Mettre à jour la liste des positions des pompiers
+ firefighterPositions = newFirefighterPositions;
+ return modifiedPositions;
+ }
+
+ @Override
+ public void initializeElement(int rowCount, int columnCount) {
+ // Pompiers
+ firefighterPositions = new ArrayList<>();
+ List<FireFighter> firefighters = firefighterFactory.createElements(rowCount, columnCount);
+ for (FireFighter firefighter : firefighters) {
+ firefighterPositions.add(firefighter.getPosition());
+ }
+ }
+
+ @Override
+ public Collection<Position> getPositions() {
+ return firefighterPositions;
+ }
+}
diff --git a/src/main/java/model/FireMovements.java b/src/main/java/model/FireMovements.java
new file mode 100644
index 0000000000000000000000000000000000000000..da96795989f2ed8e45366c8f8249bd3dc36c7211
--- /dev/null
+++ b/src/main/java/model/FireMovements.java
@@ -0,0 +1,64 @@
+package model;
+
+import util.Position;
+
+import java.util.*;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class FireMovements implements Movements{
+ private final ElementFactory<Fire> fireFactory;
+ private Set<Position> firePositions;
+
+
+ public FireMovements(ElementFactory<Fire> fireFactory) {
+ this.fireFactory = fireFactory;
+ this.firePositions = new HashSet<>();
+ }
+
+
+
+ @Override
+ public void initializeElement(int rowCount, int columnCount) {
+ // Feux
+
+ List<Fire> fires = fireFactory.createElements(rowCount, columnCount);
+ for (Fire fire : fires) {
+ firePositions.add(fire.getPosition());
+ }
+
+
+
+ }
+
+ @Override
+ public Collection<Position> getPositions() {
+ return firePositions;
+ }
+
+ @Override
+ public List<Position> updateElements() {
+ List<Position> modifiedPositions = new ArrayList<>();
+ if (getStep() % 2 == 0) {
+ List<Position> newFirePositions = new ArrayList<>();
+
+ // Pour chaque feu existant, vérifier ses voisins
+ for (Position fire : firePositions) {
+ // Si la position voisine est libre (non occupée par un feu ou un pompier), le feu peut se propager
+ for (Position neighbor : getNeighbors().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, (List<Position>) getFireFighterMovements().getPositions()) && !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;
+ }
+
+
+}
diff --git a/src/main/java/model/FirefighterBoard.java b/src/main/java/model/FirefighterBoard.java
index cf8e4e0631f8cf29a6c92ba9d77fa11de177166b..88e8b7dc5520c8caafa5126c4408860186c032f9 100644
--- a/src/main/java/model/FirefighterBoard.java
+++ b/src/main/java/model/FirefighterBoard.java
@@ -53,7 +53,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
.forEach(pos -> result.add(new Fire(pos))); // Créer un objet Fire à partir de Position
// Filtrage des éléments Firefighter (en transformant les positions en objets FireFighter)
- behavior.getFirefighterPositions().stream()
+ behavior.getFireFighterMovements().getPositions().stream()
.filter(pos -> pos.isAtPosition(position)) // Vérifier si la position correspond
.forEach(pos -> result.add(new FireFighter(pos))); // Créer un objet Firefighter à partir de Position
// Filtrage des éléments Cloud
diff --git a/src/main/java/model/InitializeElements.java b/src/main/java/model/InitializeElements.java
deleted file mode 100644
index 9da24f0dbbabf7fe38a71d396bf54394c9fe93ee..0000000000000000000000000000000000000000
--- a/src/main/java/model/InitializeElements.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package model;
-
-public interface InitializeElements {
- public void initializeElement(int rowCount, int columnCount);
-}
diff --git a/src/main/java/model/MotorizedMovements.java b/src/main/java/model/MotorizedMovements.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5be9dec1000206410ab16de6106412fd1132b54
--- /dev/null
+++ b/src/main/java/model/MotorizedMovements.java
@@ -0,0 +1,79 @@
+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class MotorizedMovements implements Movements{
+ private final ElementFactory<MotorizedFireFighter> motorizedFactory;
+ private List<Position> motorizedFighters;
+
+ public MotorizedMovements(ElementFactory<MotorizedFireFighter> motorizedFactory) {
+ this.motorizedFactory = motorizedFactory;
+ this.motorizedFighters = new ArrayList<>();
+ }
+
+ @Override
+ public List<Position> updateElements() {
+ List<Position> modifiedPositions = new ArrayList<>();
+ List<Position> newPositions = new ArrayList<>();
+
+ for (Position currentPosition : motorizedFighters) {
+ // Vérification de validité de la position actuelle
+ if (!getNeighbors().containsKey(currentPosition)) {
+ System.err.println("Position actuelle invalide : " + currentPosition);
+ newPositions.add(currentPosition);
+ continue;
+ }
+
+ // Étape 1 : Calcul du premier déplacement
+ Position firstStep = getTargetStrategy().neighborClosestToTarget(currentPosition, fireMovements.getPositions(), getNeighbors());
+ if (firstStep == null || !getNeighbors().containsKey(firstStep)) {
+ // Aucun déplacement possible, rester sur place
+ System.out.println("Pas de première étape possible pour : " + currentPosition);
+ newPositions.add(currentPosition);
+ continue;
+ }
+
+ // Étape 2 : Calcul du deuxième déplacement
+ Position secondStep = getTargetStrategy().neighborClosestToTarget(firstStep, fireMovements.getPositions(), getNeighbors());
+ Position finalPosition = (secondStep != null && getNeighbors().containsKey(secondStep)) ? secondStep : firstStep;
+
+ // Ajout de la position finale aux nouvelles positions
+ newPositions.add(finalPosition);
+
+ // Mise à jour des positions modifiées
+ modifiedPositions.add(currentPosition); // Ancienne position
+ modifiedPositions.add(finalPosition); // Nouvelle position
+
+ // Étape 3 : Éteindre les feux à la position finale
+ extinguish(finalPosition);
+ extinguishNearbyFires(finalPosition, modifiedPositions);
+ }
+
+ // Mettre à jour les positions globales
+ motorizedFighters = newPositions;
+ return modifiedPositions;
+ }
+
+ @Override
+ public void initializeElement(int rowCount, int columnCount) {
+ motorizedFighters = new ArrayList<>();
+ List<MotorizedFireFighter> motorizedFirefighters = motorizedFactory.createElements(rowCount, columnCount);
+ for (MotorizedFireFighter motorizedFirefighter : motorizedFirefighters) {
+ motorizedFighters.add(motorizedFirefighter.getPosition());
+ }
+
+ }
+
+ @Override
+ public Collection<Position> getPositions() {
+ return this.motorizedFighters;
+ }
+
+}
diff --git a/src/main/java/model/Movements.java b/src/main/java/model/Movements.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f1638a687e05f834df6965c0bdfe0fff75fb6fb
--- /dev/null
+++ b/src/main/java/model/Movements.java
@@ -0,0 +1,13 @@
+package model;
+
+import util.Position;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface Movements {
+ public List<Position> updateElements();
+ public void initializeElement(int rowCount, int columnCount);
+
+ Collection<Position> getPositions();
+}