中国象棋--基于EasyX实现图形化

最新推荐文章于 2024-06-18 18:00:49 发布
最新推荐文章于 2024-06-18 18:00:49 发布
阅读量1.2k 收藏 35
点赞数 10
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49146132/article/details/126314234
版权

最近学习EasyX，在发现[PE]经典八炮的发布的一个中国象棋算法部分的代码后，于是尝试使用EasyX实现图形化。

另外一点小提示：如果想要实现本代码，需要安装EasyX，安装方法自行百度。

算法部分代码来自：C++实现双人中国象棋（一）——算法篇（附完整代码）_[PE]经典八炮的博客-CSDN博客_c++象棋代码s​​​​​​​z最近突发奇想，要使用C++做一个双人象棋的程序，昨天肝了一天，终于把算法部分完成了，下面把开发过程中的经验分享一下。知识要求：熟练掌握C++语言面向对象编程的知识（继承，多态）掌握STL的基本操作了解中国象棋基本规则（不会还有人不知道中国象棋规则吧！）..................https://blog.csdn.net/qq_54121864/article/details/125652386?spm=1001.2014.3001.5502直接贴源码吧：

#include<string>
#include<list>
#include<string>
#include<algorithm>

using namespace std;

const bool BLACK_CHESS = 0, RED_CHESS = 1;
const uint8_t DRAW = 2, NONE = 3;

class Point {
public:
	int8_t x, y;

	Point(int8_t nx, int8_t ny) {
		this->x = nx;
		this->y = ny;
	}
	bool ColorOfTheArea() const {
		if (y <= 4) {
			return RED_CHESS;
		}
		return BLACK_CHESS;
	}
	bool IsInNinePalaces()const {
		return x >= 3 && x <= 5 && (y <= 2 || y >= 7);
	}
};

bool operator==(const Point& a, const Point& b) {
	return a.x == b.x && a.y == b.y;
}

class ChessBoard {
private:
	friend class ChessPiece;
	ChessPiece* board[10][9];
	list<ChessPiece*> red, black;
public:
	ChessBoard();
	const list<ChessPiece*>& GetRedPieces() const {
		return red;
	}
	const list<ChessPiece*>& GetBlackPieces() const {
		return black;
	}
	ChessPiece*& GetChess(const Point& point) {
		return board[point.y][point.x];
	}
	ChessPiece* const& GetChess(const Point& point) const {
		return board[point.y][point.x];
	}
	void RemoveChess(const Point& point);
	bool KingsFaceToFace() const;
	~ChessBoard();
};

class ChessPiece {
protected:
	Point pt;
	ChessBoard& board;
public:
	const bool cl;
	ChessPiece(const Point& point, bool color, ChessBoard& chessboard) :pt(point), cl(color), board(chessboard) {
		if (cl == BLACK_CHESS) {
			board.black.push_back(this);
		}
		else {
			board.red.push_back(this);
		}
		board.GetChess(pt) = this;
	}
	const Point& GetPoint() const {
		return pt;
	}

	virtual bool CanMoveTo(const Point& point)const = 0;
	virtual const char* GetName() = 0;
	virtual const bool CanCrossTheRiver() const = 0;

	bool MoveTo(const Point& point) {
		if (CanMoveTo(point)) {
			board.GetChess(pt) = nullptr;
			pt.x = point.x;
			pt.y = point.y;
			board.RemoveChess(point);
			board.GetChess(point) = this;
			return true;
		}
		return false;
	}
};

