草庐IT

Visual C++实现五子棋游戏项目实战四：游戏规则与主对话框类实现（附源码和资源 超详细）

showswoller 2023-04-13 原文

需要源码和资源请点赞关注收藏后评论区留言私信~~~

一、游戏规则的设计与实现

游戏规则类是五子棋游戏中游戏算法的真实体现，所以其实现也是最复杂的一个类，涉及如何把游戏规则编写成代码的过程

游戏规则类应该支持以下两个功能

1：能够判断一方的胜利，即在各个方向判断有无连续相同的五个颜色

2：能够判断黑方禁手的功能

下面来涉及游戏规则类，该类对外提供了两个接口函数，胜负判断接口函数win和禁手判断接口函数Ban，代码如下

#ifndef __RULE_H__
#define __RULE_H__

#define _WIN 0x00
#define _LOST 0x01
#define _OTHER 0x02

class CRule
{
public:
	CRule();								//构造函数
	~CRule();								//析构函数

	int Win(int color, int x, int y);		//胜负判断接口函数
	BOOL Ban(int x, int y, int color);		//禁手判断接口函数
private:
	BOOL forbid2(int x, int y);				//非连子禁手判断
	BOOL forbid1(int x, int y);				//连子禁手判断
};

#endif
#include "stdafx.h"
#include "rule.h"

#define NONE -1

CRule::CRule()
{
}

