[Refac] Changement de la structure du code de génération d'entités de départ

src/main/java/app/SimulatorApplication.java

@@ -13,14 +13,16 @@ import javafx.stage.Stage;
 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 = 25;
-  private static final int BOX_HEIGHT = 25;
-  public static final int INITIAL_FIRE_COUNT = 3;
-  public static final int INITIAL_FIREFIGHTER_COUNT = 6;
-  public static final int INITIAL_CLOUD_COUNT = 6;
-  public static final int INITIAL_MOUNTAIN_COUNT= 30;
+  private static final int ROW_COUNT = 40;
+  private static final int COLUMN_COUNT = 40;
+  private static final int BOX_WIDTH = 15;
+  private static final int BOX_HEIGHT = 15;
+  public static final int INITIAL_FIRE_COUNT = 4;
+  public static final int INITIAL_FIREFIGHTER_COUNT = 18;
+  public static final int INITIAL_MOTORIZED_FIREFIGHTER_COUNT = 5;
+  public static final int INITIAL_CLOUD_COUNT = 9;
+  public static final int INITIAL_MOUNTAIN_COUNT= 18;
+  public static final int TURNS_FOR_SPAWNING_AIRTANKER = 8;
 
   private Stage primaryStage;
   private Parent view;
@@ -47,7 +49,7 @@ public class SimulatorApplication extends javafx.application.Application {
     view = loader.load();
     Controller controller = loader.getController();
     controller.initialize(BOX_WIDTH, BOX_HEIGHT, COLUMN_COUNT, ROW_COUNT,
-        INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT, INITIAL_MOUNTAIN_COUNT);
+        INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_MOTORIZED_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT, INITIAL_MOUNTAIN_COUNT, TURNS_FOR_SPAWNING_AIRTANKER);
   }
 
   private void showScene() {

src/main/java/controller/Controller.java

@@ -3,9 +3,9 @@ package controller;
 import static java.util.Objects.*;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
-
-
+import java.util.Map;
 
 import javafx.animation.Animation;
 import javafx.animation.KeyFrame;
@@ -20,7 +20,13 @@ import javafx.scene.control.ToggleGroup;
 import javafx.util.Duration;
 import javafx.util.Pair;
 import model.Board;
+import model.Cloud;
+import model.EntityFactory;
+import model.Fire;
+import model.FireFighter;
 import model.FireFighterScenario;
+import model.MotorizedFireFighter;
+import model.Mountain;
 import model.Square;
 import util.Position;
 import view.Grid;
@@ -119,9 +125,19 @@ public class Controller {
   }
 
   public void initialize(int squareWidth, int squareHeight, int columnCount,
-      int rowCount, int initialFireCount, int initialFirefighterCount, int initialcloudCount, int initialmountaincount) {
+      int rowCount, int initialFireCount, int initialFirefighterCount, int initialMotorizedFirefightersCount, int initialcloudCount, int initialmountaincount, int turnsForSpawningAirTanker) {
     grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
-    this.setModel(new FireFighterScenario(columnCount, rowCount, initialFireCount, initialFirefighterCount, initialcloudCount, initialmountaincount));
+    Board<Square> model = new FireFighterScenario(columnCount, rowCount);
+    Map<EntityFactory, Integer> entityCounts = new HashMap<>();
+
+    entityCounts.put((pos, b) -> new Fire(pos), initialFireCount);
+    entityCounts.put((pos, b) -> new FireFighter(pos, b), initialFirefighterCount);
+    entityCounts.put((pos, b) -> new MotorizedFireFighter(pos, b), initialMotorizedFirefightersCount);
+    entityCounts.put((pos, b) -> new Cloud(pos, b), initialcloudCount);
+    entityCounts.put((pos, b) -> new Mountain(pos), initialmountaincount);
+
+    model.placeInitialEntities(entityCounts);
+    this.setModel(model);
     repaintGrid();
   }
 

src/main/java/model/AirTanker.java

@@ -16,8 +16,8 @@ public class AirTanker implements Entity{
     private Position position;
     private int priority = 3;
 
-    public AirTanker(Position position, Board<Square> b) {
-        this.age = 0;
+    public AirTanker(Position position, Board<Square> b, int age) {
+        this.age = age;
         this.position = position;
         determineDirection(b);
         extinguish(position,b);
@@ -41,7 +41,6 @@ public class AirTanker implements Entity{
         } else if (position.y() == rowCount - 1) {
             direction = Direction.NORTH; // Move north if on bottom edge
         } else {
-            System.out.println("not on a edge");
             // Not on an edge; default to moving east or choose a random direction
             direction = Direction.EAST;
         }
@@ -49,14 +48,12 @@ public class AirTanker implements Entity{
 
     @Override
     public List<Position> nextTurn(Board<Square> b) {
-        
         List<Position> positions = new ArrayList<>();
         // Move in the determined direction
         Position nextPos = getNextPosition(position, direction, b);
         
         if (nextPos == null || !b.doesPositionExist(nextPos)) {
             // Reached the edge; remove AirTanker from the board
-            System.out.println("end of airtanker mission");
             b.clearCaseFrom(this, position);
             positions.add(position);
             return positions;
@@ -71,10 +68,6 @@ public class AirTanker implements Entity{
             b.addEntityAtSquare(this, nextPos);
             positions.add(nextPos); // New position
 
-
-            // Increment age if needed
-            this.age++;
-
             return positions;
         }
     }
@@ -110,7 +103,6 @@ public class AirTanker implements Entity{
                 break; // Only handling cardinal directions
         }
         Position newPos = new Position(x, y);
-        System.out.println("trying to move to : " + newPos.toString());
         if (b.doesPositionExist(newPos)) {
             return newPos;
         } else {

src/main/java/model/Board.java

 package model;
 
 import java.util.List;
+import java.util.Map;
 
 import util.Position;
 
@@ -77,7 +78,7 @@ public interface Board<S> {
   public boolean doesSquareContainEntity(Position squarePos, Class<?> entityType);
 
   public void addEntityAtSquare(Entity entity, Position position);
-
+  public void placeInitialEntities(Map<EntityFactory, Integer> entityCounts);
   //Return if the position is completely free
   public boolean isPositionEmpty(Position position);
 

src/main/java/model/EntityFactory.java

+package model;
+
+import util.Position;
+
+public interface EntityFactory {
+    Entity create(Position position, Board<Square> board);
+}

src/main/java/model/EntitySpawner.java

+package model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import util.Position;
+
+public class EntitySpawner {
+    private final Board<Square> board;
+    private final Random random = new Random();
+
+    public EntitySpawner(Board<Square> board) {
+        this.board = board;
+    }
+
+    public void spawnEntities(Map<EntityFactory, Integer> entityCounts) {
+        Map<EntityFactory, Integer> counts = new HashMap<>();
+        for (EntityFactory factory : entityCounts.keySet()) {
+            counts.put(factory, 0);
+        }
+
+        int totalEntitiesToPlace = entityCounts.values().stream().mapToInt(Integer::intValue).sum();
+        int totalEntitiesPlaced = 0;
+
+        int chance = 5;
+        List<Position> positions = generateAllPositions();
+
+        while (totalEntitiesPlaced < totalEntitiesToPlace) {
+            Collections.shuffle(positions);
+
+            for (Position pos : positions) {
+                if (board.getStates(pos).isEmpty()) {
+                    for (EntityFactory factory : entityCounts.keySet()) {
+                        int desiredCount = entityCounts.get(factory);
+                        int currentCount = counts.get(factory);
+
+                        if (currentCount < desiredCount && random.nextInt(100) < chance) {
+                            Entity entity = factory.create(pos, board);
+                            board.setSquare(new Square(pos, entity));
+                            counts.put(factory, currentCount + 1);
+                            totalEntitiesPlaced++;
+
+                            if (totalEntitiesPlaced == totalEntitiesToPlace) {
+                                return;
+                            }
+
+                            break; // Move to the next position
+                        }
+                    }
+                }
+            }
+
+            // Increase chance after each full traversal
+            chance = Math.min(chance + 5, 100);
+        }
+    }
+
+    private List<Position> generateAllPositions() {
+        List<Position> positions = new ArrayList<>();
+        for (int x = 0; x < board.rowCount(); x++) {
+            for (int y = 0; y < board.columnCount(); y++) {
+                positions.add(new Position(x, y));
+            }
+        }
+        return positions;
+    }
+}

src/main/java/model/FireFighterScenario.java

 package model;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.Random;
 
 import util.Matrix;
@@ -15,80 +15,20 @@ public class FireFighterScenario extends EntityScenario implements Board<Square>
   private Matrix<Square> matrix;
   private int step;
 
-  private int initialFireCount;
-  private int initialFireFightersCount;
-  private int intialCloudCount;
-  private int initialMoutainCount;
+  private Map<EntityFactory, Integer> initialMap;
 
-  public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount, int initialCloudCount, int initialMoutainCount) {
+  public FireFighterScenario(int columns, int rows) {
     this.matrix = new Matrix<Square>(columns, rows);
-    this.initialFireCount = initialFireCount;
-    this.initialFireFightersCount = initialFireFightersCount;
-    this.intialCloudCount = initialCloudCount;
-    this.initialMoutainCount = initialMoutainCount;
     initScenario(matrix);
-    placeInitialActors(initialFireCount, initialFireFightersCount, initialCloudCount, initialMoutainCount);
     this.step = 0;
   }
 
-  private void placeInitialActors(int initialFireCount, int initialFireFightersCount, int initialCloudCount, int initialMoutainCount) {
-    int fireCount = 0;
-    int fireFighterCount = 0;
-    int cloudCount = 0;
-    int moutainCount = 0;
-    int chance = 5; // Chance initiale en pourcentage
-    Random random = new Random();
-    List<Position> positions = new ArrayList<>();
-    for (int x = 0; x < matrix.getRows(); x++) {
-      for (int y = 0; y < matrix.getColumns(); y++) {
-        positions.add(new Position(x, y));
-      }
-    }
-    //setSquare(new Square(new Position(0,0), new MotorizedFireFighter(new Position(0,0), this)));
-    while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount || cloudCount < intialCloudCount) {
-      Collections.shuffle(positions); // Mélange les positions pour un parcours aléatoire
-
-      for (Position pos : positions) {
-        if (getStates(pos).isEmpty()) {
-          if (fireCount < initialFireCount && random.nextInt(100) < chance) {
-            setSquare(new Square(pos, new Fire(pos, 0)));
-            fireCount++;
-            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount  && moutainCount == initialMoutainCount) {
-              return;
-            }
-            continue;
-          }
-
-          if (fireFighterCount < initialFireFightersCount && random.nextInt(100) < chance) {
-            setSquare(new Square(pos, new FireFighter(pos, this, 1)));
-            fireFighterCount++;
-            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount  && moutainCount == initialMoutainCount) {
-              return;
-            }
+public void placeInitialEntities(Map<EntityFactory, Integer> entityCounts) {
+    EntitySpawner spawner = new EntitySpawner(this);
+    spawner.spawnEntities(entityCounts);
+    this.initialMap = entityCounts;
 }
 
-          if (cloudCount < intialCloudCount && random.nextInt(100) < chance) {
-            setSquare(new Square(pos, new Cloud(pos, this, 1)));
-            cloudCount++;
-            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount  && moutainCount == initialMoutainCount) {
-              return;
-            }
-          }
-
-          if (moutainCount < initialMoutainCount && random.nextInt(100) < chance) {
-            setSquare(new Square(pos, new Mountain(pos, 1)));
-            moutainCount++;
-            if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount && moutainCount == initialMoutainCount) {
-              return;
-            }
-          }
-        }
-      }
-
-      // Augmente la chance de placement après chaque parcours complet
-      chance = Math.min(chance + 5, 100); // Ne dépasse pas 100%
-    }
-  }
 
   public Square getStates(Position position) {
     if (position.x() > matrix.size() || position.y() > matrix.size()) {
@@ -199,7 +139,7 @@ private void spawnAirTanker(List<Position> changedPositions) {
 
   System.out.println("Position: " + position.toString());
   // Create a new AirTanker
-  AirTanker airTanker = new AirTanker(position, this);
+  AirTanker airTanker = new AirTanker(position, this, getStepNumber());
   System.out.println(" direction : " + airTanker.getDirection());
   // Add the AirTanker to the board
   addEntityAtSquare(airTanker, position);
@@ -240,7 +180,7 @@ private void spawnAirTanker(List<Position> changedPositions) {
     step = 0;
     matrix.clear();
     initScenario(matrix);
-    placeInitialActors(initialFireCount, initialFireFightersCount, intialCloudCount, initialMoutainCount);
+    placeInitialEntities(initialMap);
   }
 
   public int stepNumber() {

src/main/java/model/Mountain.java

@@ -23,7 +23,6 @@ public class Mountain implements Entity{
 
     @Override
     public List<Position> nextTurn(Board<Square> board) {
-        List<Entity> states = board.getStates(position).getEntities();
         return List.of();
     }