class Rook :public ChessPiece {
public:
	Rook(const Point& point, bool color, ChessBoard& chessboard) :ChessPiece(point, color, chessboard) {}
	virtual bool CanMoveTo(const Point& point)const override {
		if (board.GetChess(point) == nullptr || board.GetChess(point)->cl != this->cl) {
			if (point.x == pt.x) {
				if (point.y < pt.y) {
					for (uint8_t i = point.y + 1; i < pt.y; i++) {
						if (board.GetChess(Point(point.x, i))) {
							return false;
						}
					}
				}
				else {
					for (uint8_t i = pt.y + 1; i < point.y; i++) {
						if (board.GetChess(Point(point.x, i))) {
							return false;
						}
					}
				}
				return true;
			}
			else if (point.y == pt.y) {
				if (point.x < pt.x) {
					for (uint8_t i = point.x + 1; i < pt.x; i++) {
						if (board.GetChess(Point(i, point.y))) {
							return false;
						}
					}
				}
				else {
					for (uint8_t i = pt.x + 1; i < point.x; i++) {
						if (board.GetChess(Point(i, point.y))) {
							return false;
						}
					}
				}
				return true;
			}
		}
		return false;
	}
	virtual const char* GetName() {
		return "車";
	}
	virtual const bool CanCrossTheRiver() const {
		return true;
	}
};


class Horse :public ChessPiece {
public:
	Horse(const Point& point, bool color, ChessBoard& chessboard) :ChessPiece(point, color, chessboard) {}
	virtual bool CanMoveTo(const Point& point)const override {
		static const Point s[8] = {
			{2, 1},
			{2, -1},
			{-2, -1},
			{-2, -1},
			{1, 2},
			{-1, 2},
			{1, -2},
			{-1, -2}
		},
			u[8] = {
				{1, 0},
				{1, 0},
				{-1, 0},
				{-1, 0},
				{0, 1},
				{0, 1},
				{0, -1},
				{0, -1}
		};
		if (board.GetChess(point) == nullptr || board.GetChess(point)->cl != this->cl) {
			for (size_t i = 0; i < 8; i++) {
				if (point == Point(pt.x + s[i].x, pt.y + s[i].y) && board.GetChess(Point(pt.x + u[i].x, pt.y + u[i].y)) == nullptr) {
					return true;
				}
			}
		}
		return false;
	}
	virtual const char* GetName() {
		return "馬";
	}
	virtual const bool CanCrossTheRiver() const {
		return true;
	}
};

class Cannon : public ChessPiece {
public:
	Cannon(const Point& point, bool color, ChessBoard& chessboard) : ChessPiece(point, color, chessboard) {}
	virtual bool CanMoveTo(const Point& point) const override {
		if (board.GetChess(point) == nullptr) {
			if (point.x == pt.x) {
				if (point.y < pt.y) {
					for (uint8_t i = point.y + 1; i < pt.y; i++) {
						if (board.GetChess(Point(point.x, i))) {
							return false;
						}
					}
				}
				else {
					for (uint8_t i = pt.y + 1; i < point.y; i++) {
						if (board.GetChess(Point(point.x, i))) {
							return false;
						}
					}
				}
				return true;
			}
			else if (point.y == pt.y) {
				if (point.x < pt.x) {
					for (uint8_t i = point.x + 1; i < pt.x; i++) {
						if (board.GetChess(Point(i, point.y))) {
							return false;
						}
					}
				}
				else if (pt.x < point.x) {
					for (uint8_t i = pt.x + 1; i < point.x; i++) {
						if (board.GetChess(Point(i, point.y))) {
							return false;
						}
					}
				}
				return true;
			}
			return false;
		}
		else if (board.GetChess(point)->cl != this->cl) {
			uint8_t count = 0;
			if (point.x == pt.x) {
				if (point.y < pt.y) {
					for (uint8_t i = point.y + 1; i < pt.y; i++) {
						if (board.GetChess(Point(point.x, i))) {
							count++;
						}
					}
				}
				else {
					for (uint8_t i = pt.y + 1; i < point.y; i++) {
						if (board.GetChess(Point(point.x, i))) {
							count++;
						}
					}
				}

			}
			else if (point.y == pt.y) {
				if (point.x < pt.x) {
					for (uint8_t i = point.x + 1; i < pt.x; i++) {
						if (board.GetChess(Point(i, point.y))) {
							count++;
						}
					}

				}
				else if (pt.x < point.x) {
					for (uint8_t i = pt.x + 1; i < point.x; i++) {
						if (board.GetChess(Point(i, point.y))) {
							count++;
						}
					}
				}

			}
			if (count == 1) {
				return true;
			}
		}
		return false;
	}
	virtual const char* GetName() {
		return "炮";
	}
	virtual const bool CanCrossTheRiver() const {
		return true;
	}
};