CRule::~CRule()
{
}
//
// 禁手判断接口函数
//
BOOL CRule::Ban(int x, int y, int color)
{
	if(forbid1(x, y) || forbid2(x, y))
	{
		return TRUE;
	}

	return FALSE;
}
//
// 连五判断
// 返回 0 为胜利 1为禁手 2为无状态
//
int CRule::Win(int color, int xpos, int ypos)
{
	int x, y;

    // 判断横向
    for ( y = 0; y < 15; y++ )
    {
        for ( x = 0; x < 11; x++ )
        {
            if ( color == m_data[x][y] && color == m_data[x + 1][y] &&
                color == m_data[x + 2][y] && color == m_data[x + 3][y] &&
                color == m_data[x + 4][y] )
            {
                return _WIN;
            }
        }
    }
    // 判断纵向
    for ( y = 0; y < 11; y++ )
    {
        for ( x = 0; x < 15; x++ )
        {
            if ( color == m_data[x][y] && color == m_data[x][y + 1] &&
                color == m_data[x][y + 2] && color == m_data[x][y + 3] &&
                color == m_data[x][y + 4] )
            {
                return _WIN;
            }
        }
    }
    // 判断“\”方向
    for ( y = 0; y < 11; y++ )
    {
        for ( x = 0; x < 11; x++ )
        {
            if ( color == m_data[x][y] && color == m_data[x + 1][y + 1] &&
                color == m_data[x + 2][y + 2] && color == m_data[x + 3][y + 3] &&
                color == m_data[x + 4][y + 4] )
            {
                return _WIN;
            }
        }
    }
    // 判断“/”方向
    for ( y = 0; y < 11; y++ )
    {
        for ( x = 4; x < 15; x++ )
        {
            if ( color == m_data[x][y] && color == m_data[x - 1][y + 1] &&
                color == m_data[x - 2][y + 2] && color == m_data[x - 3][y + 3] &&
                color == m_data[x - 4][y + 4] )
            {
                return _WIN;
            }
        }
    }

	if(color == BLACK)
	{
		if(Ban(xpos, ypos, color))
		{
			return _LOST;
		}
	}

	return _OTHER;
}
//
// 连子禁手判断
// 返回TRUE为禁手
//
BOOL CRule::forbid1(int x, int y)
{     
	int tt[9]={0};
    int w[4]={0};
	int j3=0,j4=0,j6=0;
	int t1=0,t2=0,t3=0,t4=0;
	//水平方向
	for(int i1=1;i1<5;i1++)
	{ 
		if(m_data[x-i1][y]==BLACK)
		{
			tt[1]++;
		}
		else if(m_data[x+1][y]==WHITE||m_data[x-i1][y]==WHITE)
		{
			tt[1]=0;
			break;
		}
	}
	   
	for(int i2=1;i2<5;i2++)
	{ 
		if(m_data[x+i2][y]==BLACK)
		{
			tt[1]++;
		}
		else if(m_data[x-1][y]==WHITE||m_data[x-i2][y]==WHITE)
		{
			tt[5]=0;
			break;
		}
	}
    if(tt[1]+tt[5]==2&&t1==1)
	{
		w[0]=0;
	}
	else
	{
		w[0]=tt[1]+tt[5];
	}
	//竖直方向
	for(int i3=1;i3<5;i3++)
	{ 
		if(m_data[x][y-i3]==BLACK)
		{
			tt[2]++;
		}
		else if(m_data[x][y+1]==WHITE||m_data[x][y+i3]==WHITE)
		{
			tt[2]=0;
			break;
		}
	}
	   
	for(int i4=1;i4<5;i4++)
	{ 
		if(m_data[x][y+i4]==BLACK)
		{
			tt[2]++;
		}
		else if(m_data[x][y-1]==WHITE||m_data[x][y+i4]==WHITE)
		{
			tt[6]=0;
			break;
		}
	}
    
	if(tt[2]+tt[4]==2&&t2==1)
	{
		w[1]=0;
	}
	else
	{
		w[1]=tt[2]+tt[6];
	}
	//右下方向
	for(int i5=1;i5<5;i5++)
	{ 
		if(m_data[x-i5][y-i5]==BLACK)
		{
			tt[1]++;
		}
		else if(m_data[x+1][y+1]==WHITE||m_data[x-i5][y-i5]==WHITE)
		{
			tt[3]=0;
			break;
		}
	}
	   
	for(int i6=1;i6<5;i6++)
	{
		if(m_data[x+i6][y+i6]==BLACK)
		{
			tt[7]++;
		}
		else if(m_data[x-1][y-1]==WHITE||m_data[x+i6][y+i6]==WHITE)
		{
			tt[7]=0;
			break;
		}
	}
	
	if(tt[3]+tt[6]==2&&t3==1)
	{
		w[2]=0;
	}
	else
	{
		w[2]=tt[3]+tt[7];
	}
	//左下方向
	for(int i7=1;i7<5;i7++)
    { 
		if(m_data[x-i7][y+i7]==BLACK)
		{
			tt[4]++;
		}
		else if(m_data[x+1][y-1]==WHITE||m_data[x-i7][y+i7]==WHITE)
		{
			tt[4]=0;
			break;
		}
	}
	   
	for(int i8=1;i8<5;i8++)
	{
		if(m_data[x+i8][y-i8]==BLACK)
		{
			tt[8]++;
		}
		else if(m_data[x-1][y+1]==WHITE||m_data[x+i8][y-i8]==WHITE)
		{
			tt[8]=0;
			break;
		}
	}
	if(tt[3]+tt[6]==2&&t4==1)
	{
		w[3]=0;
	}
	else
	{
		w[3]=tt[4]+tt[8];
	}
	   
	for(int i=0;i<4;i++)
	{
		if(w[i]==2)
		{
			j3++;
		}
		else if(w[i]==3)
		{
			j4++;
		}
		else if(w[i]==5)
		{
			j6++;
		}
	}
	
	if(j3==2&&j4!=2||j4==2||j3==2&&j4==1||j6==1)
	{
	   return TRUE;
	}

	return FALSE;
}
//
// 非连子禁手判断
// 返回TRUE为禁手
//
BOOL CRule::forbid2(int x, int y)
{   
	 //三三禁手
     if((m_data[x-1][y]==BLACK&&m_data[x-2][y]==BLACK&&m_data[x-3][y]==NONE&&m_data[x+1][y]==NONE
		 ||m_data[x+1][y]==BLACK&&m_data[x+2][y]==BLACK&&m_data[x+3][y]==NONE&&m_data[x-1][y]==NONE)
		 &&(m_data[x][y+1]==NONE&&m_data[x][y+2]==BLACK&&m_data[x][y+3]==BLACK&&m_data[x][y+4]==NONE&&m_data[x][y-1]==NONE)
		 ||m_data[x][y-1]==NONE&&m_data[x][y-2]==BLACK&&m_data[x][y-3]==BLACK&&m_data[x][y-4]==NONE&&m_data[x][y+1]==NONE)
	 {
		 return TRUE;
	 }
	 else if((m_data[x][y+1]==BLACK&&m_data[x][y+2]==BLACK&&m_data[x][y+3]==NONE&&m_data[x][y-1]==NONE
		      ||m_data[x][y-1]==BLACK&&m_data[x][y-2]==BLACK&&m_data[x][y-3]==NONE&&m_data[x][y+1]==NONE)
		 &&(m_data[x+1][y]==NONE&&m_data[x+2][y]==BLACK&&m_data[x+3][y]==BLACK&&m_data[x+4][y]==NONE&&m_data[x-1][y]==NONE
		     ||m_data[x-1][y]==NONE&&m_data[x-2][y]==BLACK&&m_data[x-3][y]==BLACK&&m_data[x+1][y]==NONE&&m_data[x-4][y]==NONE))
	 {
		 return TRUE;
	 }
	 else if((m_data[x-1][y-1]==BLACK&&m_data[x-2][y-2]==BLACK&&m_data[x-3][y-3]==NONE&&m_data[x+1][y+1]==NONE
		  ||m_data[x+1][y+1]==BLACK&&m_data[x+2][y+2]==BLACK&&m_data[x+3][y+3]==NONE&&m_data[x-1][y-1]==NONE)
		  &&(m_data[x+1][y-1]==NONE&&m_data[x+2][y-2]==BLACK&&m_data[x+3][y-3]==BLACK&&m_data[x+4][y-4]==NONE
		  ||m_data[x-1][y+1]==NONE&&m_data[x-2][y+2]==BLACK&&m_data[x-3][y+3]==BLACK&&m_data[x-4][y+4]==NONE))
	 {
		 return TRUE;
	 }
	 else if((m_data[x-1][y+1]==BLACK&&m_data[x-2][y+2]==BLACK&&m_data[x-3][y+3]==NONE&&m_data[x+1][y-1]==NONE
		  ||m_data[x+1][y-1]==BLACK&&m_data[x+2][y-2]==BLACK&&m_data[x+3][y-3]==NONE&&m_data[x-1][y+1]==NONE)
		  &&(m_data[x+1][y+1]==NONE&&m_data[x+2][y+2]==BLACK&&m_data[x+3][y+3]==BLACK&&m_data[x+4][y+4]==NONE
		  ||m_data[x-1][y-1]==NONE&&m_data[x-2][y-2]==BLACK&&m_data[x-3][y-3]==BLACK&&m_data[x-4][y-4]==NONE))
	 {
		 return TRUE;
	 }
	 //四四有界禁手
	 else if((m_data[x-1][y]==BLACK&&m_data[x-2][y]==NONE&&m_data[x-3][y]==BLACK&&m_data[x-4][y]==BLACK&&m_data[x-6][y]==NONE
		&&m_data[x-5][y]==0&&m_data[x+2][y]==BLACK&&m_data[x+3][y]==BLACK&&m_data[x+1][y]==NONE&&m_data[x+4][y]==0&&m_data[x+5][y]==NONE)
		 ||(m_data[x][y+1]==NONE&&m_data[x][y+2]==BLACK&&m_data[x][y+3]==BLACK&&m_data[x][y+4]==WHITE&&m_data[x][y+5]==NONE
		 &&m_data[x][y-1]==BLACK&&m_data[x][y-2]==NONE&&m_data[x][y-3]==BLACK&&m_data[x][y-4]==BLACK&&m_data[x][y-5]==WHITE&&m_data[x][y-6]==NONE)
		 ||(m_data[x][y+1]==BLACK&&m_data[x][y+2]==NONE&&m_data[x][y+3]==BLACK&&m_data[x][y+4]==BLACK&&m_data[x][y+5]==WHITE&&m_data[x][y+6]==NONE
		 &&m_data[x][y-1]==NONE&&m_data[x][y-2]==BLACK&&m_data[x][y-3]==BLACK&&m_data[x][y-4]==WHITE&&m_data[x][y-5]==WHITE)
		 ||(m_data[x][y+1]==NONE&&m_data[x][y+2]==BLACK&&m_data[x][y+3]==BLACK&&m_data[x][y+4]==WHITE&&m_data[x][y+5]==NONE
		 &&m_data[x][y-6]==NONE&&m_data[x][y-1]==BLACK&&m_data[x][y-2]==NONE&&m_data[x][y-3]==BLACK&&m_data[x][y-4]==BLACK&&m_data[x][y-5]==WHITE))
	 {
		 return TRUE;
	 }
	 //四四无界禁手
	 else if((m_data[x-1][y]==BLACK&&m_data[x-2][y]==NONE&&m_data[x-3][y]==BLACK&&m_data[x+1][y]==BLACK&&m_data[x+2][y]==NONE&&m_data[x+3][y]==BLACK)
	        ||(m_data[x][y+1]==BLACK&&m_data[x][y+2]==NONE&&m_data[x][y+3]==BLACK&&m_data[x][y-1]==BLACK&&m_data[x][y-2]==NONE&&m_data[x][y-3]==BLACK)
			||(m_data[x+1][y+1]==BLACK&&m_data[x+2][y+2]==NONE&&m_data[x+3][y+3]==BLACK&&m_data[x-1][y-1]==BLACK&&m_data[x-2][y-2]==NONE&&m_data[x-3][y-3]==BLACK)
		    ||(m_data[x-1][y+1]==BLACK&&m_data[x-2][y+2]==NONE&&m_data[x-3][y+3]==BLACK&&m_data[x+1][y-1]==BLACK&&m_data[x+2][y-2]==NONE&&m_data[x+3][y-3]==BLACK))
	 {
		 return TRUE;
	 }

	 return FALSE;
}

