src/main/java/app/SimulatorApplication.java

@@ -19,6 +19,8 @@ public class SimulatorApplication extends javafx.application.Application {
   private static final int BOX_HEIGHT = 50;
   public static final int INITIAL_FIRE_COUNT = 3;
   public static final int INITIAL_FIREFIGHTER_COUNT = 6;
+  private static final int INITIAL_CLOUD_COUNT = 5;
+  private static final int INITIAL_MOUNTAIN_COUNT = 5;
 
   private Stage primaryStage;
   private Parent view;
@@ -44,7 +46,7 @@ public class SimulatorApplication extends javafx.application.Application {
     view = loader.load();
     Controller controller = loader.getController();
     controller.initialize(BOX_WIDTH, BOX_HEIGHT, COLUMN_COUNT, ROW_COUNT,
-            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT);
+            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT, INITIAL_MOUNTAIN_COUNT);
   }
 
   private void showScene() {

src/main/java/controller/Controller.java

@@ -88,6 +88,12 @@ public class Controller {
     if (squareState.contains(ModelElement.FIRE)){
       return ViewElement.FIRE;
     }
+    if (squareState.contains(ModelElement.CLOUD)){
+      return ViewElement.CLOUD;
+    }
+    if(squareState.contains(ModelElement.MOUNTAIN)){
+      return ViewElement.MOUNTAIN;
+    }
     return ViewElement.EMPTY;
   }
 
@@ -124,9 +130,9 @@ public class Controller {
   }
 
   public void initialize(int squareWidth, int squareHeight, int columnCount,
-                                int rowCount, int initialFireCount, int initialFirefighterCount) {
+                                int rowCount, int initialFireCount, int initialFirefighterCount, int initialCloudCount, int initialMountainCount) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
+    this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount, initialCloudCount, initialMountainCount));
     repaintGrid();
   }
 

src/main/java/model/BoardElement.java

+package model;
+
+import util.Position;
+
+public interface BoardElement {
+    Position getPosition();
+    void setPosition(Position position);
+}
+

src/main/java/model/Cloud.java

