Some modifications in update method related to firefighter

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(){
@@ -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 =
@@ -136,7 +111,8 @@ public class Controller {
   public void initialize(int squareWidth, int squareHeight, int columnCount,
                          int rowCount, int initialFireCount, int initialFirefighterCount) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new GameBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
+    board = new GameBoard(rowCount,columnCount,initialFireCount,initialFirefighterCount);
+    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/FireFirefighterBuilder.java

+package model.Builder;
+
+public class FireFirefighterBuilder {
+    public void Build(int fires, int firefighters) {
+        ConcreteGameBuilder concreteGameBuilder;
+        concreteGameBuilder =new ConcreteGameBuilder();
+        concreteGameBuilder.setFire(fires)
+                .setFireFighter(firefighters)
+                .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.FireFighter;
+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.GRAY);
+        }
+        // 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/ExtinguishFire.java

@@ -10,8 +10,6 @@ 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);
 
 }

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,49 +52,61 @@ 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>> elementPositionCopie = new HashMap<>();
+            for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPosition.entrySet()){
+                elementPositionCopie.put(entry.getKey(),entry.getValue());
+            }
             List<Position> firePositions = new ArrayList<>();
-        for (Map.Entry<Position, ArrayList<BoardElement>> entry : gameBoard.getElementPosition().entrySet()) {
+            for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPositionCopie.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));
+            Position newFirefighterPosition = gameBoard.neighborClosestToFire(position);
+            if(elementPositionCopie.containsKey(newFirefighterPosition)){
+                elementPositionCopie.get(newFirefighterPosition).add(new FireFighter(Color.BLUE));
+            }
+            else{
+                ArrayList<BoardElement> boardElements = new ArrayList<>();
+                boardElements.add(new FireFighter(Color.BLUE));
+                elementPosition.put(newFirefighterPosition,boardElements);
+            }
             gameBoard.extinguish(newFirefighterPosition);
-            result.add(firefighterPosition);
-            result.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 newposition : neighborFirePositions){
+                if(elementPositionCopie.containsKey(newposition)){
+                    elementPosition.get(newposition).add(new FireFighter(Color.BLUE));
+                }
+                else{
+                    ArrayList<BoardElement> boardElements = new ArrayList<>();
+                    boardElements.add(new FireFighter(Color.BLUE));
+                    elementPosition.put(newposition,boardElements);
                 }
-        return result;
             }
 
+            for(Position firePosition : neighborFirePositions) {
+                gameBoard.extinguish(firePosition);
+            }
+
+        }
 }
 

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

@@ -3,6 +3,8 @@ package model.Flammable;
 import javafx.scene.paint.Color;
 import model.BoardElement;
 import model.GameBoard;
+import model.Visitor.CrossMountain;
+import model.Visitor.CrossRoad;
 import model.Visitor.FireFinder;
 import model.Visitor.Visitor;
 import util.Position;