二、游戏中主对话框类的实现

游戏主对话框类主要有以下几个功能

创建游戏的主窗口以及框架

调用棋盘类对象来显示棋盘和接收鼠标输入

调用网络连接类对象创建，监听和连接网络通信

处理Windows的其他信息

接收用户的菜单输入，并弹出相应的对话框

该类继承于CDialog类，所以可以实现对话框的基本功能

// FiveChessDlg.h : header file
//

#if !defined(AFX_FIVECHESSDLG_H__E2C58E22_5D6D_4059_A0AF_CE86F297AF00__INCLUDED_)
#define AFX_FIVECHESSDLG_H__E2C58E22_5D6D_4059_A0AF_CE86F297AF00__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

/
// CFiveChessDlg dialog

#include "SetupDlg.h"
#include "Connect.h"
#include "ConnectData.h"
#include "Board.h"

class CFiveChessDlg : public CDialog
{
// Construction
public:
	void NewGameStart(BOOL isHost);
	void SetMenuState(BOOL bEnable);		//设置菜单状态
	void Accept();							//服务器端口申请连接成功时调用
	void Connect();							//客户机申请连接成功调用
	void Send(MSGSTRUCT * pmsg);			//发送数据
	void Restart();							//重新开始游戏

	CFiveChessDlg(CWnd* pParent = NULL);	// standard constructor

// Dialog Data
	//{{AFX_DATA(CFiveChessDlg)
	enum { IDD = IDD_FIVECHESS_DIALOG };
	CBoard    m_board;			//主棋盘对象
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CFiveChessDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
	//}}AFX_VIRTUAL

public:
	CConnect m_conncet;			//监听套接字
	CConnect m_sock;			//使用套接字
	BOOL     m_bIsConnect;		//连接标志
// Implementation
protected:
	HICON m_hIcon;				//图标对象
	CMenu m_main_menu;			//主菜单对象
	CSetupDlg m_setup_dlg;		//设置对话框对象

