约翰·康威的人生游戏

Question

I have been working on a versions of Conway's Game of Life for school and I have run into a problem: cells are becoming dead or alive in the wrong places.

How can I fix that?

if (alive == 3 && aryBOARD[x][y] == 0) { //rule 4
    aryCHANGE[x][y] = 1;
}
if (alive > 3  && aryBOARD[x][y] == 1) { //rule 3
    aryCHANGE[x][y] = 0;
}
if (alive >= 2 && alive <= 3 &&  aryBOARD[x][y] == 1) { //rule 2
    aryCHANGE[x][y] = 1;
}
if (alive < 2   && aryBOARD[x][y] == 1) { //rule 1
    aryCHANGE[x][y] = 0;
}
if (dead > 5) { //rule check
    aryCHANGE[x][y] = 0;
}

That is where I assume the problem is but if having the whole code would help:

package gameoflife2;

public class Game {

  public static void main(String[] args) {

    int[][] aryBOARD = new int[5][5];
    int x = 0;
    int y = 0;
    int dead = 0;
    int alive = 0;
    int i, j;
    // Board numbers
    // 00011
    // 00001
    // 01000
    // 01100
    // 00000
    aryBOARD[0][0] = 0;
    aryBOARD[0][1] = 0;
    aryBOARD[0][2] = 0;
    aryBOARD[0][3] = 1;
    aryBOARD[0][4] = 1;
    aryBOARD[1][0] = 0;
    aryBOARD[1][1] = 0;
    aryBOARD[1][2] = 0;
    aryBOARD[1][3] = 0;
    aryBOARD[1][4] = 1;
    aryBOARD[2][0] = 0;
    aryBOARD[2][1] = 1;
    aryBOARD[2][2] = 0;
    aryBOARD[2][3] = 0;
    aryBOARD[2][4] = 0;
    aryBOARD[3][0] = 0;
    aryBOARD[3][1] = 1;
    aryBOARD[3][2] = 1;
    aryBOARD[3][3] = 0;
    aryBOARD[3][4] = 0;
    aryBOARD[4][0] = 0;
    aryBOARD[4][1] = 0;
    aryBOARD[4][2] = 0;
    aryBOARD[4][3] = 0;
    aryBOARD[4][4] = 0;
    // end of array
    int[][] aryCHANGE = aryBOARD.clone(); // array change is equal to array
                                          // board

    // printing array
    int rows = 5;
    int colums = 5;

    for (i = 0; i < rows; i++) {
      for (j = 0; j < colums; j++) {
        System.out.print(aryBOARD[i][j] + " ");
      }
      System.out.println("");
    }

    System.out.println("---------------------------");

    // done printing array
    // check for dead or alive cells

    for (x = 0; x <= 4; x++) {
      for (y = 0; y <= 4; y++) {
        alive = 0;
        dead = 0;
        if ((x + 1 < 4) && (x + 1 > 0)) { // right
          if (aryBOARD[x + 1][y] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        if (((y - 1 < 4) && (y - 1 > 0) && (x + 1 < 4) && (x + 1 > 0))) { // bottom
                                                                          // right
                                                                          // corner
          if (aryBOARD[x + 1][y - 1] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        if (((y + 1 < 4) && (y + 1 > 0) && (x + 1 < 4) && (x + 1 > 0))) { // top
                                                                          // right
                                                                          // corner
          if (aryBOARD[x + 1][y + 1] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        if ((y + 1 < 4) && (y + 1 > 0)) {// top middle
          if (aryBOARD[x][y] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        if (((y + 1 < 4) && (y + 1 > 0) && (x - 1 < 4) && (x - 1 > 0))) {// top
                                                                         // left
                                                                         // corner
          if (aryBOARD[x - 1][y + 1] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        if ((x - 1 < 4) && (x - 1 > 0)) {// left
          if (aryBOARD[x - 1][y] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        if (((y - 1 < 4) && (y - 1 > 0) && (x - 1 < 4) && (x - 1 > 0))) {// bottom
                                                                         // left
                                                                         // corner
          if (aryBOARD[x - 1][y - 1] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        // x++
        if ((y - 1 < 4) && (y - 1 > 0)) {// bottom middle
          if (aryBOARD[x][y - 1] == 0) {
            dead++;
          } else {
            alive++;
          }
        }

        // RULES
        // 1 Any live cell with fewer than two live neighbors dies, as if caused
        // by under-population.
        // 2 Any live cell with two or three live neighbors lives on to the next
        // generation.
        // 3 Any live cell with more than three live neighbors dies, as if by
        // overcrowding.
        // 4 Any dead cell with exactly three live neighbors becomes a live
        // cell, as if by reproduction.

        // test alive and dead

        if (alive == 3 && aryBOARD[x][y] == 0) {// rule 4
          aryCHANGE[x][y] = 1;
        }

        if (alive > 3 && aryBOARD[x][y] == 1) {// rule 3
          aryCHANGE[x][y] = 0;
        }

        if (alive >= 2 && alive <= 3 && aryBOARD[x][y] == 1) {// rule 2
          aryCHANGE[x][y] = 1;
        }

        if (alive < 2 && aryBOARD[x][y] == 1) {// rule 1
          aryCHANGE[x][y] = 0;
        }
        if (dead > 5) {// rule check
          aryCHANGE[x][y] = 0;
        }
      }
    }

    for (i = 0; i < rows; i++) {

      for (j = 0; j < colums; j++) {
        System.out.print(aryCHANGE[i][j] + " ");

      }
      System.out.println("");
    }
    System.out.println("---------------------------");

  } // end main
} // end class

Answer 1

You need to think a lot more about structuring your code and breaking things up into smaller chunks. That will help you a lot, especially when you move onto larger projects in the future.

For example write a simple method to count the number of living cells around a given cell.

Now your main loop through just becomes:

for (int x=0;x<width;x++) {
    for (int y=0;y<height;y++) {
        switch(countLivingAround(x,y)) {
           case 0: // Less than 2 always dies
           case 1:
               grid(x,y) = 0;
               break;
           case 2: // Do nothing, keep current state
               break;
           case 3: // Breed
               grid(x,y) = 1;
               break;
           case 4: // Dies from overcrowding
               grid(x,y) = 0;
               break;
        }
    }
}

Your count function can be simple, it just adds up the values at [x-1,y],[x,y+1], etc, remember to check for the edges of the board and handle that case correctly though.

Answer 2

In addition to breaking the logic up into different methods you need to either use a debugger to step thru the code or use printlns to display the x and y values your evaluating (See the sample below) You'll see that some of your calculations on the adjoining cells x and y coordinates need work.

    for (x = 0; x <= 4; x++) {
        for (y = 0; y <= 4; y++) {
            alive = 0;
            dead = 0;
            System.out.println("evaluating cell x=" + x + ", y = " + y);
            if ((x + 1 < 4) && (x + 1 > 0)) {// right
                if (aryBOARD[x + 1][y] == 0) {
                    dead++;
                }
                else {
                    alive++;
                }
                System.out.println(" check 1 x=" + (x + 1) + ", y = " + y);
            }