src/main/java/App.java

+import javafx.application.Application;
+import javafx.scene.Group;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+
+public class App extends Application {
+
+    boolean isInPause = true;
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+
+    @Override
+    public void start(Stage primaryStage) {
+        Group root = new Group();
+        Button restart = new Button("Restart");
+        Button switchPause = new Button("Pause");
+        VBox buttons = new VBox();
+        HBox total = new HBox();
+        Grid grid = new Grid(700,700,20,20);
+
+        root.getChildren().add(total);
+        total.getChildren().add(buttons);
+        total.getChildren().add(grid);
+        buttons.getChildren().add(restart);
+        buttons.getChildren().add(switchPause);
+        restart.setOnMouseClicked(grid::restart);
+        switchPause.setOnMouseClicked((value)->isInPause = !isInPause);
+        primaryStage.setScene(new Scene(root));
+        primaryStage.show();
+        grid.repaint();
+
+        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(1);
+        threadPoolExecutor.scheduleAtFixedRate(() -> {
+            if(!isInPause) {
+                grid.model.activation();
+                grid.repaint();
+            }
+        }, 0, 50 , TimeUnit.MILLISECONDS);
+    }
+}

src/main/java/Grid.java

+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.paint.Color;
+
+public class Grid extends Canvas{
+    int width, height, colCount, rowCount;
+    Model model;
+
+
+    public Grid(int width, int height, int colCount, int rowCount) {
+        super(width,height);
+        this.width = width;
+        this.height = height;
+        this.colCount = colCount;
+        this.rowCount = rowCount;
+        setFocusTraversable(true);
+        setOnMousePressed(this::mousePressed);
+        model = new Model(this);
+        model.initialisation(3,8, 2, 3);
+    }
+
+    public void restart(MouseEvent mouseEvent){
+        model = new Model(this);
+        model.initialisation(3,6, 2, 3);
+        getGraphicsContext2D().clearRect(0,0,width,height);
+        repaint();
+    }
+    private void mousePressed(MouseEvent mouseEvent) {
+        model.activation();
+        repaint();
+            /*double x = mouseEvent.getX();
+            double y = mouseEvent.getY();
+            model.click((int)x*rowCount/height,(int)y*colCount/width);*/
+    }
+
+    void repaint(){
+        for(int col=0; col<colCount; col++)
+            getGraphicsContext2D().strokeLine(0, col*width/colCount,height, col*width/colCount);
+        for(int row=0; row<rowCount;row++)
+            getGraphicsContext2D().strokeLine(row*height/rowCount,0,row*height/rowCount,width);
+
+    }
+
+    void paint(int row, int col){
+        getGraphicsContext2D().setFill(Color.WHITE);
+        getGraphicsContext2D().fillRect(row*height/rowCount,col*width/colCount,height/rowCount,width/colCount);
+    }
+
+    public void paintFF(int row, int col) {
+        getGraphicsContext2D().setFill(Color.BLUE);
+        getGraphicsContext2D().fillOval(row*height/rowCount,col*width/colCount,height/rowCount,width/colCount);
+    }
+
+    public void paintFire(int row, int col) {
+        getGraphicsContext2D().setFill(Color.RED);
+        getGraphicsContext2D().fillRect(row*height/rowCount,col*width/colCount,height/rowCount,width/colCount);
+    }
+
+    public void paintCloud(int row, int col){
+        getGraphicsContext2D().setFill(Color.GRAY);
+        getGraphicsContext2D().fillRect(row*height/rowCount, col*width/colCount, height/rowCount, width/colCount);
+    }
+    public void paintFFM(int row, int col){
+        getGraphicsContext2D().setFill(Color.BLACK);
+        getGraphicsContext2D().fillRect(row*height/rowCount, col*width/colCount, height/rowCount, width/colCount);
+    }
+    /*public void paintMountain(int row, int col){
+        getGraphicsContext2D().setFill(Color.YELLOW);
+        getGraphicsContext2D().fillRect(row*height/rowCount, col*width/colCount, height/rowCount, width/colCount);
+    }*/
+
+    public void paintRoad(int row, int column){
+
+    }
+    public void paintRocks(int row, int column){
+
+    }
+
+}
\ No newline at end of file

src/main/java/Model.java

