Question

My board correctly detects groups with less than 3 neighbors and kills them off, but doesn’t seem to detect and give birth to cells with 3 neighbors.

Any thoughts?

If I haven’t provided enough information let me know, and I can paste more of the code, but I think this is all of the relevant parts.

Thank you in advance for any advice offered.

public boolean getCell(int row, int col) {
    boolean state = board[row][col];
    int neighbors = 0;
    for (int x = row-1; x <= row+1; x++) {
        for (int y = col-1; y <= col+1; y++) {
            // don't include this
            if ((x != row || y != col) && x != -1 && y != -1 
            && x != NROWSCOLS && y != NROWSCOLS) {
                if (board[x][y] == ALIVE){
                    neighbors ++;
                }
            }
        }
    }
    if (neighbors > 3 || neighbors < 2)
        state = DEAD;
    else if(neighbors == 3)
        state = ALIVE;
    return state;
}

Here is the lifeCycle method requested.

/** Process one life cycle of the cellular automaton
 * 
 */
public void lifeCycle() {
    for (int x = 0; x < NROWSCOLS ; x++) {
        for (int y = 0; y < NROWSCOLS; y++) {
            getCell(x,y);
        }
    }

    generations ++;
}

I’ve attached the LifeGUI for reference, but this code is provided and not intended for me to change.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


public class LifeGUI extends JPanel {
    // game instance variables
    private Life board;        // game board

    // GUI components
    private JLabel generationsLived;          
    private JButton resetButton, cycleButton;   // reset control and cycle control
    private Cell[][] cells;         // board cells for display

    /** Construct new Life game with a graphical user interface */
    public LifeGUI()    {
        // create and initialize game board and display representation
        board = new Life();
        cells = new Cell[Life.NROWSCOLS][Life.NROWSCOLS];

        // set layout for game display
        setLayout(new BorderLayout());

        // Create board cells and add to display
        JPanel boardPanel = new JPanel();
        boardPanel.setLayout(new GridLayout(Life.NROWSCOLS, Life.NROWSCOLS));
        for (int row = 0; row < Life.NROWSCOLS; row++) {
            for (int col = 0; col < Life.NROWSCOLS; col++) {
                cells[row][col] = new Cell(Life.DEAD, row, col);
                boardPanel.add(cells[row][col]);
           }
        }
        add(boardPanel, BorderLayout.CENTER);


        // Set up 2 buttons
        // a reset button so it starts a new game when clicked
        // a cycle button to tell the Life automaton to live one cycle
        resetButton = new JButton("New Game");
        resetButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                board.newGame();
                updateDisplay();
            }
        });

        cycleButton = new JButton("Live One Cycle");
        cycleButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                board.lifeCycle();
                updateDisplay();
            }
        });

        // Put the buttons and the generation count display on the screen
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(resetButton);
        buttonPanel.add(cycleButton);
        generationsLived = new JLabel("     Generations Lived: " , JLabel.RIGHT);
        buttonPanel.add(generationsLived);
        add(buttonPanel, BorderLayout.SOUTH);

        // show initial display
        updateDisplay();
    }

    /** Update display to match game state. */
    public void updateDisplay() {
        // update count display
        generationsLived.setText("     Generations Lived: " + board.getGenerationCount());

        // update board display
        for (int row = 0; row < Life.NROWSCOLS; row++) {
            for (int col = 0; col < Life.NROWSCOLS; col++) {
                cells[row][col].setState(board.getCell(row,col));
            }
        }
        repaint();
    }

    /** Create new game and a window to display it */
    private static void test() {
        JFrame f = new JFrame("The Game of Life");     // top-level window
        LifeGUI l = new LifeGUI();
        f.getContentPane().add(l);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(600,600);
        f.validate();
        f.setVisible(true);
        f.toFront();
    }

    public static void main(String[] args) {
        // To support stand-alone application
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                LifeGUI.test();
            }
        });
    }
}

Answer 1

public boolean getCell(int row, int col) {
    boolean state = board[row][col];
    int neighbors = 0;//you are summing the alive neighbours 
       //keep var declaration outside the iteration over them

    for (int x = Math.max(0,row-1); x < Math.min(row+2,NROWSCOLS); x++) {
        for (int y = Math.max(0,col-1); y < Math.min(col+2,NROWSCOLS); y++) {
            //using min and max to ensure x and y remain between 0 and NROWSCOLS 
            //so no IOBException
                if (board[x][y] == ALIVE){
                    neighbors ++;

                }
            }
        }
    }
    if (neighbors > 3 || neighbors < 2)//only do the check when you are finished counting the alive neighbours
        state = DEAD;
    else if(neighbors == 3)
        state = ALIVE;
    return state;
}