Ajout de montain et road

src/main/java/app/SimulatorApplication.java

@@ -22,8 +22,11 @@ public class SimulatorApplication extends javafx.application.Application {
   public static final int INITIAL_CLOUD_COUNT = 2;
   public static final int INITIAL_FIRETRUCK_COUNT = 1;
 
-  public static final int[] elementsCount = new int[]{INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT, INITIAL_FIRETRUCK_COUNT};
+  public static final int INITIAL_MOUNTAIN_COUNT = 8;
 
+  public static final int INITIAL_ROAD_COUNT = 10;
+
+  public static final int[] elementsCount = {INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT, INITIAL_FIRETRUCK_COUNT, INITIAL_MOUNTAIN_COUNT, INITIAL_ROAD_COUNT};
   private Stage primaryStage;
   private Parent view;
   private void initializePrimaryStage(Stage primaryStage) {

src/main/java/controller/Controller.java

@@ -94,6 +94,12 @@ public class Controller {
     if (squareState.contains(ModelElement.FIRETRUCK)){
       return ViewElement.FIRETRUCK;
     }
+    if (squareState.contains(ModelElement.MOUNTAIN)){
+      return ViewElement.MOUNTAIN;
+    }
+    if (squareState.contains(ModelElement.ROAD)){
+      return ViewElement.ROAD;
+    }
     return ViewElement.EMPTY;
   }
 

src/main/java/model/AbstractElements.java

@@ -6,16 +6,25 @@ import java.util.*;
 
 public abstract class AbstractElements implements Elements {
     final Random randomGenerator = new Random();
-    int rowCount = 0;
-    int columnCount = 0;
+    int rowCount;
+    int columnCount;
 
     ModelElement modelElement;
 
     List<Position> elementsPositions;
 
+    AbstractElements(int columnCount, int rowCount,ModelElement modelElement){
+        this.columnCount = columnCount;
+        this.rowCount = rowCount;
+        this.modelElement = modelElement;
+    }
 
     public abstract void nextMove();
-    public abstract void initializeElements(int count, int rowCount, int columnCount);
+    public void initializeElements(int count, int rowCount, int columnCount) {
+        elementsPositions = new ArrayList<>();
+        for(int i = 0; i < count; i++)
+            elementsPositions.add(randomPosition(rowCount, columnCount));
+    }
 
     protected Position randomPosition(int rowCount, int columnCount) {
         return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
@@ -30,6 +39,22 @@ public abstract class AbstractElements implements Elements {
         return list;
     }
 
+    protected List<Position> neighborsWithoutSelectedElements(Position position, Elements... elements)  {
+
+        List<Position> list = new ArrayList<>();
+        for (Position neighbor : neighbors(position)) {
+            boolean isNeighbor = true;
+            for (Elements element : elements) {
+                if (element.getElementsPositions().contains(neighbor)) {
+                    isNeighbor = false;
+                    break;
+                }
+            }
+            if (isNeighbor) list.add(neighbor);
+        }
+        return list;
+    }
+
     public List<Position> getElementsPositions() {
         return elementsPositions;
     }

src/main/java/model/AbstractFireFighters.java

@@ -4,14 +4,14 @@ import util.Position;
 import java.util.*;
 
 public abstract class AbstractFireFighters extends AbstractElements{
-    public List<Position> elementsPositions;
+
     public Fire fire;
+    public Mountain mountain;
 
-    public AbstractFireFighters(int columnCount, int rowCount, Fire fire){
-        elementsPositions = new ArrayList<>();
-        this.columnCount = columnCount;
-        this.rowCount = rowCount;
+    public AbstractFireFighters(int columnCount, int rowCount, Fire fire, Mountain mountain, ModelElement modelElement){
+        super(columnCount, rowCount,modelElement);
         this.fire = fire;
+        this.mountain = mountain;
     }
      
 
@@ -19,7 +19,7 @@ public abstract class AbstractFireFighters extends AbstractElements{
     protected Position neighborClosestToFire(Position position) {
         Set<Position> seen = new HashSet<>();
         HashMap<Position, Position> firstMove = new HashMap<>();
-        Queue<Position> toVisit = new LinkedList<>(neighbors(position));
+        Queue<Position> toVisit = new LinkedList<>(neighborsWithoutSelectedElements(position, mountain));
         for (Position initialMove : toVisit)
             firstMove.put(initialMove, initialMove);
 
@@ -27,7 +27,7 @@ public abstract class AbstractFireFighters extends AbstractElements{
             Position current = toVisit.poll();
             if (fire.elementsPositions.contains(current)){
                 return firstMove.get(current);}
-            for (Position adjacent : neighbors(current)) {
+            for (Position adjacent : neighborsWithoutSelectedElements(current, mountain)) {
                 if (seen.contains(adjacent)) continue;
                 toVisit.add(adjacent);
                 seen.add(adjacent);
@@ -39,9 +39,5 @@ public abstract class AbstractFireFighters extends AbstractElements{
 
 
 
-    public void initializeElements(int count, int rowCount, int columnCount){
-        elementsPositions = new ArrayList<>();
-        for(int i = 0; i < count; i++)
-            elementsPositions.add(randomPosition(rowCount, columnCount));
-    }
+
 }

src/main/java/model/Cloud.java

@@ -6,15 +6,12 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class Cloud extends AbstractElements{
-    List<Position> elementsPositions;
     Fire fire;
 
 
     public Cloud(int columnCount, int rowCount, Fire fire) {
-        this.columnCount = columnCount;
-        this.rowCount = rowCount;
+        super(columnCount, rowCount, ModelElement.CLOUD);
         this.fire = fire;
-        this.modelElement = ModelElement.CLOUD;
     }
     @Override
     public void nextMove() {
@@ -28,12 +25,4 @@ public class Cloud extends AbstractElements{
 
     }
 
-    @Override
-    public void initializeElements(int count, int rowCount, int columnCount) {
-        elementsPositions = new ArrayList<>();
-        for (int i = 0; i < count; i++) {
-            elementsPositions.add(randomPosition(rowCount, columnCount));
-        }
-        System.out.println(elementsPositions);
-    }
 }

src/main/java/model/Elements.java

@@ -18,4 +18,5 @@ public interface Elements {
     ModelElement getModelElement();
 
 
+
 }

src/main/java/model/Fire.java

@@ -4,13 +4,14 @@ import util.Position;
 import java.util.*;
 
 public class Fire extends AbstractElements{
-    public List<Position> elementsPositions;
 
-    public Fire(int columnCount, int rowCount){
-        elementsPositions = new ArrayList<>();
-        this.columnCount = columnCount;
-        this.rowCount = rowCount;
-        this.modelElement = ModelElement.FIRE;
+    Mountain mountain;
+    Road road;
+
+    public Fire(int columnCount, int rowCount, Mountain mountain,Road road){
+        super(columnCount, rowCount, ModelElement.FIRE);
+        this.mountain = mountain;
+        this.road = road;
     }
      
     public void nextMove(){
@@ -18,7 +19,7 @@ public class Fire extends AbstractElements{
         // propagate the fire to the adjacent cells
         List<Position> newelementsPositions = new ArrayList<>();
         for (Position firePosition : elementsPositions) {
-            List<Position> neighborPositions = neighbors(firePosition);
+            List<Position> neighborPositions = neighborsWithoutSelectedElements(firePosition, mountain, road);
             newelementsPositions.addAll(neighborPositions);
         }
         // check if the new fire positions are not already on fire
@@ -27,13 +28,6 @@ public class Fire extends AbstractElements{
                 elementsPositions.add(newFirePosition);
     }
 
-    @Override
-    public void initializeElements(int count, int rowCount, int columnCount) {
-        elementsPositions = new ArrayList<>();
-        for(int i = 0; i < count; i++)
-            elementsPositions.add(randomPosition(rowCount, columnCount));
-    }
-
     public void extinguishs(List<Position> firefighterPositions){
 
         for (Position firefighterPosition : firefighterPositions) {

src/main/java/model/FireFighterPerson.java

@@ -6,9 +6,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class FireFighterPerson extends AbstractFireFighters{
-    public FireFighterPerson(int columnCount, int rowCount, Fire fire) {
-        super(columnCount, rowCount, fire);
-        this.modelElement = ModelElement.FIREFIGHTER;
+    public FireFighterPerson(int columnCount, int rowCount, Fire fire, Mountain mountain) {
+        super(columnCount, rowCount, fire, mountain, ModelElement.FIREFIGHTER);
     }
 
     @Override

src/main/java/model/FireTruck.java

@@ -6,9 +6,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class FireTruck extends AbstractFireFighters{
-    public FireTruck(int columnCount, int rowCount, Fire fire) {
-        super(columnCount, rowCount, fire);
-        this.modelElement = ModelElement.FIRETRUCK;
+    public FireTruck(int columnCount, int rowCount, Fire fire, Mountain mountain) {
+        super(columnCount, rowCount, fire, mountain, ModelElement.FIRETRUCK);
+
     }
 
     public void nextMove(){

src/main/java/model/FirefighterBoard.java

@@ -16,6 +16,8 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   private final int initialFirefighterCount;
   private final int initialCloudCount;
   private final int initialFireTruckCount;
+  private final int initialMountainCount;
+  private final int initialRoadCount;
   private int step = 0;
 
 
@@ -25,6 +27,10 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   public FireTruck fireTrucks;
   public Cloud cloud;
 
+  public Mountain mountain;
+
+    public Road road;
+
   public FirefighterBoard(int columnCount, int rowCount, int[] elementsCount) {
     this.columnCount = columnCount;
     this.rowCount = rowCount;
@@ -33,13 +39,18 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     this.initialFirefighterCount = elementsCount[1];
     this.initialCloudCount = elementsCount[2];
     this.initialFireTruckCount = elementsCount[3];
+    this.initialMountainCount = elementsCount[4];
+    this.initialRoadCount = elementsCount[5];
 
-    fire = new Fire(columnCount, rowCount);
-    fireFighters = new FireFighterPerson(columnCount, rowCount, fire);
+    mountain = new Mountain(columnCount, rowCount);
+    road = new Road(columnCount, rowCount);
+    fire = new Fire(columnCount, rowCount, mountain, road);
+    fireFighters = new FireFighterPerson(columnCount, rowCount, fire, mountain);
     cloud = new Cloud(columnCount, rowCount, fire);
-    fireTrucks = new FireTruck(columnCount, rowCount, fire);
+    fireTrucks = new FireTruck(columnCount, rowCount, fire, mountain);
+
 
-    elements = new Elements[]{fire, fireFighters, cloud, fireTrucks};
+    elements = new Elements[]{fire, fireFighters, cloud, fireTrucks, mountain, road};
 
     initializeElements();
   }
@@ -49,6 +60,8 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     fireFighters.initializeElements(initialFirefighterCount, rowCount, columnCount);
     cloud.initializeElements(initialCloudCount, rowCount, columnCount);
     fireTrucks.initializeElements(initialFireTruckCount, rowCount, columnCount);
+    mountain.initializeElements(initialMountainCount, rowCount, columnCount);
+    road.initializeElements(initialRoadCount, rowCount, columnCount);
   }
 
 
@@ -75,6 +88,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
   public List<Position> updateToNextGeneration() {
 
+
     List<Position> modifiedElements = new ArrayList<>();
 
     for (Elements element : elements) {
@@ -92,6 +106,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     fire.extinguishs(fireTrucks.getElementsPositions());
     fire.extinguishs(cloud.getElementsPositions());
 
+
     if (step % 2 == 0)
       fire.nextMove();
 
@@ -101,6 +116,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
       modifiedElements.addAll(element.getElementsPositions());
     }
 
+
     return modifiedElements;
   }
 
@@ -129,6 +145,8 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
         case FIREFIGHTER -> fireFighters.addElement(position);
         case CLOUD -> cloud.addElement(position);
         case FIRETRUCK -> fireTrucks.addElement(position);
+        case MOUNTAIN -> mountain.addElement(position);
+        case ROAD -> road.addElement(position);
       }
     }
   }

src/main/java/model/ModelElement.java

 package model;
 
 public enum ModelElement {
-  FIREFIGHTER, FIRE, CLOUD, FIRETRUCK
+  FIREFIGHTER, FIRE, CLOUD, FIRETRUCK, MOUNTAIN, ROAD
 }

src/main/java/model/Mountain.java

+package model;
+
+public class Mountain extends AbstractElements{
+
+    public Mountain(int columnCount, int rowCount){
+        super(columnCount, rowCount, ModelElement.MOUNTAIN);
+    }
+    @Override
+    public void nextMove() {
+    }
+
+}

src/main/java/model/Road.java

+package model;
+
+public class Road extends AbstractElements{
+
+    public Road(int columnCount, int rowCount){
+        super(columnCount, rowCount, ModelElement.ROAD);
+    }
+    @Override
+    public void nextMove() {
+
+    }
+}

src/main/java/view/ViewElement.java

@@ -3,7 +3,7 @@ package view;
 import javafx.scene.paint.Color;
 
 public enum ViewElement {
-  FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE), CLOUD(Color.GRAY), FIRETRUCK(Color.CYAN);
+  FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE), CLOUD(Color.GRAY), FIRETRUCK(Color.CYAN), MOUNTAIN(Color.BROWN), ROAD(Color.BLACK);
   final Color color;
   ViewElement(Color color) {
     this.color = color;