diff --git a/src/main/java/app/SimulatorApplication.java b/src/main/java/app/SimulatorApplication.java
index 86abb8525b4a41c5a54cea60981c01025d5ae3f8..a3b7996590737c56174cfc1539078b8028b19bbe 100644
--- a/src/main/java/app/SimulatorApplication.java
+++ b/src/main/java/app/SimulatorApplication.java
@@ -19,6 +19,7 @@ public class SimulatorApplication extends javafx.application.Application {
   private static final int BOX_HEIGHT = 25;
   public static final int INITIAL_FIRE_COUNT = 3;
   public static final int INITIAL_FIREFIGHTER_COUNT = 6;
+  public static final int INITIAL_CLOUD_COUNT = 6;
 
   private Stage primaryStage;
   private Parent view;
@@ -44,7 +45,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);
   }
 
   private void showScene() {
diff --git a/src/main/java/controller/Controller.java b/src/main/java/controller/Controller.java
index 154a1b81d01ae5805d59c55456aa57465a1e6b38..244f1381f64685a5307a517584e162e16b2aa1e6 100644
--- a/src/main/java/controller/Controller.java
+++ b/src/main/java/controller/Controller.java
@@ -62,9 +62,12 @@ public class Controller {
     List<Position> updatedPositions = board.updateToNextGeneration();
     List<Pair<Position, ViewElement>> updatedSquares = new ArrayList<>();
     for(Position updatedPosition : updatedPositions){
-      Entity squareState = board.getState(updatedPosition);
-      ViewElement viewElement = getViewElement(squareState);
-      updatedSquares.add(new Pair<>(updatedPosition, viewElement));
+      for (Entity e : board.getState(updatedPosition )){
+        Entity squareState = e;
+
+        ViewElement viewElement = getViewElement(squareState);
+        updatedSquares.add(new Pair<>(updatedPosition, viewElement));}
+
     }
     grid.repaint(updatedSquares);
     updateGenerationLabel(board.stepNumber());
@@ -76,7 +79,9 @@ public class Controller {
     ViewElement[][] viewElements = new ViewElement[rowCount][columnCount];
     for(int column = 0; column < columnCount; column++)
       for(int row = 0; row < rowCount; row++)
-        viewElements[row][column] = getViewElement(board.getState(new Position(row, column)));
+        for (Entity e : board.getState(new Position(row, column))) {
+          viewElements[row][column] = getViewElement(e);
+        }
     grid.repaint(viewElements);
     updateGenerationLabel(board.stepNumber());
   }
@@ -118,9 +123,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) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new FireFighterScenario(columnCount, rowCount, initialFireCount, initialFirefighterCount));
+    this.setModel(new FireFighterScenario(columnCount, rowCount, initialFireCount, initialFirefighterCount, initialCloudCount));
     repaintGrid();
   }
 
diff --git a/src/main/java/model/Board.java b/src/main/java/model/Board.java
index 1326ce88c7878fd042329c66fe7cdaa66941452f..beb1e8232823ed1ac938c4021e0ffcf1a01d404f 100644
--- a/src/main/java/model/Board.java
+++ b/src/main/java/model/Board.java
@@ -1,5 +1,6 @@
 package model;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import util.Position;
