win32象棋

于 2020-01-16 19:52:08 发布
阅读量259 收藏 1
点赞数
分类专栏： win32 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangdaochao/article/details/104010256
版权

这里只用了少数简单的gdi画图，来展示一下最近几个月学习win32的成果吧。。
在这里插入图片描述
下面展示代码，有哪里需要修改的可以指出来。

#include <windows.h>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <cmath>

#define BLACK_PLAYER 	0
#define RED_PLAYER 		1

struct Point {
	long x, y;
	Point(long i=0,long j=0):x{i}, y{j} {}
	bool operator==(const Point& p) const {return x==p.x && y==p.y;}
	bool operator!=(const Point& p) const {return !(*this==p);}
	bool operator<=(const Point& p) const {return x<=p.x && y<=p.y;}
	bool operator>=(const Point& p) const {return x>=p.x && y>=p.y;}
};

struct Color {
	static COLORREF black;
	static COLORREF red;
};
COLORREF Color::black = RGB(0,0,0);
COLORREF Color::red = RGB(255,0,0);

struct ChessMan {

	Point pt;	//棋盘数组对应位置，并不是中心位置 
	int size;
	std::string name;
	COLORREF color;
	bool isKill = false;
	bool isFoucs = false;
	
	ChessMan(const Point& p,const std::string& n,COLORREF col,int sz=25): pt{p}, name{n}, color{col}, size{sz} {}
	
	bool operator==(const ChessMan& cm) const {return pt==cm.pt && name==cm.name && color==cm.color;}
	
	Point getCenterPos(int rowLength,int colLength) const;
	int getChessPlayer() const {return color==Color::black ? BLACK_PLAYER : RED_PLAYER;}
	bool isAllow(std::vector<ChessMan>& vec, std::map<std::string,int>& paraMap, const Point& p, bool isChessMan=false) const;
	
	private:
		bool isAllowForCannon(std::vector<ChessMan>& vec, const Point& p,bool isChessMan) const;
		bool isAllowForSoldier(const Point& p) const;
		bool isAllowForVehicle(std::vector<ChessMan>& vec, const Point& p) const;
		bool isAllowForHorse(std::vector<ChessMan>& vec, const Point& p) const;
		bool isAllowForElephant(std::vector<ChessMan>& vec, const Point& p) const;
		bool isAllowForBodyGuad(const Point& p) const;
		bool isAllowForGeneral(const Point& p) const;
 		int getCountForTwoChessMan(std::vector<ChessMan>& vec,const Point& p) const;	//获取两个棋子之间有多少个棋子 
};
//辅助函数
bool isInChess(std::vector<ChessMan>& vec,const Point& p) 
{
	for(auto cm : vec)
	{
		if (cm.isKill) continue;
		if (cm.pt == p)
			return true;
	}
	return false;
}

Point ChessMan::getCenterPos(int rowLength,int colLength) const
{
	return {25+pt.x*colLength, 25+pt.y*rowLength};
}

