康威生命游戏 第一部分-基本功能实现（C++ & Windows SDK）

最新推荐文章于 2024-01-27 15:45:00 发布
最新推荐文章于 2024-01-27 15:45:00 发布
阅读量3.3k 收藏 7
点赞数
分类专栏： Windows开发 文章标签： 游戏 C++ windows-sdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013218907/article/details/73729787
版权

生命游戏简介

生命游戏其实是一个零玩家游戏，它包括一个二维矩形世界，这个世界中的每个方格居住着一个活着的或死了的细胞。一个细胞在下一个时刻生死取决于相邻八个方格中活着的或死了的细胞的数量。如果相邻方格活着的细胞数量过多，这个细胞会因为资源匮乏而在下一个时刻死去；相反，如果周围活细胞过少，这个细胞会因太孤单而死去。实际中，你可以设定周围活细胞的数目怎样时才适宜该细胞的生存。如果这个数目设定过低，世界中的大部分细胞会因为找不到太多的活的邻居而死去，直到整个世界都没有生命；如果这个数目设定过高，世界中又会被生命充满而没有什么变化。实际中，这个数目一般选取2或者3；这样整个生命世界才不至于太过荒凉或拥挤，而是一种动态的平衡。这样的话，游戏的规则就是：当一个方格周围有2或3个活细胞时，方格中的活细胞在下一个时刻继续存活；即使这个时刻方格中没有活细胞，在下一个时刻也会“诞生”活细胞。在这个游戏中，还可以设定一些更加复杂的规则，例如当前方格的状况不仅由父一代决定，而且还考虑祖父一代的情况。你还可以作为这个世界的上帝，随意设定某个方格细胞的死活，以观察对世界的影响。
在游戏的进行中，杂乱无序的细胞会逐渐演化出各种精致、有形的结构；这些结构往往有很好的对称性，而且每一代都在变化形状。一些形状已经锁定，不会逐代变化。有时，一些已经成形的结构会因为一些无序细胞的“入侵”而被破坏。但是形状和秩序经常能从杂乱中产生出来。

(引用自百度百科)

程序界面

使用的知识点

  1. windows窗口的建立
  2. 按钮
  3. 定时器
  4. C++基础内存操作

具体实现

整个程序分为两部分:
1. 底层数据管理
2. 界面描绘和控制逻辑

1, 底层数据管理

为了使逻辑结构可移植, 使用C++编写了类CWorld, 不涉及任何界面绘图操作

基本思路:

建立两块内存分别用于:
1. 记录当前细胞分布
2. 记录下一回合细胞分布

每一回合(Turn)的计算方法如下:
每个细胞的生死遵循下面的原则：
1． 如果一个细胞周围有3个细胞为生（一个细胞周围共有8个细胞），则该细胞为生（即该细胞若原先为死，则转为生，若原先为生，则保持不变） 。
2． 如果一个细胞周围有2个细胞为生，则该细胞的生死状态保持不变；
3． 在其它情况下，该细胞为死（即该细胞若原先为生，则转为死，若原先为死，则保持不变）

接口代码(World.h):

#ifndef _LIFE_GAME_WORLD_H_
#define _LIFE_GAME_WORLD_H_

typedef struct _SCell
{
    int isAlive;
} 
SCell;
/* 注意:
    细胞的坐标是从0开始的
*/
class CWorld
{
private:
    int m_width;
    int m_height;
    SCell* m_map1;  //地图buffer1
    SCell* m_map2;  //地图buffer2
    SCell* m_cur_map;   //当前地图
    SCell* m_new_map;   //下一轮使用的地图
    void setCurCell(int x, int y, int isAlive);
    void setNewCell(int x, int y, int isAlive);
    int getAroundCellNum(int x, int y); //获得某个位置周围存活的细胞数量
    int isPosValid(int x, int y);   //判定输入位置是否有效, 1-有效 0-无效
    void swapMap(void) { SCell* temp = m_cur_map; m_cur_map = m_new_map; m_new_map = temp; }    //交换地图
    SCell* getCell(SCell* buf, int x, int y) { return buf + y * m_width + x; }; //从地图buffer中获取某坐标的细胞指针
public:
    CWorld(int width, int height);
    ~CWorld();
    void ramdomInit(void);  //随机初始化地图
    void killAll(void);     //杀死所有细胞
    void nextTurn(void);    //进入下一回合
    int getCellAlive(int x, int y); //获取细胞存活状态 , 返回值:1-存活, 0-死亡 -1-出错
    int setCellAlive(int x, int y, int isAlive);    //设置细胞存活状态 , 返回值:0-成功 负值-失败
    int getWidth() { return m_width; }      //获得当前地图宽度
    int getHeight() { return m_height; }    //获得当前地图高度
};

