妙妙小豆子

胆子大一点,想开一点。长风破浪会有时,直挂云帆济沧海

象棋马拉松 金牌收录

程序简介

象棋马拉松,这个小游戏就是控制一个马往前跳。原游戏只有新棋子第一次出现会显示跳哪些地方会被吃。而我加了右键提示,为了判定每个格子安不安全,本身需要一个存危险点和可以移动点的函数。原游戏挺上瘾的,配有落子的音效,就是下的随便的时候很容易失误,原游戏是无尽模式,我加了一个闯关模式。

里面的所有棋子都是象棋棋子,满足象棋规则。

无尽模式是控制一个“马”,日字格向前跳,某一步下完后会被黑子吃掉的话,即为失败。里面存在别象腿,别马腿。

闯关模式,我设计了“车马炮”,合理运用他们闯过前方的布阵,一起到达顶点,即为成功,刷新关卡。为降低难度,最后一个字到达顶点时,即使会被吃,也优先算过关。

第一次更新:
1. 两个模式都增加了生命值,主要是方便闯关模式不小心的失误。无尽模式考验的更多就是耐心。以后也许能添加回血棋子。
2. 无尽模式添加动画,不至于突兀。
3. 添加游戏记录,包括前进几格(闯过几关)和吃了多少子,这是最直接的游戏目标。
4. 修复了因为“炮”子导致的落子范围错误显示的 bug。
5. 修复了闯关刷新之后无解的 bug。但不代表闯关模式一定有解,例如双“车”沉底,一定会损失一命,为此添加了刷新按钮,并且每通一关加一命,最大限度降低了影响。

也许以后更新还可以添加自定义闯关模式,设计敌我棋子的布局。或者把“车马炮”换成其他棋子。我的判断函数存了所用的全部 6 种棋子,所以是可以换的。那样能设计的模式就多了,这次就没有再加了。

第二次更新:
1. 字符串更新,不再使用 char
2. 修复因为随机种子参数,而每次开局都一样的 bug,随机种子参数变更为通过时间设置,即 srand( (unsigned)time( NULL ) )
3. 文章细节的更新。

第三次更新:
1. 图片更新,减小边框
2. 代码更新,现在兼容 vc2010,不兼容 vc6.0
vc2010:_stscanf_s,vc6.0:_stscanf
vc2010:_stprintf_s,vc6.0:_stprintf
3. 修复了闯关开局就无解的 bug。

程序执行效果

 

完整源代码

////////////////////////////////////////
// 程序:象棋马拉松
// 作者:Gary
// 编译环境:Visual C++ 2010,EasyX_20211109
// 编写日期:2021-7-14

////////////////////////////// 游戏进程头文件 //////////////////////////////

# include <math.h>
# include <graphics.h>
# include <string>
# include <time.h>
# include <stdlib.h>

// 头文件
// 头文件编译开始
#ifndef CIRCLE_H
#define CIRCLE_H

// 定义变量
static double pi = acos (-1.0);			// 圆周率π
static HWND hOut;						// 画布

// 定义一个结构体,格子
struct Node1
{
	int boxnum;							// 格子编号
	LPTSTR text;						// 刻字
	COLORREF color;						// 颜色
	int piecenum;						// 棋子类型参数
	int posx, posy;						// 坐标参数
	int type;							// 格子激活状态,有无棋子坐落
};

// 定义一个结构体,可抵达格子
struct Node2
{
	int type;							// 格子激活状态,可否抵达
};

// 定义一个结构体,危险格子
struct Node3
{
	int type;							// 格子激活状态,是否危险
};

// 定义一个结构体,按钮
struct Node4
{
	int posx1, posy1, posx2, posy2;		// 坐标
	double r;							// 原按钮半径
	LPTSTR text;						// 按钮文本
	int type;							// 按钮激活状态
};

// 定义一个类,game
class game
{
public:
	// 函数
	int carry_main ();													// 游戏进程主循函数
	void draw_piece (int posx, int posy, LPTSTR text, COLORREF color);	// 棋子绘制函数
	void draw_button ();												// 按钮绘制函数
	void creact_piece (int floor);										// 棋子生成函数
	void check ();														// 判断函数
	void check_main ();													// 判断主函数
	void carry_prepare ();												// 准备进程主循函数
	void initialization_prepare ();										// 准备进程初始化函数	
	void draw_scene_prepare ();											// 准备进程绘制函数
	void draw_word (double size, int posx, int posy, LPTSTR text);		// 标题绘制函数
	void carry_start ();												// 开始进程主循函数
	void initialization_start ();										// 开始进程初始化函数
	void draw_scene_start ();											// 开始进程绘制函数
	void draw_bk ();													// 背景绘制函数
	void draw_tip ();													// 提示绘制函数
	// 结构体
	Node1 box[16][7];													// 格子
	Node2 box1[16][7];													// 可达格子
	Node3 box2[16][7];													// 危险格子
	Node4 boxm[20];														// 按钮,预制二十个

	// 变量
	int num_button;														// 按钮数量
	int exit_carry;														// 主进程主循函数控制参数
	int exit_start;														// 开始进程主循函数控制参数
	int mod_start;														// 游戏模式参数
	int flag;															// 当前控制移动格子参数
	int tip_or_not;														// 是否提示参数
	int selected_or_not;												// 闯关模式是否选定移动目标棋子
	int start_life;														// 生命条
	int start_record;													// 记录
	int start_eat;														// 食子数
};

// 头文件编译结束
#endif


////////////////////////////// 主程序源文件 //////////////////////////////


// 窗口初始化
void initialization ()
{
	// 窗口定义,整个程序仅定义一次
	hOut = initgraph (450, 650);
	pi = acos (-1.0);
	// 窗口标题
	SetWindowText (hOut, _T ("象棋马拉松"));
}

