Javascript 我如何申请Conway'；生活的游戏正确吗？

在康威的生命游戏算法中，它写道：

第一代是通过将上述规则同时应用于种子中的每个细胞而产生的；出生和死亡同时发生，发生这种情况的离散时刻有时被称为滴答声

如何将映射函数同时应用于数组的每个元素？这真的是它要问的吗？我的代码似乎可以工作，但一旦生命开始，它的行为就不稳定，在绝对没有任何情况下它会完全消亡，它只会扩展到占据我的整个宽度/高度。因此，我的实现中显然存在一些错误，从我的角度来看，我只能将其与我对勾号的实际含义以及如何应用的误解联系起来

以下是我的实现：

conways(xRow: number, yRow: number) {

    // Any live cell with fewer than two live neighbours dies, as if by underpopulation.
    // Any live cell with two or three live neighbours lives on to the next generation.
    // Any live cell with more than three live neighbours dies, as if by overpopulation.
    // Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

    let matrix = [], tracker = [];
    const tileSize = new Dimension(Math.floor(this.dimensions.width / xRow), Math.floor(this.dimensions.height / yRow));

    for (let i = 0; i < xRow; i++) matrix[i] = new Array(yRow);

    for (let i = 0; i < matrix.length; i++) {
        for (let j = 0; j < matrix[i].length; j++) {
            if (Math.floor(Math.random() * 10) === 1) {
                matrix[i][j] = new GameObject(Model.RECTANGLE, new Point(i * tileSize.width, j * tileSize.height), new Dimension(tileSize.width, tileSize.height), "black");
                matrix[i][j].addProperty("alive", true);
            }
            else {
                matrix[i][j] = new GameObject(Model.RECTANGLE, new Point(i * tileSize.width, j * tileSize.height), new Dimension(tileSize.width, tileSize.height), "white");
                matrix[i][j].addProperty("alive", false);
            }
            this.render.requestStage(matrix[i][j]);
        }
    }

    let isAlive = (position: Point, world: GameObject[][]) => {
        let neighboursCount = 0;

        const cellStatus = world[position.x][position.y].props["alive"];

        if (world[position.x + 1] && world[position.x + 1][position.y] && 
            world[position.x + 1][position.y].props["alive"]) neighboursCount++;

        if (world[position.x - 1] && world[position.x - 1][position.y] && 
            world[position.x - 1][position.y].props["alive"]) neighboursCount++;

        if (world[position.x] && world[position.x][position.y + 1] && 
            world[position.x][position.y + 1].props["alive"]) neighboursCount++;

        if (world[position.x] && world[position.x][position.y - 1] &&
            world[position.x][position.y - 1].props["alive"]) neighboursCount++;

        if (world[position.x - 1] && world[position.x - 1][position.y + 1] && 
            world[position.x - 1][position.y + 1].props["alive"]) neighboursCount++;

        if (world[position.x + 1] && world[position.x + 1][position.y + 1] && 
            world[position.x + 1][position.y + 1].props["alive"]) neighboursCount++;

        if (world[position.x - 1] && world[position.x - 1][position.y - 1] && 
            world[position.x - 1][position.y - 1].props["alive"]) neighboursCount++;

        if (world[position.x + 1] && world[position.x + 1][position.y - 1] && 
            world[position.x + 1][position.y - 1].props["alive"]) neighboursCount++;

        if (cellStatus) {
            if (neighboursCount < 2) return false;
            if (neighboursCount === 2 || neighboursCount === 3) return true;
            if (neighboursCount > 3) return false;
        }
        else if (!cellStatus && neighboursCount === 3) return true;
        else return false;
    }

    setInterval(() => {
        for (let i = 0; i < matrix.length; i++) {
            for (let j = 0; j < matrix.length; j++) {
                let alive = isAlive(new Point(i, j), matrix);
                if (alive) {
                    matrix[i][j].color = "black";
                    matrix[i][j].props["alive"] = true;
                }
                else {
                    matrix[i][j].props["alive"] = false;
                    matrix[i][j].color = "white";
                }
            }
        }
    }, 100);
}