	// Generated message map functions
	//{{AFX_MSG(CFiveChessDlg)
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	afx_msg void OnUpdateNewGameMenu(CCmdUI* pCmdUI);
	afx_msg void OnUpdateExitGameMenu(CCmdUI* pCmdUI);
	afx_msg void OnUpdateDrawGameMenu(CCmdUI* pCmdUI);
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_FIVECHESSDLG_H__E2C58E22_5D6D_4059_A0AF_CE86F297AF00__INCLUDED_)

 

// FiveChessDlg.cpp : implementation file
//

#include "stdafx.h"
#include "FiveChess.h"
#include "FiveChessDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif




/
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/
// CFiveChessDlg dialog

CFiveChessDlg::CFiveChessDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CFiveChessDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CFiveChessDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CFiveChessDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CFiveChessDlg)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CFiveChessDlg, CDialog)
	//{{AFX_MSG_MAP(CFiveChessDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_UPDATE_COMMAND_UI(ID_NEW_GAME_MENU, OnUpdateNewGameMenu)
	ON_UPDATE_COMMAND_UI(ID_EXIT_GAME_MENU, OnUpdateExitGameMenu)
	ON_UPDATE_COMMAND_UI(ID_DRAW_GAME_MENU, OnUpdateDrawGameMenu)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/