// 总进程主循函数
void carry ()
{
	// 总进程参数初始化
	int exit_carry = 0;
	// 进程控制
	BeginBatchDraw ();
	// 创建游戏类对象
	game G;
	// 游戏进程
	while (exit_carry == 0)
	{
		// 执行游戏总进程,并接收游戏进程结束时返回值
		// 准备进程时,点击退出按钮结束返回 1
		// 开始进程时,点击返回按钮结束返回 0
		exit_carry = G.carry_main ();
	}
	EndBatchDraw ();
	// 关闭窗口
	closegraph ();
}

// 主函数
int main (void)
{
	// 初始化
	initialization ();
	// 总进程主循函数
	carry ();
	return 0;
}

////////////////////////////// 游戏进程源文件 //////////////////////////////



// 游戏进程主循函数
int game::carry_main ()
{
	// 游戏进程参数初始化
	exit_carry = 0;
	// 随机种子初始化
	srand ((unsigned)time (NULL));
	// 准备进程初始化函数
	initialization_prepare ();
	// 准备进程主循函数
	carry_prepare ();
	// 准备进程结束
	// 准备进程时,点击退出按钮结束,游戏进程参数为 1
	// 准备进程时,正常进入游戏,游戏进程参数为 0
	if (exit_carry == 0)
	{
		// 开始进程初始化函数
		initialization_start ();
		// 开始进程主循函数
		carry_start ();
	}
	// 开始进程结束
	// 点击返回按钮结束,或者正常游戏结束,游戏进程参数不变
	return exit_carry;
}

// 按钮绘制函数
void game::draw_button ()
{
	// 根据颜色结构体设置参数
	setlinecolor (RGB (125, 125, 125));
	setfillcolor (BLACK);
	setbkcolor (BLACK);
	settextcolor (WHITE);
	settextstyle (30, 15, _T ("Consolas"));
	setlinestyle (PS_SOLID, 10);

	// 根据按钮数量参数绘制
	for (int i = 0; i < num_button; i++)
	{
		if (boxm[i].type == 0)
		{
			// 边框
			fillroundrect (boxm[i].posx1, boxm[i].posy1, boxm[i].posx2, boxm[i].posy2, 25, 25);
			// 文字
			outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + 15, boxm[i].text);
		}
	}
	FlushBatchDraw ();
}


////////////////////////////// 准备进程源文件 //////////////////////////////


// 准备进程主循函数
void game::carry_prepare ()
{
	int i;
	// 鼠标定义
	ExMessage m;
	// 准备进程控制参数初始化
	int	exit_prepare = 0;
	// 绘制界面
	draw_scene_prepare ();
	// 主循开始
	while (exit_prepare == 0)
	{
		if (peekmessage (&m, EM_MOUSE | EM_KEY))
		{
			// 左键单击判断
			if (m.message == WM_LBUTTONDOWN)
			{
				// 判断是否点击了按钮,按钮状态是否为激活
				for (i = 0; i < num_button; i++)
				{
					if (m.x > boxm[i].posx1 && m.y > boxm[i].posy1 && m.x < boxm[i].posx2 && m.y < boxm[i].posy2 && boxm[i].type == 0)
					{
						break;
					}
				}

				// 开始游戏按钮
				if (i == 0 || i == 1 || i == 3)
				{
					// 游戏类型储存
					mod_start = i;
					// 准备进程控制参数置一,结束主循
					exit_prepare = 1;
					// 开始进程控制参数置零,进入开始进程
					exit_start = 0;
				}
				// 退出按钮
				else if (i == 2)
				{
					// 总进程控制参数置一,跳过开始进程
					exit_carry = 1;
					// 准备进程控制参数置一,结束主循
					exit_prepare = 1;
				}

				if (i < 3 && exit_prepare == 0)
				{
					// 点击按钮后,根据按钮激活参数,重新绘制界面
					draw_scene_prepare ();
					FlushBatchDraw ();
				}
			}
		}
	}
}

// 准备进程初始化函数	
void game::initialization_prepare ()
{
	// 按钮设置初始化
	// 按钮数量参数初始化
	num_button = 3;

	// 按钮结构体参数初始化
	boxm[0].posx1 = 140; boxm[0].posy1 = 120; boxm[0].posx2 = 310; boxm[0].posy2 = 180; boxm[0].text = _T ("无尽模式"); boxm[0].type = 0;
	boxm[1].posx1 = 140; boxm[1].posy1 = 220; boxm[1].posx2 = 310; boxm[1].posy2 = 280; boxm[1].text = _T ("闯关模式"); boxm[1].type = 0;
	boxm[2].posx1 = 140; boxm[2].posy1 = 420; boxm[2].posx2 = 310; boxm[2].posy2 = 480; boxm[2].text = _T ("退出"); boxm[2].type = 0;
}

// 准备进程绘制函数
void game::draw_scene_prepare ()
{
	// 画布绘制
	setbkcolor (WHITE);
	cleardevice ();
	// 按钮绘制
	draw_button ();
	// 标题绘制
	draw_word (50, 130, 30, _T ("象棋马拉松"));
	FlushBatchDraw ();
}

// 文字绘制函数
void game::draw_word (double size, int posx, int posy, LPTSTR text)
{
	int i, j;

	// 参数设置,填充透明
	setbkmode (TRANSPARENT);
	settextstyle (int (size), int (size / 5 * 2), _T ("Consolas"));

	// 背景色的反色
	settextcolor (BLACK);
	// 范围绘制,构造阴影
	for (i = posx - 3; i <= posx + 3; i++)
	{
		for (j = posy - 3; j <= posy + 3; j++)
		{
			outtextxy (i, j, text);
		}
	}

	// 背景色
	settextcolor (WHITE);
	// 在阴影中绘制
	outtextxy (posx, posy, text);

	// 恢复填充
	setbkmode (OPAQUE);
	FlushBatchDraw ();
}

////////////////////////////// 开始进程源文件 //////////////////////////////


