妙妙小豆子

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

六边形扫雷:扫雷模式 银牌收录

程序简介

六边形扫雷,相较于原版可能是简单了。经典扫雷高级难度 480 格,99 个雷,雷比例 20.63%。扫雷是存在需要猜的时候,这个雷的比例与要猜的比例和猜的难度可能是正相关吧。

程序中,输入边长后会自动给出总格子数,根据总格子数设置合理的雷数吧,这个我没有什么参考,只能做成自定义的样子。

机器标记是指,一些格子周围的空格子数和存在的雷数相等,点击按钮后会自动把这些空格标记上。如果后续加上模拟点击一定是安全的格子。这两步算一个周期,最后就会只剩下我需要猜的地方了......

谢谢站内学长教我画地雷和格子。

程序运行展示

完整源代码

////////////////////////////////////////
// 程序:六边形扫雷:扫雷模式
// 作者:Gary
// 编译环境:Visual C++ 2010,EasyX_20211109
// 编写日期:2020-6-19

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

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

// 定义一个结构体,按钮
struct Node1
{
	int posx1, posy1, posx2, posy2;		// 坐标
	int mod;							// 状态
	LPTSTR text;						// 文字
};

// 定义一个结构体,六边形格子
struct Node2
{
	int i, j, k;						// 特征值
	int mod_life;						// 翻开
	int mod_mine;						// 雷
	int mod_xiao;						// 消零处理
	int mod_flag;						// 标记
	int posx, posy;						// 坐标
	int num_mine;						// 周边雷数量
	int num_peace;						// 周边空地块数量
};

// 定义一个类
class Gary
{
public:
	void carry ();						// 主进程
	void initialization ();				// 初始化
	void draw_scene ();					// 绘制界面函数
	void draw_box (int num_box);		// 绘制格子函数
	void draw_mine (int num_box);		// 绘制地雷函数
	void draw_flag (int num_box);		// 绘制旗子函数
	void draw_num (int num_box, int num);	// 绘制数字函数
	void machine ();					// 机器标记函数
	void move ();						// 窗口主视角
	void create ();						// 地雷生成函数
	void check_zero (int i);			// 消零处理函数
	void check_over ();					// 结束判断函数

	int num_button;						// 按钮数量参数
	int exit_carry;						// 主循函数控制参数
	int exit_move;						// 开始界面控制参数
	int exit_game;						// 游戏进行控制参数
	int num_size;						// 边长
	int num_mine;						// 地雷数量
	int num_box;						// 地块数量
	int num_flag;						// 标记数量
	COLORREF color_text[2];				// 按钮填充颜色	
	COLORREF color_num[8];				// 数字填充颜色
	Node1 boxm[30];						// 按钮,预制 30 个
	Node2 box[1000];					// 地块格子
};

// 地雷绘制
void Gary::draw_mine (int num_box)
{
	int i;
	// 六边形绘制,格子处于被点击后状态
	setfillcolor (RGB (170, 170, 170));
	setlinecolor (RGB (85, 85, 85));
	POINT pts[6];
	setlinestyle (PS_SOLID, 1);
	for (i = 0; i < 6; i++)
	{
		pts[i].x = long(box[num_box].posx + 14.0 * cos (60.0 * double (i) * pi / 180.0));
		pts[i].y = long(box[num_box].posy + 14.0 * sin (60.0 * double (i) * pi / 180.0));
	}
	fillpolygon (pts, 6);

	// 地雷绘制
	setfillcolor (BLACK);
	setlinecolor (BLACK);
	fillcircle (box[num_box].posx, box[num_box].posy, 5);
	line (box[num_box].posx - 6, box[num_box].posy, box[num_box].posx + 6, box[num_box].posy);
	line (box[num_box].posx, box[num_box].posy - 6, box[num_box].posx, box[num_box].posy + 6);
	setfillcolor (WHITE);
	setlinecolor (WHITE);
	fillcircle (box[num_box].posx - 2, box[num_box].posy - 2, 1);
}