+package model;
+
+import util.Position;
+
+import java.util.*;
+
+public class Cloud {
+    private Position position;
+    private final Map<Position, List<Position>> neighbors;
+    private final Random randomGenerator = new Random();
+
+    public Cloud(Position startPosition, Map<Position, List<Position>> neighbors) {
+        this.position = startPosition;
+        this.neighbors = neighbors;
+    }
+
+    public void move() {
+        List<Position> validNeighbors = neighbors.get(position);
+            this.position = validNeighbors.get(randomGenerator.nextInt(validNeighbors.size()));
+    }
+
+    public void extinguishSurroundingFires(Fire fire) {
+        for (Position neighbor : neighbors.get(position)) {
+            fire.extinguishFire(neighbor); // Éteint les feux adjacents
+        }
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void protectFromFire(Fire fire) {
+        fire.getFirePositions().remove(position);
+    }
+
+    public void extinguishSurroundingFires(Set<Position> firePositions, Map<Position, List<Position>> neighbors) {
+        for (Position neighbor : neighbors.get(position)) {
+            Fire.extinguishFire(neighbor); // Éteint les feux adjacents
+        }
+    }
+}

src/main/java/model/Fire.java

+package model;
+
+import util.Position;
+
+import java.util.*;
+
+public class Fire {
+    private static Set<Position> firePositions;
+    private static Map<Position, List<Position>> neighbors;
+
+    public Fire(Set<Position> firePositions, Map<Position, List<Position>> neighbors) {
+        this.firePositions = firePositions;
+        this.neighbors = neighbors;
+    }
+
+
+    public Position getPosition(){
+        return firePositions.iterator().next();
+    }
+
+    public void setPosition(Position p){
+        this.firePositions.add(p);
+    }
+
+    public static Set<Position> getFirePositions() {
+        return firePositions;
+    }
+
+    public static List<Position> spreadFire(Set<Position> mountains) {
+        List<Position> newFires = new ArrayList<>();
+        for (Position firePosition : firePositions) {
+            for (Position neighbor : neighbors.get(firePosition)) {
+                if (!mountains.contains(neighbor) && !firePositions.contains(neighbor)) {
+                    newFires.add(neighbor);
+                }
+            }
+        }
+        firePositions.addAll(newFires);
+        return newFires;
+    }
+
+    public static void extinguishFire(Position neighbor) {
+        firePositions.remove(neighbor);
+    }
+}

src/main/java/model/Firefighter.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class Firefighter {
+    private Position position;
+
+    public Firefighter(Position position) {
+        this.position = position;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+    public Position moveToBestPosition(Set<Position> firePositions, Map<Position, List<Position>> neighbors, Set<Position> mountains) {
+        Position currentPosition = getPosition();
+        Position bestPosition = currentPosition;
+        int minDistance = Integer.MAX_VALUE;
+
+        for (Position neighbor : neighbors.get(currentPosition)) {
+            if (mountains.contains(neighbor)) continue;
+            for (Position firePosition : firePositions) {
+                int distance = Math.abs(firePosition.row() - neighbor.row()) + Math.abs(firePosition.column() - neighbor.column());
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    bestPosition = neighbor;
+                }
+            }
+        }
+
+        return bestPosition;
+    }
+
+    public void extinguish(Position position, Set<Position> firePositions) {
+        firePositions.remove(position);
+    }
+}

src/main/java/model/FirefighterBoard.java

@@ -4,21 +4,24 @@ import util.Position;
 
 import java.util.*;
 
-
 public class FirefighterBoard implements Board<List<ModelElement>> {
   private final int columnCount;
   private final int rowCount;
   private final int initialFireCount;
   private final int initialFirefighterCount;
-  private final TargetStrategy targetStrategy = new TargetStrategy();
-  private List<Position> firefighterPositions;
-  private Set<Position> firePositions;
-  private Map<Position, List<Position>> neighbors = new HashMap();
+  private final int initialCloudCount;
+  private final int initialMountainCount = 3;
+  private final model.TargetStrategy targetStrategy = new model.TargetStrategy();
+  private List<Firefighter> firefighters;
+  private Fire fire;
+  private final Map<Position, List<Position>> neighbors = new HashMap<>();
+  private List<Cloud> clouds;
+  private List<Mountain> mountains;
   private final Position[][] positions;
   private int step = 0;
   private final Random randomGenerator = new Random();
 
-  public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
+  public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount, int initialCloudCount, int initialMountainCount) {
     this.columnCount = columnCount;
     this.rowCount = rowCount;
     this.positions = new Position[rowCount][columnCount];
@@ -36,16 +39,46 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
       }
     this.initialFireCount = initialFireCount;
     this.initialFirefighterCount = initialFirefighterCount;
+    this.initialCloudCount = initialCloudCount;
     initializeElements();
   }
 
   public void initializeElements() {
-    firefighterPositions = new ArrayList<>();
-    firePositions = new HashSet<>();
+    firefighters = new ArrayList<>();
+    clouds = new ArrayList<>();
+    mountains = new ArrayList<>();
+    Set<Position> firePositions = new HashSet<>();
+    for (int index = 0; index < initialCloudCount; index++) {
+      clouds.add(new Cloud(randomPosition(), neighbors));
+    }
     for (int index = 0; index < initialFireCount; index++)
       firePositions.add(randomPosition());
+    fire = new Fire(firePositions, neighbors);
     for (int index = 0; index < initialFirefighterCount; index++)
-      firefighterPositions.add(randomPosition());
+      firefighters.add(new Firefighter(randomPosition()));
+    for (int index = 0; index < initialCloudCount; index++) {
+      clouds.add(new Cloud(randomPosition(), neighbors));
+    }
+    for (int i = 0; i < initialMountainCount; i++) {
+      Position position = randomPosition();
+      if (isPositionOccupied(position)) continue;
+      mountains.add(new Mountain(position));
+    }
+  }
+
+  private boolean isPositionOccupied(Position position) {
+    // Vérifie si la position est occupée par une montagne
+    for (Mountain mountain : mountains) {
+      if (mountain.getPosition().equals(position)) return true;
+    }
+    // Vérifie les autres éléments
+    for (Firefighter firefighter : firefighters) {
+      if (firefighter.getPosition().equals(position)) return true;
+    }
+    for (Cloud cloud : clouds) {
+      if (cloud.getPosition().equals(position)) return true;
+    }
+    return fire.getFirePositions().contains(position);
   }
 
   private Position randomPosition() {
@@ -55,10 +88,22 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   @Override
   public List<ModelElement> getState(Position position) {
     List<ModelElement> result = new ArrayList<>();
-    for (Position firefighterPosition : firefighterPositions)
-      if (firefighterPosition.equals(position))
+    for (Cloud cloud : clouds) {
+      if (cloud.getPosition().equals(position)) {
+        result.add(ModelElement.CLOUD);
+      }
+    }
+    for (Mountain mountain : mountains){
+      if(mountain.getPosition().equals(position)){
+        result.add(ModelElement.MOUNTAIN);
+      }
+    }
+
+    for (Firefighter firefighter : firefighters)
+      if (firefighter.getPosition().equals(position))
         result.add(ModelElement.FIREFIGHTER);
-    if (firePositions.contains(position))
+
+    if (fire.getFirePositions().contains(position))
       result.add(ModelElement.FIRE);
     return result;
   }
@@ -75,23 +120,24 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
   public List<Position> updateToNextGeneration() {
     List<Position> modifiedPositions = updateFirefighters();
-    modifiedPositions.addAll(updateFires());
-    step++;
-    return modifiedPositions;
-  }
-
-  private List<Position> updateFires() {
-    List<Position> modifiedPositions = new ArrayList<>();
     if (step % 2 == 0){
-      List<Position> newFirePositions = new ArrayList<>();
-      for (Position fire : firePositions) {
-        newFirePositions.addAll(neighbors.get(fire));
+      modifiedPositions.addAll(fire.spreadFire(getMountainPositions()));
     }
-      firePositions.addAll(newFirePositions);
-      modifiedPositions.addAll(newFirePositions);
+    for (Cloud cloud : clouds) {
+      cloud.move();
+      cloud.protectFromFire(fire);
+      cloud.extinguishSurroundingFires(fire);
     }
-    return modifiedPositions;
+    step++;
 
+    return modifiedPositions;
+  }
+  private Set<Position> getMountainPositions() {
+    Set<Position> mountainPositions = new HashSet<>();
+    for (Mountain mountain : mountains) {
+      mountainPositions.add(mountain.getPosition());
+    }
+    return mountainPositions;
   }
 
   @Override
@@ -101,22 +147,27 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
   private List<Position> updateFirefighters() {
     List<Position> modifiedPosition = new ArrayList<>();
-    List<Position> firefighterNewPositions = new ArrayList<>();
-    for (Position firefighterPosition : firefighterPositions) {
-      Position newFirefighterPosition =
-              targetStrategy.neighborClosestToFire(firefighterPosition,
-                      firePositions, neighbors);
-      firefighterNewPositions.add(newFirefighterPosition);
-      extinguish(newFirefighterPosition);
-      modifiedPosition.add(firefighterPosition);
-      modifiedPosition.add(newFirefighterPosition);
-      List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
-              .filter(firePositions::contains).toList();
-      for (Position firePosition : neighborFirePositions)
-        extinguish(firePosition);
-      modifiedPosition.addAll(neighborFirePositions);
-    }
-    firefighterPositions = firefighterNewPositions;
+    for (Firefighter firefighter : firefighters) {
+
+      modifiedPosition.add(firefighter.getPosition());
+
+      Position newPosition = firefighter.moveToBestPosition(fire.getFirePositions(), neighbors, getMountainPositions());
+      firefighter.setPosition(newPosition);
+
+      modifiedPosition.add(newPosition);
+
+      firefighter.extinguish(newPosition, fire.getFirePositions());
+
+      // Éteindre les feux dans les positions voisines
+      List<Position> adjacentFires = neighbors.get(newPosition).stream()
+              .filter(fire.getFirePositions()::contains)
+              .toList();
+      for (Position firePosition : adjacentFires) {
+        firefighter.extinguish(firePosition, fire.getFirePositions());
+        modifiedPosition.add(firePosition);
+      }
+
+    }
     return modifiedPosition;
   }
 
@@ -126,21 +177,18 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     initializeElements();
   }
 
-  private void extinguish(Position position) {
-    firePositions.remove(position);
-  }
-
-
   @Override
   public void setState(List<ModelElement> state, Position position) {
-    firePositions.remove(position);
-    for (; ; ) {
-      if (!firefighterPositions.remove(position)) break;
-    }
+    fire.getFirePositions().remove(position);
+    firefighters.removeIf(f -> f.getPosition().equals(position));
+    clouds.removeIf(c -> c.getPosition().equals(position));
+
     for (ModelElement element : state) {
       switch (element) {
-        case FIRE -> firePositions.add(position);
-        case FIREFIGHTER -> firefighterPositions.add(position);
+        case FIRE -> fire.getFirePositions().add(position);
+        case FIREFIGHTER -> firefighters.add(new Firefighter(position));
+        case CLOUD -> clouds.add(new Cloud(position, neighbors));
+        case MOUNTAIN -> mountains.add(new Mountain(position));
       }
     }
   }

src/main/java/model/ModelElement.java

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

src/main/java/model/Mountain.java

+package model;
+
+import util.Position;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Mountain {
+    private final Position position;
+
+    public Mountain(Position position) {
+        this.position = position;
+    }
+    public Position getPosition(){
+        return position;
+    }
+
+    public static Set<Position> getMountainPositions(List<Mountain> mountains) {
+        return mountains.stream()
+                .map(Mountain::getPosition)
+                .collect(Collectors.toSet());
+    }
+
+}

src/main/java/model/firefighterManager.java

+/*package model;
+
+import util.Position;
+
+import java.util.*;
+
+
+public class FirefighterBoard implements Board<List<ModelElement>> {
+    private final int columnCount;
+    private final int rowCount;
+    private final int initialFireCount;
+    private final int initialFirefighterCount;
+    private final model.TargetStrategy targetStrategy = new model.TargetStrategy();
+    private List<Position> firefighterPositions;
+    private Set<Position> firePositions;
+    private Map<Position, List<Position>> neighbors = new HashMap();
+    private final Position[][] positions;
+    private int step = 0;
+    private final Random randomGenerator = new Random();
+
+    public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
+        this.columnCount = columnCount;
+        this.rowCount = rowCount;
+        this.positions = new Position[rowCount][columnCount];
+        for (int column = 0; column < columnCount; column++)
+            for (int row = 0; row < rowCount; row++)
+                positions[row][column] = new Position(row, column);
+        for (int column = 0; column < columnCount; column++)
+            for (int row = 0; row < rowCount; row++) {
+                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]);
+                neighbors.put(positions[row][column], list);
+            }
+        this.initialFireCount = initialFireCount;
+        this.initialFirefighterCount = initialFirefighterCount;
+        initializeElements();
+    }
+
+    public void initializeElements() {
+        firefighterPositions = new ArrayList<>();
+        firePositions = new HashSet<>();
+        for (int index = 0; index < initialFireCount; index++)
+            firePositions.add(randomPosition());
+        for (int index = 0; index < initialFirefighterCount; index++)
+            firefighterPositions.add(randomPosition());
+    }
+
+    private Position randomPosition() {
+        return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+    }
+
+    @Override
+    public List<ModelElement> getState(Position position) {
+        List<ModelElement> result = new ArrayList<>();
+        for (Position firefighterPosition : firefighterPositions)
+            if (firefighterPosition.equals(position))
+                result.add(ModelElement.FIREFIGHTER);
+        if (firePositions.contains(position))
+            result.add(ModelElement.FIRE);
+        return result;
+    }
+
+    @Override
+    public int rowCount() {
+        return rowCount;
+    }
+
+    @Override
+    public int columnCount() {
+        return columnCount;
+    }
+
+    public List<Position> updateToNextGeneration() {
+        List<Position> modifiedPositions = updateFirefighters();
+        modifiedPositions.addAll(updateFires());
+        step++;
+        return modifiedPositions;
+    }
+
+    private List<Position> updateFires() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        if (step % 2 == 0) {
+            List<Position> newFirePositions = new ArrayList<>();
+            for (Position fire : firePositions) {
+                newFirePositions.addAll(neighbors.get(fire));
+            }
+            firePositions.addAll(newFirePositions);
+            modifiedPositions.addAll(newFirePositions);
+        }
+        return modifiedPositions;
+
+    }
+
+    @Override
+    public int stepNumber() {
+        return step;
+    }
+
+    private List<Position> updateFirefighters() {
+        List<Position> modifiedPosition = new ArrayList<>();
+        List<Position> firefighterNewPositions = new ArrayList<>();
+        for (Position firefighterPosition : firefighterPositions) {
+            Position newFirefighterPosition =
+                    targetStrategy.neighborClosestToFire(firefighterPosition,
+                            firePositions, neighbors);
+            firefighterNewPositions.add(newFirefighterPosition);
+            extinguish(newFirefighterPosition);
+            modifiedPosition.add(firefighterPosition);
+            modifiedPosition.add(newFirefighterPosition);
+            List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
+                    .filter(firePositions::contains).toList();
+            for (Position firePosition : neighborFirePositions)
+                extinguish(firePosition);
+            modifiedPosition.addAll(neighborFirePositions);
+        }
+        firefighterPositions = firefighterNewPositions;
+        return modifiedPosition;
+    }
+
+    @Override
+    public void reset() {
+        step = 0;
+        initializeElements();
+    }
+
+    private void extinguish(Position position) {
+        firePositions.remove(position);
+    }
+
+
+    @Override
+    public void setState(List<ModelElement> state, Position position) {
+        firePositions.remove(position);
+        for (; ; ) {
+            if (!firefighterPositions.remove(position)) break;
+        }
+        for (ModelElement element : state) {
+            switch (element) {
+                case FIRE -> firePositions.add(position);
+                case FIREFIGHTER -> firefighterPositions.add(position);
+            }
+        }
+    }
+}*/
\ No newline at end of file

src/main/java/model/update/FireUpdater.java

+package model.update;
+
+import model.Fire;
+import util.Position;
+
+import java.util.*;
+
+public class FireUpdater {
+    private Fire fire;
+
+    public FireUpdater(Fire fire) {
+        this.fire = fire;
+    }
+
+    public List<Position> updateFire(Map<Position, List<Position>> neighbors, Set<Position> mountainPositions) {
+        return fire.spreadFire(mountainPositions);
+    }
+}
+

src/main/java/model/update/FirefighterUpdater.java

+package model.update;
+
+import model.Fire;
+import model.Firefighter;
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class FirefighterUpdater {
+    private final List<Firefighter> firefighters;
+    private final Map<Position, List<Position>> neighbors;
+    private final Fire fire;
+
+    public FirefighterUpdater(List<Firefighter> firefighters, Map<Position, List<Position>> neighbors, Fire fire) {
+        this.firefighters = firefighters;
+        this.neighbors = neighbors;
+        this.fire = fire;
+    }
+
+    public List<Position> updateFirefighters(Set<Position> mountainPositions) {
+        List<Position> modifiedPositions = new ArrayList<>();
+
+        for (Firefighter firefighter : firefighters) {
+            modifiedPositions.add(firefighter.getPosition());
+
+            Position newPosition = firefighter.moveToBestPosition(fire.getFirePositions(), neighbors, mountainPositions);
+            firefighter.setPosition(newPosition);
+
+            modifiedPositions.add(newPosition);
+
+            firefighter.extinguish(newPosition, fire.getFirePositions());
+
+            // Éteindre les feux dans les positions voisines
+            List<Position> adjacentFires = neighbors.get(newPosition).stream()
+                    .filter(fire.getFirePositions()::contains)
+                    .toList();
+
+            for (Position firePosition : adjacentFires) {
+                firefighter.extinguish(firePosition, fire.getFirePositions());
+                modifiedPositions.add(firePosition);
+            }
+        }
+
+        return modifiedPositions;
+    }
+}

src/main/java/model/update/NeighborManager.java

+package model.update;
+
+import util.Position;
+
+import java.util.HashMap;
+import java.util.*;
+
+public class NeighborManager {
+    private final Map<Position, List<Position>> neighbors = new HashMap<>();
+
+    public NeighborManager(int rowCount, int columnCount, Position[][] positions) {
+        for (int row = 0; row < rowCount; row++) {
+            for (int column = 0; column < columnCount; column++) {
+                List<Position> neighborList = new ArrayList<>();
+                if (row > 0) neighborList.add(positions[row - 1][column]);
+                if (column > 0) neighborList.add(positions[row][column - 1]);
+                if (row < rowCount - 1) neighborList.add(positions[row + 1][column]);
+                if (column < columnCount - 1) neighborList.add(positions[row][column + 1]);
+                neighbors.put(positions[row][column], neighborList);
+            }
+        }
+    }
+
+    public List<Position> getNeighbors(Position position) {
+        return neighbors.get(position);
+    }
+}
+

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);
+  FIREFIGHTER(Color.BLUE), FIRE(Color.RED), CLOUD(Color.LIGHTGREY),MOUNTAIN(Color.CHOCOLATE), EMPTY(Color.WHITE);
   final Color color;
   ViewElement(Color color) {
     this.color = color;

src/test/java/model/FirefighterBoardTest.java

@@ -10,17 +10,17 @@ import static org.assertj.core.api.Assertions.*;
 public class FirefighterBoardTest {
   @Test
   void testColumnCount(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3, 3, 3);
     assertThat(board.columnCount()).isEqualTo(20);
   }
   @Test
   void testRowCount(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 3, 5, 3, 3);
     assertThat(board.rowCount()).isEqualTo(10);
   }
   @Test
   void testStepNumber(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 3, 5, 3, 3);
     for(int index = 0; index < 10; index++){
       assertThat(board.stepNumber()).isEqualTo(index);
       board.updateToNextGeneration();
@@ -29,7 +29,7 @@ public class FirefighterBoardTest {
   }
   @Test
   void testGetState_afterSet(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 0, 0);
+    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 0, 0, 0, 0);
     Position position = new Position(1,2);
     assertThat(board.getState(position)).isEmpty();
     board.setState(List.of(ModelElement.FIRE), position);