#endif /* _LIFE_GAME_WORLD_H_ */

具体实现代码:(World.cpp)

#include <time.h>
#include "World.h"
#include "global.h"


void CWorld::setCurCell(int x, int y, int isAlive)
{
    if (isPosValid(x, y) == 0)
    {
        return;
    }
    else
    {
        SCell* cell = getCell(m_cur_map, x, y);
        if (cell - m_cur_map >= m_width * m_height)
        {
            return;
        }
        cell->isAlive = isAlive;
    }
}

void CWorld::setNewCell(int x, int y, int isAlive)
{
    if (isPosValid(x, y) == 0)
    {
        return;
    }
    else
    {
        SCell* cell = getCell(m_new_map, x, y);
        if (cell - m_new_map >= m_width * m_height)
        {
            return;
        }
        cell->isAlive = isAlive;
    }
}

int CWorld::getAroundCellNum(int x, int y)
{
    int count = 0;

    if (isPosValid(x, y) == 0)
    {   //输入不合法
        return -1;
    }
    //尝试目标位置周围的八个相邻位置
    for (int i = x - 1; i <= x + 1; ++i)
    {
        for (int j = y - 1; j <= y + 1; ++j)
        {
            if (i == x && j == y)
            {
                continue;
            }
            if (isPosValid(i, j) == 1)
            {
                if (getCellAlive(i, j) == 1)
                {
                    count++;
                }
            }
        }
    }

    return count;
}

int CWorld::isPosValid(int x, int y)
{
    if (x >= m_width || x < 0 || y >= m_height || y < 0)
    {
        return 0;
    }
    return 1;
}

CWorld::CWorld(int width, int height)
{
    m_width = width;
    m_height = height;
    m_map1 = (SCell *) new SCell[m_width * m_height];
    m_map2 = (SCell *) new SCell[m_width * m_height];
    m_cur_map = m_map1;
    m_new_map = m_map2;
    killAll();
}


CWorld::~CWorld()
{
    delete[] m_map1;
    delete[] m_map2;
}

void CWorld::ramdomInit()
{
    killAll();

    srand((unsigned)time(NULL)); //用时间做种，每次产生随机数不一样

    for (int i = 0; i < m_width; ++i)
    {
        for (int j = 0; j < m_height; ++j)
        {
            int isAlive = rand() % 2;  //产生0或1的随机数
            setCurCell(i, j, isAlive);
        }

    }

}

void CWorld::killAll(void)
{
    if (m_cur_map != NULL && m_new_map != NULL)
    {
        for (int i = 0; i < m_width; ++i)
        {
            for (int j = 0; j < m_height; ++j)
            {
                setCurCell(i, j, 0);
                setNewCell(i, j, 0);
            }
        }
    }

}

/*
每个细胞的生死遵循下面的原则：
1． 如果一个细胞周围有3个细胞为生（一个细胞周围共有8个细胞），则该细胞为生（即该细胞若原先为死，则转为生，若原先为生，则保持不变） 。
2． 如果一个细胞周围有2个细胞为生，则该细胞的生死状态保持不变；
3． 在其它情况下，该细胞为死（即该细胞若原先为生，则转为死，若原先为死，则保持不变）
*/
void CWorld::nextTurn(void)
{
    int aroundNum = 0;
    for (int i = 0; i < m_width; ++i)
    {
        for (int j = 0; j < m_height; ++j)
        {
            aroundNum = getAroundCellNum(i, j);
            if (aroundNum == 2)
            {
                setNewCell(i, j, getCellAlive(i, j));
            }
            else if (aroundNum == 3)
            {
                setNewCell(i, j, 1);
            }
            else
            {
                setNewCell(i, j, 0);
            }
        }
    }
    swapMap();
}

int CWorld::getCellAlive(int x, int y)
{
    if (isPosValid(x, y) == 0)
    {
        return -1;
    }
    SCell* cell = getCell(m_cur_map, x, y);
    return cell->isAlive;
}