// 开始进程主循函数
void game::carry_start ()
{
	// 鼠标定义
	ExMessage m;
	int i, j, k, x, y, a;
	// 判断一下,避免返回不初始化格子判断参数
	check_main ();
	// 记录初始化
	start_record = 0;
	start_eat = 0;
	// 是否选定参数
	selected_or_not = 0;
	// 生命初始化,无尽模式初始一条命
	start_life = 1;
	// 绘制
	draw_scene_start ();
	// 无尽模式
	while (exit_start == 0 && mod_start == 0)
	{
		if (peekmessage (&m, EM_MOUSE | EM_KEY))
		{
			// 左键单击判断
			if (m.message == WM_LBUTTONDOWN)
			{
				if (m.x < 350)
				{
					i = m.x / 50 + m.y / 50 * 7 + 7;

					// 是否是可抵达位置
					if (box1[i / 7][i % 7].type == 1)
					{
						// 交换落点
						if (box[i / 7][i % 7].type == 1) { start_eat++; }

						box[i / 7][i % 7].type = box[flag / 7][flag % 7].type;
						box[i / 7][i % 7].text = box[flag / 7][flag % 7].text;
						box[i / 7][i % 7].piecenum = box[flag / 7][flag % 7].piecenum;
						box[i / 7][i % 7].color = box[flag / 7][flag % 7].color;
						box[flag / 7][flag % 7].type = 0;

						flag = i;

						// 是否是安全位置
						// 安全位置
						if (box2[i / 7][i % 7].type == 0)
						{
							// 移动视角
							if (i / 7 < 11)
							{
								x = 11 - i / 7;
								start_record += x;
								for (j = 13; j >= 0; j--)
								{
									for (k = 0; k < 7; k++)
									{
										if (box[j][k].type != 0)
										{
											box[j + x][k].type = box[j][k].type;
											box[j + x][k].text = box[j][k].text;
											box[j + x][k].piecenum = box[j][k].piecenum;
											box[j + x][k].color = box[j][k].color;

											box[j][k].type = 0;
										}
									}
								}
								flag += x * 7;
								creact_piece (0);
								// 移动视角后的卷屏动画
								// 棋子已经整体下移 x 行了,要把格子整体上移 x 行,慢慢向原值靠拢
								a = tip_or_not;
								tip_or_not = 0;
								for (y = x * 50; y >= 0; y -= 50)
								{
									for (k = 0; k < 16; k++)
									{
										for (j = 0; j < 7; j++)
										{
											box[k][j].posy = -25 + 50 * k - y;
										}
									}
									draw_scene_start ();
									Sleep (200);
								}
								tip_or_not = a;
							}

							// 清理棋子
							for (j = 0; j < 7; j++)
							{
								box[14][j].type = 0;
								box[15][j].type = 0;
							}
							// 重新判断
							check_main ();
						}
						// 危险位置
						else if (box2[i / 7][i % 7].type == 1)
						{
							// 失败动画
							tip_or_not = 1;
							for (k = 0; k < 5; k++)
							{
								box[i / 7][i % 7].type = 0;
								draw_scene_start ();
								Sleep (200);
								box[i / 7][i % 7].type = 2;
								draw_scene_start ();
								Sleep (200);
							}

							exit_start = 1;
						}

						draw_scene_start ();

					}
				}
				else
				{
					// 判断是否点击了按钮
					for (i = 0; i < num_button; i++)
					{
						if (m.x > boxm[i].posx1 && m.y > boxm[i].posy1 && m.x < boxm[i].posx2 && m.y < boxm[i].posy2 && boxm[i].type == 0)
						{
							break;
						}
					}
					if (i == 0)
					{
						exit_start = 1;

					}
				}
			}

			// 右键打开提示
			else if (m.message == WM_RBUTTONDOWN)
			{
				tip_or_not = tip_or_not == 0 ? 1 : 0;
				draw_scene_start ();
			}
		}
	}


	// 生命初始化,闯关模式初始三条命
	start_life = 3;
	// 绘制
	draw_scene_start ();
	// 闯关模式
	while (exit_start == 0 && mod_start == 1)
	{
		if (peekmessage (&m, EM_MOUSE | EM_KEY))
		{
			// 左键单击判断
			if (m.message == WM_LBUTTONDOWN)
			{
				if (m.x < 350)
				{
					i = m.x / 50 + m.y / 50 * 7 + 7;
					// 未选定状态,点击自己的棋子
					if (selected_or_not == 0 && box[i / 7][i % 7].type == 2)
					{
						selected_or_not = 1;
						flag = i;
						// 更换棋子类型
						for (k = 0; k < 16; k++)
						{
							for (j = 0; j < 7; j++)
							{
								if (box[k][j].type == 2)
								{
									box[k][j].type = 3;
								}
							}
						}
						box[flag / 7][flag % 7].type = 2;
						check_main ();
						draw_scene_start ();
					}
					// 选定状态,点击选定的棋子
					else if (selected_or_not == 1 && i == flag)
					{
						selected_or_not = 0;
						for (k = 0; k < 16; k++)
						{
							for (j = 0; j < 7; j++)
							{
								if (box[k][j].type == 3)
								{
									box[k][j].type = 2;
								}
							}
						}
						check_main ();
						draw_scene_start ();
					}
					// 选定状态,点击其他的己方棋子,切换选择
					else if (selected_or_not == 1 && box[i / 7][i % 7].type == 3)
					{
						box[i / 7][i % 7].type = 2;
						box[flag / 7][flag % 7].type = 3;
						flag = i;
						check_main ();
						draw_scene_start ();
					}
					// 选定状态,点击其他的格子
					else if (selected_or_not == 1 && i != flag)
					{
						// 是否是可抵达位置
						if (box1[i / 7][i % 7].type == 1)
						{

							selected_or_not = 0;

							// 交换落点
							if (box[i / 7][i % 7].type == 1) { start_eat++; }

							box[i / 7][i % 7].type = box[flag / 7][flag % 7].type;
							box[i / 7][i % 7].text = box[flag / 7][flag % 7].text;
							box[i / 7][i % 7].piecenum = box[flag / 7][flag % 7].piecenum;
							box[i / 7][i % 7].color = box[flag / 7][flag % 7].color;
							box[flag / 7][flag % 7].type = 0;


							for (k = 0; k < 16; k++)
							{
								for (j = 0; j < 7; j++)
								{
									if (box[k][j].type == 3)
									{
										box[k][j].type = 2;
									}
								}
							}
							// 重新判断
							check_main ();

							// 是否成功过关,三个子都抵达最上面
							x = 0;
							for (k = 0; k < 16; k++)
							{
								for (j = 0; j < 7; j++)
								{
									if (box[k][j].type == 2 && k > 1)
									{
										x = 1;
									}
								}
							}

							// 三个字在不在危险位置
							for (k = 0; k < 16; k++)
							{
								for (j = 0; j < 7; j++)
								{
									if (box[k][j].type == 2 && box2[k][j].type == 1 && x == 1)
									{
										tip_or_not = 1;
										// 失败动画
										for (y = 0; y < 5; y++)
										{
											box[k][j].type = 0;
											draw_scene_start ();
											Sleep (200);
											box[k][j].type = 2;
											draw_scene_start ();
											Sleep (200);
										}
										tip_or_not = 0;
										// 减生命
										start_life--;
										// 生命减没了,结束
										if (start_life == 0)
										{
											exit_start = 1;
										}
									}
								}
							}

							draw_scene_start ();

							// 成功过关
							if (x == 0)
							{
								start_record += 1;
								start_life++;
								// 初始化
								initialization_start ();

								// 不出现两个子及以上同时危险的情况
								y = 0;
								if (box2[11][1].type == 1) { y++; }
								if (box2[11][3].type == 1) { y++; }
								if (box2[11][5].type == 1) { y++; }
								while (y >= 2)
								{
									// 初始化
									initialization_start ();
									y = 0;
									if (box2[11][1].type == 1) { y++; }
									if (box2[11][3].type == 1) { y++; }
									if (box2[11][5].type == 1) { y++; }
								}
							}
						}
						draw_scene_start ();
					}
				}
				else
				{
					// 判断是否点击了按钮
					for (i = 0; i < num_button; i++)
					{
						if (m.x > boxm[i].posx1 && m.y > boxm[i].posy1 && m.x < boxm[i].posx2 && m.y < boxm[i].posy2 && boxm[i].type == 0)
						{
							break;
						}
					}
					// 返回按钮
					if (i == 0)
					{
						exit_start = 1;
					}
					// 刷新按钮
					else if (i == 1)
					{
						// 初始化
						initialization_start ();

						// 不出现两个子及以上同时危险的情况
						y = 0;
						if (box2[11][1].type == 1) { y++; }
						if (box2[11][3].type == 1) { y++; }
						if (box2[11][5].type == 1) { y++; }

						while (y >= 2)
						{
							// 初始化
							initialization_start ();
							y = 0;
							if (box2[11][1].type == 1) { y++; }
							if (box2[11][3].type == 1) { y++; }
							if (box2[11][5].type == 1) { y++; }
						}

						// 重新绘制
						draw_scene_start ();
					}
				}
			}

			// 右键切换提示
			else if (m.message == WM_RBUTTONDOWN)
			{
				tip_or_not = tip_or_not == 0 ? 1 : 0;
				check_main ();
				draw_scene_start ();
			}
		}
	}

	flushmessage (EM_MOUSE);
}


