Код Game of Life не работает для неравных размеров (неквадратные сетки)

Question

Я новичок в java и пытаюсь кодировать Игру Жизни. Игра влечет за собой создание сетки заданных размеров, где каждый квадрат в сетке либо мертв, либо жив. Сетка начинается со случайного мертвого или живого состояния для каждого ящика. Новые поколения имеют новые мертвые / живые ящики на основе следующих условий: Если есть 3 живых ящика, соседствующие с мертвым ящиком, он становится живым. Если рядом с живым ящиком находится менее 2 живых ящиков, этот ящик умирает. Он также умирает, если вокруг него более 3 живых ящиков.

Я подхожу к этому, создавая сетку массива boolean [] [], где true представляет живое поле, а false - мертвое. Класс представления берет эту логическую сетку и превращает ее в сетку ящиков, окрашенных в белый или красный цвет (белый = мертвый) (красный = живой)

Код работает для сеток с одинаковыми размерами. ie 3x3, 10x10. Моя проблема в том, что когда я создаю новую сетку, если мои спецификации имеют разные размеры i и j, код не работает или создает сетку с неправильными размерами. Ошибка находится в makeCopy () в строке, где она создает новую сетку. Любые другие предложения по улучшению кода приветствуются. Спасибо.

Класс игры:

import java.util.Arrays;
import java.util.Random;

public class Game {
    private boolean[][] grid;
    private int genCount;

    public Game(int i, int j) {
        genCount = 0;
        if (i < 1 || j < 1) {
            throw new IllegalArgumentException("grid too small!");
        }
        if (i > 100 || j > 100) {
            throw new IllegalArgumentException("grid too big!");
        }

        grid = new boolean[j][i];
    }

    public boolean[][] getGrid() {
        return grid;
    }

    public void setGrid(boolean[][] grid) {
        this.grid = grid;
    }

    public int getGen() {
        return genCount;
    }

    public void setGen(int gen) {
        this.genCount = gen;
    }

    public void randomGrid() {
        Random r = new Random();
        for (int j = 0; j < grid[0].length; j++) {
            for (int i = 0; i < grid[1].length; i++) {
                grid[j][i] = r.nextBoolean();
            }
        }
    }

    public boolean[][] makeCopy() {
        // making a copy of the current grid, avoiding aliasing.
        boolean[][] nGrid = new boolean[grid[0].length][grid[1].length];
        for (int j = 0; j < grid[0].length; j++) {
            for (int i = 0; i < grid[1].length; i++) {
                nGrid[j][i] = grid[j][i];
            }
        }
        return nGrid;
    }

    public void newGen() {

        boolean[][] nGrid = makeCopy();

        for (int j = 0; j < grid[0].length; j++) {
            for (int i = 0; i < grid[1].length; i++) {
                if (grid[j][i] == false) {
                    // new life, due to having 3 neighbours!
                    if (getNeighbours(j, i) == 3) {
                        nGrid[j][i] = true;
                    }
                } else {
                    // isolation death!
                    if (getNeighbours(j, i) <= 1) {
                        nGrid[j][i] = false;
                    }
                    // overcrowing death!
                    if (getNeighbours(j, i) >= 4) {
                        nGrid[j][i] = false;
                    }
                }
            }
        }
        genCount++;
        grid = nGrid;
    }

    public int getNeighbours(int j, int i) {
        int count = 0;
        int jMax = grid[0].length - 1;
        int iMax = grid[1].length - 1;

        // checking up, down, right, left, allowing wrapping
        if ((j < jMax && grid[j + 1][i]) || (j == jMax && grid[0][i])) {
            count++;
        }
        if ((j > 0 && grid[j - 1][i]) || (j == 0 && grid[jMax][i])) {
            count++;
        }
        if ((i < iMax && grid[j][i + 1]) || (i == iMax & grid[j][0])) {
            count++;
        }
        if ((i > 0 && grid[j][i - 1]) || (i == 0 && grid[j][iMax])) {
            count++;
        }

        // checking diagonals, allowing wrapping
        if ((j < jMax && i < iMax && grid[j + 1][i + 1]) || (j == jMax && i < iMax && grid[0][i + 1])
                || (j < jMax && i == iMax && grid[j + 1][0]) || (j == jMax && i == iMax && grid[0][0])) {
            count++;
        }
        if ((j < jMax && i > 0 && grid[j + 1][i - 1]) || (j == jMax && i > 0 && grid[0][i - 1])
                || (j < jMax && i == 0 && grid[j + 1][iMax]) || (j == jMax && i == 0 && grid[0][iMax])) {
            count++;
        }
        if ((j > 0 && i < iMax && grid[j - 1][i + 1]) || (j == 0 && i < iMax && grid[jMax][i + 1])
                || (j > 0 && i == iMax && grid[j - 1][0]) || (j == 0 && i == iMax && grid[jMax][0])) {
            count++;
        }
        if ((j > 0 && i > 0 && grid[j - 1][i - 1]) || (j == 0 && i > 0 && grid[jMax][i - 1])
                || (j > 0 && i == 0 && grid[j - 1][iMax]) || (j == 0 && i == 0 && grid[jMax][iMax])) {
            count++;
        }
        return count;
    }

}

Класс просмотра:

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class View extends JPanel {

    public void paint(Graphics g) {

        Game game = new Game(10, 10);
        game.randomGrid();
        game.newGen();

        boolean[][] grid = game.getGrid();


        g.setColor(Color.red);
        for (int j = 0; j < grid[0].length; j++) {
            for (int i = 0; i < grid[1].length; i++) {
                g.drawRect(100 + (50 * i), 100 + (50 * j), 50, 50);
                if (grid[j][i]) {
                    g.fillRect(100 + (50 * i), 100 + (50 * j), 50, 50);
                }
            }
        }

    }

    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.getContentPane().add(new View());

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(1000, 1000);
        frame.setVisible(true);
    }
}