Osciladores juego de la vida y las naves espaciales que no trabaja

Lucifer Uchiha :

Hola, así que estoy actualmente trabajando en un juego de la vida con una lona javafx. Sin embargo parece que hay un error en mi algoritmo. Las naturalezas muertas están trabajando sin embargo, el resto es no, los patrones como el planeador no esté circulando la manera que deberían. Im usando una matriz int 2d, VIVO es 1 y DEAD es 0. Aquí está mi algoritmo:

    private void checkRules() {
        int[][] newBoard = board;
        int amountOfAliveNeighbours;
        for (int y = 0; y < board.length; y++) {
            for (int x = 0; x < board[y].length; x++) {
                amountOfAliveNeighbours = getAmountOfAliveNeighbours(x, y);
                if (board[y][x] == ALIVE) {
                    if (amountOfAliveNeighbours == 2 || amountOfAliveNeighbours == 3) {
                        newBoard[y][x] = ALIVE;
                    }else{
                        newBoard[y][x] = DEAD;
                    }
                } else if (board[y][x] == DEAD){
                    if (amountOfAliveNeighbours == 3) {
                        newBoard[y][x] = ALIVE;
                    }else{
                        newBoard[y][x] = DEAD;
                    }
                }
            }
        }
        board = newBoard;
    }

    private int getAmountOfAliveNeighbours(int x, int y) {
        int neighbours = 0;
        // top left
        if (x - 1 >= 0 && y - 1 >= 0) {
            if (board[y - 1][x - 1] == ALIVE)
                neighbours++;
        }
        // top center
        if (y - 1 >= 0) {
            if (board[y - 1][x] == ALIVE)
                neighbours++;
        }
        // top right
        if (x + 1 < board[0].length && y - 1 >= 0) {
            if (board[y - 1][x + 1] == ALIVE)
                neighbours++;
        }
        // middle left
        if (x - 1 >= 0) {
            if (board[y][x - 1] == ALIVE)
                neighbours++;
        }
        // middle right
        if (x + 1 < board[0].length) {
            if (board[y][x + 1] == ALIVE)
                neighbours++;
        }
        // bottom left
        if (x - 1 >= 0 && y + 1 < board.length) {
            if (board[y + 1][x - 1] == ALIVE)
                neighbours++;
        }
        // bottom center
        if (y + 1 < board.length) {
            if (board[y + 1][x] == ALIVE)
                neighbours++;
        }
        // bottom right
        if (x + 1 < board[0].length && y + 1 < board.length) {
            if (board[y + 1][x + 1] == ALIVE)
                neighbours++;
        }
        return neighbours;
    }

Alex:

Asignar la memoria para la tarjeta temporal de esta manera:

int[][] newBoard = new int[board.length][board[0].length];

Yo sugeriría que el cálculo de los vecinos refactor:

  private int getAmountOfAliveNeighbours(int x, int y) {
    int neighbours = 0;
    for (int dx = -1; dx <= 1; dx++) {
      for (int dy = -1; dy <= 1; dy++) {
        if ((dx !=0 || dy != 0) && isAlive(x + dx, y + dy)) {
          neighbours++;
        }
      }
    }
    return neighbours;
  }

  private boolean isAlive(int x, int y) {
    return (x >= 0) && (x < board.length) &&
        (y >= 0) && (y < board[0].length) &&
        (board[x][y] == ALIVE);
  }