// 开始进程初始化函数
void game::initialization_start ()
{
	int i, j, k;
	// 格子初始化
	for (i = 0; i < 16; i++)
	{
		for (j = 0; j < 7; j++)
		{
			box[i][j].boxnum = i * 7 + j;
			box[i][j].color = WHITE;
			box[i][j].piecenum = 0;
			box[i][j].text = _T ("");
			box[i][j].posx = 25 + 50 * j;
			box[i][j].posy = -25 + 50 * i;
			box[i][j].type = 0;
		}
	}
	// 提示参数初始化
	tip_or_not = 0;
	// 无尽模式
	if (mod_start == 0)
	{
		box[11][3].type = 2;
		box[11][3].piecenum = 3;
		box[11][3].text = _T ("马");
		box[11][3].color = RED;
		flag = 80;
		creact_piece (1);

		// 判断初始化
		check_main ();
	}
	// 闯关模式
	else if (mod_start == 1)
	{
		k = 2;
		while (k >= 2)
		{
			// 格子初始化
			for (i = 0; i < 16; i++)
			{
				for (j = 0; j < 7; j++)
				{
					box[i][j].color = WHITE;
					box[i][j].piecenum = 0;
					box[i][j].text = _T ("");
					box[i][j].type = 0;
				}
			}
			// 红色车马炮
			box[11][1].type = 2;
			box[11][1].piecenum = 4;
			box[11][1].text = _T ("车");
			box[11][1].color = RED;

			box[11][3].type = 2;
			box[11][3].piecenum = 3;
			box[11][3].text = _T ("马");
			box[11][3].color = RED;

			box[11][5].type = 2;
			box[11][5].piecenum = 6;
			box[11][5].text = _T ("炮");
			box[11][5].color = RED;

			flag = 82;
			// 黑色障碍
			for (i = 1; i < 6; i++)
			{
				creact_piece (i);
				creact_piece (i);
			}

			// 判断初始化
			check_main ();

			k = 0;
			if (box2[11][1].type == 1) { k++; }
			if (box2[11][3].type == 1) { k++; }
			if (box2[11][5].type == 1) { k++; }
		}
	}

	// 按钮设置初始化
	num_button = 2;
	boxm[0].posx1 = 360; boxm[0].posy1 = 120; boxm[0].posx2 = 440; boxm[0].posy2 = 180; boxm[0].text = _T ("返回"); boxm[0].type = 0;
	boxm[1].posx1 = 360; boxm[1].posy1 = 220; boxm[1].posx2 = 440; boxm[1].posy2 = 280; boxm[1].text = _T ("刷新"); boxm[1].type = 1;

	// 闯关模式则打开刷新按钮
	if (mod_start == 1) { boxm[1].type = 0; }

}