// CFiveChessDlg message handlers

BOOL CFiveChessDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	m_main_menu.LoadMenu(IDR_MAIN_MENU);

	SetMenu(&m_main_menu);

	m_main_menu.EnableMenuItem(ID_DRAW_GAME_MENU, MF_GRAYED | MF_DISABLED);

	m_bIsConnect = FALSE;

    CRect rect(0, 0, 200, 200);
    m_board.CreateEx( WS_EX_CLIENTEDGE, _T("ChessBoard"), NULL, WS_VISIBLE | WS_BORDER | WS_CHILD,
        CRect( 0, 0, 401, 478 ), this, IDC_BOARD );
	//清空棋盘
	m_board.Clear( TRUE );

	GetDlgItem( IDC_BOARD )->SetFocus();
	
	return TRUE; 
}

void CFiveChessDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}


void CFiveChessDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

void CFiveChessDlg::Restart()
{
	m_conncet.Close();
	m_sock.Close();
}

HCURSOR CFiveChessDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CFiveChessDlg::OnUpdateNewGameMenu(CCmdUI* pCmdUI) 
{
	if(IDOK==m_setup_dlg.DoModal())
	{
		Restart();
		NewGameStart(m_setup_dlg.m_isHost);
	}
}

void CFiveChessDlg::OnUpdateExitGameMenu(CCmdUI* pCmdUI) 
{
	SetMenu(NULL);
	CDialog::OnCancel();
}

void CFiveChessDlg::OnUpdateDrawGameMenu(CCmdUI* pCmdUI) 
{
	if(m_bIsConnect)
	{
		m_board.DrawGame();
	}
}

void CFiveChessDlg::NewGameStart(BOOL isHost)
{
	if(isHost)
	{//当前选择的是主机
		m_conncet.Create(m_setup_dlg.m_net_port);	//建立端口对象
		m_conncet.Listen();							//监听
	}
	else
	{//当前选择的是客户机
		m_sock.Create();							//建立端口对象
													//建立连接
		m_sock.Connect(m_setup_dlg.m_strHostIP, m_setup_dlg.m_net_port);
	}
}

void CFiveChessDlg::Accept()
{
	//接受连接
	m_conncet.Accept(m_sock);
	//设置连接成功标志
	m_bIsConnect = TRUE;
	//设置当前棋子颜色
	m_board.SetColor(BLACK);
	m_board.Clear(FALSE);
	//弹出提示对话框
	MessageBox( _T("连接成功,可以开始游戏."), _T("五子棋"), MB_ICONINFORMATION);
}

void CFiveChessDlg::Connect()
{
	//设置连接成功标志
	m_bIsConnect = TRUE;
	//设置当前棋子颜色
	m_board.SetColor(WHITE);
	m_board.Clear(TRUE);
	//弹出提示对话框
	MessageBox( _T("连接成功,可以开始游戏."), _T("五子棋"), MB_ICONINFORMATION);
}

void CFiveChessDlg::Send(MSGSTRUCT * pmsg)
{
	m_sock.Send((LPVOID)pmsg, sizeof(MSGSTRUCT));
}

void CFiveChessDlg::SetMenuState(BOOL bEnable)
{
	UINT uEnable, uDisable;
    if ( bEnable )
    {
        uEnable = MF_ENABLED;
        uDisable = MF_GRAYED | MF_DISABLED;
    }
    else
    {
        uEnable = MF_GRAYED | MF_DISABLED;
        uDisable = MF_ENABLED;
    }
    
    m_main_menu.EnableMenuItem( ID_NEW_GAME_MENU, uEnable );
	m_main_menu.EnableMenuItem( ID_DRAW_GAME_MENU, uDisable );
}

