html记录之康威生命游戏（一）

已于 2023-03-23 17:13:05 修改
阅读量826 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： html 文章标签： html 游戏 javascript
于 2023-03-23 16:27:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37978057/article/details/129733146
该文章介绍了如何使用HTML和JavaScript实现康威生命游戏，这是一种基于元胞自动机的规则，通过细胞的生死状态模拟动态变化。文中提供了代码示例，包括游戏的初始化、格子创建、颜色转换事件以及游戏的开始和暂停功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

html记录之康威生命游戏（一）

第一版代码内容，有待优化的代码。

html记录之康威生命游戏（二）
html记录之康威生命游戏（三）

生命游戏是康威发明的，一种基于元胞自动机下的一种特殊规则，这个规则很简单，但是很强大，这个规则仿佛赋予了静态的东西有了生命一样在运动，有生存和死亡。

生命游戏规则：
每个细胞的生或者死均由周围的8个细胞决定，如果周围生命过多，将会因为资源不足而死亡，如果周围生命过少将会因为孤独而死亡，只有周围生命刚刚好才能处于生的状态。
规则一：如果周围细胞数大于3或者小于2，将会因为资源不足或者孤独而死。
规则二：如果周围刚好有3个细胞，如果原来是生则不变，如果是死将变为生，即为生命的诞生。
规则三：如果周围刚好有2个细胞，那么无论是生是死都不发生任何改变。

实现代码如下：

