Game of Life Processing

Question

    import processing.core.PApplet;

    public class gl extends PApplet {

    static int neighborCount;
    static int screenRows;
    int tNC; // Temporary Neighbor Count
    int newState;

    int columns = 960;
    int rows = 477;

    int[][] cells = new int[columns][rows];
    int[][] newGen = new int[columns][rows];

    public static void main(String[] args) {
        PApplet.main("gl");
    }

    public void settings() {
        size(1920, 955);
    }

    public void setup() {
        // Set background white and all of cells[][] to 0 or 1
        screenRows = 0;
        background(255);
        for (int j = 0; j < (rows / 2); j++) {
            for (int i = 0; i < (columns / 2); i++) {
                cells[i][j] = (int) random(0, 2);
            }
        }
    }

    public void draw() {
        // If program has finished generating this frame, reset everything and set cells[][] equal to newGen[][]
        if (screenRows > (height / 2)) {
            screenRows = 0;
            System.out.println("End of generation reached");
            background(255);
            cells = newGen.clone();
            for (int i = 0; i < columns; i++) {
                for (int j = 0; j < rows; j++) {
                    newGen[i][j] = 0;
                }
            }
        }
        // Go through every element in cells[][], determine it's value, and display it
        for (int x = 1; x < (width / 2) - 1; x++) {
            for (int y = 1; y < (height / 2) - 1; y++) {

                printCell(x, y);
            }
        }
        screenRows++;

    }

    public void printCell(int x, int y) {
        setCellState(x, y);

        if (newGen[x][y] == 0) {
            stroke(255);
            fill(255);

        } else if (newGen[x][y] == 1) {
            stroke(0);
            fill(0);

        }
        System.out.println(x + ", " + y);
        rect(x, y, 2, 2);
    }

    public void setCellState(int x, int y) {
        tNC = getNeighborCount(x, y);
        neighborCount = 0;
        System.out.println(tNC);

        if (tNC < 2) { // If less than 2 neighbors, cell dead
            newGen[x][y] = 0;

        } else if (tNC > 3) { // If more than 3 neighbors, cell dead
            newGen[x][y] = 0;

        } else if ((tNC == 2 || tNC == 3) && cells[x][y] == 1) { // If 2 or 3 neighbors and cell is alive, do nothing (unnecessary statement but makes visualizing easier)

        } else if (tNC == 3 && cells[x][y] == 0) { // If 3 neighbors and cell is dead, cell is alive
            newGen[x][y] = 1;

        } else if (tNC == 2 && cells[x][y] == 0) { // If 2 neighbors and cel is dead, do nothing (also unnecessary)

        } else {
            System.out.println("Error in setCellState(int, int);"); // In event of none of the conditions being met
        }
        tNC = 0; // Reset variable (probably unnecessary but might as well)
    }

    public int getNeighborCount(int x, int y) {
        // Go through each cell adjacent or diagonal to the cell and add it's value (0 or 1) to neighborCount
        for (int i = -1; i < 2; i++) {
            for (int j = -1; j < 2; j++) {
                neighborCount += cells[i + x][j + y];
            }
        }
        // Subtract the value of the cell being evaluated from neighborCount as that is not a factor in the sum of the neighbors
        neighborCount -= cells[x][y];
        return neighborCount;
    }
}

Pastebin

I am just going for functionality over speed, for now.

I am attempting to code Conway's Game of Life using Processing in Eclipse. The above code is dysfunctional in multiple ways:

The generation displayed appears much smaller in the window than I want to be. It only takes up a fraction of the window despite my efforts to counterbalance this by making each cell 2x2 pixels and half as many rows and columns as the window is tall and wide.

Also, the generation does not appear to update in the window after the first generation is displayed after a few seconds.

I noticed that the variable tNC is often equal to 0 when it should be equal to any number from 0 to 7.

Answer 1

You've got three main problems.

Problem 1: You seem to be generating the next generation as you render cells, which might be okay... but then what are you doing with the screenRows logic (the if statement in your draw() function)?

If I were you, I would split your logic up into two sections: write one function that draws your board, and another function that returns a new board based on the current one. Stop trying to calculate the next generation as you're drawing the current generation, as that's just going to give you a ton of headaches.

I also don't think your logic for switching between the arrays is correct. Which array holds the current generation, and which holds the next generation? Are you sure?

Problem 2: You seem to be switching between pixel sizes and array coordinates. For example, you're drawing each cell at its array index coordinate, but you're drawing them as 2x2 rectangles. This doesn't make a ton of sense, since you're just going to draw over top of it with the next cell anyway. Again, separate your logic: create a function that draws a cell based on the window width and height, an array position, and an array length.

Problem 3: Your print statements are killing your framerate. Print statements are notoriously slow. Your framerate is already pretty slow because of all of the calculations you're doing, but it gets even slower when you print out (960*477*2) things every single frame. This isn't really a logic error, but it makes it harder to see exactly what your program is doing.

The Solution: To fix your problems, I'd recommend refactoring your code quite a bit. If I were you, I would start over with a new program. Then:

Step 1: Separate your drawing logic from your logic for calculating the next generation. Create two functions: one for drawing, and another one that returns a new array based on the current one.

Step 2: In your drawing code, make sure you separate your array indexes and your pixel positions. Maybe write another function that takes a cell position and draws a rectangle based on the window size and the array size.

PS: Are you in the same class as this person? Are you using Daniel Shiffman's code too?