Skip to content
Snippets Groups Projects
Select Git revision
  • 5060d1acc0794c0ac415aa3b85c40bbe8db6c5d1
  • main default protected
  • melissa
  • yanis
  • variant
5 results

FireFighterScenario.java

Blame
  • Forked from COUETOUX Basile / FirefighterStarter
    40 commits ahead of the upstream repository.
    user avatar
    Yanis OUALAN authored
    5060d1ac
    History
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    FireFighterScenario.java 6.35 KiB
    package model;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Random;
    
    import util.Matrix;
    import util.Position;
    import util.PositionUtil;
    
    public class FireFighterScenario extends EntityScenario implements Board<Square> {
    
      private Matrix<Square> matrix;
      private int step;
    
      private int initialFireCount;
      private int initialFireFightersCount;
    
      public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount) {
        this.matrix = new Matrix<Square>(columns, rows);
        this.initialFireCount = initialFireCount;
        this.initialFireFightersCount = initialFireFightersCount;
        initScenario(matrix);
        placeInitialActors(initialFireCount, initialFireFightersCount);
        this.step = 0;
      }
    
      private void placeInitialActors(int initialFireCount, int initialFireFightersCount) {
        int fireCount = 0;
        int fireFighterCount = 0;
        int chance = 5; // Chance initiale en pourcentage
        Random random = new Random();
        List<Position> positions = new ArrayList<>();
        for (int x = 0; x < matrix.getRows(); x++) {
          for (int y = 0; y < matrix.getColumns(); y++) {
            positions.add(new Position(x, y));
          }
        }
    
        while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount) {
          Collections.shuffle(positions); // Mélange les positions pour un parcours aléatoire
    
          for (Position pos : positions) {
            if (getStates(pos).isEmpty()) {
              if (fireCount < initialFireCount && random.nextInt(100) < chance) {
                setSquare(new Square(pos, new Fire(pos, this, 1)));
                fireCount++;
                if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount) {
                  return;
                }
                continue;
              }
    
              if (fireFighterCount < initialFireFightersCount && random.nextInt(100) < chance) {
                setSquare(new Square(pos, new FireFighter(pos, this, 1)));
                fireFighterCount++;
                if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount) {
                  return;
                }
              }
            }
          }
    
          // Augmente la chance de placement après chaque parcours complet
          chance = Math.min(chance + 5, 100); // Ne dépasse pas 100%
        }
      }
    
      public Square getStates(Position position) {
        if (position.x() > matrix.size() || position.y() > matrix.size()) {
          throw new IllegalArgumentException(
              "The position x:" + position.x() + " y:" + position.y() + " is out of the board.");
        }
        return matrix.get(position.x(), position.y());
      }
    
      public void setSquare(Square square) {
        Position position = square.getPosition();
        if (!(getStates(position).isEmpty())) {
          return;
        }
        if (doesPositionExist(position)) {
          matrix.set(position.x(), position.y(), square);
        }
      }
    
      public void setSquare(Square square, boolean replaceStates) {
        Position position = square.getPosition();
        if (!(getStates(position).isEmpty()) && !replaceStates) {
          return;
        }
        matrix.set(position.x(), position.y(), square);
      }
    
      public void addEntityAtSquare(Entity entity, Position position) {
        if (!(getStates(position).isEmpty())) {
          return;
        }
        if (doesPositionExist(position)) {
          matrix.get(position.x(), position.y()).addEntity(entity);
          ;
        }
      }
    
      public void addEntityAtSquare(Entity entity, Position position, boolean replaceStates) {
        if (!(getStates(position).isEmpty()) && !replaceStates) {
          return;
        }
        matrix.get(position.x(), position.y()).addEntity(entity);
        ;
      }
    
      public int rowCount() {
        return matrix.getRows();
      }
    
      public int columnCount() {
        return matrix.getColumns();
      }
    
      @Override
      public void clearCaseFrom(Entity entity, Position position) {
        matrix.get(position.x(), position.y()).getEntities().removeIf(element -> element.equals(entity));
      }
    
      public List<Position> updateToNextGeneration() {
        ArrayList<Position> changedPositions = new ArrayList<>();
        Iterator<Square> iterator = matrix.iterator();
        while (iterator.hasNext()) {
          Square s = iterator.next();
          if (s.isEmpty())
            continue;
          if (s.getMaxAge() == 0) {
            s.incrementAllAges();
            continue;
          }
          if (s.getMaxAge() == step + 1) {
            continue;
          }
          List<Entity> entities = new ArrayList<>(s.getEntities());
          for (Entity e : entities) {
            List<Position> entityUpdatedPositions = e.nextTurn(this);
            e.incrementAge();
            changedPositions.addAll(entityUpdatedPositions);
          }
    
        }
        this.step = this.step + 1;
        // matrix.displayMatrix();
        return changedPositions;
      }
    
      public Position getNearestEntity(Position fromPos, Class<?> entityType) {
        int rows = matrix.getRows();
        int cols = matrix.getColumns();
        Position nearestPosition = fromPos;
    
        // Définir la distance maximale possible
        int maxDistance = rows + cols;
    
        // Parcourir les distances croissantes à partir de 1
        for (int distance = 1; distance < maxDistance; distance++) {
          List<Position> positionsAtDistance = PositionUtil.getPositionsAtManhattanDistance(fromPos, distance, rows, cols);
    
          for (Position currentPos : positionsAtDistance) {
            Square currentSquare = matrix.get(currentPos.x(), currentPos.y());
            for (Entity currentEntity : currentSquare.getEntities()) {
              if (entityType.isInstance(currentEntity)) {
                // Dès qu'une entité est trouvée à cette distance, elle est la plus proche
                // possible
                return currentPos;
              }
            }
          }
        }
    
        return nearestPosition; // Retourne null si aucune entité n'est trouvée
      }
    
      public void reset() {
        step = 0;
        matrix.clear();
        initScenario(matrix);
        placeInitialActors(initialFireCount, initialFireFightersCount);
      }
    
      public int stepNumber() {
        return this.step;
      }
    
      @Override
      public boolean doesPositionExist(Position position) {
        return matrix.validateIndex(position);
      }
    
      @Override
      public int getStepNumber() {
        return step;
      }
    
      @Override
      public boolean doesSquareContainEntity(Position squarePos, Class<?> entityType) {
        return getStates(squarePos).getEntities().stream().anyMatch(entityType::isInstance);
      }
    
      @Override
      public boolean isPositionEmpty(Position position) {
        return getStates(position).isEmpty();
      }
    }