class Elephant :public ChessPiece {
public:
	Elephant(const Point& point, bool color, ChessBoard& chessboard) :ChessPiece(point, color, chessboard) {}
	virtual bool CanMoveTo(const Point& point) const override {
		static const Point s[4] = {
			{2,2},
			{2, -2},
			{-2, 2},
			{-2, -2}
		}, u[4] = {
			{1,1},
			{1, -1},
			{-1,1},
			{-1, -1}
		};
		if (board.GetChess(point) == nullptr || board.GetChess(point)->cl != this->cl) {
			if (cl == point.ColorOfTheArea()) {
				for (size_t i = 0; i < 4; i++) {
					if (point == Point(pt.x + s[i].x, pt.y + s[i].y) && board.GetChess(Point(pt.x + u[i].x, pt.y + u[i].y)) == nullptr) {
						return true;
					}
				}
			}
		}
		return false;
	}

	virtual const char* GetName() {
		return cl == BLACK_CHESS ? "象" : "相";
	}
	virtual const bool CanCrossTheRiver()const {
		return false;
	}
};

class Adviser :public ChessPiece {
public:
	Adviser(const Point& point, bool color, ChessBoard& chessboard) :ChessPiece(point, color, chessboard) {

	}
	virtual bool CanMoveTo(const Point& point)const override {
		static const Point s[4] = {
			{1,1},
			{1,-1},
			{-1, 1},
			{-1,-1}
		};
		if (board.GetChess(point) == nullptr || board.GetChess(point)->cl != this->cl) {
			if (cl == point.ColorOfTheArea() && point.IsInNinePalaces()) {
				for (size_t i = 0; i < 4; i++) {
					if (point == Point(pt.x + s[i].x, pt.y + s[i].y)) {
						return true;
					}
				}
			}
			return false;
		}
		return false;
	}
	virtual const char* GetName() {
		return "士";
	}
	virtual const bool CanCrossTheRiver()const {
		return false;
	}
};

class Pawn :public ChessPiece {
public:
	Pawn(const Point& point, bool color, ChessBoard& chessboard) :ChessPiece(point, color, chessboard) {

	}
	virtual bool CanMoveTo(const Point& point)const override {
		if (board.GetChess(point) == nullptr || board.GetChess(point)->cl != this->cl) {
			int8_t front = (cl == RED_CHESS ? 1 : -1);
			if (cl == pt.ColorOfTheArea()) {
				return point == Point(pt.x, pt.y + front);
			}
			static const Point s[3] = {
				{0, front},
				{1, 0},
				{-1, 0}
			};
			for (size_t i = 0; i < 4; i++) {
				if (point == Point(pt.x + s[i].x, pt.y + s[i].y)) {
					return true;
				}
			}
		}
		return false;
	}
	virtual const char* GetName() {
		return cl == BLACK_CHESS ? "卒" : "兵";
	}
	virtual const bool CanCrossTheRiver()const {
		return true;
	}
};

class King :public ChessPiece {
public:
	King(const Point& point, bool color, ChessBoard& chessboard) :ChessPiece(point, color, chessboard) {

	}
	virtual bool CanMoveTo(const Point& point)const override {
		static const Point s[4] = {
			{0,1},
			{0,-1},
			{1, 0},
			{-1, 0}
		};
		if (board.GetChess(point) == nullptr || board.GetChess(point)->cl != this->cl) {
			if (point.IsInNinePalaces() && point.ColorOfTheArea() == cl) {
				for (size_t i = 0; i < 4; i++) {
					if (point == Point(pt.x + s[i].x, pt.y + s[i].y)) {
						return true;
					}
				}
			}
		}
		return false;
	}
	virtual const char* GetName() {
		return cl == BLACK_CHESS ? "将" : "帥";
	}
	virtual const bool CanCrossTheRiver()const {
		return false;
	}
};


