Implmentation of MotorizedFireFighter

src/main/java/app/SimulatorApplication.java

@@ -17,10 +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) {
@@ -45,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_CLOUD_COUNT);
+            INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT,INITIAL_MOTORIZEDFIREFIGHTER_COUNT);
   }
 
   private void showScene() {

src/main/java/controller/Controller.java

@@ -109,9 +109,9 @@ public class Controller {
   }
 
   public void initialize(int squareWidth, int squareHeight, int columnCount,
-                         int rowCount, int initialFireCount, int initialFirefighterCount,int initialCloudCount) {
+                         int rowCount, int initialFireCount, int initialFirefighterCount,int initialCloudCount,int initialMotorizedFireFighterCount) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    board = new GameBoard(rowCount,columnCount,initialFireCount,initialFirefighterCount,initialCloudCount);
+    board = new GameBoard(rowCount,columnCount,initialFireCount,initialFirefighterCount,initialCloudCount,initialMotorizedFireFighterCount);
     board.initializeElements();
     repaintGrid();
   }

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

 package model.Builder;
 
 public class FireFirefightersBuilder {
-    public void Build(int fires, int firefighters , int clouds) {
+    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/GameManage.java

@@ -3,6 +3,7 @@ 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 {
@@ -35,6 +36,9 @@ public class GameManage {
         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/ExtinguishFire/Cloud.java

@@ -55,20 +55,20 @@ public class Cloud implements ExtinguishFire{
         List<Position> neighbors = gameBoard.neighbors(position);
         Random random = new Random();
         int randomIndex = random.nextInt(neighbors.size());
-        Position newFirefighterPosition = neighbors.get(randomIndex);
-        if(newElementPosition.containsKey(newFirefighterPosition)){
-            newElementPosition.get(newFirefighterPosition).add(this);
+        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(newFirefighterPosition,boardElements);
+            newElementPosition.put(newCloudPosition,boardElements);
         }
-        extinguishPosition.add(newFirefighterPosition);
-        List<Position> neighborFirePositions = gameBoard.neighbors(newFirefighterPosition).stream()
+        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/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);
+        }
+    }
 }

src/main/java/model/Flammable/Fire.java

@@ -78,8 +78,8 @@ public class Fire implements Flammable{
                 newElementPosition.get(position).add(this);
             }
             for(Position newPosition : newPositions){
-                //if(extinguishPosition.contains(newPosition))
-                    //continue;
+                if(extinguishPosition.contains(newPosition))
+                    continue;
                 if(GameBoard.elementPosition.containsKey(newPosition)) {
                     for(BoardElement boardElement : GameBoard.elementPosition.get(newPosition)){
                         if(boardElement.accept(new FireFinder()) && boardElement.accept(new CrossRoad()) && boardElement.accept(new CrossMountain())){

src/main/java/model/GameBoard.java

@@ -15,6 +15,7 @@ public class GameBoard implements Board{
     private int initialFireCount;
     private int initialFirefighterCount;
     private int initialCloudCount;
+    private int initialMotorizedFireFighterCount;
     private int step = 0;
     static Random randomGenerator = new Random();
 
@@ -24,17 +25,18 @@ public class GameBoard implements Board{
 
     public static HashMap<Position, ArrayList<BoardElement>> elementPosition=new HashMap<>();
 
-    public GameBoard(int columnCount,int rowCount,int initialFireCount, int initialFirefighterCount,int initialCloudCount) {
+    public GameBoard(int columnCount,int rowCount,int initialFireCount, int initialFirefighterCount,int initialCloudCount,int initialMotorizedFireFighterCount) {
         this.columnCount = columnCount;
         this.rowCount = rowCount;
         this.initialFireCount = initialFireCount;
         this.initialFirefighterCount = initialFirefighterCount;
         this.initialCloudCount = initialCloudCount;
+        this.initialMotorizedFireFighterCount=initialMotorizedFireFighterCount;
     }
 
     public void initializeElements(){
         FireFirefightersBuilder fireFirefighterBuilder=new FireFirefightersBuilder();
-        fireFirefighterBuilder.Build(this.initialFireCount,this.initialFirefighterCount,this.initialCloudCount);
+        fireFirefighterBuilder.Build(this.initialFireCount,this.initialFirefighterCount,this.initialCloudCount,this.initialMotorizedFireFighterCount);
     }
 
     public static Position randomPosition() {