Ajout interface elements + class abstraite abstract elements

src/main/java/model/AbstractElements.java

+package model;
+
+import util.Position;
+
+import java.util.*;
+
+public abstract class AbstractElements implements Elements {
+    final Random randomGenerator = new Random();
+    int rowCount = 0;
+    int columnCount = 0;
+
+
+    public abstract void nextMove();
+    public abstract void initializeElements(int count, int rowCount, int columnCount);
+
+    protected Position randomPosition(int rowCount, int columnCount) {
+        return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+    }
+
+     protected List<Position> neighbors(Position position) {
+        List<Position> list = new ArrayList<>();
+        if (position.row() > 0) list.add(new Position(position.row() - 1, position.column()));
+        if (position.column() > 0) list.add(new Position(position.row(), position.column() - 1));
+        if (position.row() < rowCount - 1) list.add(new Position(position.row() + 1, position.column()));
+        if (position.column() < columnCount - 1) list.add(new Position(position.row(), position.column() + 1));
+        return list;
+    }
+
+
+}

src/main/java/model/Elements.java

+package model;
+
+
+public interface Elements {
+
+
+
+    void nextMove();
+    void initializeElements(int count, int rowCount, int columnCount);
+
+
+}

src/main/java/model/Fire.java

@@ -3,14 +3,21 @@ package model;
 import util.Position;
 import java.util.*;
 