ChessBoard::ChessBoard() {
	memset(board, 0, sizeof(board));
	new King(Point(4, 0), RED_CHESS, *this);
	new King(Point(4, 9), BLACK_CHESS, *this);

	new Adviser(Point(3, 0), RED_CHESS, *this);
	new Adviser(Point(5, 0), RED_CHESS, *this);
	new Adviser(Point(3, 9), BLACK_CHESS, *this);
	new Adviser(Point(5, 9), BLACK_CHESS, *this);

	new Elephant(Point(2, 0), RED_CHESS, *this);
	new Elephant(Point(6, 0), RED_CHESS, *this);
	new Elephant(Point(2, 9), BLACK_CHESS, *this);
	new Elephant(Point(6, 9), BLACK_CHESS, *this);

	new Horse(Point(1, 0), RED_CHESS, *this);
	new Horse(Point(7, 0), RED_CHESS, *this);
	new Horse(Point(1, 9), BLACK_CHESS, *this);
	new Horse(Point(7, 9), BLACK_CHESS, *this);

	new Rook(Point(0, 0), RED_CHESS, *this);
	new Rook(Point(8, 0), RED_CHESS, *this);
	new Rook(Point(0, 9), BLACK_CHESS, *this);
	new Rook(Point(8, 9), BLACK_CHESS, *this);

	new Cannon(Point(1, 2), RED_CHESS, *this);
	new Cannon(Point(7, 2), RED_CHESS, *this);
	new Cannon(Point(1, 7), BLACK_CHESS, *this);
	new Cannon(Point(7, 7), BLACK_CHESS, *this);

	new Pawn(Point(0, 3), RED_CHESS, *this);
	new Pawn(Point(2, 3), RED_CHESS, *this);
	new Pawn(Point(4, 3), RED_CHESS, *this);
	new Pawn(Point(6, 3), RED_CHESS, *this);
	new Pawn(Point(8, 3), RED_CHESS, *this);
	new Pawn(Point(0, 6), BLACK_CHESS, *this);
	new Pawn(Point(2, 6), BLACK_CHESS, *this);
	new Pawn(Point(4, 6), BLACK_CHESS, *this);
	new Pawn(Point(6, 6), BLACK_CHESS, *this);
	new Pawn(Point(8, 6), BLACK_CHESS, *this);
}
// 将RemoveChess 放在ChessPiece之后能防止报未定义未定义ChessPiece的错误

void ChessBoard::RemoveChess(const Point& point) {
	if (GetChess(point)) {
		if (GetChess(point)->cl == RED_CHESS) {
			red.erase(find(red.begin(), red.end(), GetChess(point)));
		}
		else {
			black.erase(find(black.begin(), black.end(), GetChess(point)));
		}
	}
	delete GetChess(point);
	GetChess(point) = nullptr;
}

bool ChessBoard::KingsFaceToFace() const {
	auto r = find_if(red.begin(), red.end(), [](ChessPiece* p) {return !strcmp(p->GetName(), "帥"); }),
		b = find_if(black.begin(), black.begin(), [](ChessPiece* p) {return !strcmp(p->GetName(), "将"); });
	if (r != red.end() && b != black.end()) {
		if ((*r)->GetPoint().x == (*b)->GetPoint().x) {
			for (uint8_t i = (*r)->GetPoint().y + 1; i < (*b)->GetPoint().y; i++) {
				if (GetChess(Point((*r)->GetPoint().x, i))) {
					return false;
				}
			}
			return true;
		}
	}
	return false;
}