int ChessMan::getCountForTwoChessMan(std::vector<ChessMan>& vec,const Point& p) const
{
	int cnt = 0;
	if (pt.x == p.x)	//同在垂直方向 
	{
		for(auto cm : vec)
		{
			if (cm.pt.x == pt.x)
				if (cm.pt.y>std::min(pt.y,p.y) && cm.pt.y<std::max(pt.y,p.y))
					cnt++;
		}
	} else if (pt.y == p.y) {	//同在水平方向 
		for(auto cm : vec)
		{
			if (cm.pt.y == pt.y)
				if (cm.pt.x>std::min(pt.x,p.x) && cm.pt.x<std::max(pt.x,p.x))
					cnt++;
		}
	}
	return cnt;
}
//炮 
bool ChessMan::isAllowForCannon(std::vector<ChessMan>& vec,const Point& p,bool isChessMan) const
{
	bool bResult = true;
	if (pt.x!=p.x && pt.y!=p.y)		//必须水平或垂直在一条线上 
		bResult = false;
	if (!isChessMan) {					//没有棋子，则中间不能有别的棋子
		if (getCountForTwoChessMan(vec, p) > 0) bResult = false;
	} else {
		if (getCountForTwoChessMan(vec, p) != 1) bResult = false;	//中间只能有一个棋子 
	}
	return bResult;
}
//兵
bool ChessMan::isAllowForSoldier(const Point& p) const 
{
	bool bResult = true;
	if ((name == "兵" && p.y > pt.y) || (name == "卒" && p.y<pt.y))		//不能倒走 
		bResult = false;
	if (std::abs(pt.x-p.x) !=1 && std::abs(pt.y-p.y) !=1) bResult = false;
	//如果没有过河只能往前走
	if (name == "兵" && pt.y>4 && pt.x!=p.x) 	bResult = false;
	if (name == "卒" && pt.y<5 && pt.x!=p.x)	bResult = false;
	return bResult;
}
//车
bool ChessMan::isAllowForVehicle(std::vector<ChessMan>& vec, const Point& p) const
{
	bool bResult = true;
	if (pt.x!=p.x && pt.y!=p.y)		//必须水平或垂直在一条线上 
		bResult = false;
	if (getCountForTwoChessMan(vec, p) > 0) bResult = false;	//中间不能有别的棋子
	return bResult;
}
//马
bool ChessMan::isAllowForHorse(std::vector<ChessMan>& vec, const Point& p) const
{
	bool bResult = true;
	if (pow(std::abs(pt.x-p.x),2) + pow(std::abs(pt.y-p.y),2) !=5)  bResult = false;	//如果不是日
	//是否憋马腿
	if (p.x > pt.x)
	{
		if (p.y < pt.y)
		{
			if (pt.y-p.y == 2 && isInChess(vec, {pt.x,pt.y-1})) bResult = false;
			if (pt.y-p.y == 1 && isInChess(vec, {pt.x+1,pt.y}))	bResult = false;
		} else {
			if (p.y-pt.y == 2 && isInChess(vec, {pt.x,pt.y+1})) bResult = false;
			if (p.y-pt.y == 1 && isInChess(vec, {pt.x+1,pt.y}))	bResult = false;
		}
	} else {
		if (p.y < pt.y)
		{
			if (pt.y-p.y == 2 && isInChess(vec, {pt.x,pt.y-1})) bResult = false;
			if (pt.y-p.y == 1 && isInChess(vec, {pt.x-1,pt.y}))	bResult = false;
		} else {
			if (p.y-pt.y == 2 && isInChess(vec, {pt.x,pt.y+1})) bResult = false;
			if (p.y-pt.y == 1 && isInChess(vec, {pt.x-1,pt.y}))	bResult = false;
		}
	}
	return bResult;
}
//象
bool ChessMan::isAllowForElephant(std::vector<ChessMan>& vec, const Point& p) const
{
	bool bResult = true;
	if (std::abs(pt.x-p.x)!=2 || std::abs(pt.y-p.y)!=2) bResult = false;	//如果不为田
	if ((name=="象" && p.y>4) || (name=="相" && p.y<5)) bResult = false;		//不能过河
	//是否憋象腿
	if (p.x > pt.x)
	{
		if (p.y < pt.y && isInChess(vec, {pt.x+1,pt.y-1})) bResult = false;
		if (p.y > pt.y && isInChess(vec, {pt.x+1,pt.y+1})) bResult = false;
	} else {
		if (p.y < pt.y && isInChess(vec, {pt.x-1,pt.y-1})) bResult = false;
		if (p.y > pt.y && isInChess(vec, {pt.x-1,pt.y+1})) bResult = false;
	}
	return bResult;
}
//士
bool ChessMan::isAllowForBodyGuad(const Point& p) const
{
	bool bResult = true;
	if (std::abs(pt.x-p.x)!=1 || std::abs(pt.y-p.y)!=1) bResult = false;
	//是否在田字格内
	if (color == Color::black)
	{
		if (p.x<3 || p.x>5 || p.y<0 || p.y>2) bResult = false;
	} else {
		if (p.x<3 || p.x>5 || p.y<7 || p.y>9) bResult = false;
	}
	return bResult;
}
//将
bool ChessMan::isAllowForGeneral(const Point& p) const
{
	bool bResult = true;
	if (pt.x!=p.x && pt.y!=p.y)	bResult = false;	//必须水平或垂直在一条线上
	if (std::abs(pt.x-p.x) + std::abs(pt.y-p.y) !=1) bResult = false;	//相隔为1
	//是否在田字格内
	if (color == Color::black)
	{
		if (p.x<3 || p.x>5 || p.y<0 || p.y>2) bResult = false;
	} else {
		if (p.x<3 || p.x>5 || p.y<7 || p.y>9) bResult = false;
	}
	return bResult;
} 

