FirefighterBoard.java

package model;

import util.Position;
import javafx.util.Pair;
import java.util.*;

import static model.ModelElement.CLOUD;

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 int initialRoadCount;
    private final int initialcloudCount;
    private final int initialmountainsCount;
    private final int initialrocksCount;

    private List<Position> firefighterPositions;
    private Set<Position> firePositions;
    private Set<Position> roadPositions;
    private final Map<Position, List<Position>> neighbors;
    private final Position[][] positions;
    private List<Position> cloudPositions;
    private Set<Position> moutainsPositions;
    private Set<Position> rocksPositions;

    private int step = 0;

    // Constructor for FirefighterBoard
    public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount, int initialRoadCount, int initialcloudCount, int initialmountainsCount, int initialrocksCount) {
        this.columnCount = columnCount;
        this.rowCount = rowCount;
        this.initialFireCount = initialFireCount;
        this.initialFirefighterCount = initialFirefighterCount;
        this.initialRoadCount = initialRoadCount;
        this.initialcloudCount = initialcloudCount;
        this.initialmountainsCount = initialmountainsCount;
        this.initialrocksCount = initialrocksCount;

        this.positions = new Position[rowCount][columnCount];
        this.firefighterPositions = new ArrayList<>();
        this.firePositions = new HashSet<>();
        this.neighbors = new HashMap<>();
        this.cloudPositions = new ArrayList<>();
        this.moutainsPositions = new HashSet<>();
        this.roadPositions = new HashSet<>();
        this.rocksPositions = new HashSet<>();

        initializeBoard();
    }

    private void initializeBoard() {
        Random random = new Random();

        // Initialize fire positions
        for (int i = 0; i < initialFireCount; i++) {
            firePositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
        }

        // Initialize firefighter positions
        for (int i = 0; i < initialFirefighterCount; i++) {
            firefighterPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
        }
        // Initialize road positions
        for (int i = 0; i < initialRoadCount; i++) {
            roadPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
        }
        // Initialize road positions
        for (int i = 0; i < initialcloudCount; i++) {
            cloudPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
        }
        // Initialize Moutains Positions
        for (int i = 0; i < initialmountainsCount; i++) {
            moutainsPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
        }
        // Initialize rocks positions
        for (int i = 0; i < initialrocksCount; i++) {
            rocksPositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount)));
        }


        // Initialize neighbors map
        for (int row = 0; row < rowCount; row++) {
            for (int col = 0; col < columnCount; col++) {
                positions[row][col] = new Position(row, col);
                neighbors.put(positions[row][col], calculateNeighbors(row, col));
            }
        }
    }

    private List<Position> calculateNeighbors(int row, int col) {
        List<Position> adjacentPositions = new ArrayList<>();
        if (row > 0) adjacentPositions.add(new Position(row - 1, col));  // Top neighbor
        if (col > 0) adjacentPositions.add(new Position(row, col - 1));  // Left neighbor
        if (row < rowCount - 1) adjacentPositions.add(new Position(row + 1, col));  // Bottom neighbor
        if (col < columnCount - 1) adjacentPositions.add(new Position(row, col + 1));  // Right neighbor
        return adjacentPositions;
    }

    @Override
    public List<ModelElement> getState(Position position) {
        List<ModelElement> result = new ArrayList<>();
        for (ModelElement element : ModelElement.values()){
            switch (element){
                case FIRE -> {
                    if (firePositions.contains(position)) {
                        result.add(ModelElement.FIRE);
                    }
                }
                case FIREFIGHTER -> {
                    if (firefighterPositions.contains(position)) {
                        result.add(ModelElement.FIREFIGHTER);
                    }
                }
                case CLOUD -> {
                    if (cloudPositions.contains(position)) {
                        result.add(ModelElement.CLOUD);
                    }
                }
                case ROAD -> {
                    if (roadPositions.contains(position)) {
                        result.add(ModelElement.ROAD);
                    }
                }
                case MOUTAIN -> {
                    if (moutainsPositions.contains(position)) {
                        result.add(ModelElement.MOUTAIN);
                    }
                }
                case ROCKS -> {
                    if (rocksPositions.contains(position)) {
                        result.add(ModelElement.ROCKS);
                    }
                }
                default ->{
                }
            }
        }
        return result;
    }

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

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

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

    @Override
    public void reset() {
        step = 0;
        Initializer initializer = new Initializer(columnCount,rowCount,initialFireCount,initialFirefighterCount, initialRoadCount,initialcloudCount, initialmountainsCount, initialrocksCount);
        resetPos(firePositions,initializer.getFirePositions());
        resetPos(firefighterPositions,initializer.getFirefighterPositions());
        resetPos(cloudPositions,initializer.getCloudPositions());
        resetPos(moutainsPositions,initializer.getMountainsPositions());
        resetPos(roadPositions,initializer.getRoadPositions());
        resetPos(rocksPositions,initializer.getRoadPositions());

        neighbors.clear();
        neighbors.putAll(initializer.getNeighbors());

        initializeBoard();
    }
    private <S> void resetPos(Collection<S> currentPositions, Collection<S> newPositions) {
        currentPositions.clear();
        currentPositions.addAll(newPositions);
  }

    @Override
    public void setState(List<ModelElement> state, Position position) {
        firePositions.remove(position);
        firefighterPositions.remove(position);

        for (ModelElement element : state) {
            switch (element) {
                case FIRE -> firePositions.add(position);
                case FIREFIGHTER -> firefighterPositions.add(position);
                case CLOUD -> cloudPositions.add(position);
            }
        }
    }

    @Override
    public List<Position> updateToNextGeneration() {
        List<ModelElement> elements = List.of(
                ModelElement.FIRE,
                ModelElement.FIREFIGHTER,
                ModelElement.CLOUD
        );
        List<Position> modifiedPositions = new ArrayList<>();

        for(ModelElement element : elements) {
            Strategy strategy = switch(element) {
                case FIRE -> new SimpleFireSpreadStrategy(firePositions, neighbors,moutainsPositions,roadPositions, rocksPositions,step);
                case FIREFIGHTER -> new FirefighterMovementStrategy(firefighterPositions,firePositions,neighbors);
                case CLOUD -> new CloudStrategy(cloudPositions,firePositions,neighbors,rowCount,columnCount);
                default -> throw new IllegalStateException("Type de modèle inconnu : " + element);
            };
            modifiedPositions.addAll(strategy.update());

            switch (element) {
                case FIRE -> firePositions = strategy.getFirePositions();
                case FIREFIGHTER -> firefighterPositions = strategy.getModelPositions();
                case CLOUD -> cloudPositions = strategy.getModelPositions();
            }
        }
        step++;
        return modifiedPositions;
    }

    public List<Pair<Position, ModelElement>> getUpdatedElements() {
        List<Pair<Position, ModelElement>> updatedElements = new ArrayList<>();

        // Add fire positions
        for (Position firePosition : firePositions) {
            updatedElements.add(new Pair<>(firePosition, ModelElement.FIRE));
        }

        // Add firefighter positions
        for (Position firefighterPosition : firefighterPositions) {
            updatedElements.add(new Pair<>(firefighterPosition, ModelElement.FIREFIGHTER));
        }
        for (Position cloudPosition : cloudPositions) {
            updatedElements.add(new Pair<>(cloudPosition, ModelElement.CLOUD));
        }
        // Add firefighter positions
        for (Position cloudPosition : cloudPositions) {
            updatedElements.add(new Pair<>(cloudPosition, ModelElement.CLOUD));
        }
        for (Position roadPosition : roadPositions) {
            updatedElements.add(new Pair<>(roadPosition, ModelElement.ROAD));
        }
        for (Position moutainPosition : moutainsPositions){
            updatedElements.add(new Pair<>(moutainPosition, ModelElement.MOUTAIN));
        }
        for (Position rockPosition : rocksPositions){
            updatedElements.add(new Pair<>(rockPosition,ModelElement.ROCKS));
        }

        return updatedElements;
    }
}










/*
import util.*;

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<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++)
        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() {
    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());
  }

  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() {
    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;
  }

  @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);
      }
    }
  }
}*/