int CWorld::setCellAlive(int x, int y, int isAlive)
{
    if (isPosValid(x, y) == 0)
    {
        return -1;
    }
    if (isAlive != 0 && isAlive != 1)
    {
        return -2;
    }
    SCell* cell = getCell(m_cur_map, x, y);
    cell->isAlive = isAlive;
    return 0;
}
2, 界面描绘和控制逻辑

main.cpp代码如下:

#include <time.h>
#include "global.h"
#include "World.h"

#define WORLD_TIMER_ID (1)  //定时器ID
#define WORLD_TIMER_ELAPSE (1000)   //定时器超时时间

#define RANDOM_BTN_ID (1)
#define START_BTN_ID (2)
#define PAUSE_BTN_ID (3)
#define NEXT_BTN_ID (4)
#define KILL_ALL_BTN_ID (5)

class CWorld *g_world = NULL;   //全局世界指针

//定时器超时回调函数
void CALLBACK WorldTimerCallBack(HWND hwnd, UINT message, UINT iTimerID, DWORD dwTime);
//描画函数
void CleanWorld(HDC hdc);
void DrawWorld(CWorld* world, int world_w, int world_h, HDC hdc);
void DrawCell(CWorld* world, HDC hdc);
void DrawGrid(HDC hdc, int w, int h);

void CreateButton(HWND hwnd, HINSTANCE hInstance);

/* 全局变量定义区 */
char* g_szApplicationName = "LifeGame";
char* g_szWindowClassName = "This Is My Window Class";

