diff --git a/.gradle/8.10.2/executionHistory/executionHistory.lock b/.gradle/8.10.2/executionHistory/executionHistory.lock
index 66d287d3b823619b05e3e0405201e0476d56d0bb..5b91c9b6e3b22a57af3710176e3952da3c4870ee 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.lock b/.gradle/8.10.2/fileHashes/fileHashes.lock
index 6ff3a415c6023cab4336fc709e46d5153dca2c9a..85111997a4d19a06a7f07551c92ddaa3bf725601 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.8/checksums/checksums.lock b/.gradle/8.8/checksums/checksums.lock
deleted file mode 100644
index 8a45a7084553486969a0e333e25707ca7f09aa8d..0000000000000000000000000000000000000000
Binary files a/.gradle/8.8/checksums/checksums.lock and /dev/null differ
diff --git a/.gradle/8.8/dependencies-accessors/gc.properties b/.gradle/8.8/dependencies-accessors/gc.properties
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.gradle/8.8/executionHistory/executionHistory.bin b/.gradle/8.8/executionHistory/executionHistory.bin
deleted file mode 100644
index 31d2a1839cbee614a0ff816d1d8bba3e57db218d..0000000000000000000000000000000000000000
Binary files a/.gradle/8.8/executionHistory/executionHistory.bin and /dev/null differ
diff --git a/.gradle/8.8/executionHistory/executionHistory.lock b/.gradle/8.8/executionHistory/executionHistory.lock
deleted file mode 100644
index 28dcf5f95f3b8611411e632c8e70bb832e839ade..0000000000000000000000000000000000000000
Binary files a/.gradle/8.8/executionHistory/executionHistory.lock and /dev/null differ
diff --git a/.gradle/8.8/fileChanges/last-build.bin b/.gradle/8.8/fileChanges/last-build.bin
deleted file mode 100644
index f76dd238ade08917e6712764a16a22005a50573d..0000000000000000000000000000000000000000
Binary files a/.gradle/8.8/fileChanges/last-build.bin and /dev/null differ
diff --git a/.gradle/8.8/fileHashes/fileHashes.bin b/.gradle/8.8/fileHashes/fileHashes.bin
deleted file mode 100644
index 54cad51c13f406f7c097b1a5990d97a41d4bf162..0000000000000000000000000000000000000000
Binary files a/.gradle/8.8/fileHashes/fileHashes.bin and /dev/null differ
diff --git a/.gradle/8.8/fileHashes/fileHashes.lock b/.gradle/8.8/fileHashes/fileHashes.lock
deleted file mode 100644
index 3b21749594fbc6d5f3d5df219da1355f3213846b..0000000000000000000000000000000000000000
Binary files a/.gradle/8.8/fileHashes/fileHashes.lock and /dev/null differ
diff --git a/.gradle/8.8/gc.properties b/.gradle/8.8/gc.properties
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/.gradle/buildOutputCleanup/buildOutputCleanup.lock
index 964c60967a2b63f66ae399dfea332826c256aeeb..bf3eeeb207ed57830e31cda038181f21f98cf9cd 100644
Binary files a/.gradle/buildOutputCleanup/buildOutputCleanup.lock and b/.gradle/buildOutputCleanup/buildOutputCleanup.lock differ
diff --git a/src/main/java/model/Cloud.java b/src/main/java/model/Cloud.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad88e366ecf4391a567df365643a70e257903cd0
--- /dev/null
+++ b/src/main/java/model/Cloud.java
@@ -0,0 +1,46 @@
+package model;
+
+import util.Position;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Cloud {
+ private List<Position> positions;
+
+ public Cloud(List<Position> initialPositions) {
+ this.positions = initialPositions;
+ }
+
+ /**
+ * Déplace chaque nuage vers une position aléatoire parmi les positions possibles.
+ *
+ * @param possiblePositions Ensemble des positions possibles.
+ * @return Liste des nouvelles positions des nuages.
+ */
+ public List<Position> moveRandomly(Set<Position> possiblePositions) {
+ Random random = new Random();
+ for (int i = 0; i < positions.size(); i++) {
+ // Choisir une position aléatoire dans l'ensemble des positions possibles
+ Position newPosition = possiblePositions.stream()
+ .skip(random.nextInt(possiblePositions.size()))
+ .findFirst()
+ .orElse(positions.get(i));
+ positions.set(i, newPosition);
+ }
+ return positions;
+ }
+
+ /**
+ * Éteint les feux situés sur les positions occupées par les nuages.
+ *
+ * @param fire L'objet Fire à modifier.
+ */
+ public void extinguishFire(Fire fire) {
+ positions.forEach(fire::extinguish);
+ }
+
+ public List<Position> getPositions() {
+ return positions;
+ }
+}
diff --git a/src/main/java/model/Fire.java b/src/main/java/model/Fire.java
index 335315ed9b8af9e3cc5aaf335a94103c7495a14d..28bc66bdef89a84b19e3670eb47ee8f524d8aa3e 100644
--- a/src/main/java/model/Fire.java
+++ b/src/main/java/model/Fire.java
@@ -17,13 +17,21 @@ public class Fire {
return positions;
}
- public List<Position> spread(Set<Position> neighbors) {
- // Logique de propagation de l'incendie
- List<Position> newFirePositions = new ArrayList<>(neighbors);
+ public List<Position> spread(Set<Position> allPositions, Set<Position> roadPositions) {
+ List<Position> newFirePositions = new ArrayList<>();
+ for (Position position : positions) {
+ for (Position neighbor : allPositions) {
+ if (!roadPositions.contains(neighbor) && !positions.contains(neighbor)) {
+ newFirePositions.add(neighbor);
+ }
+ }
+ }
positions.addAll(newFirePositions);
return newFirePositions;
}
+
+
public void extinguish(Position position) {
positions.remove(position);
}}
\ No newline at end of file
diff --git a/src/main/java/model/Firefighter.java b/src/main/java/model/Firefighter.java
index 70237fbdafd860dd9e5fab78c3da0754fc9f34da..0538a324c7f1881ec31549b61914293782998c82 100644
--- a/src/main/java/model/Firefighter.java
+++ b/src/main/java/model/Firefighter.java
@@ -1,37 +1,65 @@
package model;
import util.Position;
-
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import model.TargetStrategy;
+import util.TargetStrategy;
public class Firefighter {
private List<Position> positions;
private TargetStrategy targetStrategy;
+ // Constructor
public Firefighter(List<Position> initialPositions, TargetStrategy targetStrategy) {
this.positions = initialPositions;
this.targetStrategy = targetStrategy;
}
- public List<Position> moveToClosestFire(Set<Position> firePositions, Map<Position, List<Position>> neighbors) {
+ public boolean canFireSpreadToRock(Position position, int currentStepNumber, FirefighterBoard board) {
+ List<ModelElement> elements = board.getState(position);
+ if (elements.contains(ModelElement.ROCK)) {
+ return currentStepNumber >= 4;
+ }
+ return false;
+ }
+
+ public List<Position> moveToClosestFire(Set<Position> firePositions,
+ Map<Position, List<Position>> neighbors,
+ Set<Position> roadPositions) {
List<Position> modifiedPositions = new ArrayList<>();
List<Position> newPositions = new ArrayList<>();
- for (Position position : positions) {
- Position newPosition = targetStrategy.neighborClosestToFire(position, firePositions, neighbors);
- newPositions.add(newPosition);
+ for (Position position : getPositions()) {
+ Position firstStep = getTargetStrategy().neighborClosestToFire(position, firePositions, neighbors, roadPositions);
+
+ Position secondStep = (firstStep != null)
+ ? getTargetStrategy().neighborClosestToFire(firstStep, firePositions, neighbors, roadPositions)
+ : null;
+
+ Position newPosition = (secondStep != null) ? secondStep : firstStep;
+
modifiedPositions.add(position);
- modifiedPositions.add(newPosition);
+ if (firstStep != null) modifiedPositions.add(firstStep);
+ if (secondStep != null) modifiedPositions.add(secondStep);
+
+ newPositions.add(newPosition);
}
- this.positions = newPositions;
+
+ setPositions(newPositions);
return modifiedPositions;
}
+ public TargetStrategy getTargetStrategy() {
+ return targetStrategy;
+ }
+
public List<Position> getPositions() {
return positions;
}
-}
\ No newline at end of file
+
+ protected void setPositions(List<Position> positions) {
+ this.positions = positions;
+ }
+}
diff --git a/src/main/java/model/FirefighterBoard.java b/src/main/java/model/FirefighterBoard.java
index c84740f34bbeb8be2450813efecb299d4337656f..6b7272980ab6a282752f8aa9f75d76276caf7734 100644
--- a/src/main/java/model/FirefighterBoard.java
+++ b/src/main/java/model/FirefighterBoard.java
@@ -2,8 +2,7 @@ package model;
import util.Position;
import java.util.*;
-import model.TargetStrategy;
-
+import util.TargetStrategy;
public class FirefighterBoard implements Board<List<ModelElement>> {
private final int columnCount;
@@ -12,6 +11,10 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
private final int initialFirefighterCount;
private final Position[][] positions;
private final Map<Position, List<Position>> neighbors = new HashMap<>();
+ private Cloud clouds;
+ private Firefighter motorizedFirefighter;
+ private Set<Position> mountainPositions = new HashSet<>();
+ private Set<Position> roadPositions = new HashSet<>();
private Fire fire;
private Firefighter firefighter;
@@ -28,6 +31,14 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
initializeElements();
}
+ private boolean canFireSpreadToRock(Position position, int currentStepNumber) {
+ List<ModelElement> elements = getState(position);
+ if (elements.contains(ModelElement.ROCK)) {
+ return currentStepNumber >= 4;
+ }
+ return false;
+ }
+
private void initializePositions() {
for (int column = 0; column < columnCount; column++)
for (int row = 0; row < rowCount; row++)
@@ -58,6 +69,10 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
initialFirefighterPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
}
+ for (int i = 0; i < 10; i++) {
+ roadPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
+ }
+
fire = new Fire(initialFirePositions);
firefighter = new Firefighter(initialFirefighterPositions, new TargetStrategy());
}
@@ -65,6 +80,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
@Override
public List<ModelElement> getState(Position position) {
List<ModelElement> elements = new ArrayList<>();
+ if (mountainPositions.contains(position)) elements.add(ModelElement.MOUNTAIN);
if (fire.getPositions().contains(position)) elements.add(ModelElement.FIRE);
if (firefighter.getPositions().contains(position)) elements.add(ModelElement.FIREFIGHTER);
return elements;
@@ -72,15 +88,38 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
@Override
public List<Position> updateToNextGeneration() {
- List<Position> modifiedPositions = firefighter.moveToClosestFire(fire.getPositions(), neighbors);
- modifiedPositions.addAll(fire.spread(neighbors.keySet()));
+ List<Position> modifiedPositions = new ArrayList<>();
+ Set<Position> newFires = new HashSet<>();
+
+ for (int row = 0; row < rowCount; row++) {
+ for (int column = 0; column < columnCount; column++) {
+ Position position = positions[row][column];
+ List<ModelElement> elements = getState(position);
+
+ if (elements.contains(ModelElement.ROCK)) {
+ for (Position adj : neighbors.get(position)) {
+ List<ModelElement> adjElements = getState(adj);
+ if (adjElements.contains(ModelElement.FIRE) && canFireSpreadToRock(position, step)) {
+ newFires.add(position);
+ }
+ }
+ }
+ }
+ }
+
+ for (Position firePos : newFires) {
+ List<ModelElement> elements = getState(firePos);
+ elements.add(ModelElement.FIRE);
+ setState(elements, firePos);
+ modifiedPositions.add(firePos);
+ }
+
step++;
return modifiedPositions;
}
@Override
public void setState(List<ModelElement> state, Position position) {
- // Mise à jour des états (feu ou pompier) en fonction de la liste `state`
if (state.contains(ModelElement.FIRE)) fire.getPositions().add(position);
if (state.contains(ModelElement.FIREFIGHTER)) firefighter.getPositions().add(position);
}
diff --git a/src/main/java/model/ModelElement.java b/src/main/java/model/ModelElement.java
index 759eee5e54c3a39472d8f7defbbbe6a2b67b8f00..e5f54173d395ca09e21f27a7e0912f92c9ef47cc 100644
--- a/src/main/java/model/ModelElement.java
+++ b/src/main/java/model/ModelElement.java
@@ -1,5 +1,5 @@
package model;
public enum ModelElement {
- FIREFIGHTER, FIRE
+ FIREFIGHTER, FIRE, CLOUD, MOUNTAIN,ROCK
}
diff --git a/src/main/java/model/MotorizedFirefighter.java b/src/main/java/model/MotorizedFirefighter.java
new file mode 100644
index 0000000000000000000000000000000000000000..c88a82386b3d75926b7d451970caf0d43c419feb
--- /dev/null
+++ b/src/main/java/model/MotorizedFirefighter.java
@@ -0,0 +1,41 @@
+package model;
+
+import util.Position;
+
+import java.util.*;
+import util.TargetStrategy;
+
+public class MotorizedFirefighter extends Firefighter {
+
+ public MotorizedFirefighter(List<Position> initialPositions, TargetStrategy targetStrategy) {
+ super(initialPositions, targetStrategy);
+ }
+
+ @Override
+ public List<Position> moveToClosestFire(Set<Position> firePositions,
+ Map<Position, List<Position>> neighbors,
+ Set<Position> roadPositions) {
+ List<Position> modifiedPositions = new ArrayList<>();
+ List<Position> newPositions = new ArrayList<>();
+
+ for (Position position : getPositions()) {
+ Position firstStep = getTargetStrategy().neighborClosestToFire(position, firePositions, neighbors, roadPositions);
+
+ Position secondStep = (firstStep != null)
+ ? getTargetStrategy().neighborClosestToFire(firstStep, firePositions, neighbors, roadPositions)
+ : null;
+
+ Position newPosition = (secondStep != null) ? secondStep : firstStep;
+
+ modifiedPositions.add(position);
+ if (firstStep != null) modifiedPositions.add(firstStep);
+ if (secondStep != null) modifiedPositions.add(secondStep);
+
+ newPositions.add(newPosition);
+ }
+
+ setPositions(newPositions);
+ return modifiedPositions;
+ }
+
+}
diff --git a/src/main/java/util/Position.java b/src/main/java/util/Position.java
index 31dc4c1fb6a04b4e96649e133d1d116120d34683..5220fa02a9a2e9818a6b5929f9b4bb5b4c88ce2a 100644
--- a/src/main/java/util/Position.java
+++ b/src/main/java/util/Position.java
@@ -1,5 +1,47 @@
package util;
-public record Position(int row, int column) {
+import java.util.Objects;
+public class Position {
+ private final int row;
+ private final int column;
+
+ public Position(int row, int column) {
+ this.row = row;
+ this.column = column;
+ }
+
+ public int row() {
+ return row;
+ }
+
+ public int column() {
+ return column;
+ }
+
+ public int getRow() {
+ return row;
+ }
+
+ public int getColumn() {
+ return column;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ Position position = (Position) o;
+ return row == position.row && column == position.column;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(row, column);
+ }
+
+ @Override
+ public String toString() {
+ return "Position{" + "row=" + row + ", column=" + column + '}';
+ }
}
diff --git a/src/main/java/util/TargetStrategy.java b/src/main/java/util/TargetStrategy.java
index 583186787d4d8d47173fbe61cc424f2f7ee384c9..629b6f6f28fabbff5ebebe35399ecca443491839 100644
--- a/src/main/java/util/TargetStrategy.java
+++ b/src/main/java/util/TargetStrategy.java
@@ -1,4 +1,4 @@
-package model;
+package util;
import util.Position;
@@ -6,30 +6,48 @@ import java.util.*;
public class TargetStrategy {
-
/**
- * @param position current position.
- * @param targets positions that are targeted.
- * @return the position next to the current position that is on the path to the closest target.
+ * Trouve la case adjacente la plus proche du feu en respectant les routes.
+ *
+ * @param position Position actuelle.
+ * @param targets Positions des feux.
+ * @param neighbors Carte des voisins pour chaque position.
+ * @param roadPositions Positions représentant les routes.
+ * @return La position voisine qui se rapproche le plus d'un feu, respectant les routes.
*/
- 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>();
- Queue<Position> toVisit = new LinkedList<Position>(neighbors.get(position));
- for (Position initialMove : toVisit)
- firstMove.put(initialMove, initialMove);
+ public Position neighborClosestToFire(Position position, Collection<Position> targets,
+ Map<Position, List<Position>> neighbors,
+ Set<Position> roadPositions) {
+ Set<Position> seen = new HashSet<>();
+ Map<Position, Position> firstMove = new HashMap<>();
+ Queue<Position> toVisit = new LinkedList<>(neighbors.get(position));
+
+ // Initialisation des mouvements possibles
+ for (Position initialMove : toVisit) {
+ if (roadPositions.contains(initialMove)) {
+ firstMove.put(initialMove, initialMove);
+ }
+ }
+
+ // Parcours en largeur (BFS) pour trouver le feu le plus proche
while (!toVisit.isEmpty()) {
Position current = toVisit.poll();
- if (targets.contains(current))
+
+ // Si la position actuelle est un feu, on retourne le premier mouvement vers cette position
+ if (targets.contains(current)) {
return firstMove.get(current);
+ }
+
+ // Ajout des voisins non visités qui sont sur les routes
for (Position adjacent : neighbors.get(current)) {
- if (seen.contains(adjacent)) continue;
+ if (seen.contains(adjacent) || !roadPositions.contains(adjacent)) continue;
toVisit.add(adjacent);
seen.add(adjacent);
firstMove.put(adjacent, firstMove.get(current));
}
}
+
+ // Si aucun feu n'est trouvé, retourner la position actuelle
return position;
}
-}
\ No newline at end of file
+}