src/main/java/model/BoardElement.java

+package model;
+
+import util.Position;
+
+public abstract class BoardElement implements ModelElement{
+    protected Position position;
+
+    public BoardElement(Position position) {
+        this.position = position;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+    public boolean isAtPosition(Position position) {
+        return this.position.equals(position);
+    }
+
+    public abstract String getType(); // Ajout de la méthode abstraite
+
+
+    public abstract String toString();
+}

src/main/java/model/BoardFireFighterBehavior.java

+package model;
+
+import util.Position;
+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 Set<Position> firePositions;
+    private final ElementFactory<FireFighter> firefighterFactory;
+    private final ElementFactory<Fire> fireFactory;
+    private int step;
+
+    public BoardFireFighterBehavior(Map<Position, List<Position>> neighbors, ElementFactory<Fire> fireFactory ,ElementFactory<FireFighter> firefighterFactory) {
+        this.step=0;
+        this.neighbors = neighbors;
+        this.firefighterFactory = firefighterFactory;
+        this.fireFactory = fireFactory;
+    }
+
+    public void initializeElements(int rowCount, int columnCount) {
+        // Utilisation de la factory pour créer les feux
+        firePositions = new HashSet<>();
+        List<Fire> fires = fireFactory.createElements(rowCount, columnCount);
+        for (Fire fire : fires) {
+            firePositions.add(fire.getPosition());
+        }
+
+        // Utilisation de la factory pour créer les pompiers
+        firefighterPositions = new ArrayList<>();
+        List<FireFighter> firefighters = firefighterFactory.createElements(rowCount, columnCount);
+        for (FireFighter firefighter : firefighters) {
+            firefighterPositions.add(firefighter.getPosition());
+        }
+    }
+
+    private Position randomPosition(int rowCount, int columnCount, Random randomGenerator) {
+        return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+    }
+
+    public 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;
+    }
+
+    public List<Position> updateFirefighters() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        List<Position> newFirefighterPositions = new ArrayList<>();
+        for (Position firefighterPosition : firefighterPositions) {
+            Position newFirefighterPosition = targetStrategy.neighborClosestToTarget(firefighterPosition, firePositions, neighbors);
+            newFirefighterPositions.add(newFirefighterPosition);
+            extinguish(newFirefighterPosition);
+            modifiedPositions.add(firefighterPosition);
+            modifiedPositions.add(newFirefighterPosition);
+
+            List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
+                    .filter(firePositions::contains).toList();
+            for (Position firePosition : neighborFirePositions) {
+                extinguish(firePosition);
+            }
+            modifiedPositions.addAll(neighborFirePositions);
+        }
+        firefighterPositions = newFirefighterPositions;
+        return modifiedPositions;
+    }
+
+    private void extinguish(Position position) {
+        firePositions.remove(position);
+    }
+
+
+    public Set<Position> getFirePositions() {
+        return firePositions;
+    }
+
+    public List<Position> getFirefighterPositions() {
+        return firefighterPositions;
+    }
+
+    public void incrementStep() {
+        step++;
+    }
+
+
+    @Override
+    public int stepNumber() {
+        return step;
+    }
+
+    @Override
+    public List<Position> updateToNextGeneration() {
+        List<Position> modifiedPositions = updateFirefighters();
+        modifiedPositions.addAll(updateFires());
+        incrementStep();
+        return modifiedPositions;
+    }
+
+    @Override
+    public void reset() {
+        this.step=0;
+    }
+
+}

src/main/java/model/BoardFirefighterProperties.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+import java.util.Map;
+
+public class BoardFirefighterProperties implements BoardProperties{
+    private final int rowCount;
+    private final int columnCount;
+    private final Position[][] positions;
+
+
+    public BoardFirefighterProperties(int rowCount, int columnCount) {
+        this.rowCount = rowCount;
+        this.columnCount = columnCount;
+        this.positions = new Position[rowCount][columnCount];
+        initializePositions();
+    }
+
+
+
+
+    private void initializePositions() {
+        for (int row = 0; row < rowCount; row++) {
+            for (int column = 0; column < columnCount; column++) {
+                positions[row][column] = new Position(row, column);
+            }
+        }
+    }
+
+
+
+    public Position getPosition(int row, int column) {
+        return positions[row][column];
+    }
+    @Override
+    public int rowCount() {
+        return rowCount;
+    }
+
+    @Override
+    public int columnCount() {
+        return columnCount;
+    }
+
+
+
+}