@@ -17,7 +18,7 @@ public interface Board<S> {
    * @param position The position on the board for which to retrieve the state.
    * @return The state at the specified position.
    */
-  S getState(Position position);
+  ArrayList<S> getState(Position position);
 
   /**
    * Set the state of a specific position on the board to the specified state.
diff --git a/src/main/java/model/Fire.java b/src/main/java/model/Fire.java
index 019137ed7268f5d7ff88db50ca42d89afdda1fb2..68856d9f0a5c27e6628580607c9e1dcde178e2a8 100644
--- a/src/main/java/model/Fire.java
+++ b/src/main/java/model/Fire.java
@@ -27,8 +27,8 @@ public class Fire implements Entity{
         if(board.getStepNumber() % 2 == 0)return new ArrayList<Position>();
         List<Position> positions = PositionUtil.generateAdjacentPositions(position, board);
         for(Position p : positions){
-            if(b.getState(p) instanceof EmptySquare){
-                if(b.getState(p).getAge() < b.getStepNumber()){
+            if(b.getState(p).contains(Fire.class)){
+                if(b.getState(p).get(b.getState(p).indexOf(Fire.class)).getAge() < b.getStepNumber()){
                     board.setState(new Fire(p, board), p);
                 }
             }
@@ -60,6 +60,7 @@ public class Fire implements Entity{
         return this.age;
     }
 
+
     @Override
     public void incrementAge() {
         this.age = age + 1 ;
diff --git a/src/main/java/model/FireFighter.java b/src/main/java/model/FireFighter.java
index e9f2afb2c450b85727fea9a8fba26778a4439fea..88236a8b7ab2165da064e725001f4b8538245af3 100644
--- a/src/main/java/model/FireFighter.java
+++ b/src/main/java/model/FireFighter.java
@@ -29,7 +29,7 @@ public class FireFighter implements Entity{
     
         // Vérifier s'il y a du feu dans une des positions adjacentes
         boolean hasFire = adjacentPositions.stream()
-                                           .anyMatch(p -> b.getState(p) instanceof Fire);
+                                           .anyMatch(p -> b.getState(p).contains(Fire.class));
     
         if (hasFire) {
             // Si du feu est trouvé, on éteint les feux adjacents
@@ -62,7 +62,7 @@ public class FireFighter implements Entity{
     private List<Position> extinguish(List<Position> adjacentPositions, Board<Entity> b) {
         List<Position> extinguishedPositions = new ArrayList<>();
         for (Position p : adjacentPositions) {
-            if (b.getState(p) instanceof Fire) {
+            if (b.getState(p).contains(Fire.class)) {
                 b.clearCase(p);
                 extinguishedPositions.add(p); // Ajouter la position où le feu a été éteint
             }
@@ -75,7 +75,7 @@ public class FireFighter implements Entity{
         List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(currentPos, b);
     
         // Filtrer les positions qui sont libres
-        possibleMoves.removeIf(p -> !(b.getState(p) instanceof EmptySquare));
+        possibleMoves.removeIf(p -> !(b.getState(p).contains(Fire.class)));
     
         // Si aucune position libre n'est disponible, retourner null
         if (possibleMoves.isEmpty()) {
diff --git a/src/main/java/model/FireFighterScenario.java b/src/main/java/model/FireFighterScenario.java
index ff4d8d870836c8a5a5b7dfd772adf1319f22662e..4a2b2d47458043dfd692c55b341b6bd8a0b90c82 100644
--- a/src/main/java/model/FireFighterScenario.java
+++ b/src/main/java/model/FireFighterScenario.java
@@ -15,20 +15,24 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
   private Matrix<Entity> matrix;
   private int step;
 
+  private int initialCloudCount;
   private int initialFireCount;
   private int initialFireFightersCount;
-  public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount) {
+
+  public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount, int initialCloudCount) {
     this.matrix = new Matrix<Entity>(columns, rows);
     this.initialFireCount = initialFireCount;
     this.initialFireFightersCount = initialFireFightersCount;
+    this.initialCloudCount = initialCloudCount; //ajout de l'init cloud
     initScenario(matrix);
-    placeInitialActors(initialFireCount, initialFireFightersCount);
+    placeInitialActors();
     this.step = 0;
   }
 
-  private void placeInitialActors(int initialFireCount, int initialFireFightersCount) {
+  private void placeInitialActors() {
     int fireCount = 0;
     int fireFighterCount = 0;
+    int cloudCount =0;
     int chance = 5; // Chance initiale en pourcentage
     Random random = new Random();
 
@@ -39,15 +43,15 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
       }
     }
 
-    while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount) {
+    while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount || cloudCount < initialCloudCount) {
       Collections.shuffle(positions); // Mélange les positions pour un parcours aléatoire
 
       for (Position pos : positions) {
-        if (getState(pos) instanceof EmptySquare) {
+        if (getState(pos).contains(EmptySquare.class)) {
           if (fireCount < initialFireCount && random.nextInt(100) < chance) {
             setState(new Fire(pos, this, 1), pos);
             fireCount++;
-            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount) {
+            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount) {
               return;
             }
             continue;
@@ -56,7 +60,15 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
           if (fireFighterCount < initialFireFightersCount && random.nextInt(100) < chance) {
             setState(new FireFighter(pos, this, 1), pos);
             fireFighterCount++;
-            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount) {
+            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount) {
+              return;
+            }
+          }
+
+          if (cloudCount < initialCloudCount && random.nextInt(100) < chance) {
+            setState(new cloud(pos, this, 1), pos);
+            cloudCount++;
+            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount) {
               return;
             }
           }
@@ -68,7 +80,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
     }
   }
 
-  public Entity getState(Position position) {
+  public ArrayList<Entity> getState(Position position) {
     if (position.x() > matrix.size() || position.y() > matrix.size()) {
       throw new IllegalArgumentException(
           "The position x:" + position.x() + " y:" + position.y() + " is out of the board.");
@@ -77,7 +89,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
   }
 
   public void setState(Entity state, Position position) {
-    if (!(getState(position) instanceof EmptySquare)) {
+    if (!(getState(position).getFirst() instanceof EmptySquare)) {
       return;
     }
     if (doesPositionExist(position)) {
@@ -86,7 +98,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
   }
 
   public void setState(Entity state, Position position, boolean replaceStates) {
-    if (!(getState(position) instanceof EmptySquare) && !replaceStates) {
+    if (!(getState(position).getFirst() instanceof EmptySquare) && !replaceStates) {
       return;
     }
     matrix.set(position.x(), position.y(), state);
@@ -108,19 +120,22 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
     ArrayList<Position> changedPositions = new ArrayList<>();
     Iterator<Entity> iterator = matrix.iterator();
     while (iterator.hasNext()) {
-      Entity e = iterator.next();
-      if (e instanceof EmptySquare)
-        continue;
-      if (e.getAge() == 0) {
+
+      ArrayList<Entity> entities = (ArrayList<Entity>) iterator.next();
+      for (Entity e : entities) {
+        if (e instanceof EmptySquare)
+          continue;
+        if (e.getAge() == 0) {
+          e.incrementAge();
+          continue;
+        }
+        if (e.getAge() == step + 1) {
+          continue;
+        }
+        List<Position> entityUpdatedPositions = e.nextTurn(this);
         e.incrementAge();
-        continue;
-      }
-      if(e.getAge() == step+1){
-        continue;
+        changedPositions.addAll(entityUpdatedPositions);
       }
-      List<Position> entityUpdatedPositions = e.nextTurn(this);
-      e.incrementAge();
-      changedPositions.addAll(entityUpdatedPositions);
     }
     return changedPositions;
   }
@@ -136,14 +151,16 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
     // Parcourir les distances croissantes à partir de 1
     for (int distance = 1; distance < maxDistance; distance++) {
       List<Position> positionsAtDistance = PositionUtil.getPositionsAtManhattanDistance(fromPos, distance, rows, cols);
-
+//ligne a verifier
       for (Position currentPos : positionsAtDistance) {
-        Entity currentEntity = matrix.get(currentPos.x(), currentPos.y());
-        if (entityType.isInstance(currentEntity)) {
-          // Dès qu'une entité est trouvée à cette distance, elle est la plus proche
-          // possible
-          return currentPos;
+        ArrayList<Entity> entitiesAtPos = matrix.get(currentPos.x(), currentPos.y());
+        if (!entitiesAtPos.isEmpty()) {
+          Entity currentEntity = entitiesAtPos.get(0);  // Récupérer le premier élément de la liste
+          if (entityType.isInstance(currentEntity)) {
+            return currentPos;
+          }
         }
+
       }
     }
 
@@ -155,7 +172,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity>
     step = 0;
     matrix.clear();
     initScenario(matrix);
-    placeInitialActors(initialFireCount, initialFireFightersCount);
+    placeInitialActors();
   }
 
   public int stepNumber() {
diff --git a/src/main/java/model/cloud.java b/src/main/java/model/cloud.java
new file mode 100644
index 0000000000000000000000000000000000000000..b11b9932d430732848f1c7bf298f8b8782812c63
--- /dev/null
+++ b/src/main/java/model/cloud.java
@@ -0,0 +1,94 @@
+package model;
+
+import javafx.scene.paint.Color;
+import util.Position;
+import util.PositionUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class cloud implements Entity{
+    private int age;
+    private final Color viewColor = Color.GREY;
+    private Position position;
+    Board<Entity> b;
+
+    public cloud (Position position, Board<Entity> b, int age){
+        this.age = age;
+        this.position = position;
+        this.b = b;
+    }
+
+
+
+    @Override
+    public List<Position> nextTurn(Board<Entity> b) {
+        List<Position> positions = new ArrayList<>();
+
+        // Générer les positions adjacentes valides
+        List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(position, b);
+
+        // Sélectionner une position aléatoire parmi les mouvements possibles
+        Position next_pos = possibleMoves.get(new Random().nextInt(possibleMoves.size()));
+
+        // Vérifier l'état de la nouvelle position
+        ArrayList<Entity> nextEntities = b.getState(next_pos);
+
+        positions.add(position);
+        positions.add(next_pos);
+
+        // Si la nouvelle position contient un feu, éteindre le feu
+        if (nextEntities.contains(Fire.class)) {
+            extinguish(List.of(next_pos), b);
+        }
+
+
+        b.setState(this, next_pos);
+
+
+
+        // Retourner la position mise à jour pour affichage ou suivi
+        return positions;
+    }
+
+
+
+
+    private List<Position> extinguish(List<Position> next_pos, Board<Entity> b) {
+        List<Position> extinguishedPositions = new ArrayList<>();
+
+        if (b.getState(next_pos.get(0)).contains(Fire.class)) {
+                b.clearCase(next_pos.get(0));
+                extinguishedPositions.add(next_pos.get(0));
+        }
+
+
+        return extinguishedPositions;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public void setPosition(Position p) {
+            this.position = p;
+    }
+
+    @Override
+    public int getAge() {
+        return this.age;
+    }
+
+    @Override
+    public void incrementAge() {
+        this.age += 1;
+    }
+
+    @Override
+    public Color getViewColor() {
+        return viewColor;
+    }
+}
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index 4c36d97709b342e457203c75d081fc5cc1955c0f..1bd3e9a86156ea98b4650fee627b4411b90ff3fd 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -2,7 +2,8 @@ module firefighter {
   requires javafx.controls;
   requires javafx.fxml;
   requires javafx.graphics;
-  opens controller to javafx.fxml;
+    requires java.sql;
+    opens controller to javafx.fxml;
   exports app;
   opens app to javafx.fxml;
 }
diff --git a/src/main/java/util/Matrix.java b/src/main/java/util/Matrix.java
index 6b5000be034cb782b77e941f7114ad37ab49b38d..dcd518a02498dc82f5c16d9fe866dae0d2bf170b 100644
--- a/src/main/java/util/Matrix.java
+++ b/src/main/java/util/Matrix.java
@@ -5,7 +5,7 @@ import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 public class Matrix<E> implements Iterable<E> {
-    private ArrayList<ArrayList<E>> matrix;
+    private ArrayList<ArrayList<ArrayList<E>>> matrix;
     private final int rows;
     private final int columns;
 
@@ -16,33 +16,37 @@ public class Matrix<E> implements Iterable<E> {
         
         // Initialiser chaque ligne de la matrice
         for (int i = 0; i < rows; i++) {
-            ArrayList<E> row = new ArrayList<>(columns);
+            ArrayList<ArrayList<E>> row = new ArrayList<>(columns);
+
             // Initialiser chaque colonne avec des valeurs nulles
             for (int j = 0; j < columns; j++) {
-                row.add(null);
+                row.add(new ArrayList<E>());
             }
             this.matrix.add(row);
         }
     }
 
-    public E get(int x, int y) {
+    public ArrayList<E> get(int x, int y) {
         validateIndex(x, y);
         return matrix.get(x).get(y);
     }
 
-    public E set(int x, int y, E object) {
+    public ArrayList<E> set(int x, int y, E object) {
         validateIndex(x, y);
-        return matrix.get(x).set(y, object);
+        ArrayList<E> previous_Entities = matrix.get(x).get(y);
+        matrix.get(x).get(y).add(object);
+        return previous_Entities;
+
     }
 
     public void clear() {
         this.matrix = new ArrayList<>(rows);
         // Initialiser chaque ligne de la matrice
         for (int i = 0; i < rows; i++) {
-            ArrayList<E> row = new ArrayList<>(columns);
+            ArrayList<ArrayList<E>> row = new ArrayList<>(columns);
             // Initialiser chaque colonne avec des valeurs nulles
             for (int j = 0; j < columns; j++) {
-                row.add(null);
+                row.add(new ArrayList<E>());
             }
             this.matrix.add(row);
         }
@@ -122,11 +126,23 @@ public class Matrix<E> implements Iterable<E> {
         }
 
         @Override
-        public E next() {
+        public E next(){
             if (!hasNext()) {
                 throw new NoSuchElementException();
             }
-            E element = matrix.get(row).get(col);
+            ArrayList<E> element = matrix.get(row).get(col);
+            col++;
+            if (col >= columns) {
+                col = 0;
+                row++;
+            }
+            return element.getFirst();
+        }
+    /*    public ArrayList<E> next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            ArrayList<E> element = matrix.get(row).get(col);
             col++;
             if (col >= columns) {
                 col = 0;
@@ -134,5 +150,8 @@ public class Matrix<E> implements Iterable<E> {
             }
             return element;
         }
+
+
+     */
     }
 }