// 棋子绘制
void Gary::draw_flag (int num_box)
{
	// 棋子绘制
	setlinestyle (PS_SOLID, 1);
	setlinecolor (BLACK);
	line (box[num_box].posx + 2, box[num_box].posy + 7, box[num_box].posx + 2, box[num_box].posy - 7);
	setfillcolor (LIGHTRED);
	setlinecolor (LIGHTRED);
	fillrectangle (box[num_box].posx - 7 + 2, box[num_box].posy - 7, box[num_box].posx + 2, box[num_box].posy - 1);
}

// 数字绘制
void Gary::draw_num (int num_box, int num)
{
	int i;
	// 六边形绘制,格子处于被点击后状态
	setfillcolor (RGB (170, 170, 170));
	setlinecolor (RGB (85, 85, 85));
	POINT pts[6];
	setlinestyle (PS_SOLID, 1);
	for (i = 0; i < 6; i++)
	{
		pts[i].x = long(box[num_box].posx + 14.0 * cos (60.0 * double (i) * pi / 180.0));
		pts[i].y = long(box[num_box].posy + 14.0 * sin (60.0 * double (i) * pi / 180.0));
	}
	fillpolygon (pts, 6);

	// 数字绘制
	TCHAR s[15];
	settextcolor (color_num[num]);
	settextstyle (20, 0, _T ("Consolas"));
	_stprintf_s (s, _T ("%0.1d"), num);
	outtextxy (box[num_box].posx - 5, box[num_box].posy - 10, s);
}

// 机器标记函数
void Gary::machine ()
{
	int i, j;
	// 周边空格数统计
	// 遍历
	for (i = 0; i <= 888; i++)
	{
		// 空格初始化
		box[i].num_peace = 0;
		// 对所有已翻开的格子进行分析
		if (box[i].mod_life == 1)
		{
			// 遍历
			for (j = 0; j <= 888; j++)
			{
				// 对未翻开的格子进行分析
				if (box[j].mod_life == 0)
				{
					// 周围六个且未翻开
					if ((box[j].posx - box[i].posx) * (box[j].posx - box[i].posx) + (box[j].posy - box[i].posy) * (box[j].posy - box[i].posy) <= 900)
					{
						// 周边空格数参数加一
						box[i].num_peace++;
					}
				}
			}
			// 判断是否唯一确定,即周边空格数等于周边雷数,则这些空格都藏雷
			if (box[i].num_peace == box[i].num_mine)
			{
				// 遍历
				for (j = 0; j <= 888; j++)
				{
					// 空格
					if (box[j].mod_life == 0)
					{
						// 周围六个,空格,未标记状态
						if ((box[j].posx - box[i].posx) * (box[j].posx - box[i].posx) + (box[j].posy - box[i].posy) * (box[j].posy - box[i].posy) <= 900 && box[j].mod_flag == 0)
						{
							// 标记
							box[j].mod_flag = 1;
							// 标记数加一
							num_flag++;
							// 绘制
							draw_flag (j);
						}
					}
				}
			}
		}
	}
}

// 场景绘制函数
void Gary::draw_scene ()
{
	TCHAR s[15];
	int i, j;
	// 主界面
	setlinecolor (BLACK);
	setfillcolor (WHITE);
	setlinestyle (PS_SOLID, 1);
	fillrectangle (401, 0, 650, 400);
	// 根据按钮数量绘制	
	settextcolor (BLACK);
	for (i = 0; i < num_button; i++)
	{
		setfillcolor (color_text[boxm[i].mod]);
		setbkcolor (color_text[boxm[i].mod]);
		// 边框
		fillrectangle (boxm[i].posx1, boxm[i].posy1, boxm[i].posx2, boxm[i].posy2);
		// 文字
		outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + 4, boxm[i].text);
	}

	// 设置参数
	setbkcolor (WHITE);
	settextcolor (BLACK);
	setlinecolor (BLACK);

	// 变量绘制
	j = 25;
	// 边长
	i = 2;
	setbkcolor (color_text[boxm[i].mod]);
	_stprintf_s (s, _T ("%0.1d"), num_size);
	outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + j, s);
	// 地雷总数
	i = 3;
	setbkcolor (color_text[boxm[i].mod]);
	_stprintf_s (s, _T ("%0.1d"), num_mine);
	outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + j, s);
	// 地块总数
	i = 4;
	setbkcolor (color_text[boxm[i].mod]);
	_stprintf_s (s, _T ("%0.1d"), num_box);
	outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + j, s);
	// 标记数
	i = 5;
	setbkcolor (color_text[boxm[i].mod]);
	_stprintf_s (s, _T ("%0.1d"), num_flag);
	outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + j, s);

	FlushBatchDraw ();
}

