diff --git a/src/main/java/app/SimulatorApplication.java b/src/main/java/app/SimulatorApplication.java
index 44fd3c2512d327d67c150257255a0e1136af07f0..faa82df869ca61db8918182d852804ccdbe64ce9 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 = 15;
+ public static final int INITIAL_FIRE_COUNT = 10;
public static final int INITIAL_FIREFIGHTER_COUNT = 10;
public static final int INITIAL_CLOUD_COUNT = 5;
public static final int INITIAL_ROAD_COUNT = 5;
diff --git a/src/main/java/model/Board.java b/src/main/java/model/Board.java
index bb089a41406d57b0b2fe3d43b3c040cbd640b6b9..cf0d9686e7d14ad05a92f7e3203adb32eda4f9d8 100644
--- a/src/main/java/model/Board.java
+++ b/src/main/java/model/Board.java
@@ -3,6 +3,7 @@ package model;
import util.Position;
import java.util.List;
+import java.util.Map;
/**
* This interface represents a generic board for modeling various state-based systems.
@@ -11,6 +12,8 @@ import java.util.List;
*/
public interface Board<S> {
+
+
/**
* Get the state of the board at a specific position.
*
@@ -27,6 +30,13 @@ public interface Board<S> {
*/
void setState(S state, Position position);
+
+ Map<Position, Obstacle> getObstacles();
+ Map<Position, Extinguisher> getExtinguishers();
+
+ Map<Position, Fire> getFires();
+
+
/**
* Get the number of rows in the board.
*
diff --git a/src/main/java/model/Cloud.java b/src/main/java/model/Cloud.java
index 498385f06281b4432049270165c94b9a7d7fe29d..bf1c2312da8d46722ce80edb5a2e6fbf8f604a5f 100644
--- a/src/main/java/model/Cloud.java
+++ b/src/main/java/model/Cloud.java
@@ -29,4 +29,6 @@ public class Cloud extends Extinguisher {
}
+
+
}
diff --git a/src/main/java/model/Extinguisher.java b/src/main/java/model/Extinguisher.java
index df80a5e19143b1f59111b841c6131e84204c3474..c40981f3a8ac611dc397389073a0ed8b02249322 100644
--- a/src/main/java/model/Extinguisher.java
+++ b/src/main/java/model/Extinguisher.java
@@ -18,6 +18,7 @@ public abstract class Extinguisher implements Element{
public void setPosition(Position position) {
this.position = position;
+
}
@Override
public boolean contains(List<Position> positions) {
@@ -29,6 +30,12 @@ public abstract class Extinguisher implements Element{
public ModelElement getElement(){
return this.element;
}
+ public void extinguish(Board board,Position position) {
+ if (board.getFires().containsKey(position)) {
+ board.getFires().remove(position);
+ }
+
+ }
public abstract List<Position> update(FirefighterBoard firefighterBoard);
diff --git a/src/main/java/model/Fire.java b/src/main/java/model/Fire.java
index dc5231c8ec8efdf664fb3fbb9d10ed854e54b2dc..edc20746815c90857cf07a103c63147a65e38f79 100644
--- a/src/main/java/model/Fire.java
+++ b/src/main/java/model/Fire.java
@@ -10,11 +10,12 @@ public class Fire implements Element {
private Position position;
- private ModelElement modelElement = ModelElement.FIRE;
+ private ModelElement modelElement;
public Fire(Position position){
this.position = position;
+ modelElement = ModelElement.FIRE;
}
@@ -34,23 +35,25 @@ public class Fire implements Element {
public List<Position> update(FirefighterBoard firefighterBoard) {
List<Position> modifiedPositions = new ArrayList<>();
- Map<Position, List<Position>> neighbors = firefighterBoard.getNeighbors();
-
- // Étendre le feu seulement à chaque étape paire
if (firefighterBoard.stepNumber() % 2 == 0) {
- List<Position> neighborPositions = neighbors.get(this.getPosition());
- for (Position position : neighborPositions) {
- if (!(firefighterBoard.getState(position).contains(modelElement))) {
- // Ajouter un nouveau feu directement dans la liste des éléments
- firefighterBoard.getElements().add(new Fire(position));
+ Set<Position> newFirePositions = new HashSet<>();
+ for (Position fire : new HashSet<>(firefighterBoard.getFires().keySet())) {
+ List<Position> neighboursAvaiable = firefighterBoard.getNeighbors().get(fire);
+ neighboursAvaiable.removeAll(firefighterBoard.getObstacles().keySet());
+
+ newFirePositions.addAll(firefighterBoard.getNeighbors().get(fire));
+ }
+
+
+ for (Position position : newFirePositions) {
+ if (!firefighterBoard.getFires().containsKey(position)) {
+ firefighterBoard.getFires().put(position, new Fire(position));
+ modifiedPositions.add(position);
}
- // Marquer la position comme modifiée
- modifiedPositions.add(position);
}
}
return modifiedPositions;
}
-
public boolean contains(List<Position> positions) {
return positions.contains(this.getPosition());
diff --git a/src/main/java/model/FireFighter.java b/src/main/java/model/FireFighter.java
index c136eb4e8128ebfd698231ff642c61f8bed053d1..139a030f7a0f149840b749ce7a35e062ca262118 100644
--- a/src/main/java/model/FireFighter.java
+++ b/src/main/java/model/FireFighter.java
@@ -41,6 +41,4 @@ public class FireFighter extends Extinguisher {
return modifiedPositions;
}
-
-
}
\ No newline at end of file
diff --git a/src/main/java/model/FirefighterBoard.java b/src/main/java/model/FirefighterBoard.java
index ab4b6a7bef1ca2d639cdcc7b6d0a7af3cdd6fc31..1aaa4f23fa21611a66e1ab44b58d1124bd6ed7e3 100644
--- a/src/main/java/model/FirefighterBoard.java
+++ b/src/main/java/model/FirefighterBoard.java
@@ -14,7 +14,11 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
private final int initialCloudCount;
private final int initialRoadCount;
- private List<Element> elements;
+
+ private Map<Position, Fire> fires = new HashMap<>();
+ private Map<Position, Extinguisher> extinguishers = new HashMap<>();
+ private Map<Position, Obstacle> obstacles = new HashMap<>();
+
private final Map<Position, List<Position>> neighbors = new HashMap<>();
private final Position[][] positions;
private int step = 0;
@@ -48,38 +52,49 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
}
}
-
+ 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]);
+ return list;
+ }
public void initializeElements() {
- elements = new ArrayList<>();
+
+
+ fires.clear();
+ extinguishers.clear();
+ obstacles.clear();
+
+
for (int index = 0; index < initialFireCount; index++) {
+ Position position = randomPosition();
+ fires.put(position,new Fire(position));
+
- elements.add(new Fire(randomPosition()));
}
for (int index = 0; index < initialFirefighterCount; index++) {
- elements.add(new FireFighter(randomPosition()));
+ Position position = randomPosition();
+ extinguishers.put(position,new FireFighter(position));
+
}
for (int index = 0; index < initialCloudCount; index++) {
+ Position position = randomPosition();
+ extinguishers.put(position,new Cloud(position));
- elements.add(new Cloud(randomPosition()));
}
for (int index = 0; index < initialRoadCount; index++) {
- elements.add(new Road(randomPosition()));
- }
+ Position position = randomPosition();
+ obstacles.put(position,new Road(position));
- }
+ }
- 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]);
- return list;
}
private Position randomPosition() {
@@ -89,67 +104,81 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
@Override
public List<ModelElement> getState(Position position) {
List<ModelElement> result = new ArrayList<>();
+ if (fires.containsKey(position)) result.add(ModelElement.FIRE);
+
+
+ for (Extinguisher extinguisher : extinguishers.values()) {
+ if (extinguisher.getPosition().equals(position)) result.add(extinguisher.getElement());
+ }
- for(Element element : elements){
- if(element.getPosition().equals(position))result.add(element.getElement());
+ for (Obstacle obstacle : obstacles.values()) {
+ if (obstacle.getPosition().equals(position)) result.add(obstacle.getElement());
}
+
return result;
}
+ Position randomNeighbor(Position position) {
+ List<Position> neighborPositions = neighbors.get(position);
+ return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
+ }
+ @Override
+ public int rowCount() {
+ return rowCount;
+ }
- public List<Position> updateElements() {
- List<Position> modifiedPositions = new ArrayList<>();
+ @Override
+ public int columnCount() {
+ return columnCount;
+ }
+ public List<Position> updateToNextGeneration() {
+
+ Fire fire = new Fire(randomPosition());
+ List<Position> modifiedPositions = new ArrayList<>();
- for (Element element : new ArrayList<>(elements)) {
+ for(Extinguisher element : extinguishers.values()){
modifiedPositions.addAll(element.update(this));
}
+
+ modifiedPositions.addAll(fire.update(this));
+
+
+ step++;
return modifiedPositions;
}
- public List<Element> getElements() {
- return elements;
- }
- public boolean containsFireAt(Position position) {
- return elements.stream()
- .anyMatch(e -> e instanceof Fire && e.getPosition().equals(position));
+ public Map<Position, List<Position>> getNeighbors() {
+ return neighbors;
}
- public Position randomNeighbor(Position position) {
- List<Position> neighborPositions = neighbors.get(position);
- return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
+ @Override
+ public int stepNumber() {
+ return step;
}
- public List<Position> updateToNextGeneration() {
- List<Position> modifiedPositions = updateElements();
-
- step++;
- return modifiedPositions;
- }
+ public Map<Position,Fire>getFires(){
+ return this.fires;
- @Override
- public int stepNumber() {
- return step;
}
@Override
- public int rowCount() {
- return rowCount;
+ public Map<Position, Extinguisher> getExtinguishers() {
+ return extinguishers;
}
- @Override
- public int columnCount() {
- return columnCount;
+ public Map<Position, Obstacle> getObstacles() {
+ return obstacles;
}
@Override
@@ -159,52 +188,33 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
}
public void extinguish(Position position) {
-
- for(Fire fire : new HashSet<>(getFires().values())){
- if(fire.getPosition().equals(position)){
- elements.remove(fire);
- }
+ if (this.fires.containsKey(position)) {
+ this.fires.remove(position);
}
- }
-
-
- public Map<Position,Fire> getFires(){
- Map<Position,Fire>fires = new HashMap<>();
- for(Element element : elements){
- if(element.getClass().equals(Fire.class)){
- fires.put(element.getPosition(), (Fire) element);
- }
- }
- return fires;
- }
-
- public Map<Position, List<Position>> getNeighbors() {
- return neighbors;
- }
- public List<Position> getRoadsPosition(){
- List<Position>roadPosition = new ArrayList<>();
- for(Element road: elements){
- if(road.getClass().equals(Road.class)){
- roadPosition.add(road.getPosition());
- }
- }
- return roadPosition;
}
@Override
public void setState(List<ModelElement> state, Position position) {
extinguish(position);
- elements.removeIf(element -> element.getPosition().equals(position));
+ if(extinguishers.containsKey(position)){
+ extinguishers.remove(position);
+ }
for (ModelElement element : state) {
switch (element) {
- case FIRE -> elements.add(new Fire(position));
- case FIREFIGHTER -> elements.add(new FireFighter(position));
- case CLOUD -> elements.add(new Cloud(position));
+ case FIRE -> fires.put(position, new Fire(position));
+ case FIREFIGHTER -> extinguishers.put(position,new FireFighter(position));
+ case CLOUD -> extinguishers.put(position,new Cloud(position));
}
}
}
+
+
+
+
+
}
+
diff --git a/src/main/java/model/Obstacle.java b/src/main/java/model/Obstacle.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9347496ea1b97ab06493d0f376b0ff33fcfc6d2
--- /dev/null
+++ b/src/main/java/model/Obstacle.java
@@ -0,0 +1,35 @@
+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class Obstacle implements Element{
+ protected ModelElement element;
+ protected final Position position;
+ public Obstacle(Position position){
+ this.position = position;
+ }
+ public boolean contains(List<Position> positions) {
+ return positions.contains(this.getPosition());
+
+ }
+ @Override
+ public Position getPosition() {
+ return this.position;
+ }
+
+ @Override
+ public ModelElement getElement() {
+ return this.element;
+ }
+
+ @Override
+ public List<Position> update(FirefighterBoard firefighterBoard) {
+ List<Position>positionList = new ArrayList<>();
+ return positionList;
+ }
+
+
+}
diff --git a/src/main/java/model/Road.java b/src/main/java/model/Road.java
index bd9d09d39a3188ac4adeb525d0b69e21db3e585b..41f0d28014993bd401c6d7ab32786382ab9f4ba6 100644
--- a/src/main/java/model/Road.java
+++ b/src/main/java/model/Road.java
@@ -5,32 +5,15 @@ import util.Position;
import java.util.ArrayList;
import java.util.List;
-public class Road implements Element {
+public class Road extends Obstacle{
- private ModelElement element = ModelElement.ROAD;
- private final Position position;
public Road(Position position){
- this.position = position;
+ super(position);
+ element = ModelElement.ROAD;
}
- public Position getPosition(){
- return this.position;
- }
-
- public boolean contains(List<Position> positions) {
- return positions.contains(this.getPosition());
-
- }
- public ModelElement getElement() {
- return element;
- }
-
- @Override
- public List<Position> update(FirefighterBoard firefighterBoard) {
- return List.of();
- }
}
diff --git a/src/main/java/util/Neighbour.java b/src/main/java/util/Neighbour.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2a6225a91c8def70f8e5b3a4bef2c29640fe0f0
--- /dev/null
+++ b/src/main/java/util/Neighbour.java
@@ -0,0 +1,46 @@
+package util;
+
+import model.Board;
+
+import java.util.*;
+
+public class Neighbour {
+ private final Random randomGenerator = new Random();
+
+ private final Map<Position, List<Position>> neighbors = new HashMap<>();
+ Board board;
+ public Neighbour(Board board){
+ this.board = board;
+ initializeNeighbour();
+ }
+
+
+ private void initializeNeighbour(){
+
+ for (int column = 0; column < board.columnCount(); column++) {
+ for (int row = 0; row < board.rowCount(); row++) {
+ neighbors.put(new Position(row,column), calculateNeighbors(row, column));
+ }
+ }
+ }
+
+
+ public List<Position> calculateNeighbors(int row, int column) {
+ List<Position> list = new ArrayList<>();
+ if (row > 0) list.add(new Position(row-1,column));
+ if (column > 0) list.add(new Position(row,column-1));
+ if (row < board.rowCount() - 1) list.add(new Position(row+1,column));
+ if (column < board.columnCount() - 1) list.add(new Position(row,column+1));
+ return list;
+ }
+
+ public Position randomNeighbor(Position position) {
+ List<Position> neighborPositions = neighbors.get(position);
+ return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
+ }
+
+
+ public Map<Position, List<Position>> getNeighbors() {
+ return neighbors;
+ }
+}