二、C++应用：五子棋

已于 2022-05-14 15:08:53 修改
阅读量772 收藏 1
点赞数
分类专栏： C++小项目
于 2022-05-14 15:07:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42488216/article/details/124712945
版权

五子棋 游戏开发 AI算法 人机对战 wxWidgets
关键词由CSDN通过智能技术生成

2 五子棋

2.1 需求

基于wxWidgets实现一个五子棋游戏

2.2 功能

1、显示一个15*15线组成的围棋棋盘。
2、棋子只能落在线的交点上。
3、黑白子交替下棋。
4、当黑子或者白子连续五个子组成一条直线，则为胜利。
实例：双人对战

#include <wx/wx.h>
#include <vector>
using namespace std;
//面板类
class GoPanel:public wxPanel{
vector<wxPoint> vec;
const int cellsize = 30;
const int linelen = cellsize*14;
enum ChessType{
    EMPTY,BLACK,WHITE,
};
ChessType broad[15][15] = {EMPTY};
bool black = true;
wxPoint offset;
public:
    GoPanel(wxFrame* pframe):wxPanel(pframe){
    	//将面板与绘图绑定
	Bind(wxEVT_PAINT,&GoPanel::OnPaint,this);
	Bind(wxEVT_LEFT_DOWN,&GoPanel::OnLeftDown,this);
    }	
    void OnLeftDown(wxMouseEvent& event){
    	wxPoint point =  event.GetPosition();
	int x = round(1.0*(point.x-offset.x)/cellsize);
	int y = round(1.0*(point.y-offset.y)/cellsize);
	if(broad[x][y] != EMPTY || x >= 15 || y >= 15) return;
	broad[x][y] = black?BLACK:WHITE;
	black = !black;
	Refresh();
	if(Check(x,y)){
	    wxMessageBox(broad[x][y] == BLACK?"Black Win":"White Win","Note");
	}
    }
    bool Check(int x,int y)const {
	ChessType type = broad[x][y];
        int count = 1;
	//横向检测
	for(int i = x+1;i < 15;++i){
	    if(broad[i][y] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	for(int i = x-1;i >= 0;--i){
	    if(broad[i][y] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	//纵向检测
	count = 1;
	for(int i = y+1;i < 15;++i){
	    if(broad[x][i] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	for(int i = y-1;i >= 0;--i){
	    if(broad[x][i] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	//斜向检测
	count = 1;
	for(int i = 1;i <= 5 && x+i < 15 && y+i < 15;++i){
	    if(broad[x+i][y+i] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	for(int i = 1;i<=5 && x-i>=0 && y-i>=0;++i){
	    if(broad[x-i][y-i] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	//反斜检测
	count = 1;
	for(int i = 1;i <= 5 && x+i < 15 && y-i >= 0;++i){
	    if(broad[x+i][y-i] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	for(int i = 1;i<=5 && x-i>=0 && y+i<15;++i){
	    if(broad[x-i][y+i] == type){
	    	++count;
	    }else{
	    	break;
	    }
	}
	if(count >= 5) return true;
	
	return false;
    }
    void OnPaint(wxPaintEvent&){
    	//定义画笔
	wxPaintDC dc(this);
	//棋盘居中
	wxSize size = GetClientSize();
	int left = (size.GetWidth()-linelen)/2;
	int top = (size.GetHeight()-linelen)/2;
	offset = wxPoint(left,top);
	for(int i = 0;i < 15;++i){
	    //dc.DrawLine(wxPoint(left,top+cellsize*i),wxPoint(left+linelen,top+cellsize*i));
	    //dc.DrawLine(wxPoint(left+cellsize*i,top),wxPoint(left+cellsize*i,top+linelen));
	    dc.DrawLine(wxPoint(0,cellsize*i)+offset,wxPoint(linelen,cellsize*i)+offset);
	    dc.DrawLine(wxPoint(cellsize*i,0)+offset,wxPoint(cellsize*i,linelen)+offset);
	}
        for(int i = 0;i < 15;++i){
	    for(int j = 0;j < 15;++j){
	        if(broad[i][j] != EMPTY) DisplayChess(dc,i,j);
	    }
	}
    }
    void DisplayChess(wxPaintDC& dc,int x,int y){
	dc.SetBrush(broad[x][y] == WHITE? *wxWHITE_BRUSH:*wxBLACK_BRUSH);
        //dc.DrawCircle(offset.x+x*cellsize,offset.y+y*cellsize,cellsize/2);
        //dc.DrawCircle(wxPoint(x*cellsize,y*cellsize)+offset,cellsize/2);
        dc.DrawCircle(wxPoint(x,y)*cellsize+offset,cellsize/2);
    }
};
//框架类
//框架类中添加面板类
class GoFrame:public wxFrame{
public:
     GoFrame(const char* title):wxFrame(nullptr,wxID_ANY,title){
     	wxPanel* p = new GoPanel(this);
     }
};
//应用程序类
//应用程序类中添加框架类
class GoApp:public wxApp{
public:
    bool OnInit()override{
    	GoFrame* pframe = new GoFrame("Name");
	pframe->Show();
	return true;
    };
};

wxIMPLEMENT_APP(GoApp);

2.3 加入AI算法实现人机对战

最常见的基本棋型大体有以下几种：连五，活四，冲四，活三，眠三，活二，眠二。

  • 必胜
    在这里插入图片描述
  • 将胜
    在这里插入图片描述
  • 待胜
    在这里插入图片描述
  • 不胜

在这里插入图片描述

棋型进攻方防守方
连五胜负
活四必胜必负
冲四必须进攻必须防守
活三必须进攻必须防守
眠三可以进攻可以进攻
活二可以进攻可以进攻
眠二可以进攻可以进攻
  • 规则：
    1、连五直接判定胜负。
    2、活四、冲四、活三抢占关键点。
    3、眠三、活二、眠二优先进攻。

判断整个棋盘黑白所有的棋型，选取优势棋型进攻防守。例如，执白，如果黑棋的棋型优于白棋防守；反之进攻。

  • 实例：加入AI算法的人机五子棋对战
    注：机器方仅有防守功能，需进一步优化
#include <wx/wx.h>
#include <vector>
using namespace std;
//面板类
class GoPanel:public wxPanel {
    vector<wxPoint> vec;
    const int cellsize = 30;
    const int linelen = cellsize*14;
    enum ChessType {
        EMPTY,BLACK,WHITE,
    };
    ChessType broad[15][15] = {EMPTY};
    bool black = true;
    wxPoint offset;
    pair<int,int> nextpos;
    int maxcount = 0;
public:
    GoPanel(wxFrame* pframe):wxPanel(pframe) {
        //将面板与绘图绑定
        Bind(wxEVT_PAINT,&GoPanel::OnPaint,this);
        Bind(wxEVT_LEFT_DOWN,&GoPanel::OnLeftDown,this);
    }
    void OnLeftDown(wxMouseEvent& event) {
        wxPoint point =  event.GetPosition();
        int x = round(1.0*(point.x-offset.x)/cellsize);
        int y = round(1.0*(point.y-offset.y)/cellsize);
        if(broad[x][y] != EMPTY || x >= 15 || y >= 15) return;
        Chess(x,y);
        Refresh();
        Chess(nextpos.first,nextpos.second); //机器（白棋）
        Refresh();
    }
    void Chess(int x,int y) {
        broad[x][y] = black?BLACK:WHITE;
        black = !black;
        if(Check(x,y)) {
            wxMessageBox(broad[x][y] == BLACK?"Black Win":"White Win","Note");
        }
    }
    bool Check(int x,int y) {
        ChessType type = broad[x][y];
        int count = 1;
        maxcount = 0;
        int tryx1 = -1,tryy1 = -1, tryx2 = -1,tryy2 = -1;
        int add1= 0, add2 = 0;
        //横向检测
        for(int i = x+1; i < 15; ++i) {
            if(broad[i][y] == type) {
                ++count;
            } else {
                if(broad[i][y] == EMPTY) {
                    tryx1 = i;
                    tryy1 = y;
                    int j = i+1;
                    while(j<15 && broad[j][y] == type) {
                        ++add1;
                        ++j;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        for(int i = x-1; i >= 0; --i) {
            if(broad[i][y] == type) {
                ++count;
            } else {
                if(broad[i][y] == EMPTY) {
                    tryx2 = i;
                    tryy2 = y;
                    int j = i-1;
                    while(j>=0 && broad[j][y] == type) {
                        ++add2;
                        --j;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        if(maxcount < count+max(add1,add2) && (tryx1 != -1 || tryx2!=-1)) {
            maxcount = count+max(add1,add2);
            if(add1 == add2) {
                if(tryx1 == -1) {
                    nextpos = make_pair(tryx2,tryy2);
                } else {
                    nextpos = make_pair(tryx1,tryy1);
                }
            } else {
                nextpos = add1 > add2?make_pair(tryx1,tryy1):make_pair(tryx2,tryy2);
            }
        }
        cout << "横向检测:" << maxcount << " Point:" << nextpos.first << "," << nextpos.second << endl;
        //纵向检测
        tryx1 = tryy1 = tryx2 = tryy2 = -1;
        add1 = add2 = 0;
        count = 1;
        for(int i = y+1; i < 15; ++i) {
            if(broad[x][i] == type) {
                ++count;
            } else {
                if(broad[x][i] == EMPTY) {
                    tryx1 = x;
                    tryy1 = i;
                    int j = i+1;
                    while(j<15 && broad[x][j] == type) {
                        ++add1;
                        ++j;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        for(int i = y-1; i >= 0; --i) {
            if(broad[x][i] == type) {
                ++count;
            } else {
                if(broad[x][i] == EMPTY) {
                    tryx2 = x;
                    tryy2 = i;
                    int j = i-1;
                    while(j>=0 && broad[x][j] == type) {
                        ++add2;
                        --j;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        if(maxcount < count+max(add1,add2)&&(tryx1!=-1 || tryx2!=-1)) {
            maxcount = count+max(add1,add2);
            if(add1 == add2) {
                if(tryx1 == -1) {
                    nextpos = make_pair(tryx2,tryy2);
                } else {
                    nextpos = make_pair(tryx1,tryy1);
                }
            } else {
                nextpos = add1 > add2?make_pair(tryx1,tryy1):make_pair(tryx2,tryy2);
            }
        }
        cout << "纵向检测:" << maxcount << " Point:" << nextpos.first << "," << nextpos.second << endl;
        //斜向检测
        count = 1;
        tryx1 = tryy1 = tryx2 = tryy2 = -1;
        add1 = add2 = 0;
        for(int i = 1; i <= 5 && x+i < 15 && y+i < 15; ++i) {
            if(broad[x+i][y+i] == type) {
                ++count;
            } else {
                if(broad[x+i][y+i] == EMPTY) {
                    tryx1 = x+i;
                    tryy1 = y+i;
                    int j = i+i+1,k = y+i+1;
                    while(j < 15 && broad[j][k] == type) {
                        ++add1;
                        ++j;
			++k;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        for(int i = 1; i<=5 && x-i>=0 && y-i>=0; ++i) {
            if(broad[x-i][y-i] == type) {
                ++count;
            } else {
                if(broad[x-i][y-i] == EMPTY) {
                    tryx2 = x-i;
                    tryy2 = y-i;
                    int j = x-i-1,k = y-i-1;
                    while(j >=0 && broad[j][k] == type) {
                        ++add2;
                        --j;
			--k;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        if(maxcount < count+max(add1,add2)&&(tryx1!=-1||tryx2!=-1)) {
            maxcount = count+max(add1,add2);
            if(add1 == add2) {
                if(tryx1 == -1) {
                    nextpos = make_pair(tryx2,tryy2);
                } else {
                    nextpos = make_pair(tryx1,tryy1);
                }
            } else {
                nextpos = add1 > add2?make_pair(tryx1,tryy1):make_pair(tryx2,tryy2);
            }
        }
        cout << "斜向检测:" << maxcount << " Point:" << nextpos.first << "," << nextpos.second << endl;
        //反斜检测
        count = 1;
        tryx1 = tryy1 = tryx2 = tryy2 = -1;
        add1 = add2 = 0;
        for(int i = 1; i <= 5 && x+i < 15 && y-i >= 0; ++i) {
            if(broad[x+i][y-i] == type) {
                ++count;
            } else {
                if(broad[x+i][y-i] == EMPTY) {
                    tryx1 = x+i;
                    tryy1 = y-i;
                    int j = x+i+1,k = y-i-1;
                    while(j < 15 && k>=0 && broad[j][k] == type) {
                        ++add1;
                        ++j;
                        --k;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        for(int i = 1; i<=5 && x-i>=0 && y+i<15; ++i) {
            if(broad[x-i][y+i] == type) {
                ++count;
            } else {
                if(broad[x-i][y+i] == EMPTY) {
                    tryx2 = x-i;
                    tryy2 = y+i;
                    int j = x-i-1,k = y+i+1;
                    while(j >=0 && k<15 && broad[j][k] == type) {
                        ++add2;
                        --j;
                        ++k;
                    }
                }
                break;
            }
        }
        if(count >= 5) return true;
        if(maxcount < count+max(add1,add2)&&(tryx1!=-1||tryx2!=-1)) {
            maxcount = count+max(add1,add2);
            if(add1 == add2) {
                if(tryx1 == -1) {
                    nextpos = make_pair(tryx2,tryy2);
                } else {
                    nextpos = make_pair(tryx1,tryy1);
                }
            } else {
                nextpos = add1 > add2?make_pair(tryx1,tryy1):make_pair(tryx2,tryy2);
            }
        }
        cout << "反斜检测:" << maxcount << " Point:" << nextpos.first << "," << nextpos.second << endl;
        return false;
    }
    void OnPaint(wxPaintEvent&) {
        //定义画笔
        wxPaintDC dc(this);
        //棋盘居中
        wxSize size = GetClientSize();
        int left = (size.GetWidth()-linelen)/2;
        int top = (size.GetHeight()-linelen)/2;
        offset = wxPoint(left,top);
        for(int i = 0; i < 15; ++i) {
            //dc.DrawLine(wxPoint(left,top+cellsize*i),wxPoint(left+linelen,top+cellsize*i));
            //dc.DrawLine(wxPoint(left+cellsize*i,top),wxPoint(left+cellsize*i,top+linelen));
            dc.DrawLine(wxPoint(0,cellsize*i)+offset,wxPoint(linelen,cellsize*i)+offset);
            dc.DrawLine(wxPoint(cellsize*i,0)+offset,wxPoint(cellsize*i,linelen)+offset);
        }
        for(int i = 0; i < 15; ++i) {
            for(int j = 0; j < 15; ++j) {
                if(broad[i][j] != EMPTY) DisplayChess(dc,i,j);
            }
        }
    }
    void DisplayChess(wxPaintDC& dc,int x,int y) {
        dc.SetBrush(broad[x][y] == WHITE? *wxWHITE_BRUSH:*wxBLACK_BRUSH);
        //dc.DrawCircle(offset.x+x*cellsize,offset.y+y*cellsize,cellsize/2);
        //dc.DrawCircle(wxPoint(x*cellsize,y*cellsize)+offset,cellsize/2);
        dc.DrawCircle(wxPoint(x,y)*cellsize+offset,cellsize/2);
    }
};
//框架类
//框架类中添加面板类
class GoFrame:public wxFrame {
public:
    GoFrame(const char* title):wxFrame(nullptr,wxID_ANY,title) {
        wxPanel* p = new GoPanel(this);
        SetSize(wxSize(500,500));
    }
};
//应用程序类
//应用程序类中添加框架类
class GoApp:public wxApp {
public:
    bool OnInit()override {
        GoFrame* pframe = new GoFrame("Name");
        pframe->Show();
        return true;
    };
};

wxIMPLEMENT_APP(GoApp);
_深蓝.
关注
专栏目录
C++实现五子棋小游戏
Meliorem的博客
10-22 2697
五子棋游戏是在C++学习前期用于练手的很不错的小项目，实现粗糙的五子棋小游戏不需要对C++语法了解的非常深入也不许需要对数据结构的熟悉和理解达到多么深的层次 所以是一个非常简单的小程序实现五子棋小程序需要合理的设计整个程序的架构 整个游戏的实现分成：选择游戏方式、 初始化棋盘 、 每次落子更新棋盘 、 对是否已决出输赢的判断 和 胜者是谁的判断这几个模块 。每个模块对应实现函
C++围棋游戏
06-14
尚未完善的围棋游戏。使用vs2010开发。具有围棋棋盘，棋子界面，已经完成了提子算法。有兴趣的朋友可以与我一起来研究。欢迎大家前来交流
C++围棋小游戏1.2.1
zfx1569的博客
04-10 2498
自己写游戏的第三天
简化的围棋棋子规则（C++实现）
hhhhhhhhhk的博客
05-12 1378
笔试题
c++ opencv实现五子棋（围棋）棋局信息处理
最新发布
weixin_60739161的博客
05-04 481
之前为了完成课设学习了一下如何使用opencv进行五子棋棋局处理，但是目前网上关于棋局处理的程序大多使用python语言进行编程，所以本篇博客补充一个使用c++语言和opencv库实现五子棋棋局处理的程序，程序中涉及的图像处理算法有高斯模糊，canny边缘提取（这块使用sobel也可以），霍夫圆检测算法。此段代码的输入为一张棋局图像，输出为二维矩阵，其中每个位置可以为0（无棋子）,1（白棋子）,2（黑棋子），程序经过实测可以完成目标任务。
C++大作业：五子棋程序.zip
06-02
C++是计算机科学中广泛使用的面向对象的编程语言，它提供了丰富的功能和高效性能，适合开发这样的游戏应用。 在这个C++大作业中，我们可以预期以下几个关键知识点： 1. **基础语法与数据结构**：首先，开发者需要...
C++Builder 简易五子棋
02-21
在C++Builder中，开发五子棋游戏首先需要理解的是事件驱动编程模型，这是大多数GUI应用程序的基础。当用户点击棋盘上的某个位置时，C++Builder中的事件处理函数会被调用，执行相应的逻辑，如检查落子是否合法、判断...
基于C++实现的五子棋游戏【100012928】
07-14
这里设计和实现了一个人机对下的五子棋程序，采用了博弈树的方法，应用了剪枝和最大最小树原理进行搜索发现最好的下子位置。介绍五子棋程序的数据结构、评分规则、胜负判断方法和搜索算法过程。
C++课程设计：五子棋人机博弈系统开发
资源摘要信息:"基于C++实现人工智能课程五子棋博弈问题【***】" 一、实验目的和内容解读： 本课程设计的目标在于让学习者通过实践深入理解并掌握博弈树的启发式搜索过程、α-β剪枝算法，以及如何设计评估函数。...
C++简单的五子棋程序
04-10
**C++简单的五子棋程序**是一门编程实践，它主要使用C++语言来实现一个基本的五子棋游戏。C++是一种强大的、面向对象的编程语言，它提供了丰富的库支持和高效的执行性能，因此是开发游戏应用的理想选择。在这个项目...
c++围棋源码
12-16
c++围棋源码，良好的编程习惯，计算气以及很多测试用例都有包含
用C++编写的Win32围棋程序
11-22
以前编写的Win32围棋对棋程序，生成一个exe文件，运行菜单中有自己建立服务端，其它人可以观战。先一个程序建立棋局，第二个人输入地址加入到对棋，再是其他人加入到观战，是客户/服务方式，程序有点老。主要是对局算法和Winsock的完成端口模式可以看一下。
Visual_C++_开发的双人对弈围棋
06-05
Visual_C++_开发的双人对弈围棋
五子棋人机对战C++程序
10-18
可以实现五子棋人机对战，在VC6.0上编写
C++围棋程序.docx
11-06
计算机 电子信息工程 通信工程 实验 课程设计 工程项目 资源 必过 计算机 电子信息工程 通信工程 实验 课程设计 工程项目 资源 必过
【项目实战】C/C++语言带你实现：围棋游戏丨详细逻辑+核心源码
致力于C语言C++知识分享！
02-16 7396
下围棋的程序，实现了界面切换，选择路数，和围棋规则，也实现了点目功能，不过只有当所有死子都被提走才能点目，不然不准确
c语言写五子棋如何判断赢了,五子棋 C++ 怎么判断赢了
weixin_39560657的博客
05-23 567
满意答案hk4353322013.06.17采纳率：42%等级：12已帮助：10435人我有个笨方法：blackwins = false;whitewins = false;for(j=0;j<15;j++){for(i=0;i<11;i++){if(state[i][j]==1&&state[i+1][j]==1&&state[i+2][j] ...
C++实现人机对战围棋（使用Leela Zero权重）-界面
juebai123的博客
08-05 3215
1。在《leela-zero-next》包中有一个 从人类游戏训练的（较弱的）网络的权重文件（https://sjeng.org/zero/best_v1.txt.zip）（6残差块，128通道） 2。并在《easyx吧》百度贴吧下了一个双人对战的五子棋+围棋的游戏（去掉其中的五子棋部分）。 把这两个合成一个人机对战围棋。 虽然leela-zero也是C++写的，但是我也看不懂，这里只使用...
C++小游戏-五子棋（人机对战增强版）.cpp
11-30
电脑已经不再死板，可以与你一起下五子棋，棋艺不佳者可移步“五子棋（菜鸟版）”，下载后用C++方可打开，玩的时候一定记住，全屏！全屏！！全屏！！！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值