src/main/java/model/BoardProperties.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+
+/**
+ * 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>  {
+    /**
+     * 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.
+
+
+
+
+}

src/main/java/model/Cloud.java

+package model;
+
+import model.BoardElement;
+import util.Position;
+
+public class Cloud extends BoardElement {
+    public Cloud(Position position) {
+        super(position);
+    }
+
+    @Override
+    public String getType() {
+        return "CLOUD";
+    }
+
+    @Override
+    public String toString() {
+        return "Cloud at " + position;
+    }
+}

src/main/java/model/CloudFactory.java

+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class CloudFactory implements ElementFactory<Cloud>, PositionGenerator {
+    private final Random random;
+    private final int count;
+
+    public CloudFactory(Random random, int count) {
+        this.random = random;
+        this.count = count;
+    }
+    @Override
+    public List<Cloud> createElements(int rowCount, int columnCount) {
+        List<Cloud> clouds = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            Position position = generateRandomPosition(rowCount, columnCount);
+            clouds.add(new Cloud(position));
+        }
+        return clouds;
+    }
+
+    @Override
+    public int getCount() {
+        return 0;
+    }
+
+    @Override
+    public Position generateRandomPosition(int rowCount, int columnCount) {
+        return null;
+    }
+}

src/main/java/model/ElementFactory.java

+package model;
+
+import java.util.List;
+
+public interface ElementFactory<T extends ModelElement> {
+    List<T> createElements(int rowCount, int columnCount);
+    int getCount();
+}

src/main/java/model/Fire.java

+package model;
+
+import util.Position;
+
+public class Fire  extends BoardElement{
+    public Fire(Position position) {
+        super(position);
+    }
+
+    @Override
+    public String getType() {
+        return "FIRE";
+    }
+
+
+
+
+    @Override
+    public String toString() {
+        return "Fire{" +
+                "position=" + position +
+                '}';
+    }
+}

src/main/java/model/FireFactory.java

+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class FireFactory implements ElementFactory<Fire>,PositionGenerator{
+    private final Random random;
+    private int count;
+
+    public FireFactory(Random random, int count) {
+        this.random = random; // Injecte un générateur aléatoire pour une flexibilité.
+        this.count=count;
+    }
+
+    /**
+     * Crée une liste de feux avec des positions et intensités aléatoires.
+     *
+     * @param rowCount   Nombre de lignes du plateau.
+     * @param columnCount Nombre de colonnes du plateau.
+
+     * @return Une liste d'objets `Fire`.
+     */
+    public List<Fire> createElements(int rowCount, int columnCount) {
+        List<Fire> fires = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            Position randomPosition = generateRandomPosition(rowCount, columnCount);
+            boolean add = fires.add(new Fire(randomPosition));
+        }
+        return fires;
+    }
+
+    /**
+     * Génère une position aléatoire sur le plateau.
+     *
+     * @param rowCount   Nombre de lignes.
+     * @param columnCount Nombre de colonnes.
+     * @return Une position aléatoire.
+     */
+    @Override
+    public Position generateRandomPosition(int rowCount, int columnCount) {
+        int row = random.nextInt(rowCount);
+        int column = random.nextInt(columnCount);
+        return new Position(row, column);
+    }
+
+    public int getCount() {
+        return count;
+    }
+}

src/main/java/model/FireFighter.java

+package model;
+
+import util.Position;
+
+public class FireFighter extends BoardElement{
+    public FireFighter(Position position) {
+        super(position);
+    }
+
+    @Override
+    public String getType() {
+        return "FIREFIGHTER";
+    }
+
+    @Override
+    public String toString() {
+        return "Firefighter at " + position;
+    }
+}

src/main/java/model/FirefighterBoard.java

@@ -4,29 +4,34 @@ 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 Position[][] positions;
-  private int step = 0;
+  private final BoardFireFighterBehavior behavior;
+  private final BoardFirefighterProperties properties;
+
+
   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++)
+    Map<Position, List<Position>> neighbors = initializeNeighbors(rowCount, columnCount);
+
+    this.properties = new BoardFirefighterProperties(rowCount, columnCount);
+    this.behavior = new BoardFireFighterBehavior(neighbors,new FireFactory(randomGenerator,initialFireCount),new FirefighterFactory(randomGenerator,initialFirefighterCount));
+
+    behavior.initializeElements( properties.rowCount(), properties.columnCount());
+  }
+
+  private Map<Position, List<Position>> initializeNeighbors(int rowCount, int columnCount) {
+    Map<Position, List<Position>> neighbors = new HashMap<>();
+    Position[][] positions = new Position[rowCount][columnCount];
+
+    for (int row = 0; row < rowCount; row++) {
+      for (int column = 0; column < columnCount; column++) {
         positions[row][column] = new Position(row, column);
-    for (int column = 0; column < columnCount; column++)
+      }
+    }
+
     for (int row = 0; row < rowCount; row++) {
+      for (int column = 0; column < columnCount; column++) {
         List<Position> list = new ArrayList<>();
         if (row > 0) list.add(positions[row - 1][column]);
         if (column > 0) list.add(positions[row][column - 1]);
@@ -34,114 +39,48 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
         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));
+    return neighbors;
   }
