factorisation

src/main/java/model/Board.java

@@ -2,6 +2,8 @@ package model;
 
 import util.Position;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 
 /**
@@ -61,5 +63,6 @@ public interface Board<S> {
    * @return The current step number or generation.
    */
   int stepNumber();
+  HashMap<Position, ArrayList<BoardElement>> getElementPosition();
 }
 

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

@@ -31,9 +31,6 @@ public class GameManage {
         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);
         }
@@ -43,7 +40,9 @@ public class GameManage {
         for(int i=0;i<mountains;i++) {
             new Mountain(Color.BROWN);
         }
-        // TODO: 15/11/2023  la suite .... aussi l'initialisation va changer dans fire et firefighter
+        for(int i=0;i<firefighters;i++) {
+            new FireFighter(Color.BLUE);
+        }
     }
 
 }

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

@@ -65,10 +65,5 @@ public class Cloud implements ExtinguishFire{
             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/FireFighter.java

@@ -4,6 +4,7 @@ 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;
@@ -12,14 +13,14 @@ import java.util.*;
 
 import static model.GameBoard.elementPosition;
 
+
 public class FireFighter implements ExtinguishFire {
     private final Color color;
 
     public FireFighter(Color color) {
         this.color = color;
-        initialize();
+        initialize(); // est une bonne idée ?
     }
-
     @Override
     public Color getColor() {
         return color;
@@ -32,131 +33,81 @@ public class FireFighter implements ExtinguishFire {
 
     @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;
-                }
+        while(!canInitialise(position)){
             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);
+        addElementToElementPosition(elementPosition,position);
     }
 
-        }
+    private void addElementToElementPosition(HashMap<Position, ArrayList<BoardElement>> elementPosition, Position position) {
+        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());
     }
