Add movements classes which implements mouvements

src/main/java/app/SimulatorApplication.java

@@ -17,7 +17,7 @@ public class SimulatorApplication extends javafx.application.Application {
   private static final int COLUMN_COUNT = 20;
   private static final int BOX_WIDTH = 50;
   private static final int BOX_HEIGHT = 50;
-  public static final int INITIAL_FIRE_COUNT = 4;
+  public static final int INITIAL_FIRE_COUNT = 10;
   public static final int INITIAL_FIREFIGHTER_COUNT = 3;
   public static final int INITIAL_CLOUD_COUNT = 3;
   public static final int INITIAL_MOTORIZED_COUNT = 3;

src/main/java/model/BoardFireFighterBehavior.java

@@ -6,60 +6,36 @@ import util.TargetStrategy;
 import java.util.*;
 
 public class BoardFireFighterBehavior implements BoardBehavior{
-    private final TargetStrategy targetStrategy = new TargetStrategy();
-    private final Map<Position, List<Position>> neighbors;
-    private List<Position> firefighterPositions;
-    private List<Position> motorizedFighters;
-    private List<Position> rocky;
-    private Set<Position> firePositions;
-    private final ElementFactory<FireFighter> firefighterFactory;
-    private final ElementFactory<Fire> fireFactory;
-    private final ElementFactory<Cloud> cloudFactory;
-    private final ElementFactory<MotorizedFireFighter> motorizedFactory;
+    private static TargetStrategy targetStrategy = new TargetStrategy();
+    private static Map<Position, List<Position>> neighbors;
+
+    private static List<Position> rocky;
+
     private ElementFactory<Rocky> rockyFactory;
-    private List<Position> cloudPositions;
-    private final Map<Position, Terrain> terrainMap = new HashMap<>();
-    private int step;
+    private static  Map<Position, Terrain> terrainMap = new HashMap<>();
+    private static int step;
+    static Movements fireMovements ;
+    static Movements fireFighterMovements;
+    static Movements cloudMovements;
+    static Movements motorizedMovements;
 
     public BoardFireFighterBehavior(Map<Position, List<Position>> neighbors, ElementFactory<Fire> fireFactory ,ElementFactory<FireFighter> firefighterFactory,
                                     ElementFactory<Cloud> cloudFactory,ElementFactory<MotorizedFireFighter> motorizedFactory,ElementFactory<Rocky> rockyFactory) {
         this.step=0;
         this.neighbors = neighbors;
-        this.firefighterFactory = firefighterFactory;
-        this.fireFactory = fireFactory;
-        this.cloudFactory=cloudFactory;
-        this.motorizedFactory=motorizedFactory;
         this.rockyFactory=rockyFactory;
+        fireMovements=new FireMovements(fireFactory);
+        fireFighterMovements=new FireFighterMovements(firefighterFactory);
+        cloudMovements=new CloudMovements(cloudFactory);
+        motorizedMovements=new MotorizedMovements(motorizedFactory);
     }
 
     public void initializeElements(int rowCount, int columnCount) {
-        // Feux
-        firePositions = new HashSet<>();
-        List<Fire> fires = fireFactory.createElements(rowCount, columnCount);
-        for (Fire fire : fires) {
-            firePositions.add(fire.getPosition());
-        }
-
-        // Pompiers
-        firefighterPositions = new ArrayList<>();
-        List<FireFighter> firefighters = firefighterFactory.createElements(rowCount, columnCount);
-        for (FireFighter firefighter : firefighters) {
-            firefighterPositions.add(firefighter.getPosition());
-        }
-
-
-        // Nuages
-        cloudPositions = new ArrayList<>();
-        List<Cloud> clouds = cloudFactory.createElements(rowCount, columnCount);
-        for (Cloud cloud : clouds) {
-            cloudPositions.add(cloud.getPosition());
-        }
+         fireMovements.initializeElement(rowCount,columnCount);
+         fireFighterMovements.initializeElement(rowCount,columnCount);
+         cloudMovements.initializeElement(rowCount,columnCount);
         // Pompiers motorisés
-        motorizedFighters = new ArrayList<>();
-        List<MotorizedFireFighter> motorizedFirefighters = motorizedFactory.createElements(rowCount, columnCount);
-        for (MotorizedFireFighter motorizedFirefighter : motorizedFirefighters) {
-            motorizedFighters.add(motorizedFirefighter.getPosition());
-        }
+        motorizedMovements.initializeElement(rowCount,columnCount);
         // Rocky
         rocky = new ArrayList<>();
         List<Rocky> rockies = rockyFactory.createElements(rowCount, columnCount);
@@ -73,146 +49,20 @@ public class BoardFireFighterBehavior implements BoardBehavior{
     }
 
 
-    public List<Position> updateFires() {
-        List<Position> modifiedPositions = new ArrayList<>();
-        if (step % 2 == 0) {
-            List<Position> newFirePositions = new ArrayList<>();
-
-            // Pour chaque feu existant, vérifier ses voisins
-            for (Position fire : firePositions) {
-                // Si la position voisine est libre (non occupée par un feu ou un pompier), le feu peut se propager
-                for (Position neighbor : neighbors.get(fire)) {
-                    // Vérifier si le feu peut se propager à cette position (pas de feu déjà là et pas un terrain bloqué)
-                    if (canMoveTo(neighbor, firePositions, firefighterPositions) && !firePositions.contains(neighbor)) {
-                        newFirePositions.add(neighbor);
-                    }
-                }
-            }
-
-            // Ajouter les nouvelles positions de feu à la liste des feux existants
-            firePositions.addAll(newFirePositions);
-            modifiedPositions.addAll(newFirePositions);
-        }
-        return modifiedPositions;
-    }
-
-
-    public List<Position> updateFirefighters() {
-        List<Position> modifiedPositions = new ArrayList<>();
-        List<Position> newFirefighterPositions = new ArrayList<>();
 
-        for (Position firefighterPosition : firefighterPositions) {
-            // Calcul de la position vers laquelle le pompier devrait se déplacer
-            Position newFirefighterPosition = targetStrategy.neighborClosestToTarget(firefighterPosition, firePositions, neighbors);
-
-            // Vérification si la position cible est valide pour le mouvement
-            if (canMoveTo(newFirefighterPosition, firePositions, firefighterPositions)) {
-                // Si le déplacement est valide, on met à jour la position du pompier
-                newFirefighterPositions.add(newFirefighterPosition);
-
-                // Éteindre le feu à la nouvelle position
-                extinguish(newFirefighterPosition);
-                modifiedPositions.add(firefighterPosition);
-                modifiedPositions.add(newFirefighterPosition);
-
-                // Vérification des voisins et extinction des feux voisins
-                List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
-                        .filter(firePositions::contains).toList();
-
-                // Log pour débogage
-                System.out.println("Pompiers se déplacent de " + firefighterPosition + " vers " + newFirefighterPosition);
-
-                // Éteindre les feux voisins
-                for (Position firePosition : neighborFirePositions) {
-                    extinguish(firePosition);
-                    modifiedPositions.add(firePosition);  // Ajout des feux éteints dans la liste des positions modifiées
-                }
-            } else {
-                // Si la position n'est pas valide, le pompier reste sur place
-                newFirefighterPositions.add(firefighterPosition);
-                System.out.println("Pompier ne peut pas se déplacer à " + newFirefighterPosition + ", il reste à " + firefighterPosition);
-            }
-        }
-
-        // Mettre à jour la liste des positions des pompiers
-        firefighterPositions = newFirefighterPositions;
-        return modifiedPositions;
-    }
-
-    public List<Position> updateMotorized() {
-        List<Position> modifiedPositions = new ArrayList<>();
-        List<Position> newPositions = new ArrayList<>();
-
-        for (Position currentPosition : motorizedFighters) {
-            // Vérification de validité de la position actuelle
-            if (!neighbors.containsKey(currentPosition)) {
-                System.err.println("Position actuelle invalide : " + currentPosition);
-                newPositions.add(currentPosition);
-                continue;
-            }
-
-            // Étape 1 : Calcul du premier déplacement
-            Position firstStep = targetStrategy.neighborClosestToTarget(currentPosition, firePositions, neighbors);
-            if (firstStep == null || !neighbors.containsKey(firstStep)) {
-                // Aucun déplacement possible, rester sur place
-                System.out.println("Pas de première étape possible pour : " + currentPosition);
-                newPositions.add(currentPosition);
-                continue;
-            }
-
-            // Étape 2 : Calcul du deuxième déplacement
-            Position secondStep = targetStrategy.neighborClosestToTarget(firstStep, firePositions, neighbors);
-            Position finalPosition = (secondStep != null && neighbors.containsKey(secondStep)) ? secondStep : firstStep;
-
-            // Ajout de la position finale aux nouvelles positions
-            newPositions.add(finalPosition);
-
-            // Mise à jour des positions modifiées
-            modifiedPositions.add(currentPosition);  // Ancienne position
-            modifiedPositions.add(finalPosition);    // Nouvelle position
-
-            // Étape 3 : Éteindre les feux à la position finale
-            extinguish(finalPosition);
-            extinguishNearbyFires(finalPosition, modifiedPositions);
-        }
-
-        // Mettre à jour les positions globales
-        motorizedFighters = newPositions;
-        return modifiedPositions;
-    }
-
-    /**
-     * Éteint les feux à proximité d'une position donnée.
-     *
-     * @param firefighterPosition La position actuelle du pompier.
-     * @param modifiedPositions   Les positions modifiées pendant ce tour.
-     */
-    private void extinguishNearbyFires(Position firefighterPosition, List<Position> modifiedPositions) {
-        List<Position> nearbyFires = neighbors.getOrDefault(firefighterPosition, Collections.emptyList())
-                .stream()
-                .filter(firePositions::contains)
-                .toList();
-        for (Position fire : nearbyFires) {
-            firePositions.remove(fire);
-            modifiedPositions.add(fire);
-            System.out.println("Feu éteint à : " + fire);
-        }
-    }
 
 
-    private void extinguish(Position position) {
-        firePositions.remove(position);
+    public static void extinguish(Position position) {
+        fireMovements.getPositions().remove(position);
     }
 
 
 
     public Set<Position> getFirePositions() {
-        return firePositions;
+        return (Set<Position>) fireMovements.getPositions();
     }
 
-    public List<Position> getFirefighterPositions() {
-        return firefighterPositions;
-    }
+
 
     public void incrementStep() {
         step++;
@@ -226,10 +76,10 @@ public class BoardFireFighterBehavior implements BoardBehavior{
 
     @Override
     public List<Position> updateToNextGeneration() {
-        List<Position> modifiedPositions = updateFirefighters();
-        modifiedPositions.addAll(updateFires());
-        modifiedPositions.addAll(updateClouds());
-        modifiedPositions.addAll(updateMotorized());
+        List<Position> modifiedPositions = fireFighterMovements.updateElements();
+        modifiedPositions.addAll(fireMovements.updateElements());
+        modifiedPositions.addAll(cloudMovements.updateElements());
+        modifiedPositions.addAll(motorizedMovements.updateElements());
         incrementStep();
         return modifiedPositions;
     }
@@ -237,45 +87,16 @@ public class BoardFireFighterBehavior implements BoardBehavior{
     @Override
     public void reset() {
         this.step=0;
-    }
-    public List<Position> updateClouds() {
-        List<Position> modifiedPositions = new ArrayList<>();
-        List<Position> newCloudPositions = new ArrayList<>();
-
-        for (Position cloudPosition : cloudPositions) {
-            // Déplacement aléatoire
-            List<Position> possibleMoves = neighbors.get(cloudPosition);
-            Position newCloudPosition = possibleMoves.get(new Random().nextInt(possibleMoves.size()));
-
-            // Vérification que le nuage ne se déplace pas vers une montagne
-            if (!canMoveTo(newCloudPosition, firePositions, firefighterPositions)) {
-                continue;  // Si la position est invalide ou une montagne, le nuage reste sur place
-            }
-
-            newCloudPositions.add(newCloudPosition);
-
-            // Éteindre le feu à la position du nuage (le nuage mange le feu)
-            if (firePositions.contains(newCloudPosition)) {
-                extinguish(newCloudPosition);  // Supprimer le feu
-                modifiedPositions.add(newCloudPosition);  // Ajouter la position du feu éteint aux positions modifiées
-                System.out.println("Feu éteint par nuage à : " + newCloudPosition);
-            }
-
-            modifiedPositions.add(cloudPosition);  // Ajouter l'ancienne position du nuage
-            modifiedPositions.add(newCloudPosition);  // Ajouter la nouvelle position du nuage
-        }
 
-        cloudPositions = newCloudPositions;
-        return modifiedPositions;
     }
 
 
-    public List<Position> getCloudPositions() {
-        return cloudPositions;
+    public Collection<Position> getCloudPositions() {
+        return cloudMovements.getPositions();
     }
 
     public List<Position> getMotorizedFighters() {
-        return motorizedFighters;
+        return (List<Position>) motorizedMovements.getPositions();
     }
     private void generateMountainBlocks(int rowCount, int columnCount) {
         Random random = new Random();
@@ -317,11 +138,28 @@ public class BoardFireFighterBehavior implements BoardBehavior{
             }
         }
     }
+    /**
+     * Éteint les feux à proximité d'une position donnée.
+     *
+     * @param firefighterPosition La position actuelle du pompier.
+     * @param modifiedPositions   Les positions modifiées pendant ce tour.
+     */
+    public static void extinguishNearbyFires(Position firefighterPosition, List<Position> modifiedPositions) {
+        List<Position> nearbyFires = getNeighbors().getOrDefault(firefighterPosition, Collections.emptyList())
+                .stream()
+                .filter(fireMovements.getPositions()::contains)
+                .toList();
+        for (Position fire : nearbyFires) {
+            fireMovements.getPositions().remove(fire);
+            modifiedPositions.add(fire);
+            System.out.println("Feu éteint à : " + fire);
+        }
+    }
 
     public Map<Position, Terrain> getTerrainMap() {
         return terrainMap;
     }
-    public boolean canMoveTo(Position position, Set<Position> firePositions, List<Position> firefighterPositions) {
+    public static boolean canMoveTo(Position position, Set<Position> firePositions, List<Position> firefighterPositions) {
         // Vérifie si la position est hors des limites (par exemple, en dehors de la grille ou inaccessible)
         if (!neighbors.containsKey(position)) {
             return false;
@@ -338,7 +176,7 @@ public class BoardFireFighterBehavior implements BoardBehavior{
         }
 
         // Si la position est une montagne, aucun élément ne peut la franchir sauf les nuages
-        if (terrainMap.get(position) != null && !cloudPositions.contains(position)) {
+        if (terrainMap.get(position) != null && !cloudMovements.getPositions().contains(position)) {
             return false;  // Impossible de franchir une montagne, sauf pour un nuage
         }
         if(rocky.contains(position))
@@ -389,7 +227,33 @@ public class BoardFireFighterBehavior implements BoardBehavior{
         }
     }
 
+
     public List<Position> getRocky() {
         return rocky;
     }
+
+    public static int getStep() {
+        return step;
+    }
+
+    public static Map<Position, List<Position>> getNeighbors() {
+        return neighbors;
+    }
+
+    public static Movements getFireMovements() {
+        return fireMovements;
+    }
+
+    public static TargetStrategy getTargetStrategy() {
+        return targetStrategy;
+    }
+
+    public static Movements getFireFighterMovements() {
+        return fireFighterMovements;
+    }
+
+
+    public Collection<Position> getFirefighterPositions() {
+        return fireFighterMovements.getPositions();
+    }
 }

src/main/java/model/CloudMovements.java

+package model;
+
+import util.Position;
+
+import java.util.*;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class CloudMovements implements Movements{
+    private  List<Position> cloudPositions;
+    private final ElementFactory<Cloud> cloudFactory;
+     public CloudMovements(ElementFactory<Cloud> cloudFactory) {
+        this.cloudPositions = new ArrayList<>();
+        this.cloudFactory = cloudFactory;
+    }
+    @Override
+    public void initializeElement(int rowCount, int columnCount) {
+        // Nuages
+        cloudPositions = new ArrayList<>();
+        List<Cloud> clouds = cloudFactory.createElements(rowCount, columnCount);
+        for (Cloud cloud : clouds) {
+            cloudPositions.add(cloud.getPosition());
+        }
+    }
+
+
+    @Override
+    public List<Position> updateElements() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        List<Position> newCloudPositions = new ArrayList<>();
+
+        for (Position cloudPosition : cloudPositions) {
+            // Déplacement aléatoire
+            List<Position> possibleMoves = getNeighbors().get(cloudPosition);
+            Position newCloudPosition = possibleMoves.get(new Random().nextInt(possibleMoves.size()));
+
+            // Vérification que le nuage ne se déplace pas vers une montagne
+            if (!canMoveTo(newCloudPosition, (Set<Position>) fireMovements.getPositions(), (List<Position>) fireFighterMovements.getPositions())) {
+                continue;  // Si la position est invalide ou une montagne, le nuage reste sur place
+            }
+
+            newCloudPositions.add(newCloudPosition);
+
+            // Éteindre le feu à la position du nuage (le nuage mange le feu)
+            if (fireMovements.getPositions().contains(newCloudPosition)) {
+                extinguish(newCloudPosition);  // Supprimer le feu
+                modifiedPositions.add(newCloudPosition);  // Ajouter la position du feu éteint aux positions modifiées
+                System.out.println("Feu éteint par nuage à : " + newCloudPosition);
+            }
+
+            modifiedPositions.add(cloudPosition);  // Ajouter l'ancienne position du nuage
+            modifiedPositions.add(newCloudPosition);  // Ajouter la nouvelle position du nuage
+        }
+
+        cloudPositions = newCloudPositions;
+        return modifiedPositions;
+    }
+
+
+
+
+
+    @Override
+    public Collection<Position> getPositions() {
+        return cloudPositions;
+    }
+}

src/main/java/model/FireFactory.java

@@ -29,6 +29,7 @@ public class FireFactory implements ElementFactory<Fire>,PositionGenerator{
             Position randomPosition = generateRandomPosition(rowCount, columnCount);
             boolean add = fires.add(new Fire(randomPosition));
         }
+        System.out.println(fires.size());
         return fires;
     }
 

src/main/java/model/FireFighterMovements.java

+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class FireFighterMovements implements Movements{
+    private final ElementFactory<FireFighter> firefighterFactory;
+    private  List<Position> firefighterPositions;
+    public FireFighterMovements(ElementFactory<FireFighter> firefighterFactory) {
+        this.firefighterFactory = firefighterFactory;
+        this.firefighterPositions = new ArrayList<>();
+    }
+
+
+
+    @Override
+    public List<Position> updateElements() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        List<Position> newFirefighterPositions = new ArrayList<>();
+
+        for (Position firefighterPosition : firefighterPositions) {
+            // Calcul de la position vers laquelle le pompier devrait se déplacer
+            Position newFirefighterPosition =getTargetStrategy().neighborClosestToTarget(firefighterPosition, fireMovements.getPositions(), getNeighbors());
+
+            // Vérification si la position cible est valide pour le mouvement
+            if (canMoveTo(newFirefighterPosition, (Set<Position>) fireMovements.getPositions(), firefighterPositions)) {
+                // Si le déplacement est valide, on met à jour la position du pompier
+                newFirefighterPositions.add(newFirefighterPosition);
+
+                // Éteindre le feu à la nouvelle position
+                extinguish(newFirefighterPosition);
+                modifiedPositions.add(firefighterPosition);
+                modifiedPositions.add(newFirefighterPosition);
+
+                // Vérification des voisins et extinction des feux voisins
+                List<Position> neighborFirePositions = getNeighbors().get(newFirefighterPosition).stream()
+                        .filter(fireMovements.getPositions()::contains).toList();
+
+                // Log pour débogage
+                System.out.println("Pompiers se déplacent de " + firefighterPosition + " vers " + newFirefighterPosition);
+
+                // Éteindre les feux voisins
+                for (Position firePosition : neighborFirePositions) {
+                    extinguish(firePosition);
+                    modifiedPositions.add(firePosition);  // Ajout des feux éteints dans la liste des positions modifiées
+                }
+            } else {
+                // Si la position n'est pas valide, le pompier reste sur place
+                newFirefighterPositions.add(firefighterPosition);
+                System.out.println("Pompier ne peut pas se déplacer à " + newFirefighterPosition + ", il reste à " + firefighterPosition);
+            }
+        }
+
+        // Mettre à jour la liste des positions des pompiers
+        firefighterPositions = newFirefighterPositions;
+        return modifiedPositions;
+    }
+
+    @Override
+    public void initializeElement(int rowCount, int columnCount) {
+        // Pompiers
+        firefighterPositions = new ArrayList<>();
+        List<FireFighter> firefighters = firefighterFactory.createElements(rowCount, columnCount);
+        for (FireFighter firefighter : firefighters) {
+            firefighterPositions.add(firefighter.getPosition());
+        }
+    }
+
+    @Override
+    public Collection<Position> getPositions() {
+        return firefighterPositions;
+    }
+}

src/main/java/model/FireMovements.java

+package model;
+
+import util.Position;
+
+import java.util.*;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class FireMovements implements Movements{
+    private final ElementFactory<Fire> fireFactory;
+    private Set<Position> firePositions;
+
+
+    public FireMovements(ElementFactory<Fire> fireFactory) {
+        this.fireFactory = fireFactory;
+        this.firePositions = new HashSet<>();
+    }
+
+
+
+    @Override
+    public void initializeElement(int rowCount, int columnCount) {
+        // Feux
+
+            List<Fire> fires = fireFactory.createElements(rowCount, columnCount);
+            for (Fire fire : fires) {
+               firePositions.add(fire.getPosition());
+            }
+
+
+
+    }
+
+    @Override
+    public Collection<Position> getPositions() {
+        return firePositions;
+    }
+
+    @Override
+    public List<Position> updateElements() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        if (getStep() % 2 == 0) {
+            List<Position> newFirePositions = new ArrayList<>();
+
+            // Pour chaque feu existant, vérifier ses voisins
+            for (Position fire : firePositions) {
+                // Si la position voisine est libre (non occupée par un feu ou un pompier), le feu peut se propager
+                for (Position neighbor : getNeighbors().get(fire)) {
+                    // Vérifier si le feu peut se propager à cette position (pas de feu déjà là et pas un terrain bloqué)
+                    if (canMoveTo(neighbor, firePositions, (List<Position>) getFireFighterMovements().getPositions()) && !firePositions.contains(neighbor)) {
+                        newFirePositions.add(neighbor);
+                    }
+                }
+            }
+
+            // Ajouter les nouvelles positions de feu à la liste des feux existants
+            firePositions.addAll(newFirePositions);
+            modifiedPositions.addAll(newFirePositions);
+        }
+        return modifiedPositions;
+    }
+
+
+}

src/main/java/model/FirefighterBoard.java

@@ -53,7 +53,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
             .forEach(pos -> result.add(new Fire(pos))); // Créer un objet Fire à partir de Position
 
     // Filtrage des éléments Firefighter (en transformant les positions en objets FireFighter)
-    behavior.getFirefighterPositions().stream()
+    behavior.getFireFighterMovements().getPositions().stream()
             .filter(pos -> pos.isAtPosition(position)) // Vérifier si la position correspond
             .forEach(pos -> result.add(new FireFighter(pos))); // Créer un objet Firefighter à partir de Position
     // Filtrage des éléments Cloud

src/main/java/model/InitializeElements.java

-package model;
-
-public interface InitializeElements {
-    public void initializeElement(int rowCount, int columnCount);
-}

src/main/java/model/MotorizedMovements.java

+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import static model.BoardFireFighterBehavior.*;
+
+public class MotorizedMovements implements Movements{
+    private final ElementFactory<MotorizedFireFighter> motorizedFactory;
+    private List<Position> motorizedFighters;
+
+    public MotorizedMovements(ElementFactory<MotorizedFireFighter> motorizedFactory) {
+        this.motorizedFactory = motorizedFactory;
+        this.motorizedFighters = new ArrayList<>();
+    }
+
+    @Override
+    public List<Position> updateElements() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        List<Position> newPositions = new ArrayList<>();
+
+        for (Position currentPosition : motorizedFighters) {
+            // Vérification de validité de la position actuelle
+            if (!getNeighbors().containsKey(currentPosition)) {
+                System.err.println("Position actuelle invalide : " + currentPosition);
+                newPositions.add(currentPosition);
+                continue;
+            }
+
+            // Étape 1 : Calcul du premier déplacement
+            Position firstStep = getTargetStrategy().neighborClosestToTarget(currentPosition, fireMovements.getPositions(), getNeighbors());
+            if (firstStep == null || !getNeighbors().containsKey(firstStep)) {
+                // Aucun déplacement possible, rester sur place
+                System.out.println("Pas de première étape possible pour : " + currentPosition);
+                newPositions.add(currentPosition);
+                continue;
+            }
+
+            // Étape 2 : Calcul du deuxième déplacement
+            Position secondStep = getTargetStrategy().neighborClosestToTarget(firstStep, fireMovements.getPositions(), getNeighbors());
+            Position finalPosition = (secondStep != null && getNeighbors().containsKey(secondStep)) ? secondStep : firstStep;
+
+            // Ajout de la position finale aux nouvelles positions
+            newPositions.add(finalPosition);
+
+            // Mise à jour des positions modifiées
+            modifiedPositions.add(currentPosition);  // Ancienne position
+            modifiedPositions.add(finalPosition);    // Nouvelle position
+
+            // Étape 3 : Éteindre les feux à la position finale
+            extinguish(finalPosition);
+            extinguishNearbyFires(finalPosition, modifiedPositions);
+        }
+
+        // Mettre à jour les positions globales
+        motorizedFighters = newPositions;
+        return modifiedPositions;
+    }
+
+    @Override
+    public void initializeElement(int rowCount, int columnCount) {
+        motorizedFighters = new ArrayList<>();
+        List<MotorizedFireFighter> motorizedFirefighters = motorizedFactory.createElements(rowCount, columnCount);
+        for (MotorizedFireFighter motorizedFirefighter : motorizedFirefighters) {
+            motorizedFighters.add(motorizedFirefighter.getPosition());
+        }
+
+    }
+
+    @Override
+    public Collection<Position> getPositions() {
+       return this.motorizedFighters;
+    }
+
+}