// 地雷生成函数
void Gary::create ()
{
	int i, j;
	// 设置雷
	for (i = 0; i < num_mine; i++)
	{
		// 随机
		j = rand () % 1000;
		while (box[j].mod_mine == 1 || box[j].mod_life == 1)
		{
			// 随机
			j = rand () % 1000;
		}
		// 是雷
		box[j].mod_mine = 1;
	}
	// 周边雷数统计
	// 遍历
	for (i = 0; i <= 888; i++)
	{
		// 未翻开
		if (box[i].mod_life == 0)
		{
			// 遍历
			for (j = 0; j <= 999; j++)
			{
				// 排除自己
				if (j != i && box[j].mod_life == 0)
				{
					// 周围六个且未翻开
					if ((box[j].posx - box[i].posx) * (box[j].posx - box[i].posx) + (box[j].posy - box[i].posy) * (box[j].posy - box[i].posy) <= 900)
					{
						// 是雷
						if (box[j].mod_mine == 1)
						{
							// 周边雷数参数加一
							box[i].num_mine++;
						}
					}
				}
			}
		}
	}
}

// 消零处理函数
void Gary::check_zero (int i)
{
	int j;
	// 对所有点遍历分析
	for (j = 0; j <= 888; j++)
	{
		// 显示周围六个点
		if ((box[j].posx - box[i].posx) * (box[j].posx - box[i].posx) + (box[j].posy - box[i].posy) * (box[j].posy - box[i].posy) <= 900)
		{
			// 未翻开
			if (box[j].mod_life == 0)
			{
				// 绘制
				draw_num (j, box[j].num_mine);
				// 翻开,避免重复操作
				box[j].mod_life = 1;
			}
		}
	}
	// 改变消零状态
	box[i].mod_xiao = 1;
	// 对所有点遍历分析
	for (i = 0; i <= 888; i++)
	{
		// 对周围雷数为零,已翻开,未进行消零处理的点进行分析
		if (box[i].num_mine == 0 && box[i].mod_life == 1 && box[i].mod_xiao == 0)
		{
			// 再遍历
			for (j = 0; j <= 888; j++)
			{
				// 对该点周围六点,未翻开的点全部翻开
				if ((box[j].posx - box[i].posx) * (box[j].posx - box[i].posx) + (box[j].posy - box[i].posy) * (box[j].posy - box[i].posy) <= 900)
				{
					if (box[j].mod_life == 0)
					{
						// 绘制
						draw_num (j, box[j].num_mine);
						// 翻开,避免重复操作
						box[j].mod_life = 1;
					}
				}
			}
			// 该点已进行过消零处理
			box[i].mod_xiao = 1;
			// 重置
			i = -1;
		}
	}
}

// 结束判定函数
void Gary::check_over ()
{
	int i, k;
	k = 0;
	// 遍历
	for (i = 0; i <= 888; i++)
	{
		// 每有一个翻开且不是雷的点,则加一
		if (box[i].mod_mine == 0 && box[i].mod_life == 1)
		{
			k++;
		}
	}
	// 全翻开则结束
	if (k == num_box - num_mine)
	{
		// 将所有雷格进行小红旗标记
		for (i = 0; i <= 888; i++)
		{
			if (box[i].mod_mine == 1)
			{
				draw_flag (i);
			}
		}
		// 胜利标志,笑脸
		setfillcolor (WHITE);
		setlinecolor (WHITE);
		fillrectangle (50, 20, 75, 45);
		settextstyle (30, 0, _T ("Wingdings"));
		setbkmode (TRANSPARENT);
		settextcolor (BLACK);
		outtextxy (50, 20, 0x4A);
		setbkmode (OPAQUE);
		settextstyle (20, 0, _T ("Consolas"));
		// 结束变化,游戏控制参数变化,按钮可点击状态变化
		exit_game = 1;
		boxm[1].mod = 1;
		boxm[2].mod = 0;
		boxm[3].mod = 0;
		boxm[6].mod = 0;
		boxm[7].mod = 1;
		num_flag = 0;
		// 绘制
		draw_scene ();
	}
}

