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 int initialFireCount;
  private final int initialFirefighterCount;

  private final FireManager fireManager;
  private final FirefighterManager firefighterManager;
  private List<Position> firefighterPositions;
  private Set<Position> firePositions;
  private final Position[][] positions;
  private int step = 0;
  private final Map<Position, List<Position>> neighbors = new HashMap<>();
  private final Random randomGenerator = new Random();

  public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
    this.columnCount = columnCount;
    this.rowCount = rowCount;
    this.initialFireCount = initialFireCount;
    this.initialFirefighterCount = initialFirefighterCount;
    this.positions = new Position[rowCount][columnCount];
    initializePositions();
    initializeNeighbors();
    // Initialize managers
    this.fireManager = new FireManager(new HashSet<>());
    this.firefighterManager = new FirefighterManager(new ArrayList<>(), fireManager);

    initializeElements();
  }
  private void initializeNeighbors() {
    for (int column = 0; column < columnCount; column++) {
      for (int row = 0; row < rowCount; row++) {
        List<Position> list = new ArrayList<>();
        if (row > 0) list.add(positions[row - 1][column]);        // Voisin du haut
        if (column > 0) list.add(positions[row][column - 1]);    // Voisin de gauche
        if (row < rowCount - 1) list.add(positions[row + 1][column]); // Voisin du bas
        if (column < columnCount - 1) list.add(positions[row][column + 1]); // Voisin de droite
        neighbors.put(positions[row][column], list);
      }
    }
  }
  private void initializePositions()
  {
    // Initialize positions

    for (int column = 0; column < columnCount; column++) {
      for (int row = 0; row < rowCount; row++) {
        positions[row][column] = new Position(row, column);
      }
    }
  }


  public void initializeElements() {
    // Initialize fires
    fireManager.initializeFires(initialFireCount, rowCount, columnCount, randomGenerator);

    // Initialize firefighters
    List<Position> firefighterPositions = new ArrayList<>();
    for (int index = 0; index < initialFirefighterCount; index++) {
      firefighterPositions.add(randomPosition());
    }
    firefighterManager.getFirefighterPositions().clear();
    firefighterManager.getFirefighterPositions().addAll(firefighterPositions);
  }

  private Position randomPosition() {
    return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
  }

  @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))
      result.add(ModelElement.FIRE);
    return result;
  }

  @Override
  public int rowCount() {
    return rowCount;
  }

  @Override
  public int columnCount() {
    return columnCount;
  }

  /*public List<Position> updateToNextGeneration() {
    List<Position> modifiedPositions = updateFirefighters();
    modifiedPositions.addAll(updateFires());
    step++;
    return modifiedPositions;
  }*/

  private List<Position> updateFires() {
   return fireManager.updateFires(step,neighbors);

  }

  @Override
  public int stepNumber() {
    return step;
  }

 private List<Position> updateFirefighters() {
   return firefighterManager.updateFirefighters(step,neighbors);
  }

  @Override
  public void reset() {
    step = 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;
    }
    for (ModelElement element : state) {
      switch (element) {
        case FIRE -> firePositions.add(position);
        case FIREFIGHTER -> firefighterPositions.add(position);
      }
    }
  }
}