correction

src/main/java/model/BoardFireFighterBehavior.java

+package model;
+
+import util.Position;
+import util.TargetStrategy;
+
+import java.util.*;
+
+public class BoardFireFighterBehavior implements BoardBehavior{
+    private final TargetStrategy targetStrategy = new TargetStrategy();
+    private final Map<Position, List<Position>> neighbors;
+    private List<Position> firefighterPositions;
+    private Set<Position> firePositions;
+    private int step;
+
+    public BoardFireFighterBehavior(Map<Position, List<Position>> neighbors) {
+        this.neighbors = neighbors;
+        this.step = 0;
+    }
+
+    public void initializeElements(int initialFireCount, int initialFirefighterCount, int rowCount, int columnCount, Random randomGenerator) {
+        firefighterPositions = new ArrayList<>();
+        firePositions = new HashSet<>();
+        for (int i = 0; i < initialFireCount; i++) {
+            firePositions.add(randomPosition(rowCount, columnCount, randomGenerator));
+        }
+        for (int i = 0; i < initialFirefighterCount; i++) {
+            firefighterPositions.add(randomPosition(rowCount, columnCount, randomGenerator));
+        }
+    }
+
+    private Position randomPosition(int rowCount, int columnCount, Random randomGenerator) {
+        return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+    }
+
+    public List<Position> updateFires() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        if (step % 2 == 0) {
+            List<Position> newFirePositions = new ArrayList<>();
+            for (Position fire : firePositions) {
+                newFirePositions.addAll(neighbors.get(fire));
+            }
+            firePositions.addAll(newFirePositions);
+            modifiedPositions.addAll(newFirePositions);
+        }
+        return modifiedPositions;
+    }
+
+    public List<Position> updateFirefighters() {
+        List<Position> modifiedPositions = new ArrayList<>();
+        List<Position> newFirefighterPositions = new ArrayList<>();
+        for (Position firefighterPosition : firefighterPositions) {
+            Position newFirefighterPosition = targetStrategy.neighborClosestToFire(firefighterPosition, firePositions, neighbors);
+            newFirefighterPositions.add(newFirefighterPosition);
+            extinguish(newFirefighterPosition);
+            modifiedPositions.add(firefighterPosition);
+            modifiedPositions.add(newFirefighterPosition);
+
+            List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
+                    .filter(firePositions::contains).toList();
+            for (Position firePosition : neighborFirePositions) {
+                extinguish(firePosition);
+            }
+            modifiedPositions.addAll(neighborFirePositions);
+        }
+        firefighterPositions = newFirefighterPositions;
+        return modifiedPositions;
+    }
+
+    private void extinguish(Position position) {
+        firePositions.remove(position);
+    }
+
+    public void reset(int step) {
+        this.step = step;
+    }
+
+    public Set<Position> getFirePositions() {
+        return firePositions;
+    }
+
+    public List<Position> getFirefighterPositions() {
+        return firefighterPositions;
+    }
+
+    public void incrementStep() {
+        step++;
+    }
+
+    public int getStep() {
+        return step;
+    }
+    @Override
+    public int stepNumber() {
+        return 0;
+    }
+
+    @Override
+    public List<Position> updateToNextGeneration() {
+        return List.of();
+    }
+
+    @Override
+    public void reset() {
+
+    }
+}

src/main/java/model/BoardFirefighterProperties.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+import java.util.Map;
+
+public class BoardFirefighterProperties implements BoardProperties{
+    private final int rowCount;
+    private final int columnCount;
+    private final Position[][] positions;
+    private final Map<Position, List<Position>> neighbors;
+
+    public BoardFirefighterProperties(int rowCount, int columnCount, Map<Position, List<Position>> neighbors) {
+        this.rowCount = rowCount;
+        this.columnCount = columnCount;
+        this.positions = new Position[rowCount][columnCount];
+        this.neighbors = neighbors;
+
+        initializePositions();
+    }
+
+    private void initializePositions() {
+        for (int row = 0; row < rowCount; row++) {
+            for (int column = 0; column < columnCount; column++) {
+                positions[row][column] = new Position(row, column);
+            }
+        }
+    }
+
+    public int getRowCount() {
+        return rowCount;
+    }
+
+    public int getColumnCount() {
+        return columnCount;
+    }
+
+    public Map<Position, List<Position>> getNeighbors() {
+        return neighbors;
+    }
+
+    public Position getPosition(int row, int column) {
+        return positions[row][column];
+    }
+    @Override
+    public int rowCount() {
+        return 0;
+    }
+
+    @Override
+    public int columnCount() {
+        return 0;
+    }
+
+    @Override
+    public List<ModelElement> getState(Position position) {
+        return List.of();
+    }
+
+    @Override
+    public void setState(List<ModelElement> state, Position position) {
+
+    }
+}

src/main/java/model/FirefighterBoard.java

 package model;
+
 import util.Position;
-import util.TargetStrategy;
 
 import java.util.*;
 