效果展示如下

创作不易 觉得有帮助请点赞关注收藏~~~ 

C++五子棋m_data61amp游戏算法游戏程序

有关Visual C++实现五子棋游戏项目实战四：游戏规则与主对话框类实现（附源码和资源 超详细）的更多相关文章

  1. ruby - 如何根据特征实现 FactoryGirl 的条件行为 - 2

    我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden

  2. ruby - 安装 Ruby 时遇到问题(无法下载资源 "readline--patch") - 2

    当我尝试安装Ruby时遇到此错误。我试过查看this和this但无济于事➜~brewinstallrubyWarning:YouareusingOSX10.12.Wedonotprovidesupportforthispre-releaseversion.Youmayencounterbuildfailuresorotherbreakages.Pleasecreatepull-requestsinsteadoffilingissues.==>Installingdependenciesforruby:readline,libyaml,makedepend==>Installingrub

  3. ruby-on-rails - Rails 3，嵌套资源，没有路由匹配 [PUT] - 2

    我真的为这个而疯狂。我一直在搜索答案并尝试我找到的所有内容，包括相关问题和stackoverflow上的答案，但仍然无法正常工作。我正在使用嵌套资源，但无法使表单正常工作。我总是遇到错误，例如没有路线匹配[PUT]"/galleries/1/photos"表格在这里:/galleries/1/photos/1/edit路线.rbresources:galleriesdoresources:photosendresources:galleriesresources:photos照片Controller.rbdefnew@gallery=Gallery.find(params[:galle

  4. 华为OD机试用Python实现 -【明明的随机数】 2023Q1A - 2

    华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o

  5. 基于C#实现简易绘图工具【100010177】 - 2

    C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.

  6. MIMO-OFDM无线通信技术及MATLAB实现（1）无线信道：传播和衰落 - 2

     MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO

  7. 在VMware16虚拟机安装Ubuntu详细教程 - 2

    在VMware16.2.4安装Ubuntu一、安装VMware1.打开VMwareWorkstationPro官网，点击即可进入。2.进入后向下滑动找到Workstation16ProforWindows，点击立即下载。3.下载完成，文件大小615MB，如下图：4.鼠标右击，以管理员身份运行。5.点击下一步6.勾选条款，点击下一步7.先勾选，再点击下一步8.去掉勾选，点击下一步9.点击下一步10.点击安装11.点击许可证12.在百度上搜索VM16许可证，复制填入，然后点击输入即可，亲测有效。13.点击完成14.重启系统，点击是15.双击VMwareWorkstationPro图标，进入虚拟机主

  8. 微信小程序开发入门与实战（Behaviors使用） - 2

    @作者:SYFStrive @博客首页:HomePage📜：微信小程序📌：个人社区（欢迎大佬们加入）👉：社区链接🔗📌：觉得文章不错可以点点关注👉：专栏连接🔗💃：感谢支持,学累了可以先看小段由小胖给大家带来的街舞👉微信小程序（🔥）目录自定义组件-behaviors    1、什么是behaviors    2、behaviors的工作方式    3、创建behavior    4、导入并使用behavior    5、behavior中所有可用的节点    6、同名字段的覆盖和组合规则总结最后自定义组件-behaviors    1、什么是behaviorsbehaviors是小程序中，用于实现

  9. 【Java入门】使用Java实现文件夹的遍历 - 2

    遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg

  10. ruby - Arrays Sets 和 SortedSets 在 Ruby 中是如何实现的 - 2

    通常，数组被实现为内存块，集合被实现为HashMap，有序集合被实现为跳跃列表。在Ruby中也是如此吗？我正在尝试从性能和内存占用方面评估Ruby中不同容器的使用情况 最佳答案 数组是Ruby核心库的一部分。每个Ruby实现都有自己的数组实现。Ruby语言规范只规定了Ruby数组的行为，并没有规定任何特定的实现策略。它甚至没有指定任何会强制或至少建议特定实现策略的性能约束。然而，大多数Rubyist对数组的性能特征有一些期望，这会迫使不符合它们的实现变得默默无闻，因为实际上没有人会使用它:插入、前置或追加以及删除元素的最坏情况步骤复

随机推荐