nextState[row][col] = new State(stateEmpty); 
            } 
             
            if (cell.getState().equals(new State(stateTree))) { 
               List<Cell> neighbors = cell.getNeighborhood().getNeighbors(); 
               if (doesTreeBecomeBurning(neighbors)) { 
                  nextState[row][col] = new State(stateBurning); 
               } 
               else { 
                  nextState[row][col] = new State(stateTree); 
               } 
            } 

                  nextState[row][col] =  new State(stateAlive); 
               } 
            } 
             
            if (cell.getState().equals(new State(stateDead))) { 
               if (aliveNeighbors == 3) { 
                  nextState[row][col] =  new State(stateAlive); 
               } 
               else { 
                  nextState[row][col] = new State(stateDead); 
               } 
            } 

   private State generateRandomState() { 
      Random r = new Random(); 
      int i = r.nextInt(4); 
       
      if (i == 0) { 
         return new State(stateX); 
      } 
      if (i == 1) { 
         return new State(stateO); 
      } 
      else { 
         return new State(stateEmpty); 
      } 
   } 

   private State generateRandomState() { 
      Random r = new Random(); 
      int i = r.nextInt(4); 
       
      if (i == 0) { 
         return new State(stateAlive); 
      } 
      else { 
         return new State(stateDead); 
      } 
   } 

   private State generateRandomState() { 
      Random r = new Random(); 
      int i = r.nextInt(10); 
       
      if (i == 0) { 
         return new State(stateShark); 
      } 
      if (i == 1 || i == 2 || i == 3) { 
         return new State(stateFish); 
      } 
      else { 
         return new State(stateEmpty); 
      } 
   } 

               cellsToMoveTo.add(neighbor); 
               break; 
            } 
         } 
      } 
          
      if (cellsToMoveTo.isEmpty()) { 
         nextState[row][col] = moveFrom; 
         return; 
      } 
          
      Random r = new Random(); 
      Cell randomCell = cellsToMoveTo.get(r.nextInt(cellsToMoveTo.size())); 
       
      Point neighborLocation = grid.getLocation(randomCell);       

            cellsToBreedTo.add(neighbor); 
         } 
      } 
          
      if (cellsToBreedTo.isEmpty()) { 
         nextState[row][col] = cell.getState(); 
         return; 
      } 
          
      Random r = new Random(); 
      Cell randomCell = cellsToBreedTo.get(r.nextInt(cellsToBreedTo.size())); 
       
      Point neighborLocation = grid.getLocation(randomCell);       

      int aliveNeighbors = 0; 
       
      for (Cell neighbor : neighbors) { 
         if (neighbor.getState().equals(new State(stateAlive))) { 
            aliveNeighbors++; 
         } 
      } 

      int sameStateNeighbors = 0; 
       
      for (Cell neighbor : neighbors) { 
         if (neighbor.getState().equals(new State(stateEmpty))) { 
            continue; 
         } 
             
         nonEmptyNeighbors++; 

      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 
             
            if (cell.getState().equals(new State(stateEmpty))) { 

      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 
            if (cell.getState().equals(new State(stateEmpty))) { 

   @Override 
   protected void initStates() { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = new Cell(generateRandomState()); 
            grid.addCell(cell, row, col); 
         } 
      } 
   } 

   @Override 
   protected void initStates() { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = new Cell(generateRandomState()); 
            grid.addCell(cell, row, col); 
         } 
      } 
   } 

   @Override 
   protected void initStates() { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = new Cell(generateRandomState()); 
            grid.addCell(cell, row, col); 
         } 
      } 
   } 

    public String toString () { 
        StringBuilder result = new StringBuilder(); 
        result.append("Data{") 
              .append("title='").append(getMyTitle()).append("', ") 
              .append("author='").append((getMyAuthor())).append("', ") 
              .append("numRows='").append((getMyNumRows())).append("', ") 
              .append("numCols='").append((getMyNumCols())).append("', ") 
              .append("threshold='").append(getMyThreshold()).append("'") 
              .append('}'); 
       return result.toString(); 
    } 

    public String toString () { 
        StringBuilder result = new StringBuilder(); 
        result.append("Data{") 
              .append("title='").append(getMyTitle()).append("', ") 
              .append("author='").append((getMyAuthor())).append("', ") 
              .append("numRows='").append((getMyNumRows())).append("', ") 
              .append("numCols='").append((getMyNumCols())).append("', ") 
              .append("probCatch='").append(getMyProbCatch()).append("', ") 
              .append("initialFire='").append(getMyInitialFire()).append("'") 
              .append('}'); 
       return result.toString(); 
    } 

    public String toString () { 
        StringBuilder result = new StringBuilder(); 
        result.append("Data{") 
              .append("title='").append(getMyTitle()).append("', ") 
              .append("author='").append((getMyAuthor())).append("', ") 
              .append("numRows='").append((getMyNumRows())).append("', ") 
              .append("numCols='").append((getMyNumCols())).append("', ") 
              .append("fishBreed='").append((getMyFishBreed())).append("', ") 
              .append("fishStarve='").append((getMyFishStarve())).append("', ") 
              .append("sharkBreed='").append((getMySharkBreed())).append("', ") 
              .append("sharkStarve='").append((getMySharkStarve())).append("'") 
              .append('}'); 
       return result.toString(); 
    } 

   protected void initNeighbors() { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 

   protected void setNextStates() { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 

      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
             
            Cell cell = grid.getCell(row, col); 

      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 

      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 

   @Override 
   protected void calculateNeighbors(Cell cell, int row, int col) { 
      for (int i = -1; i <= 1; i++) { 
         for (int j = -1; j <= 1; j++) { 
            if (i == 0 && j == 0) { 
               continue; 
            } 
            if (i + row < 0 || i + row >= rows || j + col < 0 || j + col >= columns) { 
               continue; 
            } 
            Cell neighbor = grid.getCell(row + i, col + j); 
            cell.getNeighborhood().addNeighbor(neighbor); 
         } 
      } 
   } 

   @Override 
   protected void calculateNeighbors(Cell cell, int row, int col) { 
      for (int i = -1; i <= 1; i++) { 
         for (int j = -1; j <= 1; j++) { 
            if (i == 0 && j == 0) { 
               continue; 
            } 
            if (i + row < 0 || i + row >= rows || j + col < 0 || j + col >= columns) { 
               continue; 
            } 
            Cell neighbor = grid.getCell(row + i, col + j); 
            cell.getNeighborhood().addNeighbor(neighbor); 
         } 
      } 
   } 

            if (cell.getState().equals(otherState1) && nextState[row][col] == null) { 
               nextState[row][col] = otherState1; 
               continue; 
            } 

            if (cell.getState().equals(otherState2) && nextState[row][col] == null) { 
               nextState[row][col] = otherState2; 
               continue; 
            } 

   @Override 
   protected void calculateNeighbors(Cell cell, int row, int col) { 
      Point[] neighborDisplacements = {new Point(1,0), new Point(-1,0), new Point(0,1), new Point(0,-1)}; 
       
      for (Point neighborDisplacement : neighborDisplacements) { 
         int i = neighborDisplacement.x; 
         int j = neighborDisplacement.y; 
          
         if (i + row < 0 || i + row >= rows || j + col < 0 || j + col >= columns) { 
            continue; 
         } 
         Cell neighbor = grid.getCell(row + i, col + j); 
         cell.getNeighborhood().addNeighbor(neighbor); 
      } 
   } 

   @Override 
   protected void calculateNeighbors(Cell cell, int row, int col) { 
      Point[] neighborDisplacements = {new Point(1,0), new Point(-1,0), new Point(0,1), new Point(0,-1)}; 
       
      for (Point neighborDisplacement : neighborDisplacements) { 
         int i = neighborDisplacement.x; 
         int j = neighborDisplacement.y; 
          
         if (i + row < 0 || i + row >= rows || j + col < 0 || j + col >= columns) { 
            continue; 
         } 
         Cell neighbor = grid.getCell(row + i, col + j); 
         cell.getNeighborhood().addNeighbor(neighbor); 
      } 
   } 

   private void breedAnimals(State stateToBreed, State otherState1, State otherState2) { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 

   private void moveAnimals(State moveFrom, State[] moveTo, State[] otherStates) { 
      for (int row = 0; row < rows; row++) { 
         for (int col = 0; col < columns; col++) { 
            Cell cell = grid.getCell(row, col); 

            if (cell.getState().equals(otherStates[0]) && nextState[row][col] == null) { 
               nextState[row][col] = otherStates[0]; 
               continue; 
            } 

            if (cell.getState().equals(otherStates[1]) && nextState[row][col] == null) { 
               nextState[row][col] = otherStates[1]; 
               continue; 
            } 

   protected void addPlayButton() { 
      Button playButton = UIGenerator.createButton("Play", 380, 20, 100, 20, 15); 
      playButton.setOnAction(e -> activatePlay()); 
      root.getChildren().add(playButton); 
   } 

   protected void addStopButton() { 
      Button stopButton = UIGenerator.createButton("Stop", 500, 20, 100, 20, 15); 
      stopButton.setOnAction(e -> activateStop()); 
      root.getChildren().add(stopButton); 
   } 

   protected void addStepButton() { 
      Button stepButton = UIGenerator.createButton("Show Next Step", 200, 20, 150, 20, 15); 
      stepButton.setOnAction(e -> updateGrid()); 
      root.getChildren().add(stepButton); 
   } 

   protected void addMenuButton() { 
      Button menuButton = UIGenerator.createButton("Back to Menu", 20, 20, 150, 20, 15); 
      menuButton.setOnAction(e -> sceneManager.goToMenuScene(sceneManager)); 
      root.getChildren().add(menuButton); 
   } 

   @Override 
   protected void initColors() { 
      colorMap = new HashMap<State, Color>(); 
      colorMap.put(new State(stateEmpty), Color.BLUE); 
      colorMap.put(new State(stateFish), Color.GREEN); 
      colorMap.put(new State(stateShark), Color.YELLOW); 
   } 

   @Override 
   protected void initColors() { 
      colorMap = new HashMap<State, Color>(); 
      colorMap.put(new State(stateEmpty), Color.YELLOW); 
      colorMap.put(new State(stateBurning), Color.RED); 
      colorMap.put(new State(stateTree), Color.GREEN); 
   } 

   @Override 
   protected void initColors() { 
      colorMap = new HashMap<State, Color>(); 
      colorMap.put(new State(stateX), Color.BLUE); 
      colorMap.put(new State(stateO), Color.RED); 
      colorMap.put(new State(stateEmpty), Color.LIGHTGREY); 
   } 

      if (turnsSinceLastSharkBreed >= sharkTurnsToBreed) { 
         breedAnimals(new State(stateShark), new State(stateFish), new State(stateEmpty)); 
         setNextStates(); 
         turnsSinceLastSharkBreed = 0; 
      } 
      turnsSinceLastSharkBreed++; 

      if (turnsSinceLastFishBreed >= fishTurnsToBreed) { 
         breedAnimals(new State(stateFish), new State(stateShark), new State(stateEmpty)); 
         setNextStates(); 
         turnsSinceLastFishBreed = 0; 
      } 
      turnsSinceLastFishBreed++; 

    private LifeData getLifeData (Element root) throws XMLFactoryException{ 
        String title = getTextValue(root, "title"); 
        String author = getTextValue(root, "author"); 
        String numRows = getTextValue(root, "numRows"); 
        String numCols = getTextValue(root, "numCols"); 

    public SegregationData getSegregationData (Element root) throws XMLFactoryException{ 
        String title = getTextValue(root, "title"); 
        String author = getTextValue(root, "author"); 
        String numRows = getTextValue(root, "numRows"); 
        String numCols = getTextValue(root, "numCols"); 

    private PredData getPredData(Element root) throws XMLFactoryException{ 
        String title = getTextValue(root, "title"); 
        String author = getTextValue(root, "author"); 
        String numRows = getTextValue(root, "numRows"); 
        String numCols = getTextValue(root, "numCols"); 
        String fishBreed = getTextValue(root, "FishTurnsToBreed"); 
        String sharkBreed = getTextValue(root, "SharkTurnsToBreed"); 

    private FireData getFireData(Element root) throws XMLFactoryException{ 
        String title = getTextValue(root, "title"); 
        String author = getTextValue(root, "author"); 
        String numRows = getTextValue(root, "numRows"); 
        String numCols = getTextValue(root, "numCols"); 
        String probCatch = getTextValue(root, "probCatch"); 
        String initialFire = getTextValue(root, "initialFire"); 

      super(sceneManager); 
      this.rows = Integer.parseInt(rows); 
      this.columns = Integer.parseInt(columns); 
      this.probCatch = Double.parseDouble(probCatch); 

      super(sceneManager); 
      this.rows = Integer.parseInt(rows); 
      this.columns = Integer.parseInt(columns); 
      this.threshold = Double.parseDouble(threshold); 

      super(sceneManager); 
      this.rows = Integer.parseInt(rows); 
      this.columns = Integer.parseInt(columns); 

      super(sceneManager); 
      this.rows = Integer.parseInt(rows); 
      this.columns = Integer.parseInt(columns);