README.md

+Rapport de Projet : Proto-simulateur d'Automate Cellulaire
+
+Étudiants : Asfour Mohamed, Belhechemi Mehdi
+Formation : L3 Informatique, Aix-Marseille Université
+Enseignante : Mme Mesbah Ismahene
+
+
+Introduction
+
+Ce projet visait à développer un proto-simulateur d’automate cellulaire où des pompiers interagissent avec des feux sur une grille, tout en prenant en compte différents terrains et éléments dynamiques.
+
+L’objectif principal était de fournir un simulateur structuré, respectant les principes SOLID et enrichi par des fonctionnalités avancées. Ce projet a également été une opportunité de collaborer efficacement en binôme tout en mettant en pratique les concepts de programmation orientée objet.
+Problématique et Objectifs
+
+Problématique :
+Comment concevoir une simulation réaliste et flexible, capable de gérer des interactions complexes entre les pompiers, les feux, et divers terrains, tout en garantissant la maintenabilité du code ?
+
+Objectifs :
+
+    Refactoriser le code initial fourni pour respecter les principes SOLID.
+    Intégrer des éléments interactifs tels que pompiers, feux, nuages, terrains spécifiques et d’autres modules (e.g. gestion des couleurs et positions).
+    Préparer une démonstration fonctionnelle et un rapport détaillé pour évaluer le projet.
+
+Méthodologie et Répartition des Tâches
+
+Nous avons divisé le travail en plusieurs modules principaux, chaque étudiant contribuant de manière spécifique à chaque composant :
+
+1. Feux (Fire)
+
+Les feux se propagent toutes les deux itérations selon les caractéristiques des terrains environnants.
+
+    Contributions de Belhechemi Mehdi :
+        Implémentation des règles de propagation des feux.
+        Gestion des interactions entre les feux et les terrains spécifiques (ex. : propagation retardée sur rocailles).
+    Contributions d’Asfour Mohamed :
+        Tests des comportements des feux dans différents scénarios.
+        Intégration des feux dans le simulateur global.
+
+2. Pompiers (FireFighter)
+
+Les pompiers peuvent éteindre les feux autour d’eux ou se diriger vers le feu le plus proche.
+
+    Contributions d’Asfour Mohamed :
+        Développement de la logique de déplacement des pompiers et de leur capacité à éteindre les feux.
+        Tests unitaires pour valider leur comportement.
+    Contributions de Belhechemi Mehdi :
+        Gestion des interactions entre les pompiers et les terrains spécifiques (routes, montagnes).
+        Optimisation des algorithmes de déplacement pour rendre les pompiers plus efficaces.
+
+3. Pompiers Motorisés (MotorizedFireFighter)
+
+Ces pompiers disposent de déplacements accélérés, pouvant se déplacer de deux cases par tour.
+
+    Contributions d’Asfour Mohamed :
+        Développement de la classe MotorizedFireFighter, héritant de la classe FireFighter.
+        Gestion des comportements spécifiques liés aux déplacements rapides.
+    Contributions de Belhechemi Mehdi :
+        Intégration des pompiers motorisés dans le simulateur global.
+        Tests approfondis de leurs interactions avec les terrains.
+
+4. Nuages (Clouds)
+
+Les nuages se déplacent de manière aléatoire et éteignent les feux rencontrés.
+
+    Contributions d’Asfour Mohamed :
+        Développement de la logique de déplacement aléatoire des nuages.
+        Gestion des interactions entre les nuages et les feux.
+    Contributions de Belhechemi Mehdi :
+        Validation des interactions nuages-feux.
+        Tests pour s’assurer de leur intégration dans le simulateur sans conflit avec d’autres éléments.
+
+5. Terrains Spécifiques (Mountain, Road, Rocailles)
+
+    Montagnes : Infranchissables pour les feux et les pompiers.
+    Routes : Réservées aux pompiers, facilitant leurs déplacements.
+    Rocailles : Zones où le feu met quatre tours à se propager.
+    Contributions de Belhechemi Mehdi :
+        Conception et implémentation des classes représentant les terrains.
+        Gestion des interactions entre les terrains et les autres éléments.
+    Contributions d’Asfour Mohamed :
+        Tests et validation des comportements des terrains dans différents scénarios.
+        Ajustements pour garantir la cohérence des interactions.
+
+6. Gestion des Positions (Position)
+
+Un module essentiel pour suivre la position des éléments sur la grille.
+
+    Contributions d’Asfour Mohamed :
+        Développement de la classe Position pour gérer les coordonnées des éléments.
+    Contributions de Belhechemi Mehdi :
+        Optimisation des calculs liés aux déplacements.
+
+7. Gestion des Voisinages (Neighbour)
+
+Ce module permet de déterminer les éléments voisins (feux, pompiers, etc.) pour chaque case.
+
+    Contributions d’Asfour Mohamed :
+        Conception de la logique de détection des voisins sur la grille.
+    Contributions de Belhechemi Mehdi :
+        Optimisation des algorithmes pour des performances améliorées sur les grandes grilles.
+
+8. Extinction des Feux (Extinguisher)
+
+Un module spécifique pour gérer l’extinction des feux par les pompiers ou les nuages.
+
+    Contributions d’Asfour Mohamed :
+        Développement de la logique d’extinction dans la classe Extinguisher.
+    Contributions de Belhechemi Mehdi :
+        Validation des interactions et ajustements des règles d’extinction.
+
+9. Interface et Couleurs (ViewElement)
+
+La classe ViewElement gère l’affichage des éléments sur la grille avec des couleurs distinctives.
+
+    Contributions de Belhechemi Mehdi :
+        Association des éléments avec des couleurs spécifiques.
+    Contributions d’Asfour Mohamed :
+        Tests de l’affichage et ajustements pour une meilleure lisibilité.
+
+Résultats Obtenus
+
+    Refactorisation :
+        Une structure conforme aux principes SOLID, facilitant la maintenance et l’extension du code.
+
+    Fonctionnalités Implémentées :
+        Gestion des feux, pompiers, terrains, nuages, et voisinages.
+        Interaction fluide entre tous les éléments dans des scénarios variés.
+
+    Interface Fonctionnelle :
+        Une grille visuelle permettant de suivre les interactions entre les éléments en temps réel.
+
+
+Conclusion et Perspectives
+
+Ce projet nous a permis de :
+
+    Renforcer nos compétences en programmation orientée objet.
+    Appliquer les principes SOLID dans un contexte concret.
+    Collaborer efficacement en binôme pour atteindre des objectifs communs.
+
+Perspectives :
+
+    Ajouter des éléments dynamiques supplémentaires (vent, pluie) influençant la propagation des feux.
+    Optimiser les algorithmes pour améliorer les performances sur les grandes grilles.
+    Étendre les fonctionnalités en explorant des modèles alternatifs.
+
+Annexes
+
+    Dépôt Git : Code final mis à jour régulièrement, disponible avant la deadline (Vendredi 10h).
+    Diagramme de Classe : Présenté lors de la démonstration pour illustrer la structure du code.
\ No newline at end of file