+import java.util.*;
+
+
+public class Model {
+    Grid grid;
+    int colCount, rowCount;
+    List<Position> firefighters = new ArrayList<>();
+    Set<Position> fires = new HashSet<>();
+    List<Position> ffNewPositions;
+
+    List<Position> clouds = new ArrayList<>();
+    List<Position> cloudNewPositions;
+
+
+
+    List<Position> fireFightersMotorized = new ArrayList<>();
+    List<Position> fireFightersMotorizedPositions;
+
+    int step = 0;
+
+    public Model(Grid grid) {
+        this.grid = grid;
+        colCount = grid.colCount;
+        rowCount = grid.rowCount;
+    }
+
+
+    public void initialisation(int fireNumber, int fireFighterNumber, int cloudNumber, int fireFightersMotorizedNumber){
+        for(int index=0; index<fireNumber;index++)
+            fires.add(randomPosition());
+        for(int index=0; index<fireFighterNumber;index++)
+            firefighters.add(randomPosition());
+
+        //clouds
+        for(int index = 0; index < cloudNumber; index++){
+            clouds.add(randomPosition());
+        }
+
+        //fireFightersMotorized
+        for(int index = 0; index < fireFightersMotorizedNumber; index++){
+            fireFightersMotorized.add(randomPosition());
+        }
+
+
+    }
+
+    private Position randomPosition() {
+        return new Position((int) (Math.random()*rowCount), (int) (Math.random()*colCount));
+    }
+
+
+    public void activation(){
+        ffNewPositions = new ArrayList<>();
+        for(Position ff : firefighters){
+            Position newPosition = activateFirefighter(ff);
+            grid.paint(ff.row,ff.col);
+            grid.paintFF(newPosition.row, newPosition.col);
+            ffNewPositions.add(newPosition);
+        }
+        firefighters = ffNewPositions;
+
+
+        if(step%2==0){
+            List<Position> newFires = new ArrayList<>();
+            for(Position fire : fires){
+                newFires.addAll(activateFire(fire));
+            }
+            for(Position newFire : newFires)
+                grid.paintFire(newFire.row, newFire.col);
+
+            fires.addAll(newFires);}
+        step++;
+
+        //for cloud
+        cloudNewPositions = new ArrayList<>();
+        for(Position cloud : clouds){
+            Position newCloudPosition = activateClouds(cloud);
+            grid.paint(cloud.row, cloud.col);
+            grid.paintCloud(newCloudPosition.row, newCloudPosition.col);
+            cloudNewPositions.add(newCloudPosition);
+        }
+        clouds = cloudNewPositions;
+
+
+        //for fireFighterMotorized
+
+        fireFightersMotorizedPositions = new ArrayList<>();
+        for(Position ffM : fireFightersMotorized){
+            Position newPosition = activateFirefighterMotorized(ffM);
+            grid.paint(ffM.row,ffM.col);
+            grid.paintFFM(newPosition.row, newPosition.col);
+            fireFightersMotorizedPositions.add(newPosition);
+        }
+        fireFightersMotorized = fireFightersMotorizedPositions;
+
+
+
+    }
+
+
+    private List<Position> activateFire(Position position) {
+        return next(position);
+    }
+
+    private Position activateFirefighter(Position position) {
+        Position randomPosition = aStepTowardFire(position);
+        //next(position).get((int) (Math.random()*next(position).size()));
+        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+        extinguish(randomPosition);
+        for (Position fire : nextFires)
+            extinguish(fire);
+        return randomPosition;
+    }
+
+    private void extinguish(Position position) {
+        fires.remove(position);
+        grid.paint(position.row, position.col);
+    }
+
+    //activateClouds
+
+    private Position activateClouds(Position position){
+        Position newPosition;
+        Position beforeChangePosition = new Position(0,0);
+        boolean check = false;
+        while(!check) {
+            beforeChangePosition = new Position(position.row() + randomInt(), position.col() + randomInt());
+            if (beforeChangePosition.row < this.rowCount && beforeChangePosition.row > 0 && beforeChangePosition.col < this.colCount && beforeChangePosition.col > 0)
+                check = true;
+        }
+        newPosition = beforeChangePosition;
+        List<Position> nextFires = next(newPosition).stream().filter(fires::contains).toList();
+        extinguish(newPosition);
+        for (Position fire : nextFires)
+            extinguish(fire);
+        return newPosition;
+    }
+    private int randomInt () {
+        int min = 0, max=2;
+        int result = (int) (min + Math.floor ((max - min + 1) * Math.random ()));
+        return result-1;
+    }
+
+    private Position activateFirefighterMotorized(Position position) {
+        Position randomPosition = twoStepTowardFire(position);
+        //next(position).get((int) (Math.random()*next(position).size()));
+        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+        extinguish(randomPosition);
+        for (Position fire : nextFires)
+            extinguish(fire);
+        return randomPosition;
+    }
+
+    private List<Position> next(Position position){
+        List<Position> list = new ArrayList<>();
+        if(position.row>0) list.add(new Position(position.row-1, position.col));
+        if(position.col>0) list.add(new Position(position.row, position.col-1));
+        if(position.row<rowCount-1) list.add(new Position(position.row+1, position.col));
+        if(position.col<colCount-1) list.add(new Position(position.row, position.col+1));
+        return list;
+    }
+
+    private List<Position> nextTwoPosition(Position position){
+        List<Position> list = new ArrayList<>();
+        if(position.row>0) list.add(new Position(position.row-2, position.col));
+        if(position.col>0) list.add(new Position(position.row, position.col-2));
+        if(position.row<rowCount-1) list.add(new Position(position.row+2, position.col));
+        if(position.col<colCount-1) list.add(new Position(position.row, position.col+2));
+        return list;
+    }
+
+    private Position aStepTowardFire(Position position){
+        Queue<Position> toVisit = new LinkedList<>();
+        Set<Position> seen = new HashSet<>();
+        HashMap<Position,Position> firstMove = new HashMap<>();
+        toVisit.addAll(next(position));
+        for(Position initialMove : toVisit)
+            firstMove.put(initialMove,initialMove);
+        while(!toVisit.isEmpty()){
+            Position current = toVisit.poll();
+            if(fires.contains(current))
+                return firstMove.get(current);
+            for(Position adjacent : next(current)){
+                if(seen.contains(adjacent)) continue;
+                toVisit.add(adjacent);
+                seen.add(adjacent);
+                firstMove.put(adjacent, firstMove.get(current));
+            }
+        }
+        return position;
+    }
+
+    // pompiers motorisés
+
+    private Position twoStepTowardFire(Position position){
+        Queue<Position> toVisit = new LinkedList<>();
+        Set<Position> seen = new HashSet<>();
+        HashMap<Position,Position> firstMove = new HashMap<>();
+        toVisit.addAll(nextTwoPosition(position));
+        for(Position initialMove : toVisit)
+            firstMove.put(initialMove,initialMove);
+        while(!toVisit.isEmpty()){
+            Position current = toVisit.poll();
+            if(fires.contains(current))
+                return firstMove.get(current);
+            for(Position adjacent : nextTwoPosition(current)){
+                if(seen.contains(adjacent)) continue;
+                toVisit.add(adjacent);
+                seen.add(adjacent);
+                firstMove.put(adjacent, firstMove.get(current));
+            }
+        }
+        return position;
+    }
+
+
+    public record Position(int row, int col){}
+
+
+
+}
\ No newline at end of file