<html>
    <head>
        <meta charset="utf-8">
        <meta name="author" content="hwq">
        <title>康威生命游戏</title>
        <style>
            *{
                box-sizing: border-box;
            }
            #content{
                width: 1502px;
                height: 902px;
                border: 1px solid #666;
                margin: 0;
                position: relative;
            }
            #zanting{
                margin: 0 auto;
            }
            #restart{
                margin: 0 auto;
            }
            .cell{
                border: 1px solid #999;
                position: absolute;
            }
        </style>
    </head>
    <body>
        <button id="zanting">开始暂停</button>
        <button id="restart">初始化</button>
        <div id="content">
            
        </div>
        <script>
            console.log("初始化生命游戏");
            let zanting = document.getElementById('zanting');//获取暂停按钮dom元素
            let restart = document.getElementById('restart');//获取重新开始dom元素
            let content = document.getElementById("content");//获取容器dom元素
            let width = content.clientWidth;//容器宽度
            let height = content.clientHeight;//容器高度
            let sizeLeft = 250;//横向格子数
            let sizeTop = 150;//纵向格子数
            let sizeLeftCal = sizeLeft - 1;//横向坐标上限
            let sizeTopCal = sizeTop - 1;//纵向坐标上限
            let cellWidth = width/sizeLeft;//单个格子宽度
            let cellHeight = height/sizeTop;//单个格子高度
            let lifeCount = 0;//存活计数
            let clickStatus = true;//是否可点击，开始之后不再点亮格子
            let lifeReal = {};//保存所有存活格子，存活放入，死亡移除
            let lifeRealJudge = {};//保存所有需要判断周围生存数量的格子
            let lifeDead = {};//保存所有需要死亡的格子，死亡放入
            let generation = 1;//演化代数
            console.log("width:" + width);
            console.log("height:" + height);
            console.log("sizeLeft:" + sizeLeft);
            console.log("sizeTop:" + sizeTop);
            console.log("cellWidth:" + cellWidth);
            console.log("cellHeight:" + cellHeight);
            //格子实时信息0死1生
            let cellArray = new Array();
            //格子周围实时数量信息（用来判断下一轮生和死的状态）
            //也可以不保存实时数量，采用周围8个格子的方式判断生和死
            let cellLife = new Array();
            //初始化
            createCells();
            //新建格子
            function createCells(){
                for(let i=0; i<sizeLeft; i++){
                    cellArray[i] = new Array();
                    cellLife[i] = new Array();
                    for(let j=0; j<sizeTop; j++){
                        createCell(i, j);
                        cellArray[i][j] = 0;
                        cellLife[i][j] = 0;
                    }
                }
            }
            //新建格子
            function createCell(i, j){
                let div = document.createElement("div");
                div.id = "cell-" + i + "-" + j;
                div.style.width = cellWidth;
                div.style.height = cellHeight;
                div.style.left = (cellWidth*i) + "px";
                div.style.top = (cellHeight*j) + "px";
                // div.style.fontSize = 5;
                // div.innerHTML = i + "" + j;
                div.setAttribute("class", "cell");
                div.addEventListener("click", colorChange, false);//绑定格子颜色转换事件
                content.appendChild(div);
            }
            //格子颜色转换事件
            function colorChange(){
                if(!clickStatus){
                    return;
                }
                console.log(this.id);
                let arr = this.id.split("-");
                let i = arr[1] * 1;
                let j = arr[2] * 1;
                if(this.style.backgroundColor){
                    this.style.backgroundColor = "";
                    if(cellArray[i][j] == 1){
                        lifeNumber(i, j, -1, cellLife);
                        lifeCount--;
                        delete lifeReal["cell-" + i + "-" + j];
                        // delete lifeRealJudge["cell-" + i + "-" + j];
                        // delete lifeRealJudge["cell-" + i + "-" + (j-1)];
                        // delete lifeRealJudge["cell-" + i + "-" + (j+1)];
                        // delete lifeRealJudge["cell-" + (i-1) + "-" + j];
                        // delete lifeRealJudge["cell-" + (i-1) + "-" + (j-1)];
                        // delete lifeRealJudge["cell-" + (i-1) + "-" + (j+1)];
                        // delete lifeRealJudge["cell-" + (i+1) + "-" + j];
                        // delete lifeRealJudge["cell-" + (i+1) + "-" + (j-1)];
                        // delete lifeRealJudge["cell-" + (i+1) + "-" + (j+1)];
                    }
                    cellArray[i][j] = 0;
                }else{
                    this.style.backgroundColor = "#333";
                    if(cellArray[i][j] == 0){
                        lifeNumber(i, j, 1, cellLife);
                        lifeCount++;
                        lifeReal["cell-" + i + "-" + j] = 1;
                        // lifeRealJudge["cell-" + i + "-" + j] = 1;
                        // lifeRealJudge["cell-" + i + "-" + (j-1)] = 1;
                        // lifeRealJudge["cell-" + i + "-" + (j+1)] = 1;
                        // lifeRealJudge["cell-" + (i-1) + "-" + j] = 1;
                        // lifeRealJudge["cell-" + (i-1) + "-" + (j-1)] = 1;
                        // lifeRealJudge["cell-" + (i-1) + "-" + (j+1)] = 1;
                        // lifeRealJudge["cell-" + (i+1) + "-" + j] = 1;
                        // lifeRealJudge["cell-" + (i+1) + "-" + (j-1)] = 1;
                        // lifeRealJudge["cell-" + (i+1) + "-" + (j+1)] = 1;
                    }
                    cellArray[i][j] = 1;
                }
            }
            //初始化
            restart.addEventListener("click", reStart, false);
            function reStart(){
                if(!(typeof timer === "undefined")){
                    clearInterval(timer);//清空循环控制器
                }
                clickStatus = true;
                generation = 0;
                lifeReal = {};
                lifeRealJudge = {};
                for(let i=0; i<sizeLeft; i++){
                    cellArray[i] = new Array();
                    cellLife[i] = new Array();
                    for(let j=0; j<sizeTop; j++){
                        cellArray[i][j] = 0;
                        cellLife[i][j] = 0;
                        document.getElementById("cell-" + i + "-" + j).style.backgroundColor = "";
                    }
                }
            }
            //开始生命游戏
            zanting.addEventListener("click", start, false);
            function start(){
                // let cellLifeNew = new Array();
                // for(let i=0; i<sizeLeft; i++){
                //     cellLifeNew[i] = new Array();
                //     for(let j=0; j<sizeTop; j++){
                //         console.log("life game");
                //         let num = cellLife[i][j];
                //         if(num == 3) {
                //             cellArray[i][j] = 1;
                //             lifeNumber(i, j, 1);
                //         }else if(num > 3 || num < 2){
                //             cellArray[i][j] = 0;
                //             lifeNumber(i, j, -1);
                //         }
                //     }
                // }
                console.log("开始生命游戏");
                if(lifeCount == 0){
                    clickStatus = true;
                    console.log("没有存活的生命体，请先激活");
                    return;
                }
                clickStatus = false;//开始生命游戏之后不能点亮格子
                var count = 0;
                let swap = false;
                let cellLifeNew = new Array();
                for(let x=0; x<sizeLeft; x++){
                    cellLifeNew[x] = new Array();
                    for(let y=0; y<sizeTop; y++){
                        cellLifeNew[x][y] = cellLife[x][y];
                    }
                }

                let arr;
                let k;
                let q;
                //获取所有需要判断的格子
                let keys = Object.keys(lifeReal);
                for(let con=0; con<keys.length; con++){
                    arr = keys[con].split("-");
                    k = arr[1] * 1;
                    q = arr[2] * 1;
                    lifeRealJudge["cell-" + k + "-" + q] = 1;
                    lifeRealJudge["cell-" + k + "-" + (q-1)] = 1;
                    lifeRealJudge["cell-" + k + "-" + (q+1)] = 1;
                    lifeRealJudge["cell-" + (k-1) + "-" + q] = 1;
                    lifeRealJudge["cell-" + (k-1) + "-" + (q-1)] = 1;
                    lifeRealJudge["cell-" + (k-1) + "-" + (q+1)] = 1;
                    lifeRealJudge["cell-" + (k+1) + "-" + q] = 1;
                    lifeRealJudge["cell-" + (k+1) + "-" + (q-1)] = 1;
                    lifeRealJudge["cell-" + (k+1) + "-" + (q+1)] = 1;
                }
                let lifeKeys = Object.keys(lifeRealJudge);
                let length = lifeKeys.length;

                let num;
                var timer = setInterval(() => {
                    // console.log("1");
                    // k = Math.floor(count / sizeLeft);
                    // q = Math.floor(count % sizeTop);
                    if(lifeCount == 0){//没有存活
                        clearInterval(timer);//清空循环控制器
                        clickStatus = true;
                        console.log("没有存活结束，当前第" + generation + "代");
                        generation = 0;
                        return;
                    }
                    if(count >= length){
                        if(swap == false){
                            clearInterval(timer);//清空循环控制器
                            clickStatus = true;
                            console.log("没有变换结束，当前第" + generation + "代");
                            generation = 0;
                            return;
                        }
                        cellLife = cellLifeNew;
                        cellLifeNew = new Array();
                        for(let x=0; x<sizeLeft; x++){
                            cellLifeNew[x] = new Array();
                            for(let y=0; y<sizeTop; y++){
                                cellLifeNew[x][y] = cellLife[x][y];
                            }
                        }
                        //重新渲染格子
                        let keysDead = Object.keys(lifeDead);
                        for(let con=0; con<keysDead.length; con++){
                            arr = keysDead[con].split("-");
                            k = arr[1] * 1;
                            q = arr[2] * 1;
                            document.getElementById("cell-" + k + "-" + q).style.backgroundColor = "";
                        }
                        lifeDead = {};
                        //获取所有需要判断的格子
                        lifeRealJudge = {};
                        let keys = Object.keys(lifeReal);
                        console.log("lifeReal.size=" + keys.length);
                        for(let con=0; con<keys.length; con++){
                            arr = keys[con].split("-");
                            k = arr[1] * 1;
                            q = arr[2] * 1;
                            lifeRealJudge["cell-" + k + "-" + q] = 1;
                            lifeRealJudge["cell-" + k + "-" + (q-1)] = 1;
                            lifeRealJudge["cell-" + k + "-" + (q+1)] = 1;
                            lifeRealJudge["cell-" + (k-1) + "-" + q] = 1;
                            lifeRealJudge["cell-" + (k-1) + "-" + (q-1)] = 1;
                            lifeRealJudge["cell-" + (k-1) + "-" + (q+1)] = 1;
                            lifeRealJudge["cell-" + (k+1) + "-" + q] = 1;
                            lifeRealJudge["cell-" + (k+1) + "-" + (q-1)] = 1;
                            lifeRealJudge["cell-" + (k+1) + "-" + (q+1)] = 1;
                            document.getElementById("cell-" + k + "-" + q).style.backgroundColor = "#333";
                        }
                        lifeKeys = Object.keys(lifeRealJudge);
                        length = lifeKeys.length;
                        console.log("lifeRealJudge.size=" + length);
                        count = 0;
                        swap = false;
                        console.log("结束一轮，当前第" + generation + "代");
                        generation++;
                    }
                    if(count >= lifeKeys.length){
                        clearInterval(timer);
                        clickStatus = true;
                        console.log("出现异常，请检查");
                        return;
                    }
                    arr = lifeKeys[count].split("-");
                    k = arr[1] * 1;
                    q = arr[2] * 1;
                    // if(k == sizeLeft){
                    //     if(swap == false){
                    //         clickStatus = true;
                    //         clearInterval(timer);//清空循环控制器
                    //         console.log("没有变换结束");
                    //     }
                    //     count = 0;
                    //     k = Math.floor(count / sizeLeft);
                    //     swap = false;
                    //     cellLife = cellLifeNew;
                    //     cellLifeNew = new Array();
                    //     for(let x=0; x<sizeLeft; x++){
                    //         cellLifeNew[x] = new Array();
                    //     }
                    //     console.log("结束一轮");
                    // }
                    if(k < 0 || k >= sizeLeft || q < 0 || q >= sizeTop){
                        count++;
                        return;
                    }
                    num = cellLife[k][q];
                    // console.log("cell-" + k + "-" + q + "周围存活数量为：" + num);
                    if(num == 3) {
                        if(cellArray[k][q] == 0){
                            lifeNumber(k, q, 1, cellLifeNew);
                            lifeCount++;
                            swap = true;
                            lifeReal["cell-" + k + "-" + q] = 1;
                            // lifeRealJudge["cell-" + k + "-" + q] = 1;
                            // lifeRealJudge["cell-" + k + "-" + (q-1)] = 1;
                            // lifeRealJudge["cell-" + k + "-" + (q+1)] = 1;
                            // lifeRealJudge["cell-" + (k-1) + "-" + q] = 1;
                            // lifeRealJudge["cell-" + (k-1) + "-" + (q-1)] = 1;
                            // lifeRealJudge["cell-" + (k-1) + "-" + (q+1)] = 1;
                            // lifeRealJudge["cell-" + (k+1) + "-" + q] = 1;
                            // lifeRealJudge["cell-" + (k+1) + "-" + (q-1)] = 1;
                            // lifeRealJudge["cell-" + (k+1) + "-" + (q+1)] = 1;
                            cellArray[k][q] = 1;
                            // document.getElementById("cell-" + k + "-" + q).style.backgroundColor = "#333";
                        }
                    }else if(num > 3 || num < 2){
                        if(cellArray[k][q] == 1){
                            lifeNumber(k, q, -1, cellLifeNew);
                            lifeCount--;
                            swap = true;
                            delete lifeReal["cell-" + k + "-" + q];
                            lifeDead["cell-" + k + "-" + q] = 1;
                            // delete lifeRealJudge["cell-" + k + "-" + q];
                            // console.log("删除了cell-" + k + "-" + q);
                            // delete lifeRealJudge["cell-" + k + "-" + (q-1)];
                            // delete lifeRealJudge["cell-" + k + "-" + (q+1)];
                            // delete lifeRealJudge["cell-" + (k-1) + "-" + q];
                            // delete lifeRealJudge["cell-" + (k-1) + "-" + (q-1)];
                            // delete lifeRealJudge["cell-" + (k-1) + "-" + (q+1)];
                            // delete lifeRealJudge["cell-" + (k+1) + "-" + q];
                            // delete lifeRealJudge["cell-" + (k+1) + "-" + (q-1)];
                            // delete lifeRealJudge["cell-" + (k+1) + "-" + (q+1)];
                            cellArray[k][q] = 0;
                            // document.getElementById("cell-" + k + "-" + q).style.backgroundColor = "";
                        }
                    }
                    count++;
                }, 0);
            }
            //生存数量计算
            function lifeNumber(i, j, inc, cellLifeArray){
                i = i * 1;
                j = j * 1;
                // console.log("cell-" + i + "-" + j + "生存数量计算，inc：" + inc);
                if(i !=0 && j != 0 && i != sizeLeftCal && j != sizeTopCal){//如果不为边缘格子，这个判断范围最大，只判断一次的期望值高
                    cellLifeArray[i-1][j] = cellLifeArray[i-1][j] * 1 + inc;//左
                    cellLifeArray[i-1][j-1] = cellLifeArray[i-1][j-1] * 1 + inc;//左上
                    cellLifeArray[i-1][j+1] = cellLifeArray[i-1][j+1] * 1 + inc;//左下
                    cellLifeArray[i][j-1] = cellLifeArray[i][j-1] * 1 + inc;//上
                    cellLifeArray[i][j+1] = cellLifeArray[i][j+1] * 1 + inc;//下
                    cellLifeArray[i+1][j] = cellLifeArray[i+1][j] * 1 + inc;//右
                    cellLifeArray[i+1][j-1] = cellLifeArray[i+1][j-1] * 1 + inc;//右上
                    cellLifeArray[i+1][j+1] = cellLifeArray[i+1][j+1] * 1 + inc;//右下
                    // console.log("cellLifeArray[" + (i-1) + "][" + j + "]=" + cellLifeArray[i-1][j]);
                    // console.log("cellLifeArray[" + (i-1) + "][" + (j-1) + "]=" + cellLifeArray[i-1][j-1]);
                    // console.log("cellLifeArray[" + (i-1) + "][" + (j+1) + "]=" + cellLifeArray[i-1][j+1]);
                    // console.log("cellLifeArray[" + i + "][" + (j-1) + "]=" + cellLifeArray[i][j-1]);
                    // console.log("cellLifeArray[" + i + "][" + (j+1) + "]=" + cellLifeArray[i][j+1]);
                    // console.log("cellLifeArray[" + (i+1) + "][" + j + "]=" + cellLifeArray[i+1][j]);
                    // console.log("cellLifeArray[" + (i+1) + "][" + (j-1) + "]=" + cellLifeArray[i+1][j-1]);
                    // console.log("cellLifeArray[" + (i+1) + "][" + (j+1) + "]=" + cellLifeArray[i+1][j+1]);
                }else if(i == 0 && j != 0 && j != sizeTopCal){//如果为左边一片，只有上、右上、右、右下、下
                    cellLifeArray[i][j-1] = cellLifeArray[i][j-1] * 1 + inc;//上
                    cellLifeArray[i][j+1] = cellLifeArray[i][j+1] * 1 + inc;//下
                    cellLifeArray[i+1][j] = cellLifeArray[i+1][j] * 1 + inc;//右
                    cellLifeArray[i+1][j-1] = cellLifeArray[i+1][j-1] * 1 + inc;//右上
                    cellLifeArray[i+1][j+1] = cellLifeArray[i+1][j+1] * 1 + inc;//右下
                }else if(j == 0 && i != 0 && i != sizeLeftCal){//如果为上边一片，只有左、左下、下、右下、右
                    cellLifeArray[i-1][j] = cellLifeArray[i-1][j] * 1 + inc;//左
                    cellLifeArray[i-1][j+1] = cellLifeArray[i-1][j+1] * 1 + inc;//左下
                    cellLifeArray[i][j+1] = cellLifeArray[i][j+1] * 1 + inc;//下
                    cellLifeArray[i+1][j] = cellLifeArray[i+1][j] * 1 + inc;//右
                    cellLifeArray[i+1][j+1] = cellLifeArray[i+1][j+1] * 1 + inc;//右下
                }else if(i == sizeLeftCal && j != 0 && j != sizeTopCal){//如果为右边一片，只有上、左上、左、左下、下
                    cellLifeArray[i-1][j] = cellLifeArray[i-1][j] * 1 + inc;//左
                    cellLifeArray[i-1][j-1] = cellLifeArray[i-1][j-1] * 1 + inc;//左上
                    cellLifeArray[i-1][j+1] = cellLifeArray[i-1][j+1] * 1 + inc;//左下
                    cellLifeArray[i][j-1] = cellLifeArray[i][j-1] * 1 + inc;//上
                    cellLifeArray[i][j+1] = cellLifeArray[i][j+1] * 1 + inc;//下
                }else if(j == sizeTopCal && i != 0 && i != sizeLeftCal){//如果为下边一片，只有左、左上、上、右上、右
                    cellLifeArray[i-1][j] = cellLifeArray[i-1][j] * 1 + inc;//左
                    cellLifeArray[i-1][j-1] = cellLifeArray[i-1][j-1] * 1 + inc;//左上
                    cellLifeArray[i][j-1] = cellLifeArray[i][j-1] * 1 + inc;//上
                    cellLifeArray[i+1][j] = cellLifeArray[i+1][j] * 1 + inc;//右
                    cellLifeArray[i+1][j-1] = cellLifeArray[i+1][j-1] * 1 + inc;//右上
                }else if(i == 0 && j == 0){//如果为左上角，只有右、右下、下
                    // cellLifeArray[0][1] = cellLifeArray[0][1] + inc;
                    // cellLifeArray[1][0] = cellLifeArray[1][0] + inc;
                    // cellLifeArray[1][1] = cellLifeArray[1][1] + inc;
                    cellLifeArray[i+1][j] = cellLifeArray[i+1][j] * 1 + inc;//右
                    cellLifeArray[i+1][j+1] = cellLifeArray[i+1][j+1] * 1 + inc;//右下
                    cellLifeArray[i][j+1] = cellLifeArray[i][j+1] * 1 + inc;//下
                }else if(i == sizeLeftCal && j == 0){//如果为右上角，只有左、左下、下
                    cellLifeArray[i-1][j] = cellLifeArray[i-1][j] * 1 + inc;//左
                    cellLifeArray[i-1][j+1] = cellLifeArray[i-1][j+1] * 1 + inc;//左下
                    cellLifeArray[i][j+1] = cellLifeArray[i][j+1] * 1 + inc;//下
                }else if(i == 0 && j == sizeTopCal){//如果为左下角，只有上、右上、右
                    cellLifeArray[i][j-1] = cellLifeArray[i][j-1] * 1 + inc;//上
                    cellLifeArray[i+1][j-1] = cellLifeArray[i+1][j-1] * 1 + inc;//右上
                    cellLifeArray[i+1][j] = cellLifeArray[i+1][j] * 1 + inc;//右
                }else if(i == sizeLeftCal && j == sizeTopCal){//如果为右下角，只有上、左上、左
                    cellLifeArray[i][j-1] = cellLifeArray[i][j-1] * 1 + inc;//上
                    cellLifeArray[i-1][j-1] = cellLifeArray[i-1][j-1] * 1 + inc;//左上
                    cellLifeArray[i-1][j] = cellLifeArray[i-1][j] * 1 + inc;//左
                }
            }
        </script>
    </body>