+
+    private boolean canInitialise(Position position) {
+        if(elementPosition.containsKey(position)){
+            for (BoardElement element : GameBoard.elementPosition.get(position)) {
+                if (element.accept(new FireFinder()) || element.accept(new CrossMountain())) {
+                    return false;
                 }
             }
-        Position newFirefighterPosition = gameBoard.neighborClosestToFire(position);
-        if (elementPosition.containsKey(newFirefighterPosition)) {
-            boolean canMove = true;
-            for (BoardElement boardElement : elementPosition.get(newFirefighterPosition)) {
-                if (boardElement.accept(new CrossMountain())) {
-                    canMove = false;
-                    break;
         }
-            }
-            if (canMove) {
-                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) {
-                    extinguishPosition.add(firePosition);
+        return true;
     }
 
+    @Override
+    public void update(GameBoard gameBoard, Position position, HashMap<Position, ArrayList<BoardElement>> newElementPosition, ArrayList<Position> extinguishPosition) {
+        List<Position> firePositions = firePosition();
+        Position newFirefighterPosition = gameBoard.neighborClosestToFire(position);
+        extinguishPosition.add(position);
+        if(canMove(newFirefighterPosition)){
+            moveAndExtinguish(newElementPosition,newFirefighterPosition,extinguishPosition,firePositions,gameBoard);
         }else {
             List<Position> neighbors = gameBoard.neighbors(position);
-                for (Position position1 : neighbors) {
-                    canMove = true;
-                    if (!elementPosition.containsKey(position1)){
-                        ArrayList<BoardElement> boardElements = new ArrayList<>();
-                        boardElements.add(this);
-                        newElementPosition.put(position, boardElements);
-                        extinguishPosition.add(position1);
-                        List<Position> neighborFirePositions = gameBoard.neighbors(position1).stream()
-                                .filter(firePositions::contains).toList();
-                        for (Position firePosition : neighborFirePositions) {
-                            extinguishPosition.add(firePosition);
+            for (Position positionNeighbour : neighbors) {
+                if(canMove(positionNeighbour)){
+                    moveAndExtinguish(newElementPosition,positionNeighbour,extinguishPosition,firePositions,gameBoard);
+                    return;
                 }
-                        break;
             }
-                    for (BoardElement boardElement : elementPosition.get(position1)) {
-                        if (boardElement.accept(new CrossMountain())) {
-                            canMove = false;
-                            break;
+            moveAndExtinguish(newElementPosition,position,extinguishPosition,firePositions,gameBoard);
         }
     }
-                    if (canMove) {
-                        newFirefighterPosition = position1;
-                        if (newElementPosition.containsKey(newFirefighterPosition)) {
-                            newElementPosition.get(newFirefighterPosition).add(this);
-                        } else {
-                            ArrayList<BoardElement> boardElements = new ArrayList<>();
-                            boardElements.add(this);
-                            newElementPosition.put(newFirefighterPosition, boardElements);
-                        }
+    private void moveAndExtinguish(HashMap<Position, ArrayList<BoardElement>> newElementPosition, Position newFirefighterPosition, ArrayList<Position> extinguishPosition, List<Position> firePositions, GameBoard gameBoard) {
+        addElementToElementPosition(newElementPosition,newFirefighterPosition);
         extinguishPosition.add(newFirefighterPosition);
         List<Position> neighborFirePositions = gameBoard.neighbors(newFirefighterPosition).stream()
                 .filter(firePositions::contains).toList();
-                        for (Position firePosition : neighborFirePositions) {
-                            extinguishPosition.add(firePosition);
+        extinguishPosition.addAll(neighborFirePositions);
     }
-                        break;
+    private boolean canMove(Position newFirefighterPosition) {
+        if(elementPosition.containsKey(newFirefighterPosition)){
+            for (BoardElement boardElement : elementPosition.get(newFirefighterPosition)) {
+                if (boardElement.accept(new CrossMountain())) {
+                    return false;
                 }
             }
-                if (!canMove) {
-                    if (newElementPosition.containsKey(position)) {
-                        newElementPosition.get(position).add(this);
-                    } else {
-                        ArrayList<BoardElement> boardElements = new ArrayList<>();
-                        boardElements.add(this);
-                        newElementPosition.put(position, boardElements);
         }
+        return true;
     }
 
+    private List<Position> firePosition(){
+        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());
                 }
-
             }
-        else{
-            ArrayList<BoardElement> boardElements = new ArrayList<>();
-            boardElements.add(this);
-            newElementPosition.put(position, boardElements);
         }
+        return firePositions;
     }
 }
 

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

@@ -11,6 +11,8 @@ import util.Position;
 
 import java.util.*;
 
+import static model.GameBoard.elementPosition;
+
 public class Fire implements Flammable{
 
     private final Color color;
@@ -19,49 +21,34 @@ public class Fire implements Flammable{
         this.color = color;
         initialize();
     }
-
     @Override
     public Color getColor() {
         return this.color;
     }
-
     @Override
     public Boolean accept(Visitor visitor){
         return visitor.visit(this);
     }
-
     @Override
     public void initialize() {
-        FireFinder fireFinder=new FireFinder();
-        CrossMountain crossMountain = new CrossMountain();
+
         Position position = GameBoard.randomPosition();
-        boolean canInitialise;
-        if(GameBoard.elementPosition.containsKey(position)) {
-            for (;;) {
-                canInitialise=true;
-                for (BoardElement element : GameBoard.elementPosition.get(position)) {
-                    if (element.accept(fireFinder) || element.accept(crossMountain)) {
-                        canInitialise=false;
-                        break;
-                    }
+
+        while(!canInitialise(position)){
+            position = GameBoard.randomPosition();
         }
-                if(canInitialise){
-                    break;
+        addElementToElementPosition(elementPosition,position);
     }
-                position = GameBoard.randomPosition();
-                if(!GameBoard.elementPosition.containsKey(position))break;
+
+    private boolean canInitialise(Position position) {
+        if(elementPosition.containsKey(position)){
+            for (BoardElement element : GameBoard.elementPosition.get(position)) {
+                if (element.accept(new FireFinder()) || element.accept(new CrossMountain())|| element.accept(new CrossRoad())) {
+                    return false;
                 }
-            if(GameBoard.elementPosition.containsKey(position))
-                GameBoard.elementPosition.get(position).add(this);
-            else{
-                ArrayList<BoardElement> boardElements = new ArrayList<>();
-                boardElements.add(this);
-                GameBoard.elementPosition.put(position,boardElements);
             }
         }
-        ArrayList<BoardElement> boardElements = new ArrayList<>();
-        boardElements.add(this);
-        GameBoard.elementPosition.put(position,boardElements);
+        return true;
     }
 
     @Override
@@ -69,47 +56,46 @@ public class Fire implements Flammable{
         if(extinguishPosition.contains(position)) {
             return;
         }
+        if(canMove(position,newElementPosition))
+            addElementToElementPosition(newElementPosition,position);
         if (gameBoard.stepNumber() % 2 == 0 ) {
-            List<Position> newPositions = new ArrayList<>();
-            newPositions.addAll(gameBoard.neighbors(position));
-            if(newElementPosition.containsKey(position))
-                newElementPosition.get(position).add(this);
-            else {
-                newElementPosition.put(position,(new ArrayList<>()));
-                newElementPosition.get(position).add(this);
+            List<Position> positionsNeighbours = new ArrayList<>(gameBoard.neighbors(position));
+            for(Position positionNeighbour : positionsNeighbours){
+                if(!extinguishPosition.contains(positionNeighbour)&& canMove(positionNeighbour,newElementPosition)){
+                    addElementToElementPosition(newElementPosition,positionNeighbour);
                 }
-            for(Position newPosition : newPositions){
-                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())){
-                            break;
             }
-                        else if(!boardElement.accept( new FireFinder())&& !boardElement.accept(new CrossRoad()) && !boardElement.accept(new CrossMountain())){
-                            newElementPosition.get(newPosition).add(this);
         }
     }
+    private void addElementToElementPosition(HashMap<Position, ArrayList<BoardElement>> newElementPosition, Position newFirePosition) {
+        if (newElementPosition.containsKey(newFirePosition) ) {
+                newElementPosition.get(newFirePosition).add(this);
 
-                }
-                else{
+        } else {
             ArrayList<BoardElement> boardElements = new ArrayList<>();
             boardElements.add(this);
-                    newElementPosition.put(newPosition,boardElements);
+            newElementPosition.put(newFirePosition, boardElements);
         }
-
     }
+    private boolean canMove(Position newFirePosition,HashMap<Position, ArrayList<BoardElement>> newElementPosition) {
+        if(elementPosition.containsKey(newFirePosition)){
+            for (BoardElement boardElement : elementPosition.get(newFirePosition)) {
+                if (boardElement.accept(new CrossMountain())||boardElement.accept(new CrossRoad())) {
+                    return false;
                 }
-        else{
-            if(newElementPosition.containsKey(position))
-                newElementPosition.get(position).add(this);
-            else {
-                newElementPosition.put(position,(new ArrayList<>()));
-                newElementPosition.get(position).add(this);
             }
         }
-
+        if(newElementPosition.containsKey(newFirePosition)){
+            for (BoardElement boardElement : newElementPosition.get(newFirePosition)) {
+                if (boardElement.accept(new FireFinder())) {
+                    return false;
+                }
+            }
         }
+        return true;
+    }
+
+
 }
 
 

src/main/java/model/GameBoard.java

@@ -20,12 +20,12 @@ public class GameBoard implements Board{
 
     private int step = 0;
     static Random randomGenerator = new Random();
+    public static HashMap<Position, ArrayList<BoardElement>> elementPosition=new HashMap<>();
 
     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,int initialCloudCount,int initialMotorizedFireFighterCount,int initialMountainCount) {
         this.columnCount = columnCount;

src/main/java/model/Visitor/CrossMountain.java

@@ -18,7 +18,7 @@ public class CrossMountain implements Visitor {
         return false;
     }
     @Override
-    public boolean visit(Cloud cloud) {return true;}
+    public boolean visit(Cloud cloud) {return false;}
     @Override
     public boolean visit(MotorizedFireFighter motorizedFireFighter) {
         return false;
@@ -26,7 +26,7 @@ public class CrossMountain implements Visitor {
 
     @Override
     public boolean visit(Mountain mountain) {
-        return false;
+        return true;
     }
 
     @Override

src/main/java/model/Visitor/CrossRoad.java

@@ -15,15 +15,15 @@ public class CrossRoad implements Visitor {
 
     @Override
     public boolean visit(FireFighter fireFighter) {
-        return true;
+        return false;
     }
 
     @Override
-    public boolean visit(Cloud cloud) {return true;}
+    public boolean visit(Cloud cloud) {return false;}
 
     @Override
     public boolean visit(MotorizedFireFighter motorizedFireFighter) {
-        return true;
+        return false;
     }