@@ -15,6 +17,7 @@ public class Fire implements Flammable{
 
     public Fire(Color color){
         this.color = color;
+        initialize();
     }
 
     @Override
@@ -28,15 +31,14 @@ public class Fire implements Flammable{
     }
 
     @Override
-    public void initialize(int initialFireCount, HashMap<Position, ArrayList<BoardElement>> elementPosition) {
+    public void initialize() {
         FireFinder fireFinder=new FireFinder();
         Position position = GameBoard.randomPosition();
         boolean canInitialise;
-        for (int index = 0; index < initialFireCount; index++) {
-            if(elementPosition.containsKey(position)) {
+        if(GameBoard.elementPosition.containsKey(position)) {
             for (;;) {
                 canInitialise=true;
-                    for (BoardElement element : elementPosition.get(position)) {
+                for (BoardElement element : GameBoard.elementPosition.get(position)) {
                     if (element.accept(fireFinder)) {
                         canInitialise=false;
                         break;
@@ -46,43 +48,51 @@ public class Fire implements Flammable{
                     break;
                 }
                 position = GameBoard.randomPosition();
-                    if(!elementPosition.containsKey(position))break;
+                if(!GameBoard.elementPosition.containsKey(position))break;
             }
-                 if(elementPosition.containsKey(position))
-                      elementPosition.get(position).add(new Fire(Color.RED));
+            if(GameBoard.elementPosition.containsKey(position))
+                GameBoard.elementPosition.get(position).add(this);
             else{
                 ArrayList<BoardElement> boardElements = new ArrayList<>();
-                     boardElements.add(new Fire(Color.RED));
-                     elementPosition.put(position,boardElements);
+                boardElements.add(this);
+                GameBoard.elementPosition.put(position,boardElements);
             }
-                 continue;
         }
         ArrayList<BoardElement> boardElements = new ArrayList<>();
-            boardElements.add(new Fire(Color.RED));
-            elementPosition.put(position,boardElements);
-            }
+        boardElements.add(this);
+        GameBoard.elementPosition.put(position,boardElements);
     }
 
-    @Override
-    public List<Position> updateFlammable(GameBoard gameBoard) {
-            FireFinder fireFinder=new FireFinder();
-            List<Position> result = new ArrayList<>();
+    @Override   // TODO: 15/11/2023
+    public void update(GameBoard gameBoard , Position position) {
+
         if (gameBoard.stepNumber() % 2 == 0) {
             List<Position> newFirePositions = new ArrayList<>();
-                for (Map.Entry<Position, ArrayList<BoardElement>> entry : gameBoard.getElementPosition().entrySet()){
-                    for(BoardElement element : entry.getValue()){
-                        if (element.accept(fireFinder)){
-                            newFirePositions.addAll(gameBoard.neighbors(entry.getKey()));
+            newFirePositions.addAll(gameBoard.neighbors(position));
+            for(Position newPosition : newFirePositions){
+                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())){
+                            break;
+                        }
+                        else if(!boardElement.accept( new FireFinder())&& !boardElement.accept(new CrossRoad()) && !boardElement.accept(new CrossMountain())){
+                            GameBoard.elementPosition.get(newPosition).add(this);
                         }
                     }
+
                 }
-                for(Position position : newFirePositions){
-                    gameBoard.getElementPosition().get(position).add(new Fire(Color.RED));
+                else{
+                    ArrayList<BoardElement> boardElements = new ArrayList<>();
+                    boardElements.add(this);
+                    GameBoard.elementPosition.put(newPosition,boardElements);
+                    System.out.println(GameBoard.elementPosition.get(position).get(0).getColor());
                 }
-                result.addAll(newFirePositions);
+
             }
-            return result;
+        }
+
     }
 }
 
 
+

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

@@ -10,7 +10,5 @@ import java.util.List;
 
 public interface Flammable extends BoardElement{
 
-    void initialize(int initialFireCount, HashMap<Position, ArrayList<BoardElement>> elementPosition);
-
-    List<Position> updateFlammable(GameBoard gameBoard);
+    void update(GameBoard gameBoard, Position position);
 }

src/main/java/model/GameBoard.java

 package model;
 
-import javafx.scene.paint.Color;
-import model.ExtinguishFire.FireFighter;
-import model.Flammable.Fire;
+import model.Builder.FireFirefighterBuilder;
+import model.Builder.GameManage;
+import model.ExtinguishFire.ExtinguishFire;
+import model.Flammable.Flammable;
 import model.Visitor.FireFinder;
 import util.Position;
 
 import java.util.*;
 
-public class GameBoard implements Board<List<BoardElement>>{
+public class GameBoard implements Board{
     static  int columnCount;
     static  int rowCount;
-    private final int initialFireCount;
-    private final int initialFirefighterCount;
-
+    private int initialFireCount;
+    private int initialFirefighterCount;
     private int step = 0;
     static Random randomGenerator = new Random();
-    private HashMap<Position, ArrayList<BoardElement>> elementPosition;
 
     public HashMap<Position, ArrayList<BoardElement>> getElementPosition() {
         return elementPosition;
     }
 
+    public static HashMap<Position, ArrayList<BoardElement>> elementPosition=new HashMap<>();
+
     public GameBoard(int columnCount,int rowCount,int initialFireCount, int initialFirefighterCount) {
         this.columnCount = columnCount;
         this.rowCount = rowCount;
         this.initialFireCount = initialFireCount;
         this.initialFirefighterCount = initialFirefighterCount;
-        initializeElements();
     }
+
     public void initializeElements(){
-        elementPosition=new HashMap<>();
-        Fire fire=new Fire(Color.RED);
-        FireFighter fireFighter=new FireFighter(Color.BLUE);
-        fire.initialize(initialFireCount,elementPosition);
-        fireFighter.initialize(initialFirefighterCount,elementPosition);
+        FireFirefighterBuilder fireFirefighterBuilder=new FireFirefighterBuilder();
+        fireFirefighterBuilder.Build(this.initialFireCount,this.initialFirefighterCount);
     }
 
     public static Position randomPosition() {
         return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
     }
     @Override
-    public List<Position> updateToNextGeneration() {
-        List<Position> result = new FireFighter(Color.BLUE).updateFirefighters(this);
-        result.addAll(new Fire(Color.RED).updateFlammable(this));
+    public void updateToNextGeneration() {
+        HashMap<Position, ArrayList<BoardElement>> elementPositionCopie = new HashMap<>();
+        for (Map.Entry<Position, ArrayList<BoardElement>> entry : this.elementPosition.entrySet()){
+            elementPositionCopie.put(entry.getKey(),entry.getValue());
+        }
+        for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPositionCopie.entrySet()){
+            for(BoardElement element : entry.getValue()){
+
+                if (!element.accept(new FireFinder())){
+                    ExtinguishFire element1 = (ExtinguishFire) element;
+                    element1.update(this,entry.getKey());
+                }
+            }
+        }
+        /*for (Map.Entry<Position, ArrayList<BoardElement>> entryCopie : elementPositionCopie.entrySet()){
+            for(BoardElement element : entryCopie.getValue()){
+
+                if (element.accept(new FireFinder())){
+                    Flammable element1 = (Flammable) element;
+                    element1.update(this,entryCopie.getKey());
+                }
+            }
+        }*/
+
         step++;
-        return result;
+
+
     }
 
 
     @Override
-    public List<BoardElement>  getState(Position position) {
-        return elementPosition.get(position);
+    public Object getState(Position position) {
+        return null;
     }
 
     @Override
-    public void setState(List<BoardElement> state, Position position) {
-         for(int index = 0 ; index<elementPosition.get(position).size() ; index++){
-             elementPosition.get(position).remove(index);
+    public void setState(Object state, Position position) {
 
     }
-    }
 
     @Override
     public int rowCount() {
@@ -76,6 +93,7 @@ public class GameBoard implements Board<List<BoardElement>>{
     @Override
     public void reset() {
         step = 0;
+        elementPosition.clear();
         initializeElements();
     }
 
@@ -99,7 +117,7 @@ public class GameBoard implements Board<List<BoardElement>>{
         Set<Position> seen = new HashSet<>();
         HashMap<Position, Position> firstMove = new HashMap<>();
         Queue<Position> toVisit = new LinkedList<>(neighbors(position));
-        for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPosition.entrySet()){
+        for (Map.Entry<Position, ArrayList<BoardElement>> entry : this.elementPosition.entrySet()){
             for(BoardElement element : entry.getValue()){
                 if (element.accept(fireFinder)){
                     firePositions.add(entry.getKey());
@@ -124,13 +142,12 @@ public class GameBoard implements Board<List<BoardElement>>{
 
     public void extinguish(Position position) {
         FireFinder fireFinder = new FireFinder();
-        for (Map.Entry<Position, ArrayList<BoardElement>> entry : elementPosition.entrySet()){
-            for(BoardElement element : entry.getValue()){
-                if (element.accept(fireFinder)){
-                    entry.getValue().remove(element);
+        for (BoardElement boardElement : elementPosition.get(position)){
+                if (boardElement.accept(fireFinder)){
+                    this.elementPosition.get(position).remove(boardElement);
+                    break;
                 }
             }
         }
     }
 
-}

src/main/java/model/Visitor/FireFighterFinder.java

-package model.Visitor;
-
-import model.ExtinguishFire.FireFighter;
-import model.ExtinguishFire.MotorizedFireFighter;
-import model.Flammable.Fire;
-import model.Obstacle.Mountain;
-import model.Obstacle.Road;
-
-public class FireFighterFinder implements Visitor{
-
-    public boolean visit(Fire fire) {
-        return false;
-    }
-
-    @Override
-    public boolean visit(FireFighter fireFighter) {
-        return true;
-    }
-
-    @Override
-    public boolean visit(MotorizedFireFighter motorizedFireFighter) {
-        return false;
-    }
-
-    @Override
-    public boolean visit(Mountain mountain) {
-        return false;
-    }
-
-    @Override
-    public boolean visit(Road road) {
-        return false;
-    }
-}