/* 消息回调函数 */
LRESULT CALLBACK WindowProc(HWND   hwnd,
    UINT   msg,
    WPARAM wParam,
    LPARAM lParam)
{
    //存储用户窗口的宽和高
    static int cxClient, cyClient;
    //界面字体宽高
    static int cxChar, cyChar;

    //用于创建后备缓冲
    static HDC      hdcBackBuffer;
    static HBITMAP  hBitmap;
    static HBITMAP  hOldBitmap;

    switch (msg)
    {
    case WM_CREATE:
        {
        RECT rect;

        GetClientRect(hwnd, &rect);

        cxClient = rect.right;
        cyClient = rect.bottom;

        //将窗口移动到屏幕中央
        int scrWidth, scrHeight;
        scrWidth = GetSystemMetrics(SM_CXSCREEN);
        scrHeight = GetSystemMetrics(SM_CYSCREEN);
        GetWindowRect(hwnd, &rect);
        MoveWindow(hwnd, (scrWidth - rect.right) / 2, (scrHeight - rect.bottom) / 2, rect.right - rect.left, rect.bottom - rect.top, FALSE);

        //创建世界和生物
        g_world = new CWorld(WORLD_WIDTH, WORLD_HEIGHT);
        DrawWorld(g_world, WORLD_WIDTH, WORLD_HEIGHT, GetDC(hwnd));
        CreateButton(hwnd, ((LPCREATESTRUCT)lParam)->hInstance);
        EnableWindow(GetDlgItem(hwnd, START_BTN_ID), TRUE); //启用开始按钮
        EnableWindow(GetDlgItem(hwnd, PAUSE_BTN_ID), FALSE);    //禁用暂停按钮
        EnableWindow(GetDlgItem(hwnd, NEXT_BTN_ID), TRUE);  //启用下一步按钮
        EnableWindow(GetDlgItem(hwnd, KILL_ALL_BTN_ID), TRUE);  //启用杀死所有按钮

        //后备缓冲区相关处理
        hdcBackBuffer = CreateCompatibleDC(NULL);
        HDC hdc = GetDC(hwnd);
        hBitmap = CreateCompatibleBitmap(hdc, cxClient, cyClient);
        hOldBitmap = (HBITMAP)SelectObject(hdcBackBuffer, hBitmap);
        //销毁处理
        ReleaseDC(hwnd, hdc);

        }
        break;
    case WM_COMMAND:    //按钮被按下后的响应
    {
        int button_id = LOWORD(wParam);
        switch (button_id)
        {
        case RANDOM_BTN_ID: //随机初始化按钮按下
            g_world->ramdomInit();
            DrawWorld(g_world, WORLD_WIDTH, WORLD_HEIGHT, GetDC(hwnd));
            break;
        case START_BTN_ID:  //开始按钮按下
            SetTimer(hwnd, WORLD_TIMER_ID, WORLD_TIMER_ELAPSE, WorldTimerCallBack); //启动计时器
            EnableWindow(GetDlgItem(hwnd, RANDOM_BTN_ID), FALSE);   //禁用随机生成按钮
            EnableWindow(GetDlgItem(hwnd, START_BTN_ID), FALSE);    //禁用开始按钮
            EnableWindow(GetDlgItem(hwnd, PAUSE_BTN_ID), TRUE); //启用暂停按钮
            EnableWindow(GetDlgItem(hwnd, NEXT_BTN_ID), FALSE); //禁用下一步按钮
            EnableWindow(GetDlgItem(hwnd, KILL_ALL_BTN_ID), FALSE); //禁用杀死所有按钮
            break;
        case PAUSE_BTN_ID:  //暂停按钮按下
            KillTimer(hwnd, WORLD_TIMER_ID);    //销毁计时器
            EnableWindow(GetDlgItem(hwnd, RANDOM_BTN_ID), TRUE);    //启用随机生成按钮
            EnableWindow(GetDlgItem(hwnd, START_BTN_ID), TRUE); //启用开始按钮
            EnableWindow(GetDlgItem(hwnd, PAUSE_BTN_ID), FALSE);    //禁用暂停按钮
            EnableWindow(GetDlgItem(hwnd, NEXT_BTN_ID), TRUE);  //启用下一步按钮
            EnableWindow(GetDlgItem(hwnd, KILL_ALL_BTN_ID), TRUE);  //启用杀死所有按钮
            break;
        case NEXT_BTN_ID:   //下一步按钮按下
            g_world->nextTurn();
            DrawWorld(g_world, WORLD_WIDTH, WORLD_HEIGHT, GetDC(hwnd));
            break;
        case KILL_ALL_BTN_ID:   //杀死所有细胞按钮按下
            g_world->killAll();
            DrawWorld(g_world, WORLD_WIDTH, WORLD_HEIGHT, GetDC(hwnd));
            break;
        default:
            break;
        }
    }
        break;
    case WM_KEYUP:
        //按下Esc退出
        switch (wParam)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            break;
        }
        break;
    case WM_PAINT:
        PAINTSTRUCT ps;
        BeginPaint(hwnd, &ps);
        //将后备缓冲区涂上黑色背景
        BitBlt(hdcBackBuffer,
                0,
                0,
                cxClient,
                cyClient,
                NULL,
                NULL,
                NULL,
                BLACKNESS);

        //描画世界
        DrawGrid(hdcBackBuffer, WORLD_WIDTH, WORLD_HEIGHT);
        DrawCell(g_world, hdcBackBuffer);

        BitBlt(ps.hdc, 0, 0, cxClient, cyClient, hdcBackBuffer, 0, 0, SRCCOPY);
        EndPaint(hwnd, &ps);
        break;
    case WM_SIZE:
    {
        //变更窗口大小时的处理
        cxClient = LOWORD(lParam);
        cyClient = HIWORD(lParam);
        //改变世界的大小
        //world->setWorldSize(cxClient, cyClient);

        SelectObject(hdcBackBuffer, hOldBitmap);
        DeleteObject(hBitmap);
        HDC hdc = GetDC(hwnd);
        hBitmap = CreateCompatibleBitmap(hdc,
            cxClient,
            cyClient);

        ReleaseDC(hwnd, hdc);
        SelectObject(hdcBackBuffer, hBitmap);
    }
    break;
    case WM_DESTROY:
        //销毁世界
        delete g_world;

        //清除并销毁后备缓冲区
        SelectObject(hdcBackBuffer, hOldBitmap);
        DeleteDC(hdcBackBuffer);
        DeleteObject(hBitmap);

        //终了程序,发送WM_QUIT消息  
        PostQuitMessage(0);
        break;
    }

    return DefWindowProc(hwnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR     szCmdLine,
    int       iCmdShow)
{
    HWND hWnd;  //窗口句柄
    WNDCLASSEX winclass;    //窗口类对象

                            //窗口类对象的初始化
    winclass.cbSize = sizeof(WNDCLASSEX);
    winclass.style = CS_HREDRAW | CS_VREDRAW;
    winclass.lpfnWndProc = WindowProc;
    winclass.cbClsExtra = 0;
    winclass.cbWndExtra = 0;
    winclass.hInstance = hInstance;
    winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    winclass.hbrBackground = NULL;
    winclass.lpszMenuName = NULL;
    winclass.lpszClassName = g_szWindowClassName;
    winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

    //注册窗口类
    if (!RegisterClassEx(&winclass))
    {
        MessageBox(NULL, "Registration Failed!", "Error", 0);
        return 0;
    }

    //创建窗口  
    hWnd = CreateWindowEx(NULL,                 // extended style
        g_szWindowClassName,  // window class name
        g_szApplicationName,  // window caption
        WS_OVERLAPPEDWINDOW,  // window style
        0,                    // initial x position
        0,                    // initial y position
        WINDOW_WIDTH,         // initial x size
        WINDOW_HEIGHT,        // initial y size
        NULL,                 // parent window handle
        NULL,                 // window menu handle
        hInstance,            // program instance handle
        NULL);                // creation parameters

                              //容错处理
    if (!hWnd)
    {
        MessageBox(NULL, "CreateWindowEx Failed!", "Error!", 0);
        return 0;
    }

    //显示窗口
    ShowWindow(hWnd, iCmdShow);
    UpdateWindow(hWnd);

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return msg.wParam;
}

