Cześć, obecnie pracuję nad grą w życiu z płótnem JavaFX. Jednak wydaje się, że w moim algorytmie wydaje się błąd. Wciąż życie pracują jednak, że reszta nie, wzory takie jak szybowiec nie poruszają sposobu, w jaki powinni. Używam tablicy 2D INT, żywy jest 1 i martwy jest 0. Oto mój algorytm:

    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;
    }
0
Lucifer Uchiha 12 marzec 2020, 15:45

1 odpowiedź

Najlepsza odpowiedź

Przydziel pamięć na tablicę tymczasową taką jak:

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

Proponowałbym refaktoryzować obliczenie sąsiadów:

  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);
  }
3
Alex 12 marzec 2020, 13:08