Skip to content
Snippets Groups Projects
Select Git revision
  • d47496233c7ed6e155e69e241d09283f2b3d14d0
  • main default protected
  • variant
3 results

FireFighterFinder.java

Blame
  • Forked from LABOUREL Arnaud / Firefighter template
    Source project has a limited visibility.
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    Grid.java 2.81 KiB
    package model;
    import java.util.Iterator;
    import java.util.Optional;
    
    public class Grid implements Iterable<Square> {
      private final int numberOfRows;
      private final int numberOfColumns;
      private final Square[][] squares;
    
      /**
       * Creates a new {@code Grid} instance given the number of rows and columns.
       *
       * @param numberOfRows    the number of rows
       * @param numberOfColumns the number of columns
       * @throws IllegalArgumentException if {@code numberOfRows} or {@code numberOfColumns} are
       *                                  less than or equal to 0
       */
      public Grid(int numberOfRows, int numberOfColumns) {
        if(numberOfRows <= 0)
          throw new IllegalArgumentException("The number of rows must be positive and not equal to " + numberOfRows);
        if(numberOfColumns <= 0)
          throw new IllegalArgumentException("The number of columns must be positive and not equal to " + numberOfColumns);
        this.numberOfRows = numberOfRows;
        this.numberOfColumns = numberOfColumns;
        squares = new Square[getNumberOfRows()][getNumberOfColumns()];
        initializeGrid();
      }
    
      private void initializeGrid() {
        initializeSquares();
        initializeNeighborhood();
      }
    
      private void initializeSquares() {
        for(int row = 0; row < getNumberOfRows(); row++)
          for(int column = 0; column < getNumberOfColumns(); column++)
            squares[row][column] = new Square();
      }
    
      private void initializeNeighborhood() {
        for(int row = 0; row < getNumberOfRows(); row++)
          for(int column = 0; column < getNumberOfColumns(); column++) {
              for (CardinalDirection direction : CardinalDirection.values()){
                int rowNeighbor = row + direction.deltaRow;
                int columnNeighbor = column + direction.deltaColumn;
                if(containsCoordinates(rowNeighbor, columnNeighbor))
                  squares[row][column].setNeighboringSquare(squares[rowNeighbor][columnNeighbor], direction);
              }
            }
      }
    
      private boolean containsCoordinates(int row, int column){
        return  0 <= row && row < numberOfRows && 0 <= column && column < numberOfColumns;
      }
    
      /**
       * Returns an iterator over Squares.
       *
       * @return an Iterator.
       */
      @Override
      public Iterator<Square> iterator() {
        return new SquareIterator(this);
      }
    
      public Optional<Tile> getTile(int rowIndex, int columnIndex) {
        return getSquare(rowIndex, columnIndex).getSquareTile();
      }
    
      public Square getSquare(int rowIndex, int columnIndex) {
        return squares[rowIndex][columnIndex];
      }
    
      public int getNumberOfRows() {
        return numberOfRows;
      }
    
      public int getNumberOfColumns() {
        return numberOfColumns;
      }
    
      public void fill(TileGenerator tileGenerator){
        for(Square square : this)
          square.add(tileGenerator.nextTile(square));
      }
    
      public boolean hasTile(int row, int column) {
        return getSquare(row, column).hasTile();
      }
    }