//超时后回调函数
void CALLBACK WorldTimerCallBack(HWND hwnd, UINT message, UINT iTimerID, DWORD dwTime)
{
    g_world->nextTurn();
    DrawWorld(g_world, WORLD_WIDTH, WORLD_HEIGHT, GetDC(hwnd));
}

//描画整个世界
void DrawWorld(CWorld * world, int world_w, int world_h, HDC hdc)
{
    CleanWorld(hdc);
    DrawGrid(hdc, world_w, world_h);
    DrawCell(world, hdc);
}

//将世界涂成黑色(背景色)
void CleanWorld(HDC hdc)
{
    HPEN BlackPen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
    HBRUSH BlackBrush = CreateSolidBrush(RGB(0, 0, 0));
    SelectObject(hdc, BlackPen);
    SelectObject(hdc, BlackBrush);
    Rectangle(hdc, 0, 0, WORLD_WIDTH * CELL_SIZE, WORLD_HEIGHT * CELL_SIZE);
    DeleteObject(BlackPen);
    DeleteObject(BlackBrush);
}

//描画所有细胞
void DrawCell(CWorld* world, HDC hdc)
{
    HPEN BluePen = CreatePen(PS_SOLID, 1, RGB(0, 0, 128));
    HBRUSH BlueBrush = CreateSolidBrush(RGB(0, 0,128));
    SelectObject(hdc, BluePen);
    SelectObject(hdc, BlueBrush);
    for (int i = 0; i < world->getWidth(); ++i)
    {
        for (int j = 0; j < world->getHeight(); ++j)
        {
            if (world->getCellAlive(i, j) == 1)
            {
                Rectangle(hdc, i * CELL_SIZE, j * CELL_SIZE, i * CELL_SIZE + CELL_SIZE, j * CELL_SIZE + CELL_SIZE);
            }
        }
    }

    DeleteObject(BluePen);
    DeleteObject(BlueBrush);
}

//描画网格
void DrawGrid(HDC hdc, int w, int h)
{
    HPEN GrayPen = CreatePen(PS_SOLID, 1, RGB(128, 128, 128));
    //HBRUSH GreenBrush = CreateSolidBrush(RGB(0, 255, 0));
    SelectObject(hdc, GrayPen);
    //SelectObject(hdc, GreenBrush);
    for (int i = 0; i <= w; ++i)
    {
        MoveToEx(hdc, i * CELL_SIZE, 0, NULL);
        LineTo(hdc, i * CELL_SIZE, h * CELL_SIZE);
    }
    for (int i = 0; i <= h; ++i)
    {
        MoveToEx(hdc, 0, i * CELL_SIZE, NULL);
        LineTo(hdc, w * CELL_SIZE, i * CELL_SIZE);
    }

    DeleteObject(GrayPen);
    //DeleteObject(GreenBrush);
}

