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 TargetStrategy targetStrategy = new TargetStrategy();
  private List<FireFighter> firefighters;
  private Set<Fire> fires;
  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++)
        positions[row][column] = new Position(row, column);
    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]);
        if (column > 0) list.add(positions[row][column - 1]);
        if (row < rowCount - 1) list.add(positions[row + 1][column]);
        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() {
    firefighters = new ArrayList<>();
    fires = new HashSet<>();
    for (int index = 0; index < initialFireCount; index++)
      fires.add(new Fire(randomPosition()));
    for (int index = 0; index < initialFirefighterCount; index++)
      firefighters.add(new FireFighter(randomPosition()));
  }

  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 (FireFighter firefighter : firefighters)
      if (firefighter.getPosition().equals(position))
        result.add(ModelElement.FIREFIGHTER);

    if (this.getFirePositions(fires).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() {
    List<Position> modifiedPositions = new ArrayList<>();
    if (step % 2 == 0) {
      List<Position> newFirePositions = new ArrayList<>();
      for (Position fire : getFirePositions(this.fires)) {
        newFirePositions.addAll(neighbors.get(fire));
      }
      this.getFirePositions(fires).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 : this.getFireFighterPositions(this.firefighters)) {
      Position newFirefighterPosition =
              targetStrategy.neighborClosestToFire(firefighterPosition,
                      this.getFirePositions(fires), neighbors);
      firefighterNewPositions.add(newFirefighterPosition);
      extinguish(newFirefighterPosition);
      modifiedPosition.add(firefighterPosition);
      modifiedPosition.add(newFirefighterPosition);
      List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
              .filter(this.getFirePositions(fires)::contains).toList();
      for (Position firePosition : neighborFirePositions)
        extinguish(firePosition);
      modifiedPosition.addAll(neighborFirePositions);
    }
    ArrayList<FireFighter> newFireFighters = new ArrayList<>();
    for(Position position : firefighterNewPositions){
      newFireFighters.add(new FireFighter(position));
    }
    firefighters = newFireFighters;
    return modifiedPosition;
  }

  @Override
  public void reset() {
    step = 0;
    initializeElements();
  }

  private void extinguish(Position position) {
    for(Fire fire: fires){
      if(fire.getPosition().equals(position)){
        fires.remove(fire);
      }
    }
  }


  @Override
  public void setState(List<ModelElement> state, Position position) {
    extinguish(position);
    for (; ; ) {
      if (!getFireFighterPositions(this.firefighters).remove(position)) break;
    }
    for (ModelElement element : state) {
      switch (element) {
        case FIRE -> fires.add(new Fire(position));
        case FIREFIGHTER -> firefighters.add(new FireFighter(position));
      }
    }
  }




  public Set<Position> getFirePositions(Set<Fire> fireSet){
    Set<Position> firePositions = new HashSet<>();
    for(Fire fire : fireSet){
      firePositions.add(fire.getPosition());
    }
    return firePositions;
  }


  public ArrayList<Position> getFireFighterPositions(List<FireFighter> fireFighterList){
    ArrayList<Position> fireFighterPositions = new ArrayList<>();
    for(FireFighter fireFighter : fireFighterList){
      fireFighterPositions.add(fireFighter.getPosition());
    }
    return fireFighterPositions;
  }





}