ChessBoard::~ChessBoard() {
	for (ChessPiece* p : red) {
		delete p;
	}
	for (ChessPiece* p : black) {
		delete p;
	}
}

算法代码部分只做了一些小修改，如GetName() 函数中函数体后面加const ，_stprintf_s会读取失败。

#pragma once

#include<graphics.h>
#include"Chess.hpp"

const int BLOCK_SIZE = 55;
const int RowNum = 11;
const int COLNum = 10;

class Game
{
private:
	bool nextPlayer;
	ChessBoard board;
	Point* firstPoint, *secondPoint;	// 鼠标点击两次的位置
public:
	Game() {
		nextPlayer = RED_CHESS;
		firstPoint = new Point(-1, -1);
		secondPoint = new Point(-1, -1);
	}

	bool Move(const Point& a, const Point& b) {
		if (board.GetChess(a) && board.GetChess(a)->cl == nextPlayer) {
			if (board.GetChess(a)->MoveTo(b)) {
				nextPlayer = !nextPlayer;
				return true;
			}
			return false;
		}
		return false;
	}
	const ChessBoard& GetBoard() const {
		return board;
	}

	uint8_t GetWinner() const {
		if (board.KingsFaceToFace()) {
			return nextPlayer;
		}
		if (find_if(board.GetRedPieces().begin(), board.GetRedPieces().end(), [](ChessPiece* p) {return !strcmp(p->GetName(),"帥"); }) == board.GetRedPieces().end()) {
			return BLACK_CHESS;

		}
		if (find_if(board.GetBlackPieces().begin(), board.GetBlackPieces().end(), [](ChessPiece* p) {return !strcmp(p->GetName(), "将"); }) == board.GetBlackPieces().end()) {
			return RED_CHESS;
		}
		if (count_if(board.GetRedPieces().begin(), board.GetRedPieces().end(), [](ChessPiece* p) {return p->CanCrossTheRiver(); }) +
			count_if(board.GetBlackPieces().begin(), board.GetBlackPieces().end(), [](ChessPiece* p) {return p->CanCrossTheRiver(); }) == 0) {
			return DRAW;   // 双方都不能过河，平局
		}
		return NONE;
	}

	bool GetNexPlayer() const {
		return nextPlayer;
	}

	void startup();
	void show();
	void updateWithInput();

};

void Game::startup() {	
	initgraph(BLOCK_SIZE * COLNum, BLOCK_SIZE * RowNum);
	setbkcolor(RGB(221, 200, 157));
	setlinestyle(PS_SOLID, 2);
	cleardevice();
	BeginBatchDraw();
}