</html>
var foo = 'bar';

预览效果如下：
在这里插入图片描述
仅做记录，第一版代码因为每个判断都是定时器，后面格子多了会很慢

conway:康威的生命游戏 w HTML、CSS 和 JS
06-05
#康威的生命游戏 使用 Javascript、HTML、CSS 和 EaselJS 创建 要查看单元测试结果，请下载代码并在您选择的浏览器中打开“test/tests.html”或将浏览器指向
HTML5版本的生命游戏
lifegame的专栏
05-02 7083
初学HTML5，写了一个程序练练手。
构建生命游戏：理解康威生命游戏算法与实现
最新发布
gitblog_00349的博客
05-30 323
构建生命游戏：理解康威生命游戏算法与实现 什么是生命游戏？ 康威生命游戏（Game of Life）是由英国数学家约翰·康威在1970年发明的一种细胞自动机。它属于零玩家游戏，意味着一旦初始状态确定，游戏将按照既定规则自行演化，无需玩家进一步干预。 生命游戏的核心规则 生命游戏基于以下几个简单但强大的规则： 人口过少：任何活细胞（被占据的格子）如果周围活细胞少于2个，则死亡 稳定存活：任何活细胞...
conway生命游戏
01-27
conway生命游戏，可以修改初始元胞比例，输出演化动画。python代码
康威生命游戏
2301_80096779的博客
12-08 1530
用一个二维表格表示“生存空间”，空间的每个方格中都可放置一个生命细胞，每个生命细胞只有两种状态：“生”或“死”。用绿色方格表示该细胞为“生”，空格(白色)表示该细胞为“死”。或者说方格网中绿色部分表示某个时候某种“生命”的分布图。生命游戏想要模拟的是：随着时间的流逝，这个分布图将如何一代一代地变化。死亡太沉重，被人们称为“湮灭”状态。生存定律生存空间的每个方格都存在一个细胞，它的周边紧邻的8个方格上的称为邻居细胞。当前细胞为湮灭状态时，当周围有３个存活细胞时，则迭代后该细胞变成存活状态(模拟繁殖)
html5 生存游戏,html5版生命游戏
weixin_35891825的博客
05-31 122
canvas {background: #eeeeee;border: 1px solid #c3c3c3;}button {background: #aaaaaa;}startvar xOffset = 20;var yOffset = 20;var gridSize = 40;var size = 10;var board = new Array([1, 1, 0, 0, 0, 0, 0, 0...
game-of-life:处理康威生命游戏的草图（gh-pages）
07-12
康威生命游戏，由英国数学家约翰·何顿·康威在1970年提出，是一种简单的元胞自动机，通过规则模拟生命的繁衍与消亡。这个游戏在计算机科学、数学以及艺术领域都有着广泛的影响，因其简单而富有深度的规则，吸引了...
康威生活游戏：JavaScript和HTML5 Canvas实现
资源摘要信息:"康威的‘生命游戏’是一项由数学家约翰·康威在1970年发明的细胞自动机游戏，它是一种零玩家游戏，意味着它的演化是由初始状态决定的，不需要玩家进一步参与。‘生命游戏’在计算机科学和复杂系统理论...
探索HTML5实现的GameOfLife游戏
《GameOfLife》游戏的灵感很可能来源于数学家约翰·霍顿·康威（John Horton Conway）在1970年发明的一个细胞自动机游戏——“生命游戏”（Game of Life）。该游戏虽然规则简单，却能展示出非常复杂的行为模式，具有...
使用ES6和JSPM创建的Phaser生命游戏示例
- 康威的生命游戏是一种零玩家游戏，它包含一个无限的二维网格，网格中的每个格子代表一个细胞，细胞有“活着”和“死亡”两种状态。 - 本项目将生命游戏简化算法作为主题，并创建了一个基于细胞增殖模拟的简化版...
JavaScript书签：将Github贡献日历转变为生命游戏
这个工具利用了GitHub提供的API来获取用户的提交记录，并以此生成一个生命游戏的图案，用户可以将这个书签添加到浏览器中，并通过点击书签来触发功能，观察自己的提交活动在生命游戏中的呈现形式。这种方法不仅让...
康威的生命游戏Android版
12-18
自己做的一个Android小例子---康威的生命游戏，大家无聊的时候可以下载来玩玩或者优化一下。
life-js:使用 HTML Canvas + Javascript 的康威生命游戏
06-09
生活js 使用 HTML Canvas + Javascript 的康威生命游戏
生命游戏 Conway's Life
10-29
该系统研究了数学家Conway提出的生命游戏，根据生命算法，推算元胞的生死。系统刻画了滑翔机发射枪，振荡器等模型。有很高的研究意义。
GameOfLife:使用 HTML5 Canvas、FabricJS 和 Typescript 实现生命游戏
06-18
生命游戏 使用 HTML5 Canvas、FabricJS 和 Typescript 的 GameOfLife 实现
expansion_game:用 HTML 和 JS 重新制作“生命游戏”
06-19
扩张 kboy101222 的一款游戏ManiacBridge 修复的错误 ###最新版本：0.0.2.1 为游戏引擎添加了几个有用的功能 addCash(amt, changeVal) 将现金添加到玩家的总数中 除非 changeVal 为真，否则不会改变玩家可见数字 更新现金文本（） 在不改变价值的情况下更新玩家可见的现金金额 找工作（） 暂时什么都不做，以后找工作会用到 ###即将推出的功能列表： 简单的模组支持只需导入 JS 和 JSON 文件即可添加您自己的作业、事件等 广泛的工作清单
HTML JavaScript 康威生命游戏
qq_34677276的博客
01-08 1516
HTML JavaScript 康威生命游戏
MATLAB版本下载及康威生命游戏实现
康威生命游戏是计算机科学中一个经典的细胞自动机模型，由数学家约翰·何顿·康威设计。该模型不仅仅是一个简单的游戏，它还能够展示复杂的数学概念和编程技术。在这个游戏中，每个细胞在一个无限的二维格子上可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值