Merge remote-tracking branch 'origin/main'

# Conflicts:
#	.gradle/8.4/checksums/checksums.lock
#	.gradle/8.4/checksums/md5-checksums.bin
#	.gradle/8.4/checksums/sha1-checksums.bin
#	.gradle/8.4/dependencies-accessors/dependencies-accessors.lock
#	.gradle/8.4/executionHistory/executionHistory.bin
#	.gradle/8.4/executionHistory/executionHistory.lock
#	.gradle/8.4/fileHashes/fileHashes.bin
#	.gradle/8.4/fileHashes/fileHashes.lock
#	.gradle/8.4/fileHashes/resourceHashesCache.bin
#	.gradle/buildOutputCleanup/buildOutputCleanup.lock
#	.gradle/buildOutputCleanup/cache.properties
#	.gradle/buildOutputCleanup/outputFiles.bin
#	build/classes/java/main/app/SimulatorApplication.class
#	build/classes/java/main/controller/Controller.class
#	build/classes/java/main/model/Board.class
#	build/classes/java/main/model/BoardElement.class
#	build/classes/java/main/model/EmptyElement.class
#	build/classes/java/main/model/ExtinguishFire/Cloud.class
#	build/classes/java/main/model/ExtinguishFire/ExtinguishFire.class
#	build/classes/java/main/model/ExtinguishFire/FireFighter.class
#	build/classes/java/main/model/Flammable/Fire.class
#	build/classes/java/main/model/Flammable/Flammable.class
#	build/classes/java/main/model/GameBoard.class
#	build/classes/java/main/model/Visitor/CrossMountain.class
#	build/classes/java/main/model/Visitor/CrossRoad.class
#	build/classes/java/main/model/Visitor/FireFinder.class
#	build/classes/java/main/model/Visitor/Visitor.class
#	build/classes/java/main/module-info.class
#	build/tmp/compileJava/compileTransaction/stash-dir/ExtinguishFire.class.uniqueId0
#	build/tmp/compileJava/previous-compilation-data.bin

src/main/java/app/SimulatorApplication.java