src/main/java/app/SimulatorApplication.java

-package app;
-
-import controller.Controller;
-import javafx.application.Platform;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.stage.Stage;
-
-import java.io.IOException;
-import java.net.URL;
-
-public class SimulatorApplication extends javafx.application.Application {
-  private static final String VIEW_RESOURCE_PATH = "/view/view.fxml";
-  private static final String APP_NAME = "Firefighter simulator";
-  private static final int ROW_COUNT = 20;
-  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;
-  private void initializePrimaryStage(Stage primaryStage) {
-    this.primaryStage = primaryStage;
-    this.primaryStage.setTitle(APP_NAME);
-    this.primaryStage.setOnCloseRequest(event -> Platform.exit());
-    this.primaryStage.setResizable(false);
-    this.primaryStage.sizeToScene();
-  }
-
-  @Override
-  public void start(Stage primaryStage) throws IOException {
-    initializePrimaryStage(primaryStage);
-    initializeView();
-    showScene();
-  }
-
-  private void initializeView() throws IOException {
-    FXMLLoader loader = new FXMLLoader();
-    URL location = SimulatorApplication.class.getResource(VIEW_RESOURCE_PATH);
-    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);
-  }
-
-  private void showScene() {
-    Scene scene = new Scene(view);
-    primaryStage.setScene(scene);
-    primaryStage.show();
-  }
-
-  public static void main(String[] args) {
-    launch(args);
-  }
-}

src/main/java/app/SimulatorMain.java