void Game::show() {
	cleardevice();

	// 下面为绘制棋盘
	setlinecolor(BLACK);
	setfillcolor(RGB(221, 200, 157));
	for (int i = 0; i < RowNum - 2; i++) {
		for (int j = 0; j < COLNum - 2; j++) {
			if (i != 4) {
				fillrectangle((j + 1) * BLOCK_SIZE, (i + 1) * BLOCK_SIZE, (j + 2) * BLOCK_SIZE, (i + 2) * BLOCK_SIZE);
			}
			
		}
	}
	//画楚河汉界外的两笔		坐标（i = 5，j = 1      i = 5 ， j = 9
	line(1 * BLOCK_SIZE, 5 * BLOCK_SIZE, BLOCK_SIZE, 6 * BLOCK_SIZE);
	line(9 * BLOCK_SIZE, 5 * BLOCK_SIZE, 9 * BLOCK_SIZE, 6 * BLOCK_SIZE);

	//画两个九宫格  i = 1 + 2, j = 4 + 2 ; i = 1 + 2, j = 6 -2 ;		
	//  下面的：   i  = 10 - 2, j = 4 + 2; i = 8 + 2, j = 4 + 2
	line(4 * BLOCK_SIZE, 1 * BLOCK_SIZE, 6 * BLOCK_SIZE, 3 * BLOCK_SIZE);
	line(6 * BLOCK_SIZE, 1 * BLOCK_SIZE, 4 * BLOCK_SIZE, 3 * BLOCK_SIZE);
	line(4 * BLOCK_SIZE, 10 * BLOCK_SIZE, 6 * BLOCK_SIZE, 8 * BLOCK_SIZE);
	line(4 * BLOCK_SIZE, 8 * BLOCK_SIZE, 6 * BLOCK_SIZE, 10 * BLOCK_SIZE);
	
	//写楚河汉界	  楚河 i = 5 ， j = 2    汉界   i = 5， j = 6
	TCHAR s[20];
	setbkmode(TRANSPARENT);
	settextcolor(BLACK);
	settextstyle(55, 0, _T("华文行楷"));
	_stprintf_s(s, _T("楚河"));
	outtextxy(2 * BLOCK_SIZE, 5 * BLOCK_SIZE, s);

	settextcolor(RED);
	_stprintf_s(s, _T("汉界"));
	outtextxy(6 * BLOCK_SIZE, 5 * BLOCK_SIZE, s);

	//绘制棋子，首先，需要有一个画圆的函数，画出一个圆，然后中间是棋子的名字，棋子在
	setlinecolor(RGB(100, 100, 100));
	setfillcolor(RGB(221 - 20, 200 - 20, 157 -20));
	for (int y = 0; y < 10; y++) {	//这里对应的线
		for (int x = 0; x < 9; x++) {
			ChessPiece* p = this->board.GetChess(Point(x, y));
			if (p) {
				if (p->cl == BLACK_CHESS) {	// 绘制黑棋   画圆，设置字体
					fillcircle((p->GetPoint().x + 1) * BLOCK_SIZE, (p->GetPoint().y + 1)  * BLOCK_SIZE, BLOCK_SIZE / 2 - 2);

					TCHAR s[20];
					setbkmode(TRANSPARENT);
					settextcolor(BLACK);
					settextstyle(35, 0, _T("宋体"));
					
					_stprintf_s(s, _T("%hs"), p->GetName());
					outtextxy((x + 1) * BLOCK_SIZE - BLOCK_SIZE / 2 + 10, (y + 1) * BLOCK_SIZE - BLOCK_SIZE / 2 + 10, s);
				}
				else {
					fillcircle((p->GetPoint().x + 1) * BLOCK_SIZE, (p->GetPoint().y + 1) * BLOCK_SIZE, BLOCK_SIZE / 2 - 2);
					TCHAR s[20];
					setbkmode(TRANSPARENT);
					settextcolor(RED);
					settextstyle(35, 0, _T("宋体"));
					
					_stprintf_s(s, _T("%hs"),p->GetName());
					outtextxy((x + 1) * BLOCK_SIZE - BLOCK_SIZE / 2 + 10, (y + 1) * BLOCK_SIZE - BLOCK_SIZE / 2 + 10, s);
				}
				
			}
		}

	}

	//绘制第一个棋子的位置
	if (firstPoint->x != -1) {
		setlinecolor(RED);
		circle((firstPoint->y + 1) * BLOCK_SIZE, (firstPoint->x + 1) * BLOCK_SIZE, BLOCK_SIZE / 2 + 4);
		
	}
	TCHAR s1[20];
	setbkmode(TRANSPARENT);
	settextcolor(RED);
	settextstyle(35, 0, _T("宋体"));

	_stprintf_s(s1, _T("%d, %d"),firstPoint->x, firstPoint->y);
	outtextxy(0, 0, s1);

	// 判断胜利者
	auto winner = GetWinner();
	if (winner == BLACK_CHESS) {
		_stprintf_s(s1, _T("黑方胜利！"));
		outtextxy(4*BLOCK_SIZE, 5*BLOCK_SIZE, s1);
	}
	else if (winner == RED_CHESS) {
		_stprintf_s(s1, _T("红方胜利！"));
		outtextxy(4 * BLOCK_SIZE, 5 * BLOCK_SIZE, s1);
	}
	else if (winner == DRAW) {
		_stprintf_s(s1, _T("平局"));
		outtextxy(4 * BLOCK_SIZE, 5 * BLOCK_SIZE, s1);
	}
	FlushBatchDraw();
}