conways（X行：编号，Y行：编号）{
//任何少于两个活邻居的活细胞都会死亡，就好像是由于人口不足。
//任何有两个或三个活邻居的活细胞都会延续到下一代。
//任何有三个以上邻居的活细胞都会死亡，就好像是因为人口过剩。
//任何有三个活邻居的死细胞都会变成活细胞，就像通过繁殖一样。
设矩阵=[]，跟踪器=[]；
const tileSize=新尺寸（数学地板（this.dimensions.width/xRow）、数学地板（this.dimensions.height/yRow））；
对于（设i=0；i{
设邻域计数=0；
const cellStatus=world[position.x][position.y]。道具[“live”]；
如果（世界[位置x+1]&&world[位置x+1][位置y]&&
世界[position.x+1][position.y].props[“live”]）neighboursCount++；
如果(world[position.x-1]&&world[position.x-1][position.y]&&
世界[position.x-1][position.y].props[“live”]）NeightursCount++；
如果（世界[position.x]&&world[position.x][position.y+1]&&
世界[position.x][position.y+1]。道具[“live”]）邻居计数++；
如果（世界[position.x]&世界[position.x][position.y-1]&&
世界[position.x][position.y-1].props[“live”]）neighboursCount++；
如果（世界[position.x-1]&&world[position.x-1][position.y+1]&&
世界[position.x-1][position.y+1].props[“live”]）NeigursCount++；
如果（世界[position.x+1]&世界[position.x+1][position.y+1]&&
世界[position.x+1][position.y+1].props[“live”]）NeightursCount++；
如果(world[position.x-1]&&world[position.x-1][position.y-1]&&
世界[position.x-1][position.y-1].props[“live”]）NeightursCount++；
如果（世界[position.x+1]&世界[position.x+1][position.y-1]&&
世界[position.x+1][position.y-1].props[“live”]）NeightursCount++；
如果（手机状态）{
if（neighboursCount<2）返回false；
如果（neighboursCount==2 | | neighboursCount==3）返回true；
如果（neighboursCount>3）返回false；
}
如果（！cellStatus&&neighboursCount==3）返回true，则返回else；
否则返回false；
}
设置间隔（（）=>{
for（设i=0；i

请不要介意自定义构造函数和函数，因为这是我对“图形库”的理解，它实际上只链接到Canvas API和ImageData。我所做的基本上是：

-创建大小为w/h的矩阵

-当对其进行迭代时，细胞存活的几率为1/10。（由于我还没有添加输入，所以产生了一个随机种子）

-在屏幕上呈现所有内容

---

-每隔10毫秒，我将康威的规则迭代地应用于每个单元格，并相应地更改它们的颜色/状态。

使用Mike和hyde建议的缓冲策略，我使它工作起来。以下是感兴趣的用户的更改：

conways(xRow: number, yRow: number) {

        // Any live cell with fewer than two live neighbours dies, as if by underpopulation.
        // Any live cell with two or three live neighbours lives on to the next generation.
        // Any live cell with more than three live neighbours dies, as if by overpopulation.
        // Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

        let matrix = [], bufferMatrix = [];
        const tileSize = new Dimension(Math.floor(this.dimensions.width / xRow), Math.floor(this.dimensions.height / yRow));

        for (let i = 0; i < xRow; i++) matrix[i] = new Array(yRow);
        for (let i = 0; i < xRow; i++) bufferMatrix[i] = new Array(yRow);

        for (let i = 0; i < matrix.length; i++) {
            for (let j = 0; j < matrix[i].length; j++) {
                if (Math.floor(Math.random() * 10) === 1) {
                    matrix[i][j] = new GameObject(Model.RECTANGLE, new Point(i * tileSize.width, j * tileSize.height), new Dimension(tileSize.width, tileSize.height), "black");
                    matrix[i][j].addProperty("alive", true);
                    bufferMatrix[i][j] = new GameObject(Model.RECTANGLE, new Point(i * tileSize.width, j * tileSize.height), new Dimension(tileSize.width, tileSize.height), "black");
                    bufferMatrix[i][j].addProperty("alive", true);
                }
                else {
                    matrix[i][j] = new GameObject(Model.RECTANGLE, new Point(i * tileSize.width, j * tileSize.height), new Dimension(tileSize.width, tileSize.height), "white");
                    matrix[i][j].addProperty("alive", false);
                    bufferMatrix[i][j] = new GameObject(Model.RECTANGLE, new Point(i * tileSize.width, j * tileSize.height), new Dimension(tileSize.width, tileSize.height), "white");
                    bufferMatrix[i][j].addProperty("alive", false);
                }
                this.render.requestStage(matrix[i][j]);
            }
        }

        let isAlive = (position: Point, world: GameObject[][]) => {
            let neighboursCount = 0;

            const cellStatus = world[position.x][position.y].props["alive"];

            if (world[position.x + 1] && world[position.x + 1][position.y] && 
                world[position.x + 1][position.y].props["alive"]) neighboursCount++;

            if (world[position.x - 1] && world[position.x - 1][position.y] && 
                world[position.x - 1][position.y].props["alive"]) neighboursCount++;

            if (world[position.x] && world[position.x][position.y + 1] && 
                world[position.x][position.y + 1].props["alive"]) neighboursCount++;

            if (world[position.x] && world[position.x][position.y - 1] &&
                world[position.x][position.y - 1].props["alive"]) neighboursCount++;

            if (world[position.x - 1] && world[position.x - 1][position.y + 1] && 
                world[position.x - 1][position.y + 1].props["alive"]) neighboursCount++;

            if (world[position.x + 1] && world[position.x + 1][position.y + 1] && 
                world[position.x + 1][position.y + 1].props["alive"]) neighboursCount++;

            if (world[position.x - 1] && world[position.x - 1][position.y - 1] && 
                world[position.x - 1][position.y - 1].props["alive"]) neighboursCount++;

            if (world[position.x + 1] && world[position.x + 1][position.y - 1] && 
                world[position.x + 1][position.y - 1].props["alive"]) neighboursCount++;

            if (cellStatus) {
                if (neighboursCount < 2) return false;
                if (neighboursCount === 2 || neighboursCount === 3) return true;
                if (neighboursCount > 3) return false;
            }
            else if (!cellStatus && neighboursCount === 3) return true;
            else return false;
        }

        setInterval(() => {
            this.render.clearStage();
            for (let i = 0; i < matrix.length; i++) {
                for (let j = 0; j < matrix.length; j++) {
                    let alive = isAlive(new Point(i, j), matrix);
                    if (alive) {
                        bufferMatrix[i][j].color = "black";
                        bufferMatrix[i][j].props["alive"] = true;
                    }
                    else {
                        bufferMatrix[i][j].props["alive"] = false;
                        bufferMatrix[i][j].color = "white";
                    }
                    this.render.requestStage(matrix[i][j]);
                }
            }
            // Matching properties from bufferedMatrix and matrix without losing reference.
            for (let i = 0; i < matrix.length; i++) {
                for (let j = 0; j < matrix.length; j++) {
                    matrix[i][j].color = bufferMatrix[i][j].color;
                    matrix[i][j].props["alive"] = bufferMatrix[i][j].props["alive"];
                }
            }
        }, 100);
    }

conways（X行：编号，Y行：编号）{
//任何少于两个活邻居的活细胞都会死亡，就好像是由于人口不足。
//任何有两个或三个活邻居的活细胞都会延续到下一代。
//任何有三个以上邻居的活细胞都会死亡，就好像是因为人口过剩。
//任何有三个活邻居的死细胞都会变成活细胞，就像通过繁殖一样。
设矩阵=[]，缓冲矩阵=[]；
const tileSize=新尺寸（数学地板（this.dimensions.width/xRow）、数学地板（this.dimensions.height/yRow））；
对于（设i=0；i