-public class Fire {
-    public static List<Position> firePositions;
+public class Fire extends AbstractElements{
+    public List<Position> firePositions;
+
+    public Fire(int columnCount, int rowCount){
+        firePositions = new ArrayList<>();
+        this.columnCount = columnCount;
+        this.rowCount = rowCount;
+    }
+     
+    public void nextMove(){
 
-    public static void nextMove(){
         // propagate the fire to the adjacent cells
         List<Position> newFirePositions = new ArrayList<>();
         for (Position firePosition : firePositions) {
-            List<Position> neighborPositions = Utils.neighbors(firePosition);
+            List<Position> neighborPositions = neighbors(firePosition);
             newFirePositions.addAll(neighborPositions);
         }
         // check if the new fire positions are not already on fire
@@ -18,4 +25,29 @@ public class Fire {
             if (!firePositions.contains(newFirePosition))
                 firePositions.add(newFirePosition);
     }
+
+    @Override
+    public void initializeElements(int count, int rowCount, int columnCount) {
+        firePositions = new ArrayList<>();
+        for(int i = 0; i < count; i++)
+            firePositions.add(randomPosition(rowCount, columnCount));
+    }
+
+    public void extinguishs(List<Position> firefighterPositions){
+
+        for (Position firefighterPosition : firefighterPositions) {
+            List<Position> neighborFirePositions = neighbors(firefighterPosition).stream()
+                    .filter(firePositions::contains).toList();
+            for(Position firePosition : neighborFirePositions)
+                extinguish(firePosition);
+        }
+
+
+    }
+
+
+
+    public void extinguish(Position position){
+        firePositions.remove(position);
+    }
 }

src/main/java/model/FireFighters.java

@@ -3,32 +3,55 @@ package model;
 import util.Position;
 import java.util.*;
 
-public class FireFighters {
-    public static List<Position> firefighterPositions;
+public class FireFighters extends AbstractElements{
+    public List<Position> firefighterPositions;
+    public Fire fire;
+
+    public FireFighters(int columnCount, int rowCount, Fire fire){
+        firefighterPositions = new ArrayList<>();
+        this.columnCount = columnCount;
+        this.rowCount = rowCount;
+        this.fire = fire;
+    }
      
 
-    public static void nextMove(){
+    public void nextMove(){
         List<Position> firefighterNewPositions = new ArrayList<>();
         for (Position firefighterPosition : firefighterPositions) {
-            Position newFirefighterPosition = Utils.neighborClosestToFire(firefighterPosition);
+            Position newFirefighterPosition = neighborClosestToFire(firefighterPosition);
             firefighterNewPositions.add(newFirefighterPosition);
-            extinguish(newFirefighterPosition);
+            fire.extinguish(newFirefighterPosition);
+
         }
         firefighterPositions = firefighterNewPositions;
     }
 
-    public static void extinguishs(){
-        for (Position firefighterPosition : firefighterPositions) {
-            List<Position> neighborFirePositions = Utils.neighbors(firefighterPosition).stream()
-                    .filter(Fire.firePositions::contains).toList();
-            for(Position firePosition : neighborFirePositions)
-                extinguish(firePosition);
+    protected Position neighborClosestToFire(Position position) {
+        Set<Position> seen = new HashSet<>();
+        HashMap<Position, Position> firstMove = new HashMap<>();
+        Queue<Position> toVisit = new LinkedList<>(neighbors(position));
+        for (Position initialMove : toVisit)
+            firstMove.put(initialMove, initialMove);
+
+        while (!toVisit.isEmpty()) {
+            Position current = toVisit.poll();
+            if (fire.firePositions.contains(current)){
+                return firstMove.get(current);}
+            for (Position adjacent : neighbors(current)) {
+                if (seen.contains(adjacent)) continue;
+                toVisit.add(adjacent);
+                seen.add(adjacent);
+                firstMove.put(adjacent, firstMove.get(current));
+            }
         }
+        return position;
     }
 
 
 
-    public static void extinguish(Position position){
-        Fire.firePositions.remove(position);
+    public void initializeElements(int count, int rowCount, int columnCount){
+        firefighterPositions = new ArrayList<>();
+        for(int i = 0; i < count; i++)
+            firefighterPositions.add(randomPosition(rowCount, columnCount));
     }
 }

src/main/java/model/FirefighterBoard.java

@@ -6,41 +6,42 @@ import java.util.*;
 
 
 public class FirefighterBoard implements Board<List<ModelElement>> {
-  public static int columnCount;
-  public static int rowCount;
+
+  public int columnCount;
+
+  public int rowCount;
   private final int initialFireCount;
   private final int initialFirefighterCount;
   private int step = 0;
-  private final Random randomGenerator = new Random();
+
+
+  public Fire fire;
+  public FireFighters fireFighters;
 
   public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
-    FirefighterBoard.columnCount = columnCount;
-    FirefighterBoard.rowCount = rowCount;
+    this.columnCount = columnCount;
+    this.rowCount = rowCount;
     this.initialFireCount = initialFireCount;
     this.initialFirefighterCount = initialFirefighterCount;
+    fire = new Fire(columnCount, rowCount);
+    fireFighters = new FireFighters(columnCount, rowCount, fire);
     initializeElements();
   }
 
   public void initializeElements() {
-    Fire.firePositions = new ArrayList<>();
-    FireFighters.firefighterPositions = new ArrayList<>();
-    for (int index = 0; index < initialFireCount; index++)
-      Fire.firePositions.add(randomPosition());
-    for (int index = 0; index < initialFirefighterCount; index++)
-      FireFighters.firefighterPositions.add(randomPosition());
-  }
 
-  private Position randomPosition() {
-    return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+    fire.initializeElements(initialFireCount, rowCount, columnCount);
+    fireFighters.initializeElements(initialFirefighterCount, rowCount, columnCount);
   }
 
+
   @Override
   public List<ModelElement> getState(Position position) {
     List<ModelElement> result = new ArrayList<>();
-    for(Position firefighterPosition : FireFighters.firefighterPositions)
+    for(Position firefighterPosition : fireFighters.firefighterPositions)
       if (firefighterPosition.equals(position))
         result.add(ModelElement.FIREFIGHTER);
-    if(Fire.firePositions.contains(position))
+    if(fire.firePositions.contains(position))
       result.add(ModelElement.FIRE);
     return result;
   }
@@ -57,20 +58,22 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
   public List<Position> updateToNextGeneration() {
 
-    FireFighters.nextMove();
-    FireFighters.extinguishs();
+    fireFighters.nextMove();
+    //System.out.println(fireFighters.firefighterPositions);
+
+    fire.extinguishs(fireFighters.firefighterPositions);
+    //System.out.println(fire.firePositions);
 
     if (step % 2 == 0)
-      Fire.nextMove();
+      fire.nextMove();
 
     step++;
     List<Position> result = new ArrayList<>();
 
-    result.addAll(Fire.firePositions);
-    result.addAll(FireFighters.firefighterPositions);
+    result.addAll(fire.firePositions);
+    result.addAll(fireFighters.firefighterPositions);
 
     return result;
-
   }
 
   @Override
@@ -88,14 +91,14 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
   @Override
   public void setState(List<ModelElement> state, Position position) {
-    Fire.firePositions.remove(position);
+    fire.firePositions.remove(position);
     for (;;) {
-      if (!FireFighters.firefighterPositions.remove(position)) break;
+      if (!fireFighters.firefighterPositions.remove(position)) break;
     }
     for(ModelElement element : state){
       switch (element){
-        case FIRE -> Fire.firePositions.add(position);
-        case FIREFIGHTER -> FireFighters.firefighterPositions.add(position);
+        case FIRE -> fire.firePositions.add(position);
+        case FIREFIGHTER -> fireFighters.firefighterPositions.add(position);
       }
     }
   }

src/main/java/model/Utils.java

-package model;
-
-import util.Position;
-
-import java.util.*;
-
-public class Utils {
-
-    static List<Position> neighbors(Position position) {
-        List<Position> list = new ArrayList<>();
-        if (position.row() > 0) list.add(new Position(position.row() - 1, position.column()));
-        if (position.column() > 0) list.add(new Position(position.row(), position.column() - 1));
-        if (position.row() < FirefighterBoard.rowCount - 1) list.add(new Position(position.row() + 1, position.column()));
-        if (position.column() < FirefighterBoard.columnCount - 1) list.add(new Position(position.row(), position.column() + 1));
-        return list;
-    }
-
-    static Position neighborClosestToFire(Position position) {
-        Set<Position> seen = new HashSet<>();
-        HashMap<Position, Position> firstMove = new HashMap<>();
-        Queue<Position> toVisit = new LinkedList<>(neighbors(position));
-        for (Position initialMove : toVisit)
-            firstMove.put(initialMove, initialMove);
-        while (!toVisit.isEmpty()) {
-            Position current = toVisit.poll();
-            if (Fire.firePositions.contains(current))
-                return firstMove.get(current);
-            for (Position adjacent : neighbors(current)) {
-                if (seen.contains(adjacent)) continue;
-                toVisit.add(adjacent);
-                seen.add(adjacent);
-                firstMove.put(adjacent, firstMove.get(current));
-            }
-        }
-        return position;
-    }
-}