void CreateButton(HWND hwnd, HINSTANCE hInstance)
{
    RECT rect;
    GetClientRect(hwnd, &rect);
    int cxClient = rect.right;

    /* 建立按钮 */
    int cxChar = LOWORD(GetDialogBaseUnits());
    int cyChar = HIWORD(GetDialogBaseUnits());
    //开始按钮
    int button_w = cxChar * 12;
    int button_h = cyChar * 2;
    int button_x = cxClient - cxChar * 15;
    int random_btn_y = cyChar * 1;
    int start_btn_y = random_btn_y + button_h + cyChar;
    int pause_btn_y = start_btn_y + button_h + cyChar;
    int next_btn_y = pause_btn_y + button_h + cyChar;
    int kill_all_btn_y = next_btn_y + button_h + cyChar;

    CreateWindow(TEXT("Button"), TEXT("随机初始化"),
        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
        button_x, random_btn_y, button_w, button_h,
        hwnd, (HMENU)RANDOM_BTN_ID,
        hInstance, NULL);
    CreateWindow(TEXT("Button"), TEXT("开始"),
        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
        button_x, start_btn_y, button_w, button_h,
        hwnd, (HMENU)START_BTN_ID,
        hInstance, NULL);
    CreateWindow(TEXT("Button"), TEXT("暂停"),
        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
        button_x, pause_btn_y, button_w, button_h,
        hwnd, (HMENU)PAUSE_BTN_ID,
        hInstance, NULL);
    CreateWindow(TEXT("Button"), TEXT("下一步"),
        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
        button_x, next_btn_y, button_w, button_h,
        hwnd, (HMENU)NEXT_BTN_ID,
        hInstance, NULL);
    CreateWindow(TEXT("Button"), TEXT("杀死所有"),
        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
        button_x, kill_all_btn_y, button_w, button_h,
        hwnd, (HMENU)KILL_ALL_BTN_ID,
        hInstance, NULL);
}

最后, 附上global.h代码

#pragma once

#include <windows.h>
#include <iostream>

#define WINDOW_WIDTH  800
#define WINDOW_HEIGHT 600
#define WORLD_WIDTH 30
#define WORLD_HEIGHT 20
#define CELL_SIZE 20

程序还有一些地方需要改进, 将在下次进行