-
-  @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;
-  }
+    // Filtrage des éléments Fire (en transformant les positions en objets Fire)
+    behavior.getFirePositions().stream()
+            .filter(pos -> pos.isAtPosition(position)) // Vérifier si la position correspond
+            .forEach(pos -> result.add(new Fire(pos))); // Créer un objet Fire à partir de Position
 
-  @Override
-  public int columnCount() {
-    return columnCount;
-  }
+    // Filtrage des éléments Firefighter (en transformant les positions en objets FireFighter)
+    behavior.getFirefighterPositions().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
 
-  public List<Position> updateToNextGeneration() {
-    List<Position> modifiedPositions = updateFirefighters();
-    modifiedPositions.addAll(updateFires());
-    step++;
-    return modifiedPositions;
+    return result;
   }
 
-  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;
 
+  public void reset() {
+    behavior.reset();
+    behavior.initializeElements(properties.rowCount(), properties.columnCount());
   }
-
-  @Override
-  public int stepNumber() {
-    return step;
+  public void setState(List<ModelElement> state, Position position) {
+    // Pour chaque élément dans l'état, on l'ajoute sur le plateau
+    state.forEach(element -> addElementToBoard(element, position));
   }
 
-  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);
+  private void addElementToBoard(ModelElement element, Position position) {
+    if (element instanceof Fire) {
+      behavior.getFirePositions().add(position); // Ajouter un Fire
+    } else if (element instanceof FireFighter) {
+      behavior.getFirefighterPositions().add(position); // Ajouter un Firefighter
     }
-    firefighterPositions = firefighterNewPositions;
-    return modifiedPosition;
   }
 
-  @Override
-  public void reset() {
-    step = 0;
-    initializeElements();
-  }
-
-  private void extinguish(Position position) {
-    firePositions.remove(position);
+  public BoardFireFighterBehavior getBehavior() {
+    return behavior;
   }
 
-
-  @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);
-      }
-    }
+  public BoardFirefighterProperties getProperties() {
+    return properties;
   }
 }

src/main/java/model/FirefighterFactory.java

+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class FirefighterFactory implements ElementFactory<FireFighter>, PositionGenerator{
+    private final Random random;
+    private int count;
+
+    public FirefighterFactory(Random random,int count) {
+        this.random = random;
+        this.count=count;
+    }
+
+    @Override
+    public List<FireFighter> createElements(int rowCount, int columnCount) {
+        List<FireFighter> firefighters = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            Position randomPosition = generateRandomPosition(rowCount, columnCount);
+            firefighters.add(new FireFighter(randomPosition));
+        }
+        return firefighters;
+    }
+
+    @Override
+    public Position generateRandomPosition(int rowCount, int columnCount) {
+        int row = random.nextInt(rowCount);
+        int column = random.nextInt(columnCount);
+        return new Position(row, column);
+    }
+
+    public int getCount() {
+        return count;
+    }
+}

src/main/java/model/ModelElement.java

 package model;
 
-public enum ModelElement {
-  FIREFIGHTER, FIRE
+import util.Position;
+
+public interface ModelElement {
+    public Position getPosition();
+
 }

src/main/java/model/PositionGenerator.java

+package model;
+
+import util.Position;
+
+public interface PositionGenerator {
+    public Position generateRandomPosition(int rowCount, int columnCount);
+}

src/main/java/util/Position.java

 package util;
 
 public record Position(int row, int column) {
+    public boolean isAtPosition(Position position) {
+        return row == position.row() && column == position.column();
+    }
+
 
 }

src/main/java/util/Strategy.java

+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);
+}

src/main/java/util/TargetStrategy.java

-package model;
+package util;
 
 import util.Position;
+import view.ViewElement;
 
 import java.util.*;
 
-public class TargetStrategy {
+public class TargetStrategy implements Strategy{
 
 
     /**
@@ -12,7 +13,7 @@ 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.
      */
-    Position neighborClosestToFire(Position position, Collection<Position> targets,
+    public Position neighborClosestToTarget(Position position, Collection<Position> targets,
                                           Map<Position, List<Position>> neighbors) {
         Set<Position> seen = new HashSet<Position>();
         HashMap<Position, Position> firstMove = new HashMap<Position, 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)) {

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

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.GREEN), ROCKY(Color.BLACK);
   final Color color;
   ViewElement(Color color) {
     this.color = color;

src/main/resources/view/view.fxml

@@ -10,7 +10,7 @@
 <?import javafx.scene.control.Label?>
 <HBox styleClass="background" stylesheets="@DarkTheme.css"
       xmlns="http://javafx.com/javafx" xmlns:fx="http://javafx.com/fxml"
-      fx:controller="controller.Controller">
+      fx:controller="controller.Controller" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity">
   <VBox>
     <Separator maxHeight="-Infinity" maxWidth="-Infinity"
                prefHeight="24.0" prefWidth="200.0"/>