// 开始进程绘制函数
void game::draw_scene_start ()
{
	int i, j;

	// 背景绘制
	draw_bk ();
	// 绘制按钮
	draw_button ();
	// 棋子绘制
	for (i = 0; i < 16; i++)
	{
		for (j = 0; j < 7; j++)
		{
			if (box[i][j].type != 0)
			{
				draw_piece (box[i][j].posx, box[i][j].posy, box[i][j].text, box[i][j].color);
			}
		}
	}
	if (tip_or_not == 1)
	{
		draw_tip ();
	}
	// 闯关模式,选定状态,显示小箭头
	if (mod_start == 1 && selected_or_not == 1)
	{
		i = flag / 7;
		j = flag % 7;
		setlinecolor (RED);
		setlinestyle (PS_SOLID, 2);

		line (box[i][j].posx + 20, box[i][j].posy + 20, box[i][j].posx + 26, box[i][j].posy + 26);
		line (box[i][j].posx + 20, box[i][j].posy + 20, box[i][j].posx + 20, box[i][j].posy + 26);
		line (box[i][j].posx + 20, box[i][j].posy + 20, box[i][j].posx + 26, box[i][j].posy + 20);

		line (box[i][j].posx + 20, box[i][j].posy - 20, box[i][j].posx + 26, box[i][j].posy - 26);
		line (box[i][j].posx + 20, box[i][j].posy - 20, box[i][j].posx + 20, box[i][j].posy - 26);
		line (box[i][j].posx + 20, box[i][j].posy - 20, box[i][j].posx + 26, box[i][j].posy - 20);

		line (box[i][j].posx - 20, box[i][j].posy + 20, box[i][j].posx - 26, box[i][j].posy + 26);
		line (box[i][j].posx - 20, box[i][j].posy + 20, box[i][j].posx - 20, box[i][j].posy + 26);
		line (box[i][j].posx - 20, box[i][j].posy + 20, box[i][j].posx - 26, box[i][j].posy + 20);

		line (box[i][j].posx - 20, box[i][j].posy - 20, box[i][j].posx - 26, box[i][j].posy - 26);
		line (box[i][j].posx - 20, box[i][j].posy - 20, box[i][j].posx - 20, box[i][j].posy - 26);
		line (box[i][j].posx - 20, box[i][j].posy - 20, box[i][j].posx - 26, box[i][j].posy - 20);

	}
	// 文字绘制
	TCHAR s[20];
	// 记录
	if (start_record > 0) { draw_word (30, 350, 380, _T ("记录:")); }
	_stprintf_s (s, _T ("%0.0d"), start_record);
	draw_word (30, 410, 380, s);

	// 食子
	if (start_eat > 0) { draw_word (30, 350, 430, _T ("食子:")); }
	_stprintf_s (s, _T ("%0.0d"), start_eat);
	draw_word (30, 410, 430, s);

	// 生命
	if (start_life > 0) { draw_word (30, 350, 480, _T ("生命:")); }
	_stprintf_s (s, _T ("%0.0d"), start_life);
	draw_word (30, 410, 480, s);


	FlushBatchDraw ();
}


// 背景绘制函数
void game::draw_bk ()
{
	// 填充
	int i = 225;
	setbkcolor (RGB (215 - 45.0 / 180.0 * double (i), 161 - 39.0 / 180.0 * double (i), 114 - 32.0 / 180.0 * double (i)));
	cleardevice ();

	// 底色
	for (i = 225; i > 0; i--)
	{
		setlinecolor (RGB (215 - 45.0 / 180.0 * double (i), 161 - 39.0 / 180.0 * double (i), 114 - 32.0 / 180.0 * double (i)));
		setfillcolor (RGB (215 - 45.0 / 180.0 * double (i), 161 - 39.0 / 180.0 * double (i), 114 - 32.0 / 180.0 * double (i)));
		fillcircle (175, 325, 145 + i);
	}

	// 底色
	for (i = 0; i < 145; i++)
	{
		setlinecolor (RGB (215 + 10.0 / 145.0 * double (i), 161 + 7.0 / 145.0 * double (i), 114 + 5.0 / 145.0 * double (i)));
		setfillcolor (RGB (215 + 10.0 / 145.0 * double (i), 161 + 7.0 / 145.0 * double (i), 114 + 5.0 / 145.0 * double (i)));
		fillcircle (175, 325, 145 - i);
	}

	// 格子线
	setlinestyle (PS_SOLID, 3);
	setlinecolor (RGB (154, 101, 49));

	// 横线
	for (i = 0; i < 13; i++)
	{
		line (25, 25 + 50 * i, 325, 25 + 50 * i);
	}

	if (mod_start == 1)
	{
		i = 0;
		setlinecolor (YELLOW);
		line (25, 25 + 50 * i, 325, 25 + 50 * i);
	}
	// 竖线
	setlinecolor (RGB (154, 101, 49));
	for (i = 0; i < 7; i++)
	{
		line (25 + 50 * i, 0, 25 + 50 * i, 650);
	}
	line (15, 0, 15, 650);
	line (335, 0, 335, 650);

	FlushBatchDraw ();
}