bool ChessMan::isAllow(std::vector<ChessMan>& vec, std::map<std::string,int>& paraMap, const Point& p, bool isChessMan) const
{
	if (pt == p)	//目标棋子为源棋子 
		return false;
	if (name == "炮")
		return isAllowForCannon(vec, p, isChessMan);
	else if (name == "兵" || name == "卒")
		return isAllowForSoldier(p);
	else if (name == "车")
		return isAllowForVehicle(vec, p);
	else if (name == "马")
		return isAllowForHorse(vec, p);
	else if (name == "象" || name == "相")
		return isAllowForElephant(vec, p);
	else if (name == "士")
		return isAllowForBodyGuad(p);
	else if (name == "将" || name == "帅")
		return isAllowForGeneral(p);
}

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow)
{
	static TCHAR szAppName[] = TEXT("Chess");
	HWND hwnd;
	MSG msg;
	WNDCLASS wndclass;
	
	wndclass.style = CS_HREDRAW | CS_VREDRAW;
	wndclass.lpfnWndProc = WndProc;
	wndclass.cbClsExtra = 0;
	wndclass.cbWndExtra = 0;
	wndclass.hInstance = hInstance;
	wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
	wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
	wndclass.lpszMenuName = NULL;
	wndclass.lpszClassName = szAppName;
	
	if (!RegisterClass(&wndclass))
	{
		MessageBox(NULL, TEXT("This program requires windows NT!"), szAppName, MB_ICONERROR);
		return 0;
	}
	hwnd = CreateWindow(
		szAppName, TEXT("Chess"),
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT,
		850, 950,
		NULL, NULL, hInstance, NULL
	);
	ShowWindow(hwnd, iCmdShow);
	UpdateWindow(hwnd);
	while (GetMessage(&msg,NULL,0,0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return msg.wParam;
}

HFONT GetFont(HDC hdc,LPCTSTR face,int width,int height,int angle)
{
	HFONT hFont;
	hFont = CreateFont(height, width, angle, 0, FW_REGULAR, FALSE, FALSE, FALSE, GB2312_CHARSET,
					OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY, FIXED_PITCH|FF_MODERN, face);
	return hFont; 
}

void DrawChessBoard(HDC hdc,std::map<std::string,int>& paraMap)
{
	int i;
	RECT blackRect, redRect;
	HFONT hPrevFont, hFont;
	POINT pt[8];
	HPEN hPrevPen, hPen;
	std::vector<POINT> vec;
	int iChessXStart = paraMap["iChessXStart"];
	int iChessXEnd = paraMap["iChessXEnd"];
	int iChessYStart = paraMap["iChessYStart"];
	int iChessYEnd = paraMap["iChessYEnd"];
	int iRow = paraMap["iRow"];
	int iCol = paraMap["iCol"];
	
	for(i=0; i<=9; i++)
	{
		MoveToEx(hdc, iChessXStart, iChessYStart+i*iRow, NULL);
		LineTo(hdc, iChessXEnd, iChessYStart+i*iRow);
	}
	for(i=0; i<=8; i++)
	{
		MoveToEx(hdc, iChessXStart+i*iCol, iChessYStart, NULL);
		LineTo(hdc, iChessXStart+i*iCol, iChessYEnd);
		if (i!=0 && i!=8)
		{
			vec.push_back({iChessXStart+i*iCol, iChessYStart+4*iRow});
			vec.push_back({iChessXStart+i*iCol, iChessYStart+5*iRow});
		}
	}
	
	pt[0] = {iChessXStart+3*iCol, iChessYStart};
	pt[1] = {iChessXStart+5*iCol, iChessYStart+2*iRow};
	pt[2] = {iChessXStart+5*iCol, iChessYStart};
	pt[3] = {iChessXStart+3*iCol, iChessYStart+2*iRow};
	pt[4] = {iChessXStart+3*iCol, iChessYStart+7*iRow};
	pt[5] = {iChessXStart+5*iCol, iChessYStart+9*iRow};
	pt[6] = {iChessXStart+5*iCol, iChessYStart+7*iRow};
	pt[7] = {iChessXStart+3*iCol, iChessYStart+9*iRow};
	for(i=0; i<8; i+=2)
		Polyline(hdc, pt+i, 2);
	
	hPrevPen = (HPEN)SelectObject(hdc, GetStockObject(WHITE_PEN));
	for(i=0; i<vec.size(); i+=2)
	{
		MoveToEx(hdc, vec[i].x, vec[i].y, NULL);
		LineTo(hdc, vec[i+1].x, vec[i+1].y);
	}
	SelectObject(hdc, hPrevPen);
	
	hFont = GetFont(hdc, TEXT("楷体"), 30, 30, 0);
	hPrevFont = (HFONT)SelectObject(hdc, hFont);
	SetRect(&blackRect, iChessXStart+0*iCol, iChessYStart+4*iRow, iChessXStart+4*iCol, iChessYStart+5*iRow);
	SetRect(&redRect, iChessXStart+4*iCol, iChessYStart+4*iRow, iChessXStart+8*iCol, iChessYStart+5*iRow);
	SetTextColor(hdc, Color::black);
	DrawText(hdc, TEXT("楚河"), -1, &blackRect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
	SetTextColor(hdc, Color::red);
	DrawText(hdc, TEXT("汉界"), -1, &redRect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
	SelectObject(hdc, hPrevFont);
	DeleteObject(hFont);	//删除GDI对象 
}

void DrawSingleChessMan(HDC hdc,const ChessMan& cm,std::map<std::string,int>& paraMap)
{
	RECT rect;
	
	HFONT hPrevFont, hFont;
	HBRUSH hPrevBrush, hBrush;
	HPEN hPrevPen, hPen;
	int focusSize = cm.size-5;
	
	if (cm.isKill) return;
	
	hBrush = CreateSolidBrush(RGB(239,215,189));
	hFont = GetFont(hdc, TEXT("微软雅黑"), 10, 20, 0);
	SetBkColor(hdc, RGB(239,215,189));
	hPrevBrush = (HBRUSH)SelectObject(hdc, hBrush);
	hPrevFont = (HFONT)SelectObject(hdc, hFont);
	SetTextColor(hdc, cm.color);
	Point center = cm.getCenterPos(paraMap["iRow"], paraMap["iCol"]);
	Ellipse(hdc, center.x-cm.size, center.y-cm.size, center.x+cm.size, center.y+cm.size);
	if (cm.isFoucs)
	{
		hPen = CreatePen(PS_SOLID, 1, cm.color);
		hPrevPen = (HPEN)SelectObject(hdc, hPen);
		Ellipse(hdc, center.x-focusSize, center.y-focusSize, center.x+focusSize, center.y+focusSize);
		SelectObject(hdc, hPrevPen);
		DeleteObject(hPen);
	}
	SetRect(&rect, center.x-cm.size, center.y-cm.size, center.x+cm.size, center.y+cm.size);
	DrawText(hdc, TEXT(cm.name.c_str()), -1, &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	
	SelectObject(hdc, hPrevBrush);
	SelectObject(hdc, hPrevFont);
	DeleteObject(hBrush);	//删除GDI对象
	DeleteObject(hFont);
}

void DrawChessMan(HDC hdc,std::map<std::string,int>& paraMap,std::vector<ChessMan>& vec)
{
	for(int i=0; i<vec.size(); i++)
		DrawSingleChessMan(hdc, vec[i], paraMap);
}

void DrawChess(HDC hdc,std::map<std::string,int>& paraMap,std::vector<ChessMan>& vec)
{
	DrawChessBoard(hdc, paraMap);
	DrawChessMan(hdc, paraMap, vec);
}

int getChessManByPos(std::vector<ChessMan>& vec, const Point& pt, std::map<std::string,int>& paraMap)
{
	for(int i=0; i<vec.size(); i++)
	{
		if (vec[i].isKill)
			continue;
		Point center = vec[i].getCenterPos(paraMap["iRow"], paraMap["iCol"]);
		Point leftTop{center.x-vec[i].size, center.y-vec[i].size};
		Point rightBottom{center.x+vec[i].size, center.y+vec[i].size};
		if (pt>=leftTop && pt<=rightBottom)
			return i;
	}
	return -1;
}

void fillParam(std::map<std::string,int>& paraMap,int cxClient,int cyClient)
{
	int iChessXStart = 25;
	int iChessXEnd = cxClient - 25;
	int iChessYStart = 25;
	int iChessYEnd = cyClient - 25;
	int iRow = (iChessYEnd-iChessYStart) / 9;
	int iCol = (iChessXEnd-iChessXStart) / 8;
	
	paraMap["iChessXStart"] = iChessXStart;
	paraMap["iChessXEnd"] = iChessXEnd;
	paraMap["iChessYStart"] = iChessYStart;
	paraMap["iChessYEnd"] = iChessYEnd;
	paraMap["iRow"] = iRow;
	paraMap["iCol"] = iCol;
	paraMap["cxClient"] = cxClient;
	paraMap["cyClient"] = cyClient;
}

Point getChessManPos(std::map<std::string,int>& paraMap,const Point& pt)
{
	int x = (pt.x-paraMap["iChessXStart"])/paraMap["iCol"];
	int y = (pt.y-paraMap["iChessYStart"])/paraMap["iRow"];
	Point leftTop{paraMap["iChessXStart"]+x*paraMap["iCol"], paraMap["iChessYStart"]+y*paraMap["iRow"]};
	Point rightTop{paraMap["iChessXStart"]+(x+1)*paraMap["iCol"], paraMap["iChessYStart"]+y*paraMap["iRow"]};
	Point leftBottom{paraMap["iChessXStart"] + x*paraMap["iCol"], paraMap["iChessYStart"] + (y+1)*paraMap["iRow"]};
	Point rightBottom{paraMap["iChessXStart"]+(x+1)*paraMap["iCol"], paraMap["iChessYStart"]+(y+1)*paraMap["iRow"]};
	
	if (pt.x>=leftTop.x && pt.x<=leftTop.x+25 && pt.y>=leftTop.y && pt.y<=leftTop.y+25)
		return {x, y};
	else if (pt.x>=rightTop.x-25 && pt.x<=rightTop.x && pt.y>=rightTop.y && pt.y<=rightTop.y+25)
		return {x+1, y};
	else if (pt.x>=leftBottom.x && pt.x<=leftBottom.x+25 && pt.y>=leftBottom.y-25 && pt.y<=leftBottom.y)
		return {x, y+1};
	else if (pt.x>=rightBottom.x-25 && pt.x<=rightBottom.x && pt.y>=rightBottom.y-25 && pt.y<=rightBottom.y)
		return {x+1, y+1};
	else
		return {-1,-1};
}

std::vector<ChessMan> getChessMen()
{
	return std::vector<ChessMan> {
			{{0,0},"车",Color::black}, {{1,0},"马",Color::black}, {{2,0},"象",Color::black}, {{3,0},"士",Color::black},
			{{8,0},"车",Color::black}, {{7,0},"马",Color::black}, {{6,0},"象",Color::black}, {{5,0},"士",Color::black},
			{{4,0},"将",Color::black},
			{{1,2},"炮",Color::black}, {{7,2},"炮",Color::black},
			{{0,3},"卒",Color::black}, {{2,3},"卒",Color::black}, {{4,3},"卒",Color::black},
			{{6,3},"卒",Color::black}, {{8,3},"卒",Color::black},
			
			{{0,9},"车",Color::red}, {{1,9},"马",Color::red}, {{2,9},"相",Color::red}, {{3,9},"士",Color::red},
			{{8,9},"车",Color::red}, {{7,9},"马",Color::red}, {{6,9},"相",Color::red}, {{5,9},"士",Color::red},
			{{4,9},"帅",Color::red},
			{{1,7},"炮",Color::red}, {{7,7},"炮",Color::red},
			{{0,6},"兵",Color::red}, {{2,6},"兵",Color::red}, {{4,6},"兵",Color::red},
			{{6,6},"兵",Color::red}, {{8,6},"兵",Color::red}
		};
}

LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	static int currentChessPlayer = RED_PLAYER;
	static int cxClient, cyClient, idFoucs=-1;
	static std::map<std::string,int> paraMap;
	static std::vector<ChessMan> vec{getChessMen()};
	int iChessXStart, iChessXEnd, iChessYStart, iChessYEnd, iRow, iCol;
	HDC hdc;
	PAINTSTRUCT ps;
	TEXTMETRIC tm;
	RECT rect;
	int i, currentId;
	Point pt;
	
	switch (message)
	{
		case WM_CREATE:
			hdc = GetDC(hwnd);
			GetClientRect(hwnd, &rect);
			cxClient = rect.right - rect.left;
			cyClient = rect.bottom - rect.top;
			ReleaseDC(hwnd, hdc);
			fillParam(paraMap, cxClient, cyClient);
			return 0;
		case WM_SIZE:
			cxClient = LOWORD(lParam);
			cyClient = HIWORD(lParam);
			fillParam(paraMap, cxClient, cyClient);
			return 0;
		case WM_LBUTTONDOWN:
			pt.x = LOWORD(lParam);
			pt.y = HIWORD(lParam);

			if (idFoucs != -1)	//已选中棋子 
			{
				currentId = getChessManByPos(vec, pt, paraMap);
				if (currentId == -1) {								//空白地方 
					pt = getChessManPos(paraMap, pt);
					if (pt == Point{-1,-1})
						MessageBeep(0);
					else {
						if (vec[idFoucs].isAllow(vec,paraMap,pt))
						{
							vec[idFoucs].pt = pt;
							currentChessPlayer ^= 1;
						} else
							MessageBeep(0);
						vec[idFoucs].isFoucs = false;
						idFoucs = -1;
					}
				} else {
					if (vec[idFoucs].color == vec[currentId].color)	//己方 
					{
						if (idFoucs == currentId)
						{
							vec[idFoucs].isFoucs = false;
							idFoucs = -1;
						}
						else
							MessageBeep(0);
					}
					else {											//对方
						if (vec[idFoucs].isAllow(vec,paraMap,vec[currentId].pt,true))
						{
							vec[currentId].isKill = true;
							vec[idFoucs].pt = vec[currentId].pt;
							currentChessPlayer ^= 1;
							if (vec[currentId].name == "将" || vec[currentId].name == "帅")
							{
								InvalidateRect(hwnd, NULL, TRUE);
								MessageBeep(0);
								if (vec[idFoucs].color == Color::red)
									MessageBox(hwnd, TEXT("红方获胜!"), TEXT("结果"), MB_OK);
								else 
									MessageBox(hwnd, TEXT("黑方获胜!"), TEXT("结果"), MB_OK);
								//复原棋盘
								vec = getChessMen();
							}
						} else 
							MessageBeep(0);
						vec[idFoucs].isFoucs = false;
						idFoucs = -1;
					}
				}
			} else {	
				currentId = getChessManByPos(vec, pt, paraMap);
				if (currentId == -1)
					MessageBeep(0);
				else {
					if (vec[currentId].getChessPlayer() == currentChessPlayer)
					{
						idFoucs = currentId;
						vec[idFoucs].isFoucs = true;
					} else 
						MessageBeep(0);
				}
			}
			InvalidateRect(hwnd, NULL, TRUE);
			return 0;
		case WM_PAINT:
			hdc = BeginPaint(hwnd, &ps);
			DrawChess(hdc, paraMap, vec);
			EndPaint(hwnd, &ps);
			return 0;
		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;
	}
	return DefWindowProc(hwnd,message,wParam,lParam);
}
明天过后mm
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于win32的象棋游戏
04-17
不能联网，也不能与电脑对战，只完成了象棋的基本规则及图像显示。
[源码和文档分享]基于Win32 API实现的中国象棋游戏
qq_38474647的博客
04-06 173
一、选题 在《实践：程序设计实践》中选中了“中国象棋”为最后作业的题目。 中国象棋是一种交互性的、在固定大小的棋盘上进行的游戏，具有一定的规则来约束棋子的行走规律，同时行走的规律会随着时间和位置的不同而进行变化。 该题目的难点并不在图像界面的绘制，最难的地方在于对棋子行走规律的判断和棋子规则的约束条件。设计的功能特性就是利用每次对鼠...
WIN32 SDK版本的象棋游戏源代码 - 作者:thecct
02-23
WIN32 SDK版本的象棋游戏源代码 - 作者:thecct
黑白棋（win32实现）
08-06
以黑白棋为例，做的一个win32的小游戏。 压缩包里是详细代码，项目是vs2010的，其他IDE请自行创建项目然后添加源文件。 详细介绍可以参考我的博客：http://blog.csdn.net/zilaishuichina/article/details/38235313 注：代码仅供学习交流使用，请勿用于其他用途。
WIN32 SDK版本的象棋游戏源代码
09-13
WIN32 SDK版本的象棋游戏源代码
win32 象棋源码非mfc
08-24
【标题】"win32 象棋源码非mfc"所指的是一份使用Windows API编写，而非Microsoft Foundation Class (MFC)库的Windows象棋程序的源代码。MFC是微软提供的一套C++类库，用于简化Windows应用程序开发，而此源码选择不...
SourceCode_Engine.rar_win32_中国象棋
07-14
该项目系在Visual Studio.net 2003下所建的Win32控制台项目（使用其它版本的编译器只需新建一个Win32控制台项目，然后逐一加入所有的.cpp文件和.h文件即可），其目的只是简单地测试引擎。因而该程序不提供用户着法的...
象棋win32源代码
12-22
《象棋win32源代码解析与探讨》 在计算机编程领域，开发一款象棋程序不仅可以展示编程技术，还能深入理解人工智能和游戏策略。本文将围绕“象棋win32源代码”这一主题，深入剖析其中的核心技术，包括C++语言的应用...
chess网络双人对战版win国际象棋
最新发布
06-04
"chess网络双人对战版win"是一款专为Windows操作系统设计的国际象棋软件，让玩家可以在互联网上与全世界的爱好者进行实时对弈。 该软件的核心功能是提供网络对战平台，让两个玩家通过互联网连接，无论相隔多远，都...
中国象棋源代码以及设计思路
10-20
毕业设计，中国象棋源代码以及设计思路，学习编程绝佳资料
纯C++中国象棋控制台程序（学习版）
C++ 爱好者 make_it_simple888
03-25 6547
适合人群： 这个游戏适合初学C++语言，不想了解MFC的同学。 界面： 用数字表示棋子和棋盘 跨平台： 也可以在Linux下面运行，可以作为一个C++中国象棋的游戏引擎。 走棋： 通过写程序走棋，例如 #include "../chess_lib/chessbase.h" #include "../chess_lib/chessplay.h" #include using na
无图片纯css实现中国象棋棋子
鞠培中的专栏
02-14 1712
纯当锻炼前端编程能力了，效果还不错。纯用css不用图片的好处就是加载迅速。代码如下： .pieces{ width:84px; height:84px; border-radius:50px; border:rgb(78,56,23) double 8px; background-color:rgb(192,149,106); margin:auto;text-align:ce
中国象棋程序的设计与实现(十二)--棋盘绘制算法(尽管注释非常详细,完全理解仍有难度) 中国象棋程序的设计与实现(八)-如何构造一个棋子(車馬炮等) 中国象棋程序的设计与实现(九)–...
放眼长期，稳中求进；知行合一，日拱一卒
10-26 456
上几篇中，我们详细介绍了，棋盘类的定义和关键属性，简要介绍了棋盘绘制算法的骨架。 本篇，我们将详细解读棋盘绘制算法的每一个细节。 强烈建议，大家结合文章末尾的“棋盘截图”来思考绘制算法细节，不然，很可能会遇到问题。 有些绘制细节，很难懂，不好描述，不再详细叙述。 1.绘制算法骨架 /** * 绘制棋盘 * &lt;P&gt; * 绘制棋盘背景 *...
【C++】C++下的简易中国象棋
Shaw的博客
04-15 7181
大作业——中国象棋（C++） 参考自Originum学长的博客，个人进行了一些小修改， 原博客地址：https://blog.csdn.net/Originum/article/details/80356452 联系邮箱：Originum@126.com 一个简单的中国象棋游戏，主要实现： 1、两人对弈； 2、简单的棋子移动以及规则判断，不符合规则便重走； 3、有一方获胜便结束游戏。 一、类的设计...
中国象棋软件-引擎实现（一）概述
laoxing643的博客
02-20 5120
程序的基本框架：从程序的结构上讲，大体上可以将本程序划分为四大部分：棋局表示、 着法生成、 搜索算法、 局面评估程序的大概的思想是：首先使用一个数据结构来描述棋局信息，对某一特定的棋局信息由着法生成器生成当前下棋方所有合法的着法并依次存入着法队列。然后通过搜索算法来逐一读取着法并调用局面评估函数对该着法所产生的后继局面进行评估打分，从中选出一个最有可能导致走棋方取胜的着法。在搜索的过程中还可以采用...
windows编程（Qt）实现中国象棋——人机对战，网络对战
去流浪
06-25 2192
1. 本程序包含AI思想，具有判断决策功能，但不具有学习功能2. 本程序借鉴已有程序学习摸索，代码并非完全由我本人自己写出的3. 本程序实现了：人机对战，网络对战功能#ifndef STONE_H #define STONE_H /* **棋子头文件 */ #include &lt;QRect&gt; #include &lt;QPainter&gt; //绘制头函数 class St...
win32象棋代码大概多少行
05-15
Win32象棋代码的行数取决于具体实现的复杂程度和功能，因为涉及到图形界面的绘制、鼠标操作、游戏规则、AI算法等不同的方面。一般而言，一个比较简单的Win32象棋游戏可能会有数千行代码，而一个更加复杂、完善的版本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值