diff --git a/src/main/java/model/FirefighterBoard.java b/src/main/java/model/FirefighterBoard.java
index 07d1c16d311d205e8a8bfa09f9a4ebe9378678a2..8cd860a6497647176be4efd55dceb2d1d84fa66a 100644
--- a/src/main/java/model/FirefighterBoard.java
+++ b/src/main/java/model/FirefighterBoard.java
@@ -178,4 +178,5 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
       }
     }
   }
-}
\ No newline at end of file
+
+}
diff --git a/src/main/java/newmodel/Case.java b/src/main/java/newmodel/Case.java
new file mode 100644
index 0000000000000000000000000000000000000000..072e391facf87b85817748f8581c665d8e608a52
--- /dev/null
+++ b/src/main/java/newmodel/Case.java
@@ -0,0 +1,4 @@
+package newmodel;
+
+public interface Case {
+}
diff --git a/src/main/java/newmodel/Extinguisher.java b/src/main/java/newmodel/Extinguisher.java
index 7901754f302ba7ee9aea3f4a909f5923fc82ed5e..5d5abacf6d40f598f71573490f6256479866ad5f 100644
--- a/src/main/java/newmodel/Extinguisher.java
+++ b/src/main/java/newmodel/Extinguisher.java
@@ -6,11 +6,12 @@ import util.Position;
 import java.util.List;
 
 public interface Extinguisher {
-    public List<Position> updateExtinguisher(Fboard board);
-    public void extinguish();
+    public List<Position> updateExtinguisher();
+    public void extinguish(Position position);
     public void setState();
     public String getState();
 
     public void initialize();
+    public List<Position> getPositions();
 
 }
diff --git a/src/main/java/newmodel/Fboard.java b/src/main/java/newmodel/Fboard.java
index 54012622fa95d3b5aaa638bf42fb0b527d23d6bf..d86ef42a8362783db2c3d98e327514eab8402cc2 100644
--- a/src/main/java/newmodel/Fboard.java
+++ b/src/main/java/newmodel/Fboard.java
@@ -1,29 +1,25 @@
 package newmodel;
 
+import model.ModelElement;
 import util.Position;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