// 判断主函数
void game::check_main ()
{
	int i, j, k, x, y;
	// 临时储存两个结构体的值
	int eat1[16][7], eat2[16][7];
	// 参数重置
	for (i = 0; i < 16; i++)
	{
		for (j = 0; j < 7; j++)
		{
			box1[i][j].type = 0;
			box2[i][j].type = 0;
		}
	}
	// 先整体判断一次
	check ();
	// 存起来
	for (i = 0; i < 16; i++)
	{
		for (j = 0; j < 7; j++)
		{
			eat1[i][j] = box1[i][j].type;
			eat2[i][j] = box2[i][j].type;
		}
	}

	// 纠正,对两个值都是一的格子进行纠正,每个格子,要么是可抵达且安全,要么是危险
	// 纠正的原因是“炮”子导致的
	if (selected_or_not == 1)
	{
		for (i = 0; i < 16; i++)
		{
			for (j = 0; j < 7; j++)
			{
				// 对可抵达且危险的格子进行纠正
				if (eat1[i][j] == 1 && eat2[i][j] == 1)
				{
					// 先假设选定棋子(flag)走到该格
					k = box[i][j].type;
					box[i][j].type = 2;
					box[flag / 7][flag % 7].type = 0;

					// 参数重置
					for (x = 0; x < 16; x++)
					{
						for (y = 0; y < 7; y++)
						{
							box1[x][y].type = 0;
							box2[x][y].type = 0;
						}
					}

					// 重新判断
					check ();

					// 依旧是危险格,则是危险,但不改变可抵达状态
					if (box2[i][j].type == 1)
					{
						// 若改变为不可抵达,则不能落子到危险格了,避免了操作失误
						// eat1[i][j]=0;
					}
					// 否则就是安全格
					else
					{
						eat2[i][j] = 0;
					}

					// 棋子还原
					box[i][j].type = k;
					box[flag / 7][flag % 7].type = 2;
				}
			}
		}

		// 纠正,反取
		for (i = 0; i < 16; i++)
		{
			for (j = 0; j < 7; j++)
			{
				box1[i][j].type = eat1[i][j];
				box2[i][j].type = eat2[i][j];
			}
		}
	}
}


