Подсчет соседей с обходом в 2d массиве (игра в жизнь)

Question

Итак, я пытаюсь создать программу "игра в жизнь", и я довольно новичок в java/ кодировании в целом, и у меня возникают проблемы, когда я оборачиваюсь вокруг, оборачиваясь в двумерные массивы. У меня есть конструктор и методы, которые создадут мне массив и разместят "ячейки" там, где я хочу, но я не понимаю, как я могу видеть, сколько соседей имеет ячейка.

Подвести итог:

Я могу сделать 2D-массив любого типа.

Я могу разместить "клетки" на разных элементах в массиве

Теперь, как я могу увидеть, что у пробелов рядом с моей проверяемой ячейкой есть соседи со всех сторон (я использую вложенный цикл for для прохождения каждой ячейки)?

ИМЕТЬ ВВИДУ! Обтекание действует здесь.

ОБНОВЛЕНИЕ: Это то, что у меня есть, но когда я проверяю его, он возвращает на 1 соседа меньше, чем должно быть. ОБНОВЛЕНИЕ 2: я удалил первое утверждение if, потому что я не думаю, что это имеет смысл с этим. Но сейчас я не могу заставить C подняться 1.

public int neighborCount(int row, int col) {
    int count = 0;
    for (int r = 0; r < society.length; r++) {
        for (int c = 0; c < society[0].length; c++) {
                // up and left
                if ((society[(r - 1 + row) % row][(c - 1 + col) %    col]) == cell) {
                    count++;
                }
                // up
                if ((society[(r - 1 + row) % row][c]) == cell) {
                    count++;
                }
                // up and right
                if ((society[(r - 1 + row) % row][(c + 1 + col) % col]) == cell) {
                    count++;
                }
                // left
                if ((society[r][(c - 1 + col) % col]) == cell) {
                    count++;
                }
                // right
                if ((society[r][(c + 1 + col) % col]) == cell) {
                    count++;
                }
                // down and left
                if ((society[(r + 1 + row) % row][(c - 1 + col) % col]) == cell) {
                    count++;
                }
                // down
                if ((society[(r + 1 + row) % row][c]) == cell) {
                    count++;
                }
                // down and right
                if ((society[(r + 1 + row) % row][(c + 1 + col) % col]) == cell) {
                    count++;
                }
        }
    }
    return count;
}

Мой тест:

@Test
public void testNeighborsWrapping() {
    GameOfLife society = new GameOfLife(10, 16);
    society.growCellAt(3, 3);
    society.growCellAt(3, 4);
    society.growCellAt(3, 5);
    assertEquals(0, society.neighborCount(2, 1));
    assertEquals(1, society.neighborCount(2, 2));
    assertEquals(2, society.neighborCount(2, 3));
    assertEquals(3, society.neighborCount(2, 4));

}

}

Answer 1

Если я правильно понимаю проблему, код может быть что-то вроде

Object[] getNeighbors(int i, int j) {
    // put code to return the neighbors given an index
}

boolean allNeighborsFull(int i, int j) {
    Object[] neighbors = getNeighbors(i, j);
    boolean allFull = true;
    for (Object neighbor : neighbors) {
        if (!neighbor.full()) {
            allFull = false;
            break;
        }
    }
    return allFull;
}

boolean allNeighborsSurrounded() {
    Object[] neighbors = getNeighbors(i, j);
    // check each one of these using the method above
}

Answer 2

Это будет работать:

public Cell[] getNeighbours(int i, int j) {
    int i2 = i - 1;
    int i3 = i + 1;
    int j2 = j - 1;
    int j3 = j + 1;
    if (i2 == -1)
        i2 = board.length - 1;
    if (i3 == board.length)
        i3 = 0;
    if (j2 == -1)
        j2 = board[i].length - 1;
    if (j3 == board[i].length)
        j3 = 0;
    return new Cell[] {
        board[i2][j2], board[i2][j], board[i2][j3],
        board[i][j2], board[i][j3], board[i3][j2],
        board[i3][j], board[i3][j3]
    };
}