+import java.util.*;
 
 public class Fboard {
-    private final int columnCount;
-    private final int rowCount;
-    private int step = 0;
-    private final Random randomGenerator = new Random();
 
-    private List<FireManager> fire;
-    private List<Extinguisher> extinguishe;
+    protected final int columnCount;
+    protected final int rowCount;
+    private int step = 0;
+    private FireManager fire;
+    private List<Extinguisher> extinguishers;
 
-    public Fboard(int columnCount, int rowCount) {
+    public Fboard(int columnCount, int rowCount, Fire fire ,List<Extinguisher> Extinguishers) {
         this.columnCount = columnCount;
         this.rowCount = rowCount;
-        this.fire=new ArrayList<>();
-        this.extinguishe=new ArrayList<>();
+        this.extinguishers=new ArrayList<>();
+        this.fire=fire;
+        extinguishers.addAll(Extinguishers);
         }
-    private Position randomPosition() {
-        return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
-    }
 
     public int rowCount() {
         return rowCount;
@@ -35,11 +31,9 @@ public class Fboard {
 
     public List<Position> updateToNextGeneration() {
         List<Position> result = new ArrayList<>();
-        for (FireManager f : fire) {
-           result.addAll(f.updateFire(this));
-        }
-        for(Extinguisher e : extinguishe) {
-            result.addAll(e.updateExtinguisher(this));
+           result.addAll(fire.updateFire());
+        for(Extinguisher e : extinguishers) {
+            result.addAll(e.updateExtinguisher());
         }
         step++;
         return result;
@@ -52,21 +46,66 @@ public class Fboard {
         step = 0;
         initializeElements();
     }
-    public void   initializeElements() {
-        for (FireManager f : fire) {
-            f.initialize();
-        }
-        for(Extinguisher e: extinguishe) {
+    public void initializeElements() {
+        fire.initialize();
+        for(Extinguisher e: extinguishers) {
             e.initialize();
         }
+    }
+    public int getStep(){
+        return step;
+    }
+    public int getColumnCount(){
+        return this.columnCount;
+    }
 
+    public int getRowCount(){
+        return this.rowCount;
+    }
 
-
-
+    public FireManager getFire(){
+        return this.fire;
     }
+    public List<Position> neighbors(Position position) {
+        List<Position> list = new ArrayList<>();
+        if (position.row() > 0) list.add(new Position(position.row() - 1, position.column()));
+        if (position.column() > 0) list.add(new Position(position.row(), position.column() - 1));
+        if (position.row() < rowCount - 1) list.add(new Position(position.row() + 1, position.column()));
+        if (position.column() < columnCount - 1) list.add(new Position(position.row(), position.column() + 1));
+        return list;
     }
 
+    public Position neighborClosestToFire(Position position) {
+        Set<Position> seen = new HashSet<>();
+        HashMap<Position, Position> firstMove = new HashMap<>();
+        Queue<Position> toVisit = new LinkedList<>(neighbors(position)); //Queue is initialised with the neighbors of position
+        for (Position initialMove : toVisit)
+            firstMove.put(initialMove, initialMove);
+        while (!toVisit.isEmpty()) {
+            Position current = toVisit.poll();
+            if (this.fire.getFirepositions().contains(current))
+                return firstMove.get(current);
+            for (Position adjacent : neighbors(current)) {
+                if (seen.contains(adjacent)) continue;
+                toVisit.add(adjacent);
+                seen.add(adjacent);
+                firstMove.put(adjacent, firstMove.get(current));
+            }
+        }
+        return position;
+    }
 
+    public List<String> getState(Position position){
+        List<String> result = new ArrayList<>();
+        for (Extinguisher e :extinguishers){
+            if (e.getPositions().equals(position)){
+                result.add(e.getState());
+            }
+        }
+        if(fire.containsFire(position))
+            result.add(fire.getState());
+        return result;
+    }
 
 
 }
diff --git a/src/main/java/newmodel/Fire.java b/src/main/java/newmodel/Fire.java
index 8326cb27e115b8ebbb5edf81847db8d09ae9a814..44532b09088819d6f2249666ad44eb3afe1302d3 100644
--- a/src/main/java/newmodel/Fire.java
+++ b/src/main/java/newmodel/Fire.java
@@ -2,36 +2,70 @@ package newmodel;
 
 import util.Position;
 
-import java.util.List;
+import java.util.*;
 
 public class Fire implements FireManager {
 
     private final int initialFireCount;
 
+    private Set<Position> firePositions;
+    private String state;
+    private final Random randomGenerator = new Random();
 
-    public Fire(int initialFireCount) {
+    private final Fboard board;
+    public Fire(int initialFireCount,Fboard b) {
         this.initialFireCount = initialFireCount;
+        this.board=b;
     }
 
-    @Override
-    public List<Position> updateFire(Fboard board) {
-        return null;
+
+    public List<Position> updateFire() {
+        List<Position> result = new ArrayList<>();
+        if (board.getStep() % 2 == 0) {
+            List<Position> newFirePositions = new ArrayList<>();
+            for (Position fire : firePositions) {
+                newFirePositions.addAll(board.neighbors(fire));
+            }
+            firePositions.addAll(newFirePositions);
+            result.addAll(newFirePositions);
+        }
+        return result;
+
     }
 
-    @Override
     public void setState() {
-
+        state="Fire";
     }
 
     @Override
     public String getState() {
-        return null;
+        return state;
     }
 
     @Override
     public void initialize() {
+        firePositions = new HashSet<>();
+        for (int index = 0; index < initialFireCount; index++)
+            firePositions.add(randomPosition());
+    }
+    public Position randomPosition() {
+        return new Position(randomGenerator.nextInt(board.rowCount), randomGenerator.nextInt(board.columnCount));
+    }
+
+    public void extinguish(Position position) {
+        firePositions.remove(position);
+    }
 
+    public Set<Position> getFirepositions(){
+        return firePositions;
     }
 
+    @Override
+    public boolean containsFire(Position position) {
+        if (firePositions.contains(position)) {
+            return true;
+        }
+        else return false;
+    }
 
 }
diff --git a/src/main/java/newmodel/FireFighter.java b/src/main/java/newmodel/FireFighter.java
index a73e3e46e236794790b1507e27bccf485e54b984..ce04b21553592726847cd858765cbc74295a2302 100644
--- a/src/main/java/newmodel/FireFighter.java
+++ b/src/main/java/newmodel/FireFighter.java
@@ -1,34 +1,68 @@
 package newmodel;
-
-import newmodel.Extinguisher;
-import newmodel.Fboard;
 import util.Position;
-
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Random;
 
 public class FireFighter implements Extinguisher {
-    @Override
-    public List<Position> updateExtinguisher(Fboard board) {
-        return null;
+    private String state;
+    private final Fboard board;
+    private List<Position> firefighterPositions;
+    private final Random randomGenerator = new Random();
+
+    private final int initialFirefighterCount;
+    public FireFighter(int initialFirefighterCount,Fboard b){
+        this.board=b;
+        this.initialFirefighterCount=initialFirefighterCount;
     }
 
-    @Override
-    public void extinguish() {
 
+    public List<Position> updateExtinguisher() {
+            List<Position> result = new ArrayList<>();
+            List<Position> firefighterNewPositions = new ArrayList<>();
+            for (Position firefighterPosition : firefighterPositions) {
+                Position newFirefighterPosition = board.neighborClosestToFire(firefighterPosition);
+                firefighterNewPositions.add(newFirefighterPosition);
+                extinguish(newFirefighterPosition);
+                result.add(firefighterPosition);
+                result.add(newFirefighterPosition);
+                List<Position> neighborFirePositions = board.neighbors(newFirefighterPosition).stream()
+                        .filter(board.getFire().getFirepositions()::contains).toList(); //this code create a list filtred with only the fire positions that are close to the newfirefighter position
+                for(Position firePosition : neighborFirePositions) //and exist in the firepositions list also
+                    extinguish(firePosition);
+                result.addAll(neighborFirePositions);
+            }
+            firefighterPositions = firefighterNewPositions;
+            return result;
+        }
+
+
+    public void extinguish(Position position) {
+        this.board.getFire().extinguish(position);
     }
 
-    @Override
-    public void setState() {
 
+    public void setState() {
+        state="FireFighter";
     }
 
-    @Override
+
     public String getState() {
-        return null;
+        return state;
     }
 
-    @Override
     public void initialize() {
+        firefighterPositions = new ArrayList<>();
+        for (int index = 0; index < initialFirefighterCount; index++)
+            firefighterPositions.add(randomPosition());
+    }
+    private Position randomPosition() {
+        return new Position(randomGenerator.nextInt(board.rowCount), randomGenerator.nextInt(board.columnCount));
+    }
 
+    public List<Position> getPositions(){
+        return this.firefighterPositions;
     }
+
 }
+
diff --git a/src/main/java/newmodel/FireManager.java b/src/main/java/newmodel/FireManager.java
index e7fc7694a55d7be763581062e35a41a5649bb492..11969a89057c71a6fee5e9e3e2b8d55a68434dcf 100644
--- a/src/main/java/newmodel/FireManager.java
+++ b/src/main/java/newmodel/FireManager.java
@@ -4,11 +4,16 @@ import newmodel.Fboard;
 import util.Position;
 
 import java.util.List;
+import java.util.Set;
 
 public interface FireManager {
-    public List<Position> updateFire(Fboard board);
+    public List<Position> updateFire();
     public void setState();
     public String getState();
-
+    public void extinguish(Position position);
     public void initialize();
+
+    public Set<Position> getFirepositions();
+
+    public boolean containsFire(Position position);
 }
diff --git a/src/main/java/newmodel/MotoFireFighter.java b/src/main/java/newmodel/MotoFireFighter.java
new file mode 100644
index 0000000000000000000000000000000000000000..040ef171f85ae16821a337e59a50d7e4753d0c49
--- /dev/null
+++ b/src/main/java/newmodel/MotoFireFighter.java
@@ -0,0 +1,4 @@
+package newmodel;
+
+public class MotoFireFighter {
+}
diff --git a/src/main/java/newmodel/Nuages.java b/src/main/java/newmodel/Nuages.java
new file mode 100644
index 0000000000000000000000000000000000000000..340f966e7955198eb4b1ec7137ba82d09d0120c9
--- /dev/null
+++ b/src/main/java/newmodel/Nuages.java
@@ -0,0 +1,56 @@
+package newmodel;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Nuages implements Extinguisher{
+    private String state;
+    private final Fboard board;
+    private List<Position> nuagesPositions;
+    private final Random randomGenerator = new Random();
+
+    private final int initialNuagesCount;
+
+    public Nuages(int initialNuagesCount,Fboard b){
+        this.initialNuagesCount=initialNuagesCount;
+        this.board=b;
+    }
+
+    public List<Position> updateExtinguisher() {
+
+    }
+
+
+    public void extinguish(Position position) {
+        this.board.getFire().extinguish(position);
+    }
+
+
+    public void setState() {
+     state="Nuage";
+    }
+
+
+    public String getState() {
+        return state;
+    }
+
+
+    public void initialize() {
+        nuagesPositions = new ArrayList<>();
+        for (int index = 0; index < initialNuagesCount; index++)
+            nuagesPositions.add(randomPosition());
+    }
+
+
+
+    public List<Position> getPositions() {
+        return null;
+    }
+    private Position randomPosition() {
+        return new Position(randomGenerator.nextInt(board.rowCount), randomGenerator.nextInt(board.columnCount));
+    }
+}