// 判定落点,安全点函数
void game::check ()
{
	int i, j, k;

	for (i = 1; i < 14; i++)
	{
		for (j = 0; j < 7; j++)
		{
			if (box[i][j].type == 1)
			{
				switch (box[i][j].piecenum)
				{
					// 兵
				case 1:
				{
					// 下方
					box2[i + 1][j].type = 1;
					// 左方
					if (j > 0) { box2[i][j - 1].type = 1; }
					// 右方
					if (j < 6) { box2[i][j + 1].type = 1; }
					break;
				}
				// 相
				case 2:
				{
					// 不能憋象腿,四角
					if ((j) > 1 && box[i - 1][j - 1].type == 0) { box2[i - 2][j - 2].type = 1; }
					if ((j) > 1 && box[i + 1][j - 1].type == 0) { box2[i + 2][j - 2].type = 1; }
					if ((j) < 5 && box[i - 1][j + 1].type == 0) { box2[i - 2][j + 2].type = 1; }
					if ((j) < 5 && box[i + 1][j + 1].type == 0) { box2[i + 2][j + 2].type = 1; }
					break;
				}
				// 马
				case 3:
				{
					// 不能憋马腿,八角
					if (j > 1 && box[i][j - 1].type == 0) { box2[i - 1][j - 2].type = 1; box2[i + 1][j - 2].type = 1; }
					if (j < 5 && box[i][j + 1].type == 0) { box2[i - 1][j + 2].type = 1; box2[i + 1][j + 2].type = 1; }

					if (box[i - 1][j].type == 0 && j > 0) { box2[i - 2][j - 1].type = 1; }
					if (box[i - 1][j].type == 0 && j < 6) { box2[i - 2][j + 1].type = 1; }

					if (box[i + 1][j].type == 0 && j > 0) { box2[i + 2][j - 1].type = 1; }
					if (box[i + 1][j].type == 0 && j < 6) { box2[i + 2][j + 1].type = 1; }
					break;
				}
				// 车
				case 4:
				{
					// 四条直线,阻碍则止
					// 左
					k = j;
					while ((k - 1) >= 0 && box[i][k - 1].type != 1) { box2[i][k - 1].type = 1; k--; }
					if ((k - 1) >= 0 && box[i][k - 1].type == 1) { box2[i][k - 1].type = 1; }
					// 右
					k = j;
					while ((k + 1) <= 6 && box[i][k + 1].type != 1) { box2[i][k + 1].type = 1; k++; }
					if ((k + 1) <= 6 && box[i][k + 1].type == 1) { box2[i][k + 1].type = 1; }
					// 上
					k = i;
					while ((k - 1) >= 0 && box[k - 1][j].type != 1) { box2[k - 1][j].type = 1; k--; }
					if ((k - 1) >= 0 && box[k - 1][j].type == 1) { box2[k - 1][j].type = 1; }
					// 下
					k = i;
					while ((k + 1) <= 13 && box[k + 1][j].type != 1) { box2[k + 1][j].type = 1; k++; }
					if ((k + 1) <= 13 && box[k + 1][j].type == 1) { box2[k + 1][j].type = 1; }
					break;
				}
				// 士
				case 5:
				{
					// 四角
					if (j > 0) { box2[i + 1][j - 1].type = 1; box2[i - 1][j - 1].type = 1; }
					if (j < 6) { box2[i + 1][j + 1].type = 1; box2[i - 1][j + 1].type = 1; }
					break;
				}
				// 炮
				case 6:
				{
					// 架炮后与车一样
					// 四条直线,遇阻碍则开始,再遇则结束
					// 左
					k = j;
					while ((k - 1) >= 0 && box[i][k - 1].type == 0) { k--; }
					if ((k - 1) >= 0 && box[i][k - 1].type != 0)
					{
						k--;
						while ((k - 1) >= 0 && box[i][k - 1].type != 1) { box2[i][k - 1].type = 1; k--; }
						if ((k - 1) >= 0 && box[i][k - 1].type == 1) { box2[i][k - 1].type = 1; }
					}
					// 右
					k = j;
					while ((k + 1) <= 6 && box[i][k + 1].type == 0) { k++; }
					if ((k + 1) <= 6 && box[i][k + 1].type != 0)
					{
						k++;
						while ((k + 1) <= 6 && box[i][k + 1].type != 1) { box2[i][k + 1].type = 1; k++; }
						if ((k + 1) <= 6 && box[i][k + 1].type == 1) { box2[i][k + 1].type = 1; }
					}
					// 上
					k = i;
					while ((k - 1) >= 0 && box[k - 1][j].type == 0) { k--; }
					if ((k - 1) >= 0 && box[k - 1][j].type != 0)
					{
						k--;
						while ((k - 1) >= 0 && box[k - 1][j].type != 1) { box2[k - 1][j].type = 1; k--; }
						if ((k - 1) >= 0 && box[k - 1][j].type == 1) { box2[k - 1][j].type = 1; }
					}
					// 下
					k = i;
					while ((k + 1) <= 13 && box[k + 1][j].type == 0) { k++; }
					if ((k + 1) <= 13 && box[k + 1][j].type != 0)
					{
						k++;
						while ((k + 1) <= 13 && box[k + 1][j].type != 1) { box2[k + 1][j].type = 1; k++; }
						if ((k + 1) <= 13 && box[k + 1][j].type == 1) { box2[k + 1][j].type = 1; }
					}
					break;
				}
				default:break;
				}
			}
			else if (box[i][j].type == 2)
			{
				switch (box[i][j].piecenum)
				{
					// 兵
				case 1:
				{
					// 下方
					box1[i - 1][j].type = 1;
					// 左方
					if (j > 0) { box1[i][j - 1].type = 1; }
					// 右方
					if (j < 6) { box1[i][j + 1].type = 1; }
					break;
				}
				// 相
				case 2:
				{
					// 不能憋象腿,四角
					if ((j) > 1 && box[i - 1][j - 1].type == 0) { box1[i - 2][j - 2].type = 1; }
					if ((j) > 1 && box[i + 1][j - 1].type == 0) { box1[i + 2][j - 2].type = 1; }
					if ((j) < 5 && box[i - 1][j + 1].type == 0) { box1[i - 2][j + 2].type = 1; }
					if ((j) < 5 && box[i + 1][j + 1].type == 0) { box1[i + 2][j + 2].type = 1; }
					break;
				}
				// 马
				case 3:
				{
					// 不能憋马腿,八角
					if (j > 1 && box[i][j - 1].type == 0) { box1[i - 1][j - 2].type = 1; box1[i + 1][j - 2].type = 1; }
					if (j < 5 && box[i][j + 1].type == 0) { box1[i - 1][j + 2].type = 1; box1[i + 1][j + 2].type = 1; }

					if (box[i - 1][j].type == 0 && j > 0) { box1[i - 2][j - 1].type = 1; }
					if (box[i - 1][j].type == 0 && j < 6) { box1[i - 2][j + 1].type = 1; }

					if (box[i + 1][j].type == 0 && j > 0) { box1[i + 2][j - 1].type = 1; }
					if (box[i + 1][j].type == 0 && j < 6) { box1[i + 2][j + 1].type = 1; }
					break;
				}
				// 车
				case 4:
				{
					// 四条直线,阻碍则止
					// 左
					k = j;
					while ((k - 1) >= 0 && box[i][k - 1].type == 0) { box1[i][k - 1].type = 1; k--; }
					if ((k - 1) >= 0 && box[i][k - 1].type == 1) { box1[i][k - 1].type = 1; }
					// 右
					k = j;
					while ((k + 1) <= 6 && box[i][k + 1].type == 0) { box1[i][k + 1].type = 1; k++; }
					if ((k + 1) <= 6 && box[i][k + 1].type == 1) { box1[i][k + 1].type = 1; }
					// 上
					k = i;
					while ((k - 1) >= 0 && box[k - 1][j].type == 0) { box1[k - 1][j].type = 1; k--; }
					if ((k - 1) >= 0 && box[k - 1][j].type == 1) { box1[k - 1][j].type = 1; }
					// 下
					k = i;
					while ((k + 1) <= 13 && box[k + 1][j].type == 0) { box1[k + 1][j].type = 1; k++; }
					if ((k + 1) <= 13 && box[k + 1][j].type == 1) { box1[k + 1][j].type = 1; }
					break;
				}
				// 士
				case 5:
				{
					// 四角
					if (j > 0) { box1[i + 1][j - 1].type = 1; box1[i - 1][j - 1].type = 1; }
					if (j < 6) { box1[i + 1][j + 1].type = 1; box1[i - 1][j + 1].type = 1; }
					break;
				}
				// 炮
				case 6:
				{
					// 架炮前与车一样
					// 四条直线,阻碍则可以打下一个阻碍
					// 左
					k = j;
					while ((k - 1) >= 0 && box[i][k - 1].type == 0) { box1[i][k - 1].type = 1; k--; }
					if ((k - 1) >= 0 && box[i][k - 1].type != 0)
					{
						k--;
						while ((k - 1) >= 0 && box[i][k - 1].type == 0) { k--; }
						if ((k - 1) >= 0 && box[i][k - 1].type == 1)
						{
							box1[i][k - 1].type = 1;
						}
					}
					// 右
					k = j;
					while ((k + 1) <= 6 && box[i][k + 1].type == 0) { box1[i][k + 1].type = 1; k++; }
					if ((k + 1) <= 6 && box[i][k + 1].type != 0)
					{
						k++;
						while ((k + 1) <= 6 && box[i][k + 1].type == 0) { k++; }
						if ((k + 1) <= 6 && box[i][k + 1].type == 1)
						{
							box1[i][k + 1].type = 1;
						}
					}
					// 上
					k = i;
					while ((k - 1) >= 0 && box[k - 1][j].type == 0) { box1[k - 1][j].type = 1; k--; }
					if ((k - 1) >= 0 && box[k - 1][j].type != 0)
					{
						k--;
						while ((k - 1) >= 0 && box[k - 1][j].type == 0) { k--; }
						if ((k - 1) >= 0 && box[k - 1][j].type == 1)
						{
							box1[k - 1][j].type = 1;
						}
					}
					// 下
					k = i;
					while ((k + 1) <= 13 && box[k + 1][j].type == 0) { box1[k + 1][j].type = 1; k++; }
					if ((k + 1) <= 13 && box[k + 1][j].type != 0)
					{
						k++;
						while ((k + 1) <= 13 && box[k + 1][j].type == 0) { k++; }
						if ((k + 1) <= 13 && box[k + 1][j].type == 1)
						{
							box1[k + 1][j].type = 1;
						}
					}
					break;
				}
				default:break;
				}
			}
		}
	}
}