// 格子绘制函数
void Gary::draw_box (int num_box)
{
	int i;
	int posx, posy;
	
	// 六边形绘制,格子处于点击前状态
	posx = box[num_box].posx;
	posy = box[num_box].posy;

	POINT pts[6];
	setlinestyle (PS_SOLID, 2);
	// 背景色
	setfillcolor (RGB (255, 255, 255));
	for (i = 0; i < 6; i++)
	{
		pts[i].x = long(posx + 14.0 * cos (60.0 * double (i) * pi / 180.0));
		pts[i].y = long(posy + 14.0 * sin (60.0 * double (i) * pi / 180.0));
	}
	solidpolygon (pts, 6);
	// 灰边
	setlinecolor (RGB (85, 85, 85));
	line (pts[0].x, pts[0].y, pts[1].x, pts[1].y);
	line (pts[5].x, pts[5].y, pts[0].x, pts[0].y);
	line (pts[1].x, pts[1].y, pts[2].x, pts[2].y);
	// 前景色
	setfillcolor (RGB (170, 170, 170));
	for (i = 0; i < 6; i++)
	{
		pts[i].x = long(posx + 12.0 * cos (60.0 * double (i) * pi / 180.0));
		pts[i].y = long(posy + 12.0 * sin (60.0 * double (i) * pi / 180.0));
	}
	solidpolygon (pts, 6);
	FlushBatchDraw ();
}

// 初始化函数
void Gary::initialization ()
{
	int i, j, k, t;
	// 随机初始化
	srand ((unsigned)time (NULL));
	// 颜色初始化
	color_text[0] = WHITE;
	color_text[1] = RGB (170, 170, 170);

	color_num[0] = RGB (170, 170, 170);
	color_num[1] = RGB (0, 0, 200);
	color_num[2] = RGB (0, 150, 0);
	color_num[3] = RGB (255, 0, 0);
	color_num[4] = RGB (0, 0, 100);
	color_num[5] = RGB (130, 0, 0);
	color_num[6] = RGB (0, 150, 150);

	// 按钮的初始化
	num_button = 10;

	// 坐标
	for (i = 0; i < 10; i++)
	{
		boxm[i].posx1 = 410 + 120 * (i % 2);
		boxm[i].posy1 = 25 + 75 * (i / 2);
		boxm[i].posx2 = 520 + 120 * (i % 2);
		boxm[i].posy2 = 75 + 75 * (i / 2);
	}

	// 内容
	boxm[0].text = _T ("扫雷模式");	boxm[1].text = _T ("机器标记");
	boxm[2].text = _T ("地图边长");	boxm[3].text = _T ("总地雷数");
	boxm[4].text = _T ("总地块数");	boxm[5].text = _T ("已标记数");
	boxm[6].text = _T ("开始");		boxm[7].text = _T ("重置");
	boxm[8].text = _T ("截图");		boxm[9].text = _T ("退出");

	// 状态
	boxm[0].mod = 1;
	boxm[1].mod = 0;
	boxm[2].mod = 1;
	boxm[3].mod = 1;
	boxm[4].mod = 1;
	boxm[5].mod = 1;
	boxm[6].mod = 1;
	boxm[7].mod = 0;
	boxm[8].mod = 0;
	boxm[9].mod = 0;

	// 参数初始化
	num_box = 3 * num_size * (num_size - 1) + 1;
	num_flag = 0;

	// 绘制参数初始化
	setlinecolor (BLACK);
	setlinestyle (PS_SOLID, 1);
	settextstyle (20, 0, _T ("Consolas"));
	// 第一次绘制
	draw_scene ();

	// 重置
	setfillcolor (WHITE);
	fillrectangle (0, 0, 400, 400);

	// 平静脸
	setfillcolor (WHITE);
	setlinecolor (WHITE);
	fillrectangle (50, 20, 75, 45);
	settextstyle (30, 0, _T ("Wingdings"));
	setbkmode (TRANSPARENT);
	settextcolor (BLACK);
	outtextxy (50, 20, 0x4B);
	setbkmode (OPAQUE);
	settextstyle (20, 0, _T ("Consolas"));

	// 格子初始化,全部视为城墙
	for (t = 0; t <= 999; t++)
	{
		// 已翻开
		box[t].mod_life = 1;
		// 已进行消零处理
		box[t].mod_xiao = 1;
		// 城墙
		box[t].mod_mine = 2;
		// 坐标,点不到
		box[t].posx = -200;
		box[t].posy = -200;
	}

	// 根据边长初始化
	for (i = 0; i < num_size; i++)
	{
		for (j = 0; j < num_size; j++)
		{
			for (k = 0; k < num_size; k++)
			{
				// 六边形保证至少一个特征值为零
				if (i == 0 || j == 0 || k == 0)
				{
					// 编号
					t = i * 100 + j * 10 + k;
					// 特征值
					box[t].i = i;
					box[t].j = j;
					box[t].k = k;
					// 未翻开
					box[t].mod_life = 0;
					// 不是雷
					box[t].mod_mine = 0;
					// 未进行消零处理
					box[t].mod_xiao = 0;
					// 未标记
					box[t].mod_flag = 0;
					// 坐标
					box[t].posx = 200 + 22 * (j - k);
					box[t].posy = 200 - 25 * i + 13 * (j + k);
					// 周围雷数初始化
					box[t].num_mine = 0;
					box[t].num_peace = 0;
					// 绘制地块
					draw_box (t);
				}
			}
		}
	}
	// 根据设定地雷数生成地雷
	create ();
}