src/main/java/app/SimulatorApplication.java

@@ -17,8 +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 = 3;
-  public static final int INITIAL_FIREFIGHTER_COUNT = 6;
+
 
   private Stage primaryStage;
   private Parent view;
@@ -43,8 +42,7 @@ public class SimulatorApplication extends javafx.application.Application {
     loader.setLocation(location);
     view = loader.load();
     Controller controller = loader.getController();
-    controller.initialize(BOX_WIDTH, BOX_HEIGHT, COLUMN_COUNT, ROW_COUNT,
-            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT);
+    controller.initialize(BOX_WIDTH, BOX_HEIGHT, COLUMN_COUNT, ROW_COUNT);
   }
 
   private void showScene() {

src/main/java/controller/Controller.java

@@ -12,9 +12,9 @@ import javafx.scene.control.ToggleButton;
 import javafx.scene.control.ToggleGroup;
 import javafx.util.Duration;
 import javafx.util.Pair;
-import model.Board;
-import model.ModelElement;
-import model.FirefighterBoard;
+import model.Board.Board;
+import model.Elements.ModelElement;
+import model.Board.FirefighterBoard;
 import util.Position;
 import view.Grid;
 import view.ViewElement;
@@ -88,9 +88,25 @@ public class Controller {
     if (squareState.contains(ModelElement.FIRE)) {
       return ViewElement.FIRE;
     }
+    if (squareState.contains(ModelElement.CLOUD)) {
+      return ViewElement.CLOUD;
+    }
+    if (squareState.contains(ModelElement.ROAD)) {
+      return ViewElement.ROAD;
+    }
+    if (squareState.contains(ModelElement.MOUNTAIN)) {
+      return ViewElement.MOUNTAIN;
+    }
+    if (squareState.contains(ModelElement.ROCAILLE)) {
+      return ViewElement.ROCAILLE;
+    }
+    if (squareState.contains(ModelElement.MOTORIZEDFIREFIGHTER)) {
+      return ViewElement.MOTORIZEDFIREFIGHTER;
+    }
     return ViewElement.EMPTY;
   }
 
+
   private void initializeTimeline() {
     Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);
     EventHandler<ActionEvent> eventHandler =
@@ -124,9 +140,9 @@ public class Controller {
   }
 
   public void initialize(int squareWidth, int squareHeight, int columnCount,
-                                int rowCount, int initialFireCount, int initialFirefighterCount) {
+                                int rowCount) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
+    this.setModel(new FirefighterBoard(columnCount, rowCount));
     repaintGrid();
   }
 