// 提示绘制函数
void game::draw_tip ()
{

	int i, j;

	for (i = 1; i < 14; i++)
	{
		for (j = 0; j < 7; j++)
		{
			// 是可达位,或危险位
			if (box2[i][j].type == 1 || box1[i][j].type == 1)
			{
				// 优先危险显示
				if (box2[i][j].type == 1)
				{
					setlinecolor (BLACK);
				}
				// 可抵达显示
				else if (box1[i][j].type == 1)
				{
					setlinecolor (LIGHTGREEN);
				}
				setlinestyle (PS_SOLID, 2);
				// 空位显示架空十字架
				if (box[i][j].type == 0)
				{
					line (box[i][j].posx + 5, box[i][j].posy + 5, box[i][j].posx + 5, box[i][j].posy + 10);
					line (box[i][j].posx + 5, box[i][j].posy + 5, box[i][j].posx + 10, box[i][j].posy + 5);

					line (box[i][j].posx + 5, box[i][j].posy - 5, box[i][j].posx + 5, box[i][j].posy - 10);
					line (box[i][j].posx + 5, box[i][j].posy - 5, box[i][j].posx + 10, box[i][j].posy - 5);

					line (box[i][j].posx - 5, box[i][j].posy + 5, box[i][j].posx - 5, box[i][j].posy + 10);
					line (box[i][j].posx - 5, box[i][j].posy + 5, box[i][j].posx - 10, box[i][j].posy + 5);

					line (box[i][j].posx - 5, box[i][j].posy - 5, box[i][j].posx - 5, box[i][j].posy - 10);
					line (box[i][j].posx - 5, box[i][j].posy - 5, box[i][j].posx - 10, box[i][j].posy - 5);
				}
				// 非空位显示小方框
				else
				{
					line (box[i][j].posx + 15, box[i][j].posy + 15, box[i][j].posx + 15, box[i][j].posy + 10);
					line (box[i][j].posx + 15, box[i][j].posy + 15, box[i][j].posx + 10, box[i][j].posy + 15);

					line (box[i][j].posx + 15, box[i][j].posy - 15, box[i][j].posx + 15, box[i][j].posy - 10);
					line (box[i][j].posx + 15, box[i][j].posy - 15, box[i][j].posx + 10, box[i][j].posy - 15);

					line (box[i][j].posx - 15, box[i][j].posy + 15, box[i][j].posx - 15, box[i][j].posy + 10);
					line (box[i][j].posx - 15, box[i][j].posy + 15, box[i][j].posx - 10, box[i][j].posy + 15);

					line (box[i][j].posx - 15, box[i][j].posy - 15, box[i][j].posx - 15, box[i][j].posy - 10);
					line (box[i][j].posx - 15, box[i][j].posy - 15, box[i][j].posx - 10, box[i][j].posy - 15);
				}
			}
		}
	}
	FlushBatchDraw ();
}


// 棋子绘制
void game::draw_piece (int posx, int posy, LPTSTR text, COLORREF color)
{
	int i, j;

	setlinestyle (PS_SOLID, 1);
	// 阴影
	setlinecolor (RGB (121, 75, 52));
	setfillcolor (RGB (121, 75, 52));
	fillcircle (posx, posy + 7, 20);

	// 侧面
	setlinecolor (RGB (212, 158, 111));
	setfillcolor (RGB (212, 158, 111));
	for (i = 0; i < 3; i++)
	{
		fillcircle (posx, posy + i + 4, 18);
	}

	// 正面
	setlinecolor (RGB (246, 203, 155));
	setfillcolor (RGB (246, 203, 155));
	fillcircle (posx, posy, 15);

	// 刻字
	setlinecolor (color);

	setlinestyle (PS_SOLID, 2);
	setfillstyle (BS_NULL);
	fillcircle (posx, posy, 14);
	setfillstyle (BS_SOLID);


	settextcolor (color);
	setbkmode (TRANSPARENT);
	settextstyle (22, 11, _T ("Consolas"));
	for (i = 0; i < 1; i++)
	{
		for (j = 0; j < 2; j++)
		{
			outtextxy (posx - 10 + i, posy - 10 + j, text);
		}
	}
	setbkmode (OPAQUE);

	FlushBatchDraw ();
}


// 棋子生成函数,已知行数
void game::creact_piece (int floor)
{
	int i, k;

	// 随机列数
	do
	{
		i = rand () % 7;
	} while (box[floor][i].type != 0);

	box[floor][i].type = 1;
	box[floor][i].color = BLACK;

	// 随机棋子
	k = rand () % 6 + 1;
	box[floor][i].piecenum = k;

	switch (k)
	{
	case 1:box[floor][i].text = _T ("兵"); break;
	case 2:box[floor][i].text = _T ("相"); break;
	case 3:box[floor][i].text = _T ("马"); break;
	case 4:box[floor][i].text = _T ("车"); break;
	case 5:box[floor][i].text = _T ("士"); break;
	case 6:box[floor][i].text = _T ("炮"); break;
	case 7:box[floor][i].text = _T (""); break;
	default:break;
	}
}

参考资料

添加评论