diff --git a/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance01.pdf b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance01.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..90cfdef7c5999416c34f1b0788ceb4c17046d4df
Binary files /dev/null and b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance01.pdf differ
diff --git a/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance02.pdf b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance02.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..5d06ba7047f3f2c98d63add3fcc4316759b8ae11
Binary files /dev/null and b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance02.pdf differ
diff --git a/src/main/java/app/SimulatorMain.java b/src/main/java/app/SimulatorMain.java
index f2e49f262ebec4136cf57d3b50fea3987b3b69fc..1520ca6013b265b8a0d0b872cec5f0454c311520 100644
--- a/src/main/java/app/SimulatorMain.java
+++ b/src/main/java/app/SimulatorMain.java
@@ -4,4 +4,5 @@ public class SimulatorMain {
   public static void main(String[] args){
     SimulatorApplication.main(args);
   }
+
 }
diff --git a/src/main/java/controller/CloudController.java b/src/main/java/controller/CloudController.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7604b19bedc9c11c69d5985cc91ff6af678f6c5
--- /dev/null
+++ b/src/main/java/controller/CloudController.java
@@ -0,0 +1,52 @@
+package controller;
+
+import util.Position;
+import view.ViewElement;
+
+import java.util.*;
+
+public class CloudController {
+    private final int rowCount;
+    private final int columnCount;
+    private final Set<Position> clouds = new HashSet<>();
+
+    public CloudController(int rowCount, int columnCount) {
+        this.rowCount = rowCount;
+        this.columnCount = columnCount;
+    }
+
+    public void addCloud(Position position) {
+        clouds.add(position);
+    }
+
+    public Set<Position> getCloudPositions() {
+        return clouds;
+    }
+
+    public void moveClouds() {
+        Set<Position> newCloudPositions = new HashSet<>();
+        Random random = new Random();
+
+        for (Position cloud : clouds) {
+            int newRow = cloud.row() + random.nextInt(3) - 1; // Mouvement aléatoire (-1, 0, 1)
+            int newCol = cloud.column() + random.nextInt(3) - 1;
+
+            // S'assurer que les nuages restent dans les limites de la grille
+            newRow = Math.max(0, Math.min(rowCount - 1, newRow));
+            newCol = Math.max(0, Math.min(columnCount - 1, newCol));
+
+            newCloudPositions.add(new Position(newRow, newCol));
+        }
+
+        clouds.clear();
+        clouds.addAll(newCloudPositions);
+    }
+
+    public void extinguishFires(ViewElement[][] grid) {
+        for (Position cloud : clouds) {
+            if (grid[cloud.row()][cloud.column()] == ViewElement.FIRE) {
+                grid[cloud.row()][cloud.column()] = ViewElement.EMPTY; // Éteindre le feu
+            }
+        }
+    }
+}
diff --git a/src/main/java/controller/Controller.java b/src/main/java/controller/Controller.java
index 2a60897c6eb8ba847cb8589840c16a0f175ce0a3..55cd3293e690c550ee2c28451dd942ecd81694dc 100644
--- a/src/main/java/controller/Controller.java
+++ b/src/main/java/controller/Controller.java
@@ -40,7 +40,7 @@ public class Controller {
   @FXML
   private Grid<ViewElement> grid;
   private Timeline timeline;
-  private Board<List<ModelElement>> board;
+  private FirefighterBoard board;
 
   @FXML
   private void initialize() {
diff --git a/src/main/java/model/Board.java b/src/main/java/model/Board.java
index bb089a41406d57b0b2fe3d43b3c040cbd640b6b9..e671eb09e2dcb2b788d40b7fe87cefcaf19d4fd3 100644
--- a/src/main/java/model/Board.java
+++ b/src/main/java/model/Board.java
@@ -4,62 +4,9 @@ import util.Position;
 
 import java.util.List;
 
-/**
- * This interface represents a generic board for modeling various state-based systems.
- *
- * @param <S> The type of state represented on the board.
- */
-public interface Board<S> {
-
-  /**
-   * Get the state of the board at a specific position.
-   *
-   * @param position The position on the board for which to retrieve the state.
-   * @return The state at the specified position.
-   */
-  S getState(Position position);
-
-  /**
-   * Set the state of a specific position on the board to the specified state.
-   *
-   * @param state The state to set for the given position.
-   * @param position The position on the board for which to set the state.
-   */
-  void setState(S state, Position position);
 
-  /**
-   * Get the number of rows in the board.
-   *
-   * @return The number of rows in the board.
-   */
-  int rowCount();
-
-  /**
-   * Get the number of columns in the board.
-   *
-   * @return The number of columns in the board.
-   */
-  int columnCount();
-
-  /**
-   * Update the board to its next generation or state. This method may modify the
-   * internal state of the board and return a list of positions that have changed
-   * during the update.
-   *
-   * @return A list of positions that have changed during the update.
-   */
-  List<Position> updateToNextGeneration();
+public interface Board<S> {
 
-  /**
-   * Reset the board to its initial state.
-   */
-  void reset();
 
-  /**
-   * Get the current step number or generation of the board.
-   *
-   * @return The current step number or generation.
-   */
-  int stepNumber();
 }
 
diff --git a/src/main/java/model/BoardBehavior.java b/src/main/java/model/BoardBehavior.java
index cf02e8d51b15f2ab1a27c662fea95c457756a2fb..0ce2952092106532eccd12b91fdede4fe30085a4 100644
--- a/src/main/java/model/BoardBehavior.java
+++ b/src/main/java/model/BoardBehavior.java
@@ -1,11 +1,27 @@
 package model;
 
 import util.Position;
-
 import java.util.List;
 
-public interface BoardBehavior {
-    public int stepNumber(); // Numéro de l'étape actuelle.
-   public List<Position> updateToNextGeneration();
-   public void reset();
+public interface BoardBehavior<S> extends Board<S>{
+    /**
+     * Get the current step number or generation of the board.
+     *
+     * @return The current step number or generation.
+     */
+    int stepNumber();
+
+    /**
+     * Update the board to its next generation or state. This method may modify the
+     * internal state of the board and return a list of positions that have changed
+     * during the update.
+     *
+     * @return A list of positions that have changed during the update.
+     */
+    List<Position> updateToNextGeneration();
+
+    /**
+     * Reset the board to its initial state.
+     */
+    void reset();
 }
diff --git a/src/main/java/model/BoardProperties.java b/src/main/java/model/BoardProperties.java
index 901b1164479373cd9bb9484a63caaab650f31c50..ec37435d035edda6babe33cc2d05f41f28e2cea9 100644
--- a/src/main/java/model/BoardProperties.java
+++ b/src/main/java/model/BoardProperties.java
@@ -4,9 +4,39 @@ import util.Position;
 
 import java.util.List;
 
-public interface BoardProperties {
+/**
+ * Interface représentant les propriétés d'un tableau générique pour la gestion de l'état.
+ *
+ * @param <S> Le type d'état utilisé pour les éléments du tableau.
+ */
+public interface BoardProperties<S> extends Board<S>  {
+    /**
+     * Retourne le nombre de lignes du tableau.
+     *
+     * @return Le nombre de lignes.
+     */
     int rowCount(); // Nombre de lignes.
+
+    /**
+     * Retourne le nombre de colonnes du tableau.
+     *
+     * @return Le nombre de colonnes.
+     */
     int columnCount(); // Nombre de colonnes.
-    List<ModelElement> getState(Position position); // État des éléments sur une position donnée.
-    void setState(List<ModelElement> state, Position position);
+
+    /**
+     * Retourne l'état des éléments situés à une position spécifique du tableau.
+     *
+     * @param position La position sur le tableau pour laquelle récupérer l'état.
+     * @return L'état des éléments à la position donnée.
+     */
+    S getState(Position position); // État des éléments sur une position donnée.
+
+    /**
+     * Définit l'état des éléments à une position spécifique du tableau.
+     *
+     * @param state    L'état à définir pour la position donnée.
+     * @param position La position sur le tableau pour laquelle définir l'état.
+     */
+    void setState(S state, Position position);
 }
diff --git a/src/main/java/model/ClassicFireFighter.java b/src/main/java/model/ClassicFireFighter.java
new file mode 100644
index 0000000000000000000000000000000000000000..13fefbecb116637cb28375a542138efd742ebf6f
--- /dev/null
+++ b/src/main/java/model/ClassicFireFighter.java
@@ -0,0 +1,29 @@
+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ClassicFireFighter extends FirefighterManager{
+    public ClassicFireFighter(List<Position> firefighterPositions) {
+        super(firefighterPositions);
+    }
+    @Override
+    public List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors) {
+        List<Position> modifiedPositions = new ArrayList<>();
+        for (Position firefighterPosition : firefighterPositions) {
+            Position newFirefighterPosition = moveToTarget(firefighterPosition, fireManager.getFirePosition(), neighbors);
+            setFirefighterPosition(firefighterPosition, newFirefighterPosition);
+
+            if (fireManager.isOnFire(newFirefighterPosition)) {
+                extinguishFire(newFirefighterPosition);
+            }
+
+            modifiedPositions.add(firefighterPosition);
+            modifiedPositions.add(newFirefighterPosition);
+        }
+        return modifiedPositions;
+    }
+}
diff --git a/src/main/java/model/FireBehavior.java b/src/main/java/model/FireBehavior.java
new file mode 100644
index 0000000000000000000000000000000000000000..bfa1aca7a681982c92fc20b9106ce0b83ffd7f9b
--- /dev/null
+++ b/src/main/java/model/FireBehavior.java
@@ -0,0 +1,11 @@
+package model;
+
+import util.Position;
+
+import java.util.List;
+import java.util.Map;
+
+public interface FireBehavior {
+    public List<Position> updateFires(int step, Map<Position, List<Position>> neighbors);
+    void extinguishFire(Position position);
+}
diff --git a/src/main/java/model/FireManager.java b/src/main/java/model/FireManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..93b0299eb840fa28a3fa4d9e7c6b777917f93b33
--- /dev/null
+++ b/src/main/java/model/FireManager.java
@@ -0,0 +1,127 @@
+package model;
+
+import util.Position;
+import view.ViewElement;
+
+import java.util.*;
+
+public class FireManager implements FireBehavior, FireProperties{
+    private Set<Position> firePositions;
+    private FirefighterManager firefighterManager;
+
+    public FireManager(Set<Position> firePositions,FirefighterManager firefighterManager) {
+        this.firePositions = firePositions;
+        this.firefighterManager=firefighterManager;
+
+    }
+
+    // Initialize fire positions randomly
+    public void initializeFires(int fireCount, int rowCount, int columnCount, Random random) {
+        firePositions.clear();
+        for (int i = 0; i < fireCount; i++) {
+            firePositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
+        }
+    }
+    @Override
+    public List<Position> updateFires(int step, Map<Position, List<Position>> neighbors) {
+        List<Position> newFirePositions = new ArrayList<>();
+        if (step % 2 == 0) { // Le feu se propage tous les deux pas
+            for (Position fire : firePositions) {
+                for (Position neighbor : neighbors.get(fire)) {
+                    // Vérifier si le voisin est déjà en feu ou s'il y a un pompier
+                    if (!firePositions.contains(neighbor) && !firefighterManager.getFirefighterPositions().contains(neighbor)) {
+                        newFirePositions.add(neighbor);
+                    }
+                }
+            }
+            firePositions.addAll(newFirePositions);
+        }
+        return newFirePositions;
+    }
+    public void spreadFire(ViewElement[][] grid) {
+        int rows = grid.length;
+        int columns = grid[0].length;
+
+        // Créez un tableau pour suivre les tours avant que le feu se propage sur les rocailles
+        int[][] fireCooldown = new int[rows][columns];
+
+        // Initialisation du tableau de cooldown des rocailles à 0
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < columns; j++) {
+                if (grid[i][j] == ViewElement.ROCKY) {
+                    fireCooldown[i][j] = 4;  // Le feu prend 4 tours pour se propager sur les rocailles
+                } else {
+                    fireCooldown[i][j] = 0;  // Aucune attente pour les autres cases
+                }
+            }
+        }
+
+        ViewElement[][] newGrid = new ViewElement[rows][columns];
+        for (int i = 0; i < rows; i++) {
+            System.arraycopy(grid[i], 0, newGrid[i], 0, columns);
+        }
+
+        // Propagation du feu
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < columns; j++) {
+                if (grid[i][j] == ViewElement.FIRE) {
+                    // Propager le feu sur les voisins si possible
+                    for (Position neighbor : getNeighbors(i, j, rows, columns)) {
+                        if (grid[neighbor.row()][neighbor.column()] == ViewElement.EMPTY) {
+                            newGrid[neighbor.row()][neighbor.column()] = ViewElement.FIRE;
+                        }
+                        // Empêcher la propagation sur les montagnes
+                        if (grid[neighbor.row()][neighbor.column()] == ViewElement.MOUNTAIN) {
+                            newGrid[neighbor.row()][neighbor.column()] = ViewElement.MOUNTAIN;
+                        }
+                        // Propagation du feu sur les rocailles après 4 tours
+                        if (grid[neighbor.row()][neighbor.column()] == ViewElement.ROCKY && fireCooldown[neighbor.row()][neighbor.column()] == 0) {
+                            newGrid[neighbor.row()][neighbor.column()] = ViewElement.FIRE;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Mise à jour de la grille après propagation
+        for (int i = 0; i < rows; i++) {
+            System.arraycopy(newGrid[i], 0, grid[i], 0, columns);
+        }
+
+        // Décrémenter le cooldown des rocailles chaque tour
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < columns; j++) {
+                if (fireCooldown[i][j] > 0) {
+                    fireCooldown[i][j]--;  // Décrémenter le compteur de cooldown
+                }
+            }
+        }
+    }
+
+
+    private List<Position> getNeighbors(int row, int column, int rows, int columns) {
+        List<Position> neighbors = new ArrayList<>();
+        if (row > 0) neighbors.add(new Position(row - 1, column));
+        if (row < rows - 1) neighbors.add(new Position(row + 1, column));
+        if (column > 0) neighbors.add(new Position(row, column - 1));
+        if (column < columns - 1) neighbors.add(new Position(row, column + 1));
+        return neighbors;
+    }
+
+
+
+    // Extinguish a fire at a specific position
+    @Override
+    public void extinguishFire(Position position) {
+        firePositions.remove(position);
+    }
+    // Query if a position is on fire
+    @Override
+    public boolean isOnFire(Position position) {
+        return firePositions.contains(position);
+    }
+    @Override
+    public Set<Position> getFirePosition()
+    {  return new HashSet<>(firePositions);}
+
+}
diff --git a/src/main/java/model/FireProperties.java b/src/main/java/model/FireProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..906756108d3c70143a50f6bc9aba89d37e8c658b
--- /dev/null
+++ b/src/main/java/model/FireProperties.java
@@ -0,0 +1,10 @@
+package model;
+
+import util.Position;
+
+import java.util.Set;
+
+public interface FireProperties {
+    public boolean isOnFire(Position position);
+    Set<Position> getFirePosition();
+}
diff --git a/src/main/java/model/FirefighterBehavior.java b/src/main/java/model/FirefighterBehavior.java
new file mode 100644
index 0000000000000000000000000000000000000000..89773dcfad96ff72878698e316b9b92c4b3fa22b
--- /dev/null
+++ b/src/main/java/model/FirefighterBehavior.java
@@ -0,0 +1,14 @@
+package model;
+
+import util.Position;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public interface FirefighterBehavior {
+    Position moveToTarget(Position currentPosition, Collection<Position> firePositions,
+                          Map<Position, List<Position>> neighbors); // Déplacer un pompier vers une cible.
+    void extinguishFire(Position firePosition); // Éteindre un feu à une position donnée.
+   // public List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors);
+}
diff --git a/src/main/java/model/FirefighterManager.java b/src/main/java/model/FirefighterManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..1317bb1cbd7b025e0a223383dec11810c718968f
--- /dev/null
+++ b/src/main/java/model/FirefighterManager.java
@@ -0,0 +1,47 @@
+package model;
+
+import util.Position;
+import util.TargetStrategy;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public abstract class FirefighterManager implements FirefighterBehavior, FirefighterProperties {
+    protected List<Position> firefighterPositions;
+    FireManager fireManager;
+
+    public void setFireManager(FireManager fireManager) {
+        this.fireManager = fireManager;
+    }
+
+    public FirefighterManager(List<Position> firefighterPositions) {
+        this.firefighterPositions = firefighterPositions;
+    }
+
+    @Override
+    public Position moveToTarget(Position currentPosition, Collection<Position> firePositions, Map<Position, List<Position>> neighbors) {
+        TargetStrategy targetStrategy = new TargetStrategy();
+        return targetStrategy.neighborClosestToFire(currentPosition, firePositions, neighbors);
+    }
+
+    @Override
+    public void extinguishFire(Position firePosition) {
+          fireManager.extinguishFire(firePosition);
+    }
+
+    @Override
+    public List<Position> getFirefighterPositions() {
+        return firefighterPositions;
+    }
+
+    @Override
+    public void setFirefighterPosition(Position oldPosition, Position newPosition) {
+        firefighterPositions.remove(oldPosition);
+        firefighterPositions.add(newPosition);
+    }
+
+    public abstract List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors) ;
+
+}
diff --git a/src/main/java/model/FirefighterProperties.java b/src/main/java/model/FirefighterProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8cac29a8cb31901654f45af4f911b94d4c7d8cb
--- /dev/null
+++ b/src/main/java/model/FirefighterProperties.java
@@ -0,0 +1,10 @@
+package model;
+
+import util.Position;
+
+import java.util.List;
+
+public interface FirefighterProperties {
+    List<Position> getFirefighterPositions();
+    void setFirefighterPosition(Position oldPosition, Position newPosition);
+}
diff --git a/src/main/java/model/MotorizedFirefighter.java b/src/main/java/model/MotorizedFirefighter.java
new file mode 100644
index 0000000000000000000000000000000000000000..71edb72c600981ef91a2b1d524f7e2f87dadbe1f
--- /dev/null
+++ b/src/main/java/model/MotorizedFirefighter.java
@@ -0,0 +1,49 @@
+package model;
+
+import util.Position;
+
+import java.util.*;
+
+public class MotorizedFirefighter extends FirefighterManager {
+    private Random random =new Random();
+    public MotorizedFirefighter(List<Position> firefighterPositions) {
+        super(firefighterPositions);
+    }
+
+    @Override
+    public List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors) {
+        List<Position> modifiedPositions = new ArrayList<>();
+        for (Position firefighterPosition : firefighterPositions) {
+            // Déplacement motorisé, on se déplace de deux cases
+            Position newFirefighterPosition = moveToTarget(firefighterPosition, fireManager.getFirePosition(), neighbors);
+            setFirefighterPosition(firefighterPosition, newFirefighterPosition);
+
+            // Vérifier si un feu est à la nouvelle position et l'éteindre
+            if (fireManager.isOnFire(newFirefighterPosition)) {
+                extinguishFire(newFirefighterPosition);
+            }
+
+            modifiedPositions.add(firefighterPosition);
+            modifiedPositions.add(newFirefighterPosition);
+        }
+        return modifiedPositions;
+    }
+    @Override
+    public Position moveToTarget(Position currentPosition, Collection<Position> firePositions, Map<Position, List<Position>> neighbors) {
+        // Logique spécifique pour le déplacement motorisé (deux cases)
+        List<Position> possibleMoves = new ArrayList<>();
+        for (Position neighbor : neighbors.get(currentPosition)) {
+            for (Position secondNeighbor : neighbors.get(neighbor)) {
+                if (!secondNeighbor.equals(currentPosition)) {
+                    possibleMoves.add(secondNeighbor);
+                }
+            }
+        }
+
+        if (!possibleMoves.isEmpty()) {
+            return possibleMoves.get(random.nextInt(possibleMoves.size()));
+        } else {
+            return currentPosition;
+        }
+    }
+}
diff --git a/src/main/java/util/MotorizedStrategy.java b/src/main/java/util/MotorizedStrategy.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f5b092c3764a2b2070a1ee8ab2c3c9b26d3eb10
--- /dev/null
+++ b/src/main/java/util/MotorizedStrategy.java
@@ -0,0 +1,22 @@
+package util;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public class MotorizedStrategy implements Strategy{
+    @Override
+    public Position neighborClosestToTarget(Position position, Collection<Position> targets, Map<Position, List<Position>> neighbors) {
+        TargetStrategy normalStrategy = new TargetStrategy();
+        Position firstMove = normalStrategy.neighborClosestToTarget(position, targets, neighbors);
+
+        // Si un premier mouvement est trouvé, on simule un second déplacement
+        if (firstMove != null && neighbors.containsKey(firstMove)) {
+            return normalStrategy.neighborClosestToTarget(firstMove, targets, neighbors);
+        }
+
+        return position;
+    }
+
+
+}
diff --git a/src/main/java/util/Strategy.java b/src/main/java/util/Strategy.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ca44e7aa30160c942c83f6abe8a44e1b44c509e
--- /dev/null
+++ b/src/main/java/util/Strategy.java
@@ -0,0 +1,11 @@
+package util;
+
+import view.ViewElement;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public interface Strategy {
+    Position neighborClosestToTarget(Position position, Collection<Position> targets, Map<Position, List<Position>> neighbors, ViewElement[][] grid);
+}
diff --git a/src/main/java/util/TargetStrategy.java b/src/main/java/util/TargetStrategy.java
index 5e2e743affb2795efbf641942452fe0339d5bce9..7a2b0519452f37629da82619457c4c1739596eba 100644
--- a/src/main/java/util/TargetStrategy.java
+++ b/src/main/java/util/TargetStrategy.java
@@ -1,10 +1,11 @@
 package util;
 
 import util.Position;
+import view.ViewElement;
 
 import java.util.*;
 
-public class TargetStrategy {
+public class TargetStrategy implements Strategy{
 
 
     /**
@@ -12,8 +13,8 @@ public class TargetStrategy {
      * @param targets positions that are targeted.
      * @return the position next to the current position that is on the path to the closest target.
      */
-    public Position neighborClosestToFire(Position position, Collection<Position> targets,
-                                          Map<Position, List<Position>> neighbors) {
+    public Position neighborClosestToTarget(Position position, Collection<Position> targets,
+                                          Map<Position, List<Position>> neighbors, ViewElement[][] grid) {
         Set<Position> seen = new HashSet<Position>();
         HashMap<Position, Position> firstMove = new HashMap<Position, Position>();
         Queue<Position> toVisit = new LinkedList<Position>(neighbors.get(position));
@@ -21,6 +22,7 @@ public class TargetStrategy {
             firstMove.put(initialMove, initialMove);
         while (!toVisit.isEmpty()) {
             Position current = toVisit.poll();
+            if (grid[current.row()][current.column()] == ViewElement.MOUNTAIN) continue;
             if (targets.contains(current))
                 return firstMove.get(current);
             for (Position adjacent : neighbors.get(current)) {
diff --git a/src/main/java/view/FirefighterGrid.java b/src/main/java/view/FirefighterGrid.java
index 4c9041f034ec9a4eb07ce4334de237f1e99ccdc9..59aa2f0cdfad13835a96cfa344ae8be66f1c89f0 100644
--- a/src/main/java/view/FirefighterGrid.java
+++ b/src/main/java/view/FirefighterGrid.java
@@ -96,4 +96,5 @@ public class FirefighterGrid extends Canvas implements Grid<ViewElement>{
     private void clearBox(int row, int column){
         getGraphicsContext2D().clearRect(column * boxWidth,row * boxHeight, boxWidth, boxHeight);
     }
+
 }
\ No newline at end of file
diff --git a/src/main/java/view/ViewElement.java b/src/main/java/view/ViewElement.java
index ffb76112e1af543df5af41fa906082ef11be9967..ed16ed1465ca78a590cd05a9e438baaf950101ba 100644
--- a/src/main/java/view/ViewElement.java
+++ b/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), EMPTY(Color.WHITE) ,  CLOUD(Color.GRAY),  MOUNTAIN(Color.GRAY), ROCKY(Color.GRAY);
   final Color color;
   ViewElement(Color color) {
     this.color = color;
diff --git a/src/test/java/model/FirefighterBoardTest.java b/src/test/java/model/FirefighterBoardTest.java
index 25cc8dbca8acea698879df68a5006a179f281ecc..b9db2fd319c61d7369c42c16231163ec683b2e5a 100644
--- a/src/test/java/model/FirefighterBoardTest.java
+++ b/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);
+    FirefighterBoard board = new FirefighterBoard(20, 10, 1, 3);
     assertThat(board.columnCount()).isEqualTo(20);
   }
   @Test
   void testRowCount(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    FirefighterBoard board = new FirefighterBoard(20, 10, 1, 3);
     assertThat(board.rowCount()).isEqualTo(10);
   }
   @Test
   void testStepNumber(){
-    Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
+    FirefighterBoard board = new FirefighterBoard(20, 10, 1, 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);
+    FirefighterBoard board = new FirefighterBoard(20, 10, 0, 0);
     Position position = new Position(1,2);
     assertThat(board.getState(position)).isEmpty();
     board.setState(List.of(ModelElement.FIRE), position);