代码之炼金术师
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生命游戏 Conway's Life
10-29
该系统研究了数学家Conway提出的生命游戏，根据生命算法，推算元胞的生死。系统刻画了滑翔机发射枪，振荡器等模型。有很高的研究意义。
3D 中的康威生命游戏：康威生命游戏的三维扩展。-matlab开发
06-01
康威生命游戏的 3 维版本。 “生命”是由约翰康威发明的细胞自动机，它涉及矩形二维宇宙中的活细胞和死细胞。 此实现使用 M x M x M 网格； 可以使用滑块控件更改初始随机生成的单元格的数量。 细胞是存活、死亡还是产生新细胞取决于它们的八个可能的邻居中有多少是活着的。 通过使用稀疏矩阵，所需的计算变得非常简单。 我们在宇宙边缘使用周期性（环面）边界条件。 按下“开始”按钮会自动在这个宇宙中播种几个小的随机社区。 有些人会成功，有些人会失败。
pygame + numpy实现康威生命游戏
最新发布
cnds123的专栏
01-27 929
pygame + numpy实现康威生命游戏
康威-生命游戏 软件 golly
10-01
第一次看到生命游戏,我被那简单规则涌现出的奇妙模式震惊了, 尤其是用小方块构成大方块, 大方块的行为和小方块一直, 可以无限嵌套, 这不就是分行吗, 简直就是二维的我的世界了, 有人在我的世界里建造出我的世界, 在我的世界里玩我的世界, 那震撼的场面, 让人知乎卧槽, 这世界的奥妙也隐藏在里面把, 后来被证明是图灵完备的, 也就是计算机能干的是 生命游戏也能干, 只不过需要强大的算力和硬件做支撑
康威生命游戏简单演示实现（Visual c++ MFC)
我的程序世界
07-10 864
最近刷视频看到有UP主介绍了康威的生命游戏．该游戏由康威发明于1970年，关于游戏详细内容，网上有很多，这里就不再详述了，感兴趣的同学可以在百科查阅．简单的说就是在二维平面通过简单规则规定单元格子的存活来产生出极其复杂的演变．类似于生命里的细胞构造，所以称为生命游戏． 康威最初定的规则很简单，如下所述： １、当格子周围有3个存活细胞时，如果细胞为死亡状态时，当前格子诞生新细胞。如果存在活细胞则保持不变。 ２、当格子周围有２个存活细胞时，当前格子保持不变。 ３、当格子周......
康威生命游戏
2301_80096779的博客
12-08 152
用一个二维表格表示“生存空间”，空间的每个方格中都可放置一个生命细胞，每个生命细胞只有两种状态：“生”或“死”。用绿色方格表示该细胞为“生”，空格(白色)表示该细胞为“死”。或者说方格网中绿色部分表示某个时候某种“生命”的分布图。生命游戏想要模拟的是：随着时间的流逝，这个分布图将如何一代一代地变化。死亡太沉重，被人们称为“湮灭”状态。生存定律生存空间的每个方格都存在一个细胞，它的周边紧邻的8个方格上的称为邻居细胞。当前细胞为湮灭状态时，当周围有３个存活细胞时，则迭代后该细胞变成存活状态(模拟繁殖)
生命游戏：C++实现与功能设计说明
howard2005的专栏
01-13 4289
生命游戏是一款富有挑战性和趣味性的游戏，它可以激发我们对数学、计算机科学和生命哲学的兴趣。
conway生命游戏
01-27
conway生命游戏，可以修改初始元胞比例，输出演化动画。python代码
生命游戏C++版
2202_76049826的博客
02-04 1421
生命游戏简介，编程过程（C++），附源代码
Rust and WebAssembly -- 康威生命游戏
一个新时代的好少年的博客
11-20 1329
rust wasm 实现康威生命游戏
康威生命游戏 Conway's game of life
Tao_exe的博客
02-23 8066
一、需求描述你的任务是写一个程序来计算给定起始位置下的下一代康威生命游戏。游戏从一个两维的网格开始，每一个网格有两种状态：存活、死亡。网格是有限的，没有生命可以存活在边界之外。当计算下一代网格时，需要遵循下述四个规则：1. 任何四周邻居存活数少于两个的存活网格将死亡，因为人口稀少。2. 任何四周邻居存活数多于三个的存活网格将死亡，因为过度拥挤。3. 任何四周邻居存活数等于两个或三个的存活网格将在下
生命游戏：用C＃Windows窗体编写的生命游戏
02-26
生命游戏 用C＃Windows窗体编写的“生活游戏”。
康威生命游戏简单实现Visual Studio 2010(MFC)
07-24
康威生命游戏Windows演示程序，使用MFC实现，Visual C++ 2010编译，这个是演示程序，源代码后面上传。有这方面研究兴趣的可以下载来玩玩。
康威生命游戏源代码
07-10
使用C++和Windows SDK实现的康威生命游戏
康威的生命游戏Android版
12-18
自己做的一个Android小例子---康威的生命游戏，大家无聊的时候可以下载来玩玩或者优化一下。
课程设计基于Qt和c++实现康威生命游戏源码+sln解决方案.zip
10-25
课程设计-基于Qt和c++实现康威生命游戏源码+sln解决方案.zip课程设计-基于Qt和c++实现康威生命游戏源码+sln解决方案.zip课程设计-基于Qt和c++实现康威生命游戏源码+sln解决方案.zip课程设计-基于Qt和c++实现康威生命...
课程设计基于Qt和c++实现的康威生命游戏源码+sln解决方案
01-20
课程设计基于Qt和c++实现康威生命游戏源码+sln解决方案 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用...
game-of-life:康威生命游戏的蹩脚 C++ SDL2 版本
07-14
康威生命游戏的 C++/SDL2 版本 用鼠标点击棋盘，绘制初始状态或修改当前状态。 通过按下或按住空格键推进模拟。 输入“q”退出。 在 Mac OSX 10.10.0 (Yosemite) 和 Arch Linux w/ GCC 4.9.0 上测试
Conway's Game of Life for Excel:康威的 Excel 生命游戏实现-开源
06-08
另一个针对 MS Excel 的简单康威生命游戏实现。 创建只是为了好玩。
用c++写一个康威生命游戏
05-19
好的，我可以为您提供一个简单的C++实现康威生命游戏的代码。康威生命游戏是一个基于细胞自动机的零玩家游戏，它是由英国数学家约翰·康威在1970年发明的。 以下是一个简单的实现： ```c++ #include #include #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值