// 窗口主视角函数,获取用户操作
void Gary::move ()
{
	// 鼠标定义
	ExMessage m;
	TCHAR ss[15];
	int i, t;
	exit_move = 0;
	exit_game = 0;
	while (exit_move == 0)
	{
		// 鼠标信息
		if (peekmessage (&m, EM_MOUSE | EM_KEY))
		{
			// 左键单击判断
			if (m.message == WM_LBUTTONDOWN)
			{
				// 判断是否点击了格子且游戏处于进行阶段
				if (m.x > 0 && m.y > 0 && m.x < 400 && m.y < 400 && exit_game == 0)
				{
					for (t = 0; t <= 888; t++)
					{
						// 成功点击未被标记的空格子
						if ((m.x - box[t].posx) * (m.x - box[t].posx) + (m.y - box[t].posy) * (m.y - box[t].posy) <= 144 && box[t].mod_life == 0 && box[t].mod_flag == 0)
						{
							// 点击的格子不是雷
							if (box[t].mod_mine == 0)
							{
								// 绘制
								draw_num (t, box[t].num_mine);
								// 改为翻开
								box[t].mod_life = 1;
								// 消零处理,点击的是周围无雷的零格子
								if (box[t].num_mine == 0)
								{
									check_zero (t);
								}
							}
							// 点击的格子是雷
							else if (box[t].mod_mine == 1)
							{
								// 失败结束处理
								// 所有的雷地块已雷的形式出现
								for (i = 0; i <= 888; i++)
								{
									if (box[i].mod_mine == 1)
									{
										draw_mine (i);
									}
								}
								// 失败标志:哭脸
								setfillcolor (WHITE);
								setlinecolor (WHITE);
								fillrectangle (50, 20, 75, 45);
								settextstyle (30, 0, _T ("Wingdings"));
								setbkmode (TRANSPARENT);
								settextcolor (BLACK);
								outtextxy (50, 20, 0x4C);
								setbkmode (OPAQUE);
								settextstyle (20, 0, _T ("Consolas"));
								// 结束处理
								exit_game = 1;
								boxm[1].mod = 1;
								boxm[2].mod = 0;
								boxm[3].mod = 0;
								boxm[6].mod = 0;
								boxm[7].mod = 1;
								num_flag = 0;
								// 绘制
								draw_scene ();
							}
							// 成功结束判断
							check_over ();
							break;
						}
					}
				}

				// 判断是否点击了有效按钮
				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].mod == 0)
					{
						break;
					}
				}

				// 点击矩形按钮
				switch (i)
				{
				// 机器标记
				case 1:
				{
					// 机器标记
					machine ();
					// 绘制
					draw_scene ();
					break;
				}
				// 地图边长:num_size
				case 2:
				{
					// 输入
					InputBox (ss, 10, _T ("输入边长(2 ~ 8)"));
					_stscanf_s (ss, _T ("%d"), &i);
					if (i > 1 && i <= 8)
					{
						// 边长
						num_size = i;
						// 地块总数
						num_box = 3 * num_size * (num_size - 1) + 1;
					}
					else { MessageBox (hOut, _T ("输入错误,不在范围内"), _T ("来自小豆子的提醒"), MB_OK); }
					// 绘制
					draw_scene ();
					break;
				}
				// 总地雷数:num_mine
				case 3:
				{
					InputBox (ss, 10, _T ("输入地雷数(1 ~ 总格子数)"));
					_stscanf_s (ss, _T ("%d"), &i);
					if (i > 0 && i < num_box)
					{
						num_mine = i;
					}
					else { MessageBox (hOut, _T ("输入错误,不在范围内"), _T ("来自小豆子的提醒"), MB_OK); }
					// 绘制
					draw_scene ();
					break;
				}
				// 开始
				case 6:
				{
					// 地块总数
					num_box = 3 * num_size * (num_size - 1) + 1;
					// 要求雷数小于地块总数
					// 如果有第一下不为雷的功能,雷数就要小于地块总数减一
					if (num_mine < num_box)
					{
						// 游戏处于进行阶段,退出准备阶段
						exit_game = 0;
						// 初始化
						initialization ();
						
					}
					else
					{
						MessageBox (hOut, _T ("请将雷数修改为小于格子数"), _T ("来自小豆子的提醒"), MB_OK);
					}
					break;
				}
				// 重置
				case 7:
				{
					// 游戏退出进行阶段,进入准备阶段,强行结束
					if (exit_game == 0)
					{
						exit_game = 1;
						boxm[1].mod = 1;
						boxm[2].mod = 0;
						boxm[3].mod = 0;
						boxm[6].mod = 0;
						boxm[7].mod = 1;
						num_flag = 0;
						// 绘制
						draw_scene ();
					}
					break;
				}
				// 截图
				case 8:
				{
					// 不用自己截图了
					saveimage (_T ("image.png"));
					break;
				}
				// 退出
				case 9:
				{
					// 所有控制参数结束
					exit_game = 1;
					exit_move = 1;
					exit_carry = 1;
					break;
				}
				default:break;
				}
			}
			// 右键标记
			else if (m.message == WM_RBUTTONDOWN && exit_game == 0)
			{
				for (t = 0; t <= 888; t++)
				{
					// 成功点击空格子
					if ((m.x - box[t].posx) * (m.x - box[t].posx) + (m.y - box[t].posy) * (m.y - box[t].posy) <= 144 && box[t].mod_life == 0)
					{
						// 标记状态转换
						box[t].mod_flag = (box[t].mod_flag == 0 ? 1 : 0);
						// 绘制
						draw_box (t);
						// 标记状态
						if (box[t].mod_flag == 1)
						{
							// 绘制
							draw_flag (t);
							// 标记数加一
							num_flag++;
						}
						else
						{
							// 标记数减一
							num_flag--;
						}
						// 绘制
						draw_scene ();
					}
				}
			}
		}
	}
}

// 主进程
void Gary::carry ()
{
	// 窗口定义
	hOut = initgraph (651, 401);
	SetWindowText (hOut, _T ("六边形扫雷:扫雷模式"));
	// 参数初始化
	num_size = 5;
	num_mine = 10;
	// 背景绘制
	setbkcolor (WHITE);
	cleardevice ();
	// 进程控制
	exit_carry = 0;
	while (exit_carry == 0)
	{
		initialization ();
		move ();
	}
	closegraph ();
}

// 主函数
int main (void)
{
	Gary G;
	G.carry ();
	return 0;
}

添加评论