@@ -17,9 +17,10 @@ public class SimulatorApplication extends javafx.application.Application {
   private static final int COLUMN_COUNT = 20;
   private static final int SQUARE_WIDTH = 30;
   private static final int SQUARE_HEIGHT = 30;
-  public static final int INITIAL_FIRE_COUNT = 3;
-  public static final int INITIAL_FIREFIGHTER_COUNT = 6;
-
+  public static final int INITIAL_FIRE_COUNT = 5;
+  public static final int INITIAL_FIREFIGHTER_COUNT = 3;
+  public static final int INITIAL_CLOUD_COUNT = 2;
+  public static final int INITIAL_MOTORIZEDFIREFIGHTER_COUNT = 2;
   private Stage primaryStage;
   private Parent view;
   private void initializePrimaryStage(Stage primaryStage) {
@@ -44,7 +45,7 @@ public class SimulatorApplication extends javafx.application.Application {
     view = loader.load();
     Controller controller = loader.getController();
     controller.initialize(SQUARE_WIDTH, SQUARE_HEIGHT, COLUMN_COUNT, ROW_COUNT,
-            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT);
+            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT,INITIAL_MOTORIZEDFIREFIGHTER_COUNT);
   }
 
   private void showScene() {

src/main/java/controller/Controller.java

@@ -10,14 +10,9 @@ import javafx.scene.control.Button;
 import javafx.scene.control.Label;
 import javafx.scene.control.ToggleButton;
 import javafx.scene.control.ToggleGroup;
-import javafx.scene.paint.Color;
 import javafx.util.Duration;
 import javafx.util.Pair;
 import model.*;
-import model.ExtinguishFire.FireFighter;
-import model.Flammable.Fire;
-import model.Visitor.FireFighterFinder;
-import model.Visitor.FireFinder;
 import util.Position;
 import view.Grid;
 
@@ -56,20 +51,13 @@ public class Controller {
     pauseToggleButton.setSelected(true);
   }
 
-  private void setModel(GameBoard gameBoard) {
+ /* private void setModel(GameBoard gameBoard) {
     this.board = requireNonNull(gameBoard, "GameBoard.model is null");
-  }
+  }*/
 
   private void updateBoard(){
-    List<Position> updatedPositions = board.updateToNextGeneration();
-    List<Pair<Position, BoardElement>> updatedSquares = new ArrayList<>();
-    for(Position updatedPosition : updatedPositions){
-      List<BoardElement> squareState = board.getState(updatedPosition);
-      BoardElement boardElement = getViewElement(squareState);
-      updatedSquares.add(new Pair<>(updatedPosition,boardElement));
-    }
-    grid.repaint(updatedSquares);
-    updateGenerationLabel(board.stepNumber());
+    board.updateToNextGeneration();
+    repaintGrid();
   }
 
   private void repaintGrid(){
@@ -78,7 +66,7 @@ public class Controller {
     model.BoardElement[][] boardElements = new model.BoardElement[rowCount][columnCount];
     for(int column = 0; column < columnCount; column++)
       for(int row = 0; row < rowCount; row++){
-        if(board.getElementPosition().containsKey(new Position(row,column))){
+        if(board.getElementPosition().containsKey(new Position(row,column)) && board.getElementPosition().get(new Position(row,column)).size()!=0){
           boardElements[row][column] = board.getElementPosition().get(new Position(row,column)).get(0);
         }else{
           boardElements[row][column]=new EmptyElement();
@@ -88,19 +76,6 @@ public class Controller {
     updateGenerationLabel(board.stepNumber());
   }
 
-  private BoardElement getViewElement(List<BoardElement> squareState) {
-    for (BoardElement boardElement : squareState) {
-      if (boardElement.accept(new FireFinder())) {
-        return new Fire(Color.RED);
-      } else if (boardElement.accept(new FireFighterFinder())) {
-        return new FireFighter(Color.BLUE);
-      }
-    }
-        return new EmptyElement();
-
-    }
-
-
   private void initializeTimeline() {
     Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);
     EventHandler<ActionEvent> eventHandler =
@@ -134,9 +109,10 @@ public class Controller {
   }
 
   public void initialize(int squareWidth, int squareHeight, int columnCount,
-                                int rowCount, int initialFireCount, int initialFirefighterCount) {
+                         int rowCount, int initialFireCount, int initialFirefighterCount,int initialCloudCount,int initialMotorizedFireFighterCount) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new GameBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
+    board = new GameBoard(rowCount,columnCount,initialFireCount,initialFirefighterCount,initialCloudCount,initialMotorizedFireFighterCount);
+    board.initializeElements();
     repaintGrid();
   }
 

src/main/java/model/Board.java

@@ -48,7 +48,7 @@ public interface Board<S> {
    *
    * @return A list of positions that have changed during the update.
    */
-  List<Position> updateToNextGeneration();
+  void updateToNextGeneration();
 
   /**
    * Reset the board to its initial state.

src/main/java/model/BoardElement.java

@@ -13,5 +13,5 @@ public interface BoardElement {
 
     Color getColor();
     Boolean accept(Visitor visitor);
-    void initialize(int initialElementCount, HashMap<Position, ArrayList<BoardElement>> elementPosition);
+    void initialize();
 }

src/main/java/model/Builder/ConcreteGameBuilder.java

+package model.Builder;
+
+public class ConcreteGameBuilder implements GameBuilder{
+    int firefighter=0;
+    int fire=0;
+    int clouds=0;
+    int motorizedFireFighters=0;
+    int roads=0;
+    int mountains=0;
+    @Override
+    public GameBuilder setFire(int fires) {
+        this.fire=fires;
+        return this;
+    }
+
+    @Override
+    public GameBuilder setFireFighter(int fireFighters) {
+        this.firefighter=fireFighters;
+        return this;
+    }
+
+    @Override
+    public GameBuilder setCloud(int clouds) {
+        this.clouds=clouds;
+        return this;
+    }
+
+    @Override
+    public GameBuilder setMotorizedFireFighter(int motorizedFireFighters) {
+        this.motorizedFireFighters=motorizedFireFighters;
+        return this;
+    }
+
+    @Override
+    public GameBuilder setMountain(int mountains) {
+        this.mountains=mountains;
+        return this;
+    }
+
+    @Override
+    public GameManage build() {
+        return new GameManage(fire,firefighter,clouds,motorizedFireFighters,roads,mountains);
+    }
+}
\ No newline at end of file

src/main/java/model/Builder/FireFirefightersBuilder.java

+package model.Builder;
+
+public class FireFirefightersBuilder {
+    public void Build(int fires, int firefighters , int clouds , int motorizedFireFighter) {
+        ConcreteGameBuilder concreteGameBuilder;
+        concreteGameBuilder =new ConcreteGameBuilder();
+        concreteGameBuilder.setFire(fires)
+                .setFireFighter(firefighters)
+                .setCloud(clouds)
+                .setMotorizedFireFighter(motorizedFireFighter)
+                .build();
+    }
+}

src/main/java/model/Builder/GameBuilder.java

+package model.Builder;
+
+public interface GameBuilder {
+
+        model.Builder.GameBuilder setFire(int fire);
+        model.Builder.GameBuilder setFireFighter(int fireFighter);
+        model.Builder.GameBuilder setCloud(int cloud);
+        model.Builder.GameBuilder setMotorizedFireFighter(int motorizedFireFighter);
+        model.Builder.GameBuilder setMountain(int mountain);
+
+        // TODO: 15/11/2023 la suite
+        GameManage build();
+
+}

src/main/java/model/Builder/GameManage.java

+package model.Builder;
+
+import javafx.scene.paint.Color;
+import model.ExtinguishFire.Cloud;
+import model.ExtinguishFire.FireFighter;
+import model.ExtinguishFire.MotorizedFireFighter;
+import model.Flammable.Fire;
+
+public class GameManage {
+    private final int fires;
+    private final int firefighters;
+    private final int clouds;
+    private final int motorizedFireFighters;
+    private final int roads;
+    private final int mountains;
+
+
+
+    public GameManage(int fires, int firefighters, int clouds, int motorizedFireFighters, int roads, int mountains) {
+        this.fires = fires;
+        this.firefighters = firefighters;
+        this.clouds = clouds;
+        this.motorizedFireFighters = motorizedFireFighters;
+        this.roads = roads;
+        this.mountains = mountains;
+        Initialize();
+    }
+
+    public void Initialize(){
+        for(int i=0;i<fires;i++) {
+            new Fire(Color.RED);
+        }
+        for(int i=0;i<firefighters;i++) {
+            new FireFighter(Color.BLUE);
+        }
+        for(int i=0;i<clouds;i++) {
+            new Cloud(Color.DARKBLUE);
+        }
+        for(int i=0;i<motorizedFireFighters;i++) {
+            new MotorizedFireFighter(Color.ORANGE);
+        }
+        // TODO: 15/11/2023  la suite .... aussi l'initialisation va changer dans fire et firefighter
+    }
+
+}
+

src/main/java/model/EmptyElement.java

@@ -19,7 +19,7 @@ public class EmptyElement implements BoardElement{
     }
 
     @Override
-    public void initialize(int initialElementCount, HashMap<Position, ArrayList<BoardElement>> elementPosition) {
+    public void initialize() {
 
     }
 }

src/main/java/model/ExtinguishFire/Cloud.java

 package model.ExtinguishFire;
 
-public class Cloud {
+import javafx.scene.paint.Color;
+import model.BoardElement;
+import model.GameBoard;
+import model.Visitor.FireFinder;
+import model.Visitor.Visitor;
+import util.Position;
+
+import java.util.*;
+
+import static model.GameBoard.elementPosition;
+import static model.GameBoard.randomPosition;
+
+public class Cloud implements ExtinguishFire{
+
+    Color color;
+
+    public Cloud(Color color){
+        this.color=color;
+        initialize();
+    }
+    @Override
+    public Color getColor() {
+        return color;
+    }
+
+    @Override
+    public Boolean accept(Visitor visitor) {
+        return visitor.visit(this);
+    }
+
+    @Override
+    public void initialize() {
+        Position position = GameBoard.randomPosition();
+        if (elementPosition.containsKey(position))
+            elementPosition.get(position).add(this);
+        else {
+            ArrayList<BoardElement> boardElements = new ArrayList<>();
+            boardElements.add(this);
+            elementPosition.put(position, boardElements);
+        }
+    }
+
+    @Override
+    public void update(GameBoard gameBoard, Position position, HashMap<Position, ArrayList<BoardElement>> newElementPosition, ArrayList<Position> extinguishPosition) {
+        List<Position> firePositions = new ArrayList<>();
+        for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPosition.entrySet()) {
+            for (BoardElement element : entry.getValue()) {
+                if (element.accept(new FireFinder())) {
+                    firePositions.add(entry.getKey());
+                }
+            }
+        }
+        List<Position> neighbors = gameBoard.neighbors(position);
+        Random random = new Random();
+        int randomIndex = random.nextInt(neighbors.size());
+        Position newCloudPosition = neighbors.get(randomIndex);
+        if(newElementPosition.containsKey(newCloudPosition)){
+            newElementPosition.get(newCloudPosition).add(this);
+        }
+        else{
+            ArrayList<BoardElement> boardElements = new ArrayList<>();
+            boardElements.add(this);
+            newElementPosition.put(newCloudPosition,boardElements);
+        }
+        extinguishPosition.add(newCloudPosition);
+        /*List<Position> neighborFirePositions = gameBoard.neighbors(newFirefighterPosition).stream()
+                .filter(firePositions::contains).toList();
+        for(Position firePosition : neighborFirePositions) {
+            extinguishPosition.add(firePosition);
+        }*/
+    }
 }

src/main/java/model/ExtinguishFire/ExtinguishFire.java

@@ -6,12 +6,9 @@ import util.Position;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 
 public interface ExtinguishFire extends BoardElement {
 
-    void initialize(int initialFireFighterCount, HashMap<Position, ArrayList<BoardElement>> elementPosition);
-
-    List<Position> updateFirefighters(GameBoard gameBoard);
+    void update(GameBoard gameBoard , Position position, HashMap<Position, ArrayList<BoardElement>> newElementPosition, ArrayList<Position> extinguishPosition);
 
 }

src/main/java/model/ExtinguishFire/FireFighter.java

@@ -2,9 +2,8 @@ package model.ExtinguishFire;
 
 import javafx.scene.paint.Color;
 import model.BoardElement;
-import model.Flammable.Fire;
 import model.GameBoard;
-import model.Visitor.FireFighterFinder;
+import model.Visitor.CrossMountain;
 import model.Visitor.FireFinder;
 import model.Visitor.Visitor;
 import util.Position;
@@ -14,10 +13,13 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static model.GameBoard.elementPosition;
+
 public class FireFighter implements ExtinguishFire {
     Color color;
     public FireFighter(Color color){
         this.color=color;
+        initialize();
     }
     @Override
     public Color getColor() {
@@ -30,16 +32,15 @@ public class FireFighter implements ExtinguishFire{
     }
 
     @Override
-    public void initialize(int initialFireFighterCount, HashMap<Position, ArrayList<BoardElement>> elementPosition) {
-        FireFinder fireFinder=new FireFinder();
+    public void initialize( ) {
+        CrossMountain crossMountain=new CrossMountain();
         boolean canInitialise;
-        for (int index = 0; index < initialFireFighterCount; index++) {
         Position position = GameBoard.randomPosition();
         if(elementPosition.containsKey(position)) {
             for (;;) {
                 canInitialise = true;
                 for (BoardElement element : elementPosition.get(position)) {
-                        if (element.accept(fireFinder)) {
+                    if (element.accept(crossMountain)) {
                         canInitialise = false;
                         break;
                     }
@@ -51,48 +52,46 @@ public class FireFighter implements ExtinguishFire{
                 if (!elementPosition.containsKey(position)) break;
             }
             if (elementPosition.containsKey(position))
-                    elementPosition.get(position).add(new FireFighter(Color.BLUE));
+                elementPosition.get(position).add(this);
             else {
                 ArrayList<BoardElement> boardElements = new ArrayList<>();
-                    boardElements.add(new FireFighter(Color.BLUE));
+                boardElements.add(this);
                 elementPosition.put(position, boardElements);
             }
-                continue;
+
         }
         ArrayList<BoardElement> boardElements = new ArrayList<>();
-            boardElements.add(new FireFighter(Color.BLUE));
+        boardElements.add(this);
         elementPosition.put(position,boardElements);
     }
-    }
 
     @Override
-    public List<Position> updateFirefighters(GameBoard gameBoard) {
-        List<Position> result = new ArrayList<>();
-        List<Position> firefighterPositions = new ArrayList<>();
+    public void update(GameBoard gameBoard, Position position, HashMap<Position, ArrayList<BoardElement>> newElementPosition, ArrayList<Position> extinguishPosition) {
+
             List<Position> firePositions = new ArrayList<>();
-        for (Map.Entry<Position, ArrayList<BoardElement>> entry : gameBoard.getElementPosition().entrySet()) {
+            for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPosition.entrySet()) {
                 for (BoardElement element : entry.getValue()) {
-                if (element.accept(new FireFighterFinder())) {
-                    firefighterPositions.add(entry.getKey());
-                }
                     if (element.accept(new FireFinder())) {
                      firePositions.add(entry.getKey());
                     }
                 }
             }
-        for (Position firefighterPosition : firefighterPositions) {
-            Position newFirefighterPosition = gameBoard.neighborClosestToFire(firefighterPosition);
-            gameBoard.getElementPosition().get(newFirefighterPosition).add(new FireFighter(Color.BLUE));
-            gameBoard.extinguish(newFirefighterPosition);
-            result.add(firefighterPosition);
-            result.add(newFirefighterPosition);
+            Position newFirefighterPosition = gameBoard.neighborClosestToFire(position);
+            if(newElementPosition.containsKey(newFirefighterPosition)){
+                newElementPosition.get(newFirefighterPosition).add(this);
+            }
+            else{
+                ArrayList<BoardElement> boardElements = new ArrayList<>();
+                boardElements.add(this);
+                newElementPosition.put(newFirefighterPosition,boardElements);
+            }
+            extinguishPosition.add(newFirefighterPosition);
             List<Position> neighborFirePositions = gameBoard.neighbors(newFirefighterPosition).stream()
                     .filter(firePositions::contains).toList();
-            for(Position firePosition : neighborFirePositions)
-                gameBoard.extinguish(firePosition);
-            result.addAll(neighborFirePositions);
+            for(Position firePosition : neighborFirePositions) {
+                extinguishPosition.add(firePosition);
             }
-        return result;
+
         }
 
 }

src/main/java/model/ExtinguishFire/MotorizedFireFighter.java

 package model.ExtinguishFire;
 
-public class MotorizedFireFighter {
+import javafx.scene.paint.Color;
+import model.BoardElement;
+import model.GameBoard;
+import model.Visitor.CrossMountain;
+import model.Visitor.FireFinder;
+import model.Visitor.Visitor;
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static model.GameBoard.elementPosition;
+
+public class MotorizedFireFighter implements ExtinguishFire {
+
+    Color color;
+
+    public MotorizedFireFighter(Color color){
+        this.color=color;
+        initialize();
+    }
+    @Override
+    public Color getColor() {
+        return color;
+    }
+
+    @Override
+    public Boolean accept(Visitor visitor) {
+        return visitor.visit(this);
+    }
+
+    @Override
+    public void initialize() {
+        CrossMountain crossMountain=new CrossMountain();
+        boolean canInitialise;
+        Position position = GameBoard.randomPosition();
+        if(elementPosition.containsKey(position)) {
+            for (;;) {
+                canInitialise = true;
+                for (BoardElement element : elementPosition.get(position)) {
+                    if (element.accept(crossMountain)) {
+                        canInitialise = false;
+                        break;
+                    }
+                }
+                if (canInitialise) {
+                    break;
+                }
+                position = GameBoard.randomPosition();
+                if (!elementPosition.containsKey(position)) break;
+            }
+            if (elementPosition.containsKey(position))
+                elementPosition.get(position).add(this);
+            else {
+                ArrayList<BoardElement> boardElements = new ArrayList<>();
+                boardElements.add(this);
+                elementPosition.put(position, boardElements);
+            }
+
+        }
+        ArrayList<BoardElement> boardElements = new ArrayList<>();
+        boardElements.add(this);
+        elementPosition.put(position,boardElements);
+    }
+
+    @Override
+    public void update(GameBoard gameBoard, Position position, HashMap<Position, ArrayList<BoardElement>> newElementPosition, ArrayList<Position> extinguishPosition) {
+
+        List<Position> firePositions = new ArrayList<>();
+        for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPosition.entrySet()) {
+            for (BoardElement element : entry.getValue()) {
+                if (element.accept(new FireFinder())) {
+                    firePositions.add(entry.getKey());
+                }
+            }
+        }
+        ArrayList<Position> newMotorizedFireFighterPositions = new ArrayList<>();
+        Position newMotorizedFireFighterPosition1 = gameBoard.neighborClosestToFire(position);
+        newMotorizedFireFighterPositions.add(newMotorizedFireFighterPosition1);
+        Position newMotorizedFireFighterPosition2 = gameBoard.neighborClosestToFire(newMotorizedFireFighterPosition1);
+        newMotorizedFireFighterPositions.add(newMotorizedFireFighterPosition2);
+
+        if(newElementPosition.containsKey(newMotorizedFireFighterPosition2)){
+            newElementPosition.get(newMotorizedFireFighterPosition2).add(this);
+        }
+        else{
+            ArrayList<BoardElement> boardElements = new ArrayList<>();
+            boardElements.add(this);
+            newElementPosition.put(newMotorizedFireFighterPosition2,boardElements);
+        }
+        for(Position newPosition : newMotorizedFireFighterPositions) {
+            extinguishPosition.add(newPosition);
+        }
+        List<Position> neighborFirePositions = new ArrayList<>();
+        neighborFirePositions.addAll(gameBoard.neighbors(newMotorizedFireFighterPosition1).stream()
+                .filter(firePositions::contains).toList());
+        neighborFirePositions.addAll(gameBoard.neighbors(newMotorizedFireFighterPosition2).stream()
+                .filter(firePositions::contains).toList());
+        for(Position firePosition : neighborFirePositions) {
+            extinguishPosition.add(firePosition);
+        }
+    }
 }