-package app;
-
-public class SimulatorMain {
-  public static void main(String[] args){
-    SimulatorApplication.main(args);
-  }
-}

src/main/java/controller/Controller.java

-package controller;
-
-import javafx.animation.Animation;
-import javafx.animation.KeyFrame;
-import javafx.animation.Timeline;
-import javafx.event.ActionEvent;
-import javafx.event.EventHandler;
-import javafx.fxml.FXML;
-import javafx.scene.control.Button;
-import javafx.scene.control.Label;
-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 util.Position;
-import view.Grid;
-import view.ViewElement;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static java.util.Objects.requireNonNull;
-
-public class Controller {
-
-  public static final int PERIOD_IN_MILLISECONDS = 50;
-  @FXML
-  public Button restartButton;
-  @FXML
-  public Button oneStepButton;
-  @FXML
-  public Label generationNumberLabel;
-  @FXML
-  private ToggleButton pauseToggleButton;
-  @FXML
-  private ToggleButton playToggleButton;
-  @FXML
-  private Grid<ViewElement> grid;
-  private Timeline timeline;
-  private Board<List<ModelElement>> board;
-
-  @FXML
-  private void initialize() {
-    initializePlayAndPauseToggleButtons();
-    initializeTimeline();
-  }
-
-  private void initializePlayAndPauseToggleButtons() {
-    ToggleGroup toggleGroup = new PersistentToggleGroup();
-    toggleGroup.getToggles().addAll(playToggleButton, pauseToggleButton);
-    pauseToggleButton.setSelected(true);
-  }
-
-  private void setModel(FirefighterBoard firefighterBoard) {
-    this.board = requireNonNull(firefighterBoard, "firefighter.model is null");
-  }
-
-  private void updateBoard(){
-    List<Position> updatedPositions = board.updateToNextGeneration();
-    List<Pair<Position, ViewElement>> updatedSquares = new ArrayList<>();
-    for(Position updatedPosition : updatedPositions){
-      List<ModelElement> squareState = board.getState(updatedPosition);
-      ViewElement viewElement = getViewElement(squareState);
-      updatedSquares.add(new Pair<>(updatedPosition, viewElement));
-    }
-    grid.repaint(updatedSquares);
-    updateGenerationLabel(board.stepNumber());
-  }
-
-  private void repaintGrid(){
-    int columnCount = board.columnCount();
-    int rowCount = board.rowCount();
-    ViewElement[][] viewElements = new ViewElement[rowCount][columnCount];
-    for(int column = 0; column < columnCount; column++)
-      for(int row = 0; row < rowCount; row++)
-        viewElements[row][column] = getViewElement(board.getState(new Position(row, column)));
-    grid.repaint(viewElements);
-    updateGenerationLabel(board.stepNumber());
-  }
-
-  private ViewElement getViewElement(List<ModelElement> squareState) {
-    if(squareState.contains(ModelElement.FIREFIGHTER)){
-      return ViewElement.FIREFIGHTER;
-    }
-    if (squareState.contains(ModelElement.FIRE)){
-      return ViewElement.FIRE;
-    }
-    return ViewElement.EMPTY;
-  }
-
-  private void initializeTimeline() {
-    Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);
-    EventHandler<ActionEvent> eventHandler =
-            event -> updateBoard();
-    KeyFrame keyFrame = new KeyFrame(duration, eventHandler);
-    timeline = new Timeline(keyFrame);
-    timeline.setCycleCount(Animation.INDEFINITE);
-  }
-
-  public void play() {
-    timeline.play();
-  }
-
-  public void pause() {
-    timeline.pause();
-  }
-
-  public void pauseToggleButtonAction() {
-    this.pause();
-  }
-
-  public void playToggleButtonAction() {
-    this.play();
-  }
-
-  public void restartButtonAction() {
-    this.pause();
-    board.reset();
-    pauseToggleButton.setSelected(true);
-    repaintGrid();
-  }
-
-  public void initialize(int squareWidth, int squareHeight, int columnCount,
-                                int rowCount, int initialFireCount, int initialFirefighterCount) {
-    grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
-    repaintGrid();
-  }
-
-  public void oneStepButtonAction() {
-    this.pause();
-    updateBoard();
-  }
-
-  private void updateGenerationLabel(int value){
-    generationNumberLabel.setText(Integer.toString(value));
-  }
-}
\ No newline at end of file

src/main/java/controller/PersistentToggleGroup.java