src/main/java/model/Board.java → src/main/java/model/Board/Board.java

-package model;
+package model.Board;
 
+import model.Elements.Fire;
+import model.Elements.Obstacle.Obstacle;
 import util.Position;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * This interface represents a generic board for modeling various state-based systems.
@@ -11,6 +14,8 @@ import java.util.List;
  */
 public interface Board<S> {
 
+
+
   /**
    * Get the state of the board at a specific position.
    *
@@ -27,6 +32,14 @@ public interface Board<S> {
    */
   void setState(S state, Position position);
 
+
+   Map<Position, Obstacle> getObstacles();
+
+
+  Map<Position, Fire> getFires();
+
+
+
   /**
    * Get the number of rows in the board.
    *

src/main/java/model/Board/FirefighterBoard.java

+package model.Board;
+
+
+import model.Elements.Extinguisher.Cloud;
+import model.Elements.Extinguisher.Extinguisher;
+import model.Elements.Extinguisher.FireFighter;
+import model.Elements.Fire;
+import model.Elements.ModelElement;
+import model.Elements.Obstacle.Obstacle;
+import util.Position;
+
+import java.util.*;
+
+
+public class FirefighterBoard implements Board<List<ModelElement>> {
+  private final int columnCount;
+  private final int rowCount;
+  private final Map<Position, Fire> fires = new HashMap<>();
+  private final Map<Position, Extinguisher> extinguishers = new HashMap<>();
+  private final Map<Position, Obstacle> obstacles = new HashMap<>();
+
+  private final Position[][] positions;
+  private int step = 0;
+  private final Random randomGenerator = new Random();
+
+
+  public FirefighterBoard(int columnCount, int rowCount) {
+    this.columnCount = columnCount;
+    this.rowCount = rowCount;
+    this.positions = new Position[rowCount][columnCount];
+
+    initializePositions();
+    initializeElements();
+  }
+
+  private void initializePositions() {
+    for (int column = 0; column < columnCount; column++) {
+      for (int row = 0; row < rowCount; row++) {
+        positions[row][column] = new Position(row, column);
+      }
+    }
+  }
+
+
+  public void initializeElements() {
+    for(ModelElement modelElement : ModelElement.values()){
+      for(int elementCount = 0; elementCount< modelElement.getInitialNumber();elementCount++){
+        Position position = randomPosition();
+        if(modelElement.isObstacle()){
+          obstacles.put(position, (Obstacle) modelElement.getModelElementClass(position));
+        } else if (modelElement.isExtinguisher()) {
+          extinguishers.put(position, (Extinguisher) modelElement.getModelElementClass(position));
+        }
+        else{
+          fires.put(position, (Fire) modelElement.getModelElementClass(position));
+        }
+      }
+    }
+  }
+
+  private Position randomPosition() {
+    return positions[randomGenerator.nextInt(rowCount)][randomGenerator.nextInt(columnCount)];
+  }
+
+  @Override
+  public List<ModelElement> getState(Position position) {
+    List<ModelElement> result = new ArrayList<>();
+    if (fires.containsKey(position)) result.add(ModelElement.FIRE);
+
+
+    for (Extinguisher extinguisher : extinguishers.values()) {
+      if (extinguisher.getPosition().equals(position)) result.add(extinguisher.getElement());
+    }
+
+    for (Obstacle obstacle : obstacles.values()) {
+      if (obstacle.getPosition().equals(position)) result.add(obstacle.getElement());
+    }
+
+    return result;
+  }
+
+  @Override
+  public int rowCount() {
+    return rowCount;
+  }
+
+  @Override
+  public int columnCount() {
+    return columnCount;
+  }
+
+  public List<Position> updateToNextGeneration() {
+
+    Fire fire = new Fire(null);
+    List<Position> modifiedPositions = new ArrayList<>();
+
+    for(Extinguisher element : extinguishers.values()){
+      modifiedPositions.addAll(element.update(this));
+    }
+    modifiedPositions.addAll(fire.update(this));
+
+    step++;
+    return modifiedPositions;
+  }
+
+  @Override
+  public int stepNumber() {
+    return step;
+  }
+
+  public Map<Position,Fire>getFires(){
+    return this.fires;
+  }
+
+
+  public Map<Position, Obstacle> getObstacles() {
+    return obstacles;
+  }
+
+
+  @Override
+  public void reset() {
+    step = 0;
+    obstacles.clear();
+    extinguishers.clear();
+    fires.clear();
+    initializeElements();
+  }
+
+  @Override
+  public void setState(List<ModelElement> state, Position position) {
+
+    if(extinguishers.containsKey(position)){
+      extinguishers.remove(position);
+      extinguishers.get(position).extinguish(this,position);
+    }
+    for (ModelElement element : state) {
+      switch (element) {
+        case FIRE -> fires.put(position, new Fire(position));
+        case FIREFIGHTER -> extinguishers.put(position,new FireFighter(position));
+        case CLOUD ->  extinguishers.put(position,new Cloud(position));
+      }
+    }
+  }
+
+
+
+
+
+}
+

src/main/java/model/Elements/Element.java

+package model.Elements;
+
+import model.Board.Board;
+import util.Position;
+
+import java.util.List;
+
+public interface Element {
+
+
+
+    Position getPosition();
+
+    ModelElement getElement();
+
+    List<Position> update(Board<List<ModelElement>> firefighterBoard);
+
+}

src/main/java/model/Elements/Extinguisher/Cloud.java

+package model.Elements.Extinguisher;
+
+import model.Board.Board;
+import model.Elements.ModelElement;
+import util.Neighbour;
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Cloud extends Extinguisher {
+
+
+    public Cloud(Position position) {
+        super(position);
+        element = ModelElement.CLOUD;
+    }
+
+    public List<Position>update(Board<List<ModelElement>> firefighterBoard){
+
+        this.neighbour = new Neighbour(firefighterBoard);
+        List<Position> modifiedPositions = new ArrayList<>();
+
+        Position currentPosition = this.getPosition();
+        Position newPosition = this.neighbour.randomNeighbor(currentPosition);
+        this.setPosition(newPosition);
+        modifiedPositions.add(currentPosition);
+        modifiedPositions.add(newPosition);
+
+
+        extinguish(firefighterBoard,newPosition);
+
+        for (Position neighbor : this.neighbour.getNeighbors().get(newPosition)) {
+            extinguish(firefighterBoard,neighbor);
+            modifiedPositions.add(neighbor);
+        }
+
+        return modifiedPositions;
+    }
+
+
+
+
+}

src/main/java/model/Elements/Extinguisher/Extinguisher.java

+package model.Elements.Extinguisher;
+
+
+import model.Board.Board;
+import model.Elements.Element;
+import model.Elements.ModelElement;
+import util.Neighbour;
+import util.Position;
+import util.TargetStrategy;
+
+import java.util.List;
+
+public abstract class Extinguisher implements Element {
+
+    protected final TargetStrategy targetStrategy = new TargetStrategy();
+    protected Neighbour neighbour;
+    protected Position position;
+    protected ModelElement element;
+
+    public Extinguisher(Position position){
+        this.position = position;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+    public ModelElement getElement(){
+        return this.element;
+    }
+
+    public void extinguish(Board board, Position position) {
+        if (board.getFires().containsKey(position)) {
+            board.getFires().remove(position);
+        }
+    }
+
+    public abstract List<Position> update(Board<List<ModelElement>> firefighterBoard);
+
+}

src/main/java/model/Elements/Extinguisher/FireFighter.java

+package model.Elements.Extinguisher;
+
+
+
+
+import model.Board.Board;
+import model.Elements.ModelElement;
+import model.Elements.Obstacle.Mountain;
+import model.Elements.Obstacle.Obstacle;
+import util.Neighbour;
+import util.Position;
+
+
+import java.util.ArrayList;
+
+
+import java.util.List;
+
+
+
+public class FireFighter extends Extinguisher {
+
+
+    public FireFighter(Position position) {
+        super(position);
+        element = ModelElement.FIREFIGHTER;
+    }
+
+
+    public List<Position> update(Board<List<ModelElement>> firefighterBoard) {
+        this.neighbour = new Neighbour(firefighterBoard);
+        List<Position> modifiedPositions = new ArrayList<>();
+
+        Position currentPosition = this.getPosition();
+        Position newPosition = targetStrategy.neighborClosestToFire(currentPosition, firefighterBoard.getFires().keySet(), this.neighbour.getNeighbors());
+        this.setPosition(newPosition);
+
+
+        modifiedPositions.add(currentPosition);
+        modifiedPositions.add(newPosition);
+
+        extinguish(firefighterBoard,newPosition);
+
+
+
+        for (Position neighbor : this.neighbour.getNeighbors().get(newPosition)) {
+            extinguish(firefighterBoard,neighbor);
+            modifiedPositions.add(neighbor);
+        }
+
+        for(Obstacle obstacle : firefighterBoard.getObstacles().values()){
+            if(obstacle instanceof Mountain){
+                modifiedPositions.remove(obstacle.getPosition());
+            }
+        }
+
+        return modifiedPositions;
+    }
+
+
+
+    }
+
+

src/main/java/model/Elements/Extinguisher/MotorizedFireFighter.java

+package model.Elements.Extinguisher;
+
+
+import model.Board.Board;
+import model.Elements.ModelElement;
+import model.Elements.Obstacle.Mountain;
+import model.Elements.Obstacle.Obstacle;
+import util.Neighbour;
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MotorizedFireFighter extends Extinguisher {
+
+    public MotorizedFireFighter(Position position) {
+        super(position);
+        this.element = ModelElement.MOTORIZEDFIREFIGHTER;
+    }
+
+    @Override
+    public List<Position> update(Board<List<ModelElement>> firefighterBoard) {
+        this.neighbour = new Neighbour(firefighterBoard);
+
+        List<Position> modifiedPositions = new ArrayList<>();
+
+        Position currentPosition = this.getPosition();
+        Position newPosition = targetStrategy.neighborClosestToFire(currentPosition, firefighterBoard.getFires().keySet(), this.neighbour.getNeighbors());
+        Position DoublenewPosition = targetStrategy.neighborClosestToFire(newPosition, firefighterBoard.getFires().keySet(), this.neighbour.getNeighbors());
+        this.setPosition(DoublenewPosition);
+
+        modifiedPositions.add(currentPosition);
+
+        modifiedPositions.add(DoublenewPosition);
+
+        extinguish(firefighterBoard, newPosition);
+        extinguish(firefighterBoard, DoublenewPosition);
+
+
+        for (Position neighbor : this.neighbour.getNeighbors().get(DoublenewPosition)) {
+            extinguish(firefighterBoard, neighbor);
+            modifiedPositions.add(neighbor);
+        }
+
+        for (Obstacle obstacle : firefighterBoard.getObstacles().values()) {
+            if (obstacle instanceof Mountain) {
+                modifiedPositions.remove(obstacle.getPosition());
+            }
+        }
+
+        return modifiedPositions;
+
+    }
+}

src/main/java/model/Elements/Fire.java

+package model.Elements;
+
+
+import model.Board.Board;
+import model.Elements.Obstacle.Mountain;
+import model.Elements.Obstacle.Obstacle;
+import model.Elements.Obstacle.Road;
+import util.Neighbour;
+import util.Position;
+
+import java.util.*;
+
+
+public class Fire implements Element {
+
+    private Position position;
+
+    private Neighbour neighbour;
+    private final ModelElement modelElement;
+
+
+    public Fire(Position position){
+        this.position = position;
+        modelElement = ModelElement.FIRE;
+    }
+
+
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ModelElement getElement() {
+        return modelElement;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+
+    public List<Position> update(Board<List<ModelElement>> firefighterBoard) {
+        this.neighbour = new Neighbour(firefighterBoard);
+
+        List<Position> modifiedPositions = new ArrayList<>();
+        if (firefighterBoard.stepNumber() % 2 == 0) {
+            Set<Position> newFirePositions = new HashSet<>();
+
+            for (Position fire : new HashSet<>(firefighterBoard.getFires().keySet())) {
+                newFirePositions.addAll(removeMountainAndRoads(firefighterBoard,fire));
+            }
+
+            for (Position position : newFirePositions) {
+                if (!firefighterBoard.getFires().containsKey(position)) {
+                    firefighterBoard.getFires().put(position, new Fire(position));
+                    modifiedPositions.add(position);
+                }
+            }
+        }
+        return modifiedPositions;
+    }
+
+    private List<Position>removeMountainAndRoads(Board<List<ModelElement>> firefighterBoard,Position position){
+        List<Position>neighboursAvailable;
+
+        neighboursAvailable = this.neighbour.getNeighbors().get(position);
+        if(firefighterBoard.stepNumber()%4==0){
+            List<Position>MountainAndRoadsPositions = new ArrayList<>();
+            for(Obstacle obstacle : firefighterBoard.getObstacles().values()){
+                if(obstacle instanceof Road || obstacle instanceof Mountain){
+                    MountainAndRoadsPositions.add(obstacle.getPosition());
+                    neighboursAvailable.removeAll(MountainAndRoadsPositions);
+                }
+            }
+        }
+        else{
+
+            neighboursAvailable.removeAll(firefighterBoard.getObstacles().keySet());
+        }
+
+
+        return neighboursAvailable;
+    }
+
+
+
+
+
+}
\ No newline at end of file

src/main/java/model/Elements/ModelElement.java

+package model.Elements;
+
+
+import model.Elements.Extinguisher.Cloud;
+import model.Elements.Extinguisher.Extinguisher;
+import model.Elements.Extinguisher.FireFighter;
+import model.Elements.Extinguisher.MotorizedFireFighter;
+import model.Elements.Obstacle.Mountain;
+import model.Elements.Obstacle.Obstacle;
+import model.Elements.Obstacle.Road;
+import model.Elements.Obstacle.Rocaille;
+import util.Position;
+
+
+public enum ModelElement {
+
+  FIREFIGHTER(5),
+  FIRE(25),
+  CLOUD(10),
+  ROAD(5),
+  MOUNTAIN(5),
+  ROCAILLE(3),
+  MOTORIZEDFIREFIGHTER(3);
+
+
+  private final int initialNumber;
+
+
+
+  ModelElement(int initialNumber) {
+    this.initialNumber = initialNumber;
+  }
+
+  public int getInitialNumber(){
+    return this.initialNumber;
+  }
+
+  public Element getModelElementClass(Position position){
+    return switch (this){
+      case FIRE -> new Fire(position);
+      case ROAD -> new Road(position);
+      case FIREFIGHTER -> new FireFighter(position);
+      case CLOUD -> new Cloud(position);
+      case MOUNTAIN -> new Mountain(position);
+      case ROCAILLE -> new Rocaille(position);
+      case MOTORIZEDFIREFIGHTER -> new MotorizedFireFighter(position);
+      default -> throw new IllegalArgumentException("Unknown ModelElement: " + this);
+      };
+
+    }
+
+
+
+
+
+  public boolean isObstacle() {
+    return this.getModelElementClass(null) instanceof Obstacle;
+
+  }
+  public boolean isExtinguisher(){
+    return this.getModelElementClass(null) instanceof Extinguisher;
+  }
+
+
+
+
+
+}
+

src/main/java/model/Elements/Obstacle/Mountain.java

+package model.Elements.Obstacle;
+
+
+import model.Elements.ModelElement;
+
+import util.Position;
+
+public class Mountain extends Obstacle {
+    public Mountain(Position position) {
+        super(position);
+        element = ModelElement.MOUNTAIN;
+    }
+
+
+}

src/main/java/model/Elements/Obstacle/Obstacle.java

+package model.Elements.Obstacle;
+
+
+import model.Board.Board;
+import model.Elements.Element;
+import model.Elements.ModelElement;
+import util.Position;
+
+import java.util.List;
+
+public abstract class Obstacle implements Element {
+    protected ModelElement element;
+    protected final Position position;
+    public Obstacle(Position position){
+        this.position = position;
+    }
+
+    @Override
+    public Position getPosition() {
+        return this.position;
+    }
+
+    @Override
+    public ModelElement getElement() {
+        return this.element;
+    }
+
+
+    public List<Position> update(Board<List<ModelElement>> firefighterBoard) {
+        return null;
+    }
+
+
+}

src/main/java/model/Elements/Obstacle/Road.java

+package model.Elements.Obstacle;
+
+
+import model.Elements.ModelElement;
+
+import util.Position;
+
+public class Road extends Obstacle {
+
+
+
+
+    public Road(Position position){
+        super(position);
+        element = ModelElement.ROAD;
+    }
+
+
+}

src/main/java/model/Elements/Obstacle/Rocaille.java

+package model.Elements.Obstacle;
+
+
+
+import model.Elements.ModelElement;
+
+import util.Position;
+
+public class Rocaille extends Obstacle {
+    public Rocaille(Position position) {
+        super(position);
+        this.element = ModelElement.ROCAILLE;
+    }
+}

src/main/java/model/FirefighterBoard.java

-package model;
-
-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 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++)
-        positions[row][column] = new Position(row, column);
-    for (int column = 0; column < columnCount; column++)
-      for (int row = 0; row < rowCount; row++) {
-        List<Position> list = new ArrayList<>();
-        if (row > 0) list.add(positions[row - 1][column]);
-        if (column > 0) list.add(positions[row][column - 1]);
-        if (row < rowCount - 1) list.add(positions[row + 1][column]);
-        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));
-  }
-
-  @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;
-  }
-
-  @Override
-  public int columnCount() {
-    return columnCount;
-  }
-
-  public List<Position> updateToNextGeneration() {
-    List<Position> modifiedPositions = updateFirefighters();
-    modifiedPositions.addAll(updateFires());
-    step++;
-    return modifiedPositions;
-  }
-
-  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;
-
-  }
-
-  @Override
-  public int stepNumber() {
-    return step;
-  }
-
-  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);
-    }
-    firefighterPositions = firefighterNewPositions;
-    return modifiedPosition;
-  }
-
-  @Override
-  public void reset() {
-    step = 0;
-    initializeElements();
-  }
-
-  private void extinguish(Position position) {
-    firePositions.remove(position);
-  }
-
-
-  @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);
-      }
-    }
-  }
-}
\ No newline at end of file