mehdi and mohamed : adding Obstacle abstract class and modifiying FirefighterBoard implementation

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;

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.
    *

src/main/java/model/Cloud.java

@@ -29,4 +29,6 @@ public class Cloud extends Extinguisher {
     }
 
 
+
+
 }

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);
 

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));
             }
-                // Marquer la position comme modifiée
+
+
+            for (Position position : newFirePositions) {
+                if (!firefighterBoard.getFires().containsKey(position)) {
+                    firefighterBoard.getFires().put(position, new Fire(position));
                     modifiedPositions.add(position);
                 }
             }
+        }
         return modifiedPositions;
     }
-
     public boolean contains(List<Position> positions) {
         return positions.contains(this.getPosition());
 

src/main/java/model/FireFighter.java

@@ -41,6 +41,4 @@ public class FireFighter extends Extinguisher {
         return modifiedPositions;
     }
 
-
-
 }
\ No newline at end of file

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(Element element : elements){
-      if(element.getPosition().equals(position))result.add(element.getElement());
-    }
 
-    return result;
+    for (Extinguisher extinguisher : extinguishers.values()) {
+      if (extinguisher.getPosition().equals(position)) result.add(extinguisher.getElement());
     }
 
+    for (Obstacle obstacle : obstacles.values()) {
+      if (obstacle.getPosition().equals(position)) result.add(obstacle.getElement());
+    }
 
 
+    return result;
+  }
 
 
-  public List<Position> updateElements() {
-    List<Position> modifiedPositions = new ArrayList<>();
+  Position randomNeighbor(Position position) {
+    List<Position> neighborPositions = neighbors.get(position);
+    return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
+  }
 
 
-    for (Element element : new ArrayList<>(elements)) {
-      modifiedPositions.addAll(element.update(this));
+  @Override
+  public int rowCount() {
+    return rowCount;
   }
 
-    return modifiedPositions;
+  @Override
+  public int columnCount() {
+    return columnCount;
   }
 
-  public List<Element> getElements() {
-    return elements;
-  }
+  public List<Position> updateToNextGeneration() {
 
-  public boolean containsFireAt(Position position) {
-    return elements.stream()
-            .anyMatch(e -> e instanceof Fire && e.getPosition().equals(position));
-  }
+    Fire fire = new Fire(randomPosition());
+    List<Position> modifiedPositions = new ArrayList<>();
 
-  public Position randomNeighbor(Position position) {
-    List<Position> neighborPositions = neighbors.get(position);
-    return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
+    for(Extinguisher element : extinguishers.values()){
+      modifiedPositions.addAll(element.update(this));
     }
 
 
+    modifiedPositions.addAll(fire.update(this));
 
 
-  public List<Position> updateToNextGeneration() {
-    List<Position> modifiedPositions = updateElements();
-
     step++;
     return modifiedPositions;
   }
 
 
+  public Map<Position, List<Position>> getNeighbors() {
+    return neighbors;
+  }
+
   @Override
   public int stepNumber() {
     return step;
   }
 
-  @Override
-  public int rowCount() {
-    return rowCount;
+
+
+
+  public Map<Position,Fire>getFires(){
+
+    return this.fires;
+
   }
 
   @Override
-  public int columnCount() {
-    return columnCount;
+  public Map<Position, Extinguisher> getExtinguishers() {
+    return extinguishers;
+  }
+
+  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);
-        }
-    }
-  }
-
-
-  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;
+    if (this.fires.containsKey(position)) {
+      this.fires.remove(position);
     }
 
-  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));
       }
     }
   }
+
+
+
+
+
 }
+

src/main/java/model/Obstacle.java

+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;
+    }
+
+
+}

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();
-    }
 }

src/main/java/util/Neighbour.java

+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;
+    }
+}