-
 public class FirefighterBoard implements Board<List<ModelElement>> {
-  private final int columnCount;
-  private final int rowCount;
+  private final BoardFireFighterBehavior behavior;
+  private final BoardFirefighterProperties properties;
+
   private final int initialFireCount;
   private final int initialFirefighterCount;
-  private final TargetStrategy targetStrategy = new TargetStrategy();
-  private List<Position> firefighterPositions;
-  private Set<Position> firePositions;
-  private Map<Position, List<Position>> neighbors = new HashMap();
-  private final Position[][] positions;
-  private int step = 0;
   private final Random randomGenerator = new Random();
 
   public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
-    this.columnCount = columnCount;
-    this.rowCount = rowCount;
-    this.positions = new Position[rowCount][columnCount];
-    for (int column = 0; column < columnCount; column++)
-      for (int row = 0; row < rowCount; row++)
+    Map<Position, List<Position>> neighbors = initializeNeighbors(rowCount, columnCount);
+
+    this.properties = new BoardFirefighterProperties(rowCount, columnCount, neighbors);
+    this.behavior = new BoardFireFighterBehavior(neighbors);
+
+    this.initialFireCount = initialFireCount;
+    this.initialFirefighterCount = initialFirefighterCount;
+
+    initializeElements();
+  }
+
+  private Map<Position, List<Position>> initializeNeighbors(int rowCount, int columnCount) {
+    Map<Position, List<Position>> neighbors = new HashMap<>();
+    Position[][] positions = new Position[rowCount][columnCount];
+
+    for (int row = 0; row < rowCount; row++) {
+      for (int column = 0; column < columnCount; column++) {
         positions[row][column] = new Position(row, column);
-    for (int column = 0; column < columnCount; column++)
+      }
+    }
+
     for (int row = 0; row < rowCount; row++) {
+      for (int column = 0; column < columnCount; column++) {
         List<Position> list = new ArrayList<>();
         if (row > 0) list.add(positions[row - 1][column]);
         if (column > 0) list.add(positions[row][column - 1]);
@@ -34,114 +43,62 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
         if (column < columnCount - 1) list.add(positions[row][column + 1]);
         neighbors.put(positions[row][column], list);
       }
-    this.initialFireCount = initialFireCount;
-    this.initialFirefighterCount = initialFirefighterCount;
-    initializeElements();
     }
-
-  public void initializeElements() {
-    firefighterPositions = new ArrayList<>();
-    firePositions = new HashSet<>();
-    for (int index = 0; index < initialFireCount; index++)
-      firePositions.add(randomPosition());
-    for (int index = 0; index < initialFirefighterCount; index++)
-      firefighterPositions.add(randomPosition());
+    return neighbors;
   }
 
-  private Position randomPosition() {
-    return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
+  public void initializeElements() {
+    behavior.initializeElements(initialFireCount, initialFirefighterCount, properties.getRowCount(), properties.getColumnCount(), randomGenerator);
   }
 
   @Override
   public List<ModelElement> getState(Position position) {
     List<ModelElement> result = new ArrayList<>();
-    for (Position firefighterPosition : firefighterPositions)
-      if (firefighterPosition.equals(position))
-        result.add(ModelElement.FIREFIGHTER);
-    if (firePositions.contains(position))
+    if (behavior.getFirePositions().contains(position)) {
       result.add(ModelElement.FIRE);
+    }
+    if (behavior.getFirefighterPositions().contains(position)) {
+      result.add(ModelElement.FIREFIGHTER);
+    }
     return result;
   }
 
   @Override
   public int rowCount() {
-    return rowCount;
+    return properties.getRowCount();
   }
 
   @Override
   public int columnCount() {
-    return columnCount;
-  }
-
-  public List<Position> updateToNextGeneration() {
-    List<Position> modifiedPositions = updateFirefighters();
-    modifiedPositions.addAll(updateFires());
-    step++;
-    return modifiedPositions;
-  }
-
-  private List<Position> updateFires() {
-    List<Position> modifiedPositions = new ArrayList<>();
-    if (step % 2 == 0) {
-      List<Position> newFirePositions = new ArrayList<>();
-      for (Position fire : firePositions) {
-        newFirePositions.addAll(neighbors.get(fire));
-      }
-      firePositions.addAll(newFirePositions);
-      modifiedPositions.addAll(newFirePositions);
-    }
-    return modifiedPositions;
-
-  }
-
-  @Override
-  public int stepNumber() {
-    return step;
-  }
-
-  private List<Position> updateFirefighters() {
-    List<Position> modifiedPosition = new ArrayList<>();
-    List<Position> firefighterNewPositions = new ArrayList<>();
-    for (Position firefighterPosition : firefighterPositions) {
-      Position newFirefighterPosition =
-              targetStrategy.neighborClosestToFire(firefighterPosition,
-                      firePositions, neighbors);
-      firefighterNewPositions.add(newFirefighterPosition);
-      extinguish(newFirefighterPosition);
-      modifiedPosition.add(firefighterPosition);
-      modifiedPosition.add(newFirefighterPosition);
-      List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
-              .filter(firePositions::contains).toList();
-      for (Position firePosition : neighborFirePositions)
-        extinguish(firePosition);
-      modifiedPosition.addAll(neighborFirePositions);
-    }
-    firefighterPositions = firefighterNewPositions;
-    return modifiedPosition;
+    return properties.getColumnCount();
   }
 
   @Override
   public void reset() {
-    step = 0;
+    behavior.reset(0);
     initializeElements();
   }
 
-  private void extinguish(Position position) {
-    firePositions.remove(position);
-  }
-
-
   @Override
   public void setState(List<ModelElement> state, Position position) {
-    firePositions.remove(position);
-    for (; ; ) {
-      if (!firefighterPositions.remove(position)) break;
+    if (state.contains(ModelElement.FIRE)) {
+      behavior.getFirePositions().add(position);
+    }
+    if (state.contains(ModelElement.FIREFIGHTER)) {
+      behavior.getFirefighterPositions().add(position);
     }
-    for (ModelElement element : state) {
-      switch (element) {
-        case FIRE -> firePositions.add(position);
-        case FIREFIGHTER -> firefighterPositions.add(position);
   }
+
+  @Override
+  public List<Position> updateToNextGeneration() {
+    List<Position> modifiedPositions = behavior.updateFirefighters();
+    modifiedPositions.addAll(behavior.updateFires());
+    behavior.incrementStep();
+    return modifiedPositions;
   }
+
+  @Override
+  public int stepNumber() {
+    return behavior.getStep();
   }
 }