-package controller;
-
-import javafx.collections.ListChangeListener.Change;
-import javafx.scene.control.Toggle;
-import javafx.scene.control.ToggleButton;
-import javafx.scene.control.ToggleGroup;
-import javafx.scene.input.MouseEvent;
-
-/**
- * An extension of {@link ToggleGroup} that ensures that a {@link Toggle} in a group must always be
- * selected.
- *
- */
-class PersistentToggleGroup extends ToggleGroup {
-
-  /**
-   * Creates a new {@code PersistentToggleGroup}.
-   */
-  PersistentToggleGroup() {
-    getToggles().addListener((Change<? extends Toggle> change) -> {
-      while (change.next()) {
-        for (Toggle toggle : change.getAddedSubList()) {
-          ToggleButton toggleButton = (ToggleButton) toggle;
-          toggleButton.addEventFilter(MouseEvent.MOUSE_RELEASED, mouseEvent -> {
-            if (toggleButton.equals(getSelectedToggle())) {
-              mouseEvent.consume();
-            }
-          });
-        }
-      }
-    });
-  }
-
-}

src/main/java/model/Board.java

-package model;
-
-import util.Position;
-
-import java.util.List;
-
-/**
- * This interface represents a generic board for modeling various state-based systems.
- *
- * @param <S> The type of state represented on the board.
- */
-public interface Board<S> {
-
-  /**
-   * Get the state of the board at a specific position.
-   *
-   * @param position The position on the board for which to retrieve the state.
-   * @return The state at the specified position.
-   */
-  S getState(Position position);
-
-  /**
-   * Set the state of a specific position on the board to the specified state.
-   *
-   * @param state The state to set for the given position.
-   * @param position The position on the board for which to set the state.
-   */
-  void setState(S state, Position position);
-
-  /**
-   * Get the number of rows in the board.
-   *
-   * @return The number of rows in the board.
-   */
-  int rowCount();
-
-  /**
-   * Get the number of columns in the board.
-   *
-   * @return The number of columns in the board.
-   */
-  int columnCount();
-
-  /**
-   * Update the board to its next generation or state. This method may modify the
-   * internal state of the board and return a list of positions that have changed
-   * during the update.
-   *
-   * @return A list of positions that have changed during the update.
-   */
-  List<Position> updateToNextGeneration();
-
-  /**
-   * Reset the board to its initial state.
-   */
-  void reset();
-
-  /**
-   * Get the current step number or generation of the board.
-   *
-   * @return The current step number or generation.
-   */
-  int stepNumber();
-}
-

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 List<Position> firefighterPositions;
-  private Set<Position> firePositions;
-  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.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(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 = neighborClosestToFire(firefighterPosition);
-      firefighterNewPositions.add(newFirefighterPosition);
-      extinguish(newFirefighterPosition);
-      modifiedPosition.add(firefighterPosition);
-      modifiedPosition.add(newFirefighterPosition);
-      List<Position> neighborFirePositions = neighbors(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);
-  }
-
-  private 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;
-  }
-
-  private Position neighborClosestToFire(Position position) {
-    Set<Position> seen = new HashSet<>();
-    HashMap<Position, Position> firstMove = new HashMap<>();
-    Queue<Position> toVisit = new LinkedList<>(neighbors(position));
-    for (Position initialMove : toVisit)
-      firstMove.put(initialMove, initialMove);
-    while (!toVisit.isEmpty()) {
-      Position current = toVisit.poll();
-      if (firePositions.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;
-  }
-
-  @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

src/main/java/model/ModelElement.java

-package model;
-
-public enum ModelElement {
-  FIREFIGHTER, FIRE
-}

src/main/java/module-info.java

-module firefighter {
-  requires javafx.controls;
-  requires javafx.fxml;
-  requires javafx.graphics;
-  opens controller to javafx.fxml;
-  exports app;
-  opens app to javafx.fxml;
-}

src/main/java/util/Position.java

-package util;
-
-public record Position(int row, int column) {
-
-}

src/main/java/view/FirefighterGrid.java

-package view;
-
-import javafx.scene.canvas.Canvas;
-import javafx.scene.paint.Color;
-import javafx.util.Pair;
-import util.Position;
-
-import java.util.List;
-
-public class FirefighterGrid extends Canvas implements Grid<ViewElement>{
-
-    private void paintElementAtPosition(ViewElement element, Position position) {
-        paintBox(position.row(), position.column(), element.color);
-    }
-    private int boxWidth;
-    private int boxHeight;
-    private int columnCount;
-    private int rowCount;
-
-    @Override
-    public void repaint(List<Pair<Position, ViewElement>> positionedElements) {
-        clear(positionedElements);
-        paint(positionedElements);
-        paintLines();
-    }
-
-    private void clear(List<Pair<Position, ViewElement>> positionedElements) {
-        for (Pair<Position, ViewElement> positionElement : positionedElements) {
-            Position position = positionElement.getKey();
-            clearBox(position.row(), position.column());
-        }
-    }
-
-    private void paint(List<Pair<Position, ViewElement>> positionedElements) {
-        for(Pair<Position, ViewElement> pair : positionedElements){
-            paintElementAtPosition(pair.getValue(), pair.getKey());
-        }
-    }
-
-    @Override
-    public void repaint(ViewElement[][] elements) {
-        clear();
-        paint(elements);
-        paintLines();
-    }
-
-    private void clear() {
-        getGraphicsContext2D().clearRect(0,0,getWidth(), getHeight());
-    }
-
-    private void paint(ViewElement[][] elements) {
-        for(int column = 0; column < columnCount; column++)
-            for(int row = 0; row < rowCount; row++){
-                paintElementAtPosition(elements[row][column], new Position(row, column));
-            }
-    }
-
-    public int columnCount() {
-        return columnCount;
-    }
-
-    public int rowCount() {
-        return rowCount;
-    }
-
-    @Override
-    public void setDimensions(int columnCount, int rowCount, int boxWidth, int boxHeight) {
-        this.boxWidth = boxWidth;
-        this.boxHeight = boxHeight;
-        this.columnCount = columnCount;
-        this.rowCount = rowCount;
-        super.setWidth(boxWidth * columnCount);
-        super.setHeight(boxHeight * rowCount);
-    }
-
-    private void paintLines(){
-        paintHorizontalLines();
-        paintVerticalLines();
-    }
-
-    private void paintVerticalLines() {
-        for(int column = 0; column < columnCount; column++)
-            getGraphicsContext2D().strokeLine(column * boxWidth, 0,column * boxWidth, getHeight());
-    }
-
-    private void paintHorizontalLines() {
-        for(int row = 0; row < rowCount; row++)
-            getGraphicsContext2D().strokeLine(0, row * boxHeight, getWidth(), row * boxHeight);
-    }
-
-    private void paintBox(int row, int column, Color color){
-        getGraphicsContext2D().setFill(color);
-        getGraphicsContext2D().fillRect(column * boxWidth,row * boxHeight, boxWidth, boxHeight);
-    }
-
-    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/Grid.java

-package view;
-
-import javafx.util.Pair;
-import util.Position;
-
-import java.util.List;
-
-/**
- * This interface represents a generic grid structure for displaying two-dimensional data.
- *
- * @param <E> The type of elements stored in the grid.
- */
-public interface Grid<E> {
-
-  /**
-   * Repaint the grid with a list of elements, each associated with their respective positions.
-   *
-   * @param elements A list of pairs, each containing a position and the element to be displayed at that position.
-   */
-  void repaint(List<Pair<Position, E>> elements);
-
-  /**
-   * Repaint the grid with a two-dimensional array of elements. The array's dimensions should match
-   * the row and column count of the grid.
-   *
-   * @param elements A two-dimensional array of elements to be displayed on the grid.
-   */
-  void repaint(E[][] elements);
-
-  /**
-   * Set the dimensions of the grid to the specified number of columns, number of rows, square width,
-   * and square height.
-   *
-   * @param columnCount The new number of columns in the grid.
-   * @param rowCount The new number of rows in the grid.
-   * @param squareWidth The width of each square within the grid.
-   * @param squareHeight The height of each square within the grid.
-   */
-  void setDimensions(int columnCount, int rowCount, int squareWidth, int squareHeight);
-
-  /**
-   * Get the number of columns in the grid.
-   *
-   * @return The number of columns in the grid.
-   */
-  int columnCount();
-
-  /**
-   * Get the number of rows in the grid.
-   *
-   * @return The number of rows in the grid.
-   */
-  int rowCount();
-}
-

src/main/java/view/ViewElement.java

-package view;
-
-import javafx.scene.paint.Color;
-
-public enum ViewElement {
-  FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE);
-  final Color color;
-  ViewElement(Color color) {
-    this.color = color;
-  }
-}