void Game::updateWithInput() {
	MOUSEMSG m;
	if (MouseHit()) {
		m = GetMouseMsg();
		if (m.uMsg == WM_LBUTTONDOWN) {
			int clicked_j = int(m.y - BLOCK_SIZE / 2) / BLOCK_SIZE;
			int clicked_i = int(m.x - BLOCK_SIZE / 2) / BLOCK_SIZE;
			
			//首先应该判断点击次数，两种方法，静态变量，和成员变量
			static int i = 1;
			//第一次点击判断是否有棋子 
			if (i == 1) {
				i++;
				firstPoint->y = clicked_i;
				firstPoint->x = clicked_j;
				show();

			}
			else {	//第二次点击
				i = 1;
				secondPoint->y = clicked_i;
				secondPoint->x = clicked_j;
				Move(Point(firstPoint->y, firstPoint->x), Point(secondPoint->y, secondPoint->x));
				firstPoint->y = -1;
				firstPoint->x = -1;
				show();
			}

		}
	}
}

主要图形化实现部分：游戏总体的框架为 startup（）初始化，  然后无限循环show（）和updateWithInput（）直到得到游戏结果。

startup主要新建一个窗口，并且，设置一些基本参数。

show（）主要绘制棋盘，楚河汉界的文字，棋子，如果出现胜利者需要宣布胜利

updateWithInput（）主要读取鼠标状态，进行棋子的移动。

#include<iostream>
#include<conio.h>
#include"Game.hpp"
using namespace std;

// 在此声明，Height为y为RowNum， Width为x为ColNum

int main() {
	Game g;
	g.startup();
	while (1) {
		g.show();
		g.updateWithInput();
		if (g.GetWinner() != NONE) {
			break;
		}
	}
	_getch();
	closegraph();
	return 0;
}

主程序主要执行程序框架。

执行效果如图：

 

可以看出，选择棋子的界面有点简陋，本来想做一个类似于直角引号的选择提示，但是发现代码量比直接画圆复杂很多，遂放弃。。。

啥时候睡觉
关注
  • 10
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
C语言实现象棋人人版
11-24
C语言基础+easyx知识便可实现,主要功能有开始界面的设计，游戏界面的设计，棋子布局，对战吃子，输赢判断
函数安装--图形化easyX工具
02-26
然而，对于初学者或希望快速实现图形化功能的开发者来说，EasyX是一个非常有用的工具。这个“函数安装--图形化easyX工具”就是为了解决这个问题，它提供了一个图形化的接口，简化了C语言中的图形编程。 EasyX是一个...
象棋_fourvn7_C++象棋ai_C++_软件设计_easyX_
09-29
由C++编写的象棋对战软件，自带界面（需要安装easyX库才可以运行），象棋AI由博弈论，广度优先搜索等算法构成。可AI对战也可以双人对战，自动绘制棋盘，鼠标点击操作棋子。
基于QT和C++实现的中国象棋
最新发布
2303_76580416的博客
06-18 927
中国象棋
中国象棋——基于EasyX图形库
忆梦初心的博客
12-04 2105
中国象棋
使用Easyx进行图形化编程（目标是生成一个象棋棋盘）
liourenyu的博客
03-19 843
代码如下 #define _CRT_SECURE_NO_WARNINGS #pragma once // stdafx.h : 标准系统包含文件的包含文件， // 或是经常使用但不常更改的 // 特定于项目的包含文件 #include<corecrt.h> // 包括 SDKDDKVer.h 将定义可用的最高版本的 Windows 平台。 // 如果要为以前的 Windows 平台生成应用程序，请包括 WinSDKVer.h，并将 // 将 _WIN32_WINNT 宏设置为要支持的平台，然后再
EasyX绘制国际象棋棋盘
tanjuan918的博客
12-16 1015
#include <graphics.h> #include <conio.h> #define HIGH 400 #define WIDTH 400 int main(void) { initgraph(WIDTH, HIGH); setbkcolor(WHITE); cleardevice(); for (int i = 1; i <= 8; i++) { for (int j = 1; j <= 8; j++) { if (((i % 2 =
EasyX-中国象棋棋盘
m0_74278107的博客
04-17 572
EasyX绘图实践
TDM-gcc mingw64 easyx
11-23
EasyX库的核心函数包括`initGraph()`用于初始化图形窗口，`drawPixel()`用于绘制像素，`drawLine()`用于画线，`drawCircle()`用于画圆，等等。 3. **配置EasyX**： 在Dev-C++中配置EasyX需要以下步骤： - 将下载...
C++基于EasyX图形库实现2048小游戏
08-24
在这里，我们初始化图形环境，然后进入游戏循环。循环内，首先创建一个`Game2048`实例，然后不断地显示游戏地图，获取玩家输入并执行相应动作，直到游戏结束。当游戏结束时，询问玩家是否要重新开始，如果玩家选择不...
C语言利用EasyX实现图形化界面的小游戏
03-30
- `initgraph()`：初始化图形窗口，参数为窗口的宽度和高度。 - `closegraph()`：关闭图形窗口。 2. 防止闪屏技术： - 闪屏问题通常由频繁的屏幕刷新引起。 - 双缓冲技术可以解决这个问题，使用`BeginBatchDraw...
中国象棋（简易版）（java se+mysql）
06-30
1.利用网络编程模拟实现了象棋的双人对战（端口实现） 2.未增加人机对战模块 3.代码较为简单，仅供参考
可供两人对弈的中国象棋程序
03-10
仅仅是人和人对弈的中国象棋程序，没有规则
C++ 利用EasyX库绘制五子棋功能
01-10
C++ 利用EasyX库绘制五子棋功能，需要先安装EasyX图形库，我是利用VS2017编译直接运行
C++编写中国象棋源代码
04-05
这是基于vc++6.0开发平台，丰富的数据算法融于一体的代码组合，利用MFC图形界面而开发的益智的棋盘游戏，代码希望爱好编程的学者学习
c语言实现的象棋源码
06-03
象棋游戏源码 。
基于EasyX和c++的图形化界面对角线数独游戏
07-31
《基于EasyX和C++的图形化界面对角线数独游戏详解》 数独，一种深受人们喜爱的逻辑推理游戏，近年来在编程领域也得到了广泛的应用，尤其是将其与图形化界面结合，使得游戏体验更加直观和友好。本文将深入探讨一款...
利用opencv霍夫变检测中国象棋的外形——圆
耶律大石的博客
04-19 2447
今天将opencv的霍夫变换修改并优化了一下，就是先预处理，切割、二值化、去噪之后进行霍夫变换，效果还不错，从识别70多个圆，慢慢修改到识别32个圆。 效果如下： 原理毛星云写的就很好，他的文章链接：https://blog.csdn.net/poem_qianmo/article/details/26977557 下面附上代码： #include "stdafx.h" #incl...
c++ easyX的学习
weixin_30480075的博客
05-12 363
画象棋盘来浅显学习了解easyx 了解象棋盘的构成： 如图就为一个基本的象棋棋盘我们下面就用esayx来画出这个棋盘，我的感觉这个棋盘大概分为两个部分：第一部分就是棋盘的大致布局，第二个就是棋盘的细节实现 棋盘的代码实现： 首先根据网上的数据我们可以得到一个棋盘的长大概为420像素点，宽大概370个像素点， 1 initgraph(720, 640);// 初始化72...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值