利用c语言写扫雷游戏

最新推荐文章于 2024-07-08 19:48:19 发布
最新推荐文章于 2024-07-08 19:48:19 发布
阅读量336 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangzhi_521/article/details/80362663
版权

 

 

         本人菜鸟一枚，文章中有那些错误或者有一些改进的意见，希望各位大神可以指正。

  首先写任何代码之前要明白自己的代码功能，即要解决的问题、或者要实现的功能。（我没写图形界面，只完成了游戏的逻辑）。        

 

我的扫雷游戏要实现功能有：

<1>玩家走第一步不能被炸死

<2>显示该点周围有几颗雷

<3>如果坐标周围没有雷，可以实现展开

 

 

然后我们来分析扫雷游戏的逻辑（最后附源代码）
<1>首先我们得有雷可扫，所以我们应该先制作棋盘，而棋盘，就是一个二维数组。

            （1）因为以后我们要计算周围雷的个数，保证数组不越界，所以多两行两列

             （2）因为不能显示雷的位置，所以我们制作两个二维数组，一个定义雷，一个显示给玩家

             （3）我们需要初始化棋盘和打印棋盘，因为以后要反复初始化和打印，所以定义为函数              

 

 
//初始化棋盘
void InitiaBorder(char border[ROWS][COLS], int row, int col,char set)
{
	memset(border, set, col*row*sizeof(border[0][0]));
}

// 打印棋盘
void ShowBorder(char border[ROWS][COLS], int row, int col)
{
	int i = 0;
	//打印第一行
	for (int i = 0; i < col-2; i++)
	{
		if (i == 0)
			printf("|");
		printf("---|");
	}
	printf("\n");

	for (i = 1; i < row-1; i++)
	{
		int j = 0;
		printf("|");//每行第一个打印一个|
		//打印（ %c |）
		for (j = 1; j < col-1; j++)
		{
			printf(" %c |", border[i][j]);
		}
		printf("\n");
		//打印(---|)
		for (j = 0; j < col-2; j++)
		{
			if (j == 0)
				printf("|");//每行第一个打印一个 |
			printf("---|");
		}
		printf("\n");
	}
}

 

<2>然后我们需要产生雷，将此功能封装为函数

//产生雷
void CreateMine(char border[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int count = EASY ;
	while (count)
	{
		x = rand() % (row - 2) + 1;
		y = rand() % (col - 2) + 1;
		if (border[x][y] == '0')
		{
			border[x][y] = '1';
			count--;
		}
	}
}

 

 

 

<3>用户扫雷

            （1）用户首先输入坐标，先判断是否合法（是否在区域内），然后再判断是否该坐标已经被扫

            （2）如果（1）条件满足，我们需要判断是否为雷，如果是雷，则游戏结束（先不考虑第一步被炸死）

            （3）如果不是雷，则需要判断周围雷的数量（先不考虑展开），所以需要一个函数来判断周围雷的数量

//计算雷的数量
char MineCount(char border[ROWS][COLS],int x, int y)
{
 return border[x - 1][y] + border[x - 1][y + 1] + border[x][y + 1] + border[x + 1][y + 1]
  + border[x + 1][y] + border[x + 1][y - 1] + border[x][y - 1] + border[x - 1][y - 1] - 7 * '0';
}

 

           （4）现在我们来实现如果周围雷的数量为0，实现展开，

                            在实现展开时，我们应该先判断周围的区域是否已经被判断，如果已经被判断，如果再判断会造成死循环

//判断是否已经展开
int IsBlack(char border[ROWS][COLS],int row,int col,int x, int y)
{
	if ((border[x][y] == '*'&&x >= 1 && x < row - 1 && y >= 1 && y < col - 1))
	{
		return 1;
	} 
		return -1;
}

                   然后我们再判断周围的八个点（周围的八个点如果为零，则需要在判断，这就是递归）

//判断周围的雷
void JudegeMineCount(char border1[ROWS][COLS], char border2[ROWS][COLS],int x, int y)
{
	int Judge = 1;
	if (Judge == IsBlack(border2, ROWS, COLS, x, y - 1))
	{
		if (MineCount(border1, x, y - 1) != '0')
		{
			border2[x][y - 1] = MineCount(border1, x, y - 1);
		}
		else
		{
			border2[x][y - 1] = MineCount(border1, x, y - 1);
			JudegeMineCount(border1, border2, x, y - 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x - 1, y - 1))
	{
		if (MineCount(border1, x - 1, y - 1) != '0')
		{
			border2[x - 1][y - 1] = MineCount(border1, x - 1, y - 1);
		}
		else
		{
			border2[x - 1][y - 1] = MineCount(border1, x - 1, y - 1);
			JudegeMineCount(border1, border2, x - 1, y - 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x - 1, y))
	{
		if (MineCount(border1, x - 1, y) != '0')
		{
			border2[x - 1][y] = MineCount(border1, x - 1, y);
		}
		else
		{
			border2[x - 1][y] = MineCount(border1, x - 1, y);
			JudegeMineCount(border1, border2, x - 1, y);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x - 1, y + 1))
	{
		if (MineCount(border1, x - 1, y + 1) != '0')
		{
			border2[x - 1][y + 1] = MineCount(border1, x - 1, y + 1);
		}
		else
		{
			border2[x - 1][y + 1] = MineCount(border1, x - 1, y + 1);
			JudegeMineCount(border1, border2, x - 1, y + 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x, y + 1))
	{
		if (MineCount(border1, x, y + 1) != '0')
		{
			border2[x][y + 1] = MineCount(border1, x, y + 1);
		}
		else
		{
			border2[x][y + 1] = MineCount(border1, x, y + 1);
			JudegeMineCount(border1, border2, x, y + 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x + 1, y + 1))
	{
		if (MineCount(border1, x + 1, y + 1) != '0')
		{
			border2[x + 1][y + 1] = MineCount(border1, x + 1, y + 1);
		}
		else
		{
			border2[x + 1][y + 1] = MineCount(border1, x + 1, y + 1);
			JudegeMineCount(border1, border2, x + 1, y + 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x + 1, y))
	{
		if (MineCount(border1, x + 1, y) != '0')
		{
			border2[x + 1][y] = MineCount(border1, x + 1, y);
		}
		else
		{
			border2[x + 1][y] = MineCount(border1, x + 1, y);
			JudegeMineCount(border1, border2, x + 1, y);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x + 1, y - 1))
	{
		if (MineCount(border1, x + 1, y - 1) != '0')
		{
			border2[x + 1][y - 1] = MineCount(border1, x + 1, y - 1);
		}
		else
		{
			border2[x + 1][y - 1] = MineCount(border1, x + 1, y - 1);
			JudegeMineCount(border1, border2, x + 1, y - 1);
		}
	}
}

 

<5>实现第一步不被炸死，我们在定义一个变量count = 1；将它的地址传给找雷函数，（不能在函数内部创建，因为要多次调用找雷函数，count将每次被调用）如果第一步是雷，我们需要重新产生雷

char FindMine(char border1[ROWS][COLS], char border2[ROWS][COLS], int row, int col,int *count)
{
	int x = 0;
	int y = 0;
	int x1 = 0;
	int y1 = 0;
	while (1)
	{
		printf("请输入要查找的坐标：");
		scanf("%d%d", &x, &y);
		if (x >= 1 && x < row - 1 && y >= 1 && y < col - 1)
		{
			if (border1[x][y] == '1'&&*count != 1)
			{
				return '1';
			}
			else
			{
				if ((*count) == 1 && border1[x][y] == '1')
				//重新产生雷
				{
					border1[x][y] = '0';
					while (*count)
					{
						x1 = rand() % (row - 2) + 1;
						y1 = rand() % (col - 2) + 1;
						if (border1[x1][y1] == '0')
						{
							border1[x1][y1] = '1';
							(*count)--;
						}
					}
				}
				(*count)--;
				if (border2[x][y] == '*')
				{
					if (MineCount(border1, x, y) != '0')
					{
						border2[x][y] = MineCount(border1, x, y);
					}
					else
					{
						border2[x][y] = MineCount(border1, x, y);
						JudegeMineCount(border1, border2, x, y);
					}
					return 0;
				}
				else
				{
					printf("该坐标已被判断！！\n");
				}
			}
		}
		else
		{
			printf("请输入合法坐标\n");
		}
	}
}

<6>当未知区域等于雷的个数，游戏胜利，所以我们需要一个函数来计算当前未知区域的个数

//未判断的数量
int BlackCount(char border[ROWS][COLS],int row,int col)
{
	int blackcount = 0;
	int i = 1;
	for (i = 1; i <= row; i++)
	{
		int j = 1;
		for (j = 1; j <= col; j++)
		{
			if (border[i][j] == '*')
				blackcount++;
		}
	
	}
	return blackcount;
}

 


源代码

 

头文件

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

#define EASY 20

#define ROW 10
#define COL 10

#define ROWS ROW + 2
#define COLS COL + 2

//初始化棋盘
void InitiaBorder(char border[ROWS][COLS], int row, int col,char set);

// 打印棋盘
void ShowBorder(char border[ROWS][COLS], int row, int col);

//产生雷
void CreateMine(char border[ROWS][COLS], int row, int col);

//找雷
char FindMine(char border1[ROWS][COLS],char border2[ROWS][COLS],int row, int col,int *count);

//未判断的数量
int BlackCount(char border[ROWS][COLS],int row,int col);

函数实现

#define  _CRT_SECURE_NO_WARNINGS
#include "game.h"

//初始化棋盘
void InitiaBorder(char border[ROWS][COLS], int row, int col,char set)
{
	memset(border, set, col*row*sizeof(border[0][0]));
}

// 打印棋盘
void ShowBorder(char border[ROWS][COLS], int row, int col)
{
	int i = 0;
	//打印第一行
	for (int i = 0; i < col-2; i++)
	{
		if (i == 0)
			printf("|");
		printf("---|");
	}
	printf("\n");

	for (i = 1; i < row-1; i++)
	{
		int j = 0;
		printf("|");//每行第一个打印一个|
		//打印（ %c |）
		for (j = 1; j < col-1; j++)
		{
			printf(" %c |", border[i][j]);
		}
		printf("\n");
		//打印(---|)
		for (j = 0; j < col-2; j++)
		{
			if (j == 0)
				printf("|");//每行第一个打印一个 |
			printf("---|");
		}
		printf("\n");
	}
}

//产生雷
void CreateMine(char border[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int count = EASY ;
	while (count)
	{
		x = rand() % (row - 2) + 1;
		y = rand() % (col - 2) + 1;
		if (border[x][y] == '0')
		{
			border[x][y] = '1';
			count--;
		}
	}
}

//计算雷的数量
char MineCount(char border[ROWS][COLS],int x, int y)
{
	return border[x - 1][y] + border[x - 1][y + 1] + border[x][y + 1] + border[x + 1][y + 1]
		+ border[x + 1][y] + border[x + 1][y - 1] + border[x][y - 1] + border[x - 1][y - 1] - 7 * '0';
}
//判断是否已经展开
int IsBlack(char border[ROWS][COLS],int row,int col,int x, int y)
{
	if ((border[x][y] == '*'&&x >= 1 && x < row - 1 && y >= 1 && y < col - 1))
	{
		return 1;
	} 
		return -1;
}
//判断周围的雷
void JudegeMineCount(char border1[ROWS][COLS], char border2[ROWS][COLS],int x, int y)
{
	int Judge = 1;
	if (Judge == IsBlack(border2, ROWS, COLS, x, y - 1))
	{
		if (MineCount(border1, x, y - 1) != '0')
		{
			border2[x][y - 1] = MineCount(border1, x, y - 1);
		}
		else
		{
			border2[x][y - 1] = MineCount(border1, x, y - 1);
			JudegeMineCount(border1, border2, x, y - 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x - 1, y - 1))
	{
		if (MineCount(border1, x - 1, y - 1) != '0')
		{
			border2[x - 1][y - 1] = MineCount(border1, x - 1, y - 1);
		}
		else
		{
			border2[x - 1][y - 1] = MineCount(border1, x - 1, y - 1);
			JudegeMineCount(border1, border2, x - 1, y - 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x - 1, y))
	{
		if (MineCount(border1, x - 1, y) != '0')
		{
			border2[x - 1][y] = MineCount(border1, x - 1, y);
		}
		else
		{
			border2[x - 1][y] = MineCount(border1, x - 1, y);
			JudegeMineCount(border1, border2, x - 1, y);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x - 1, y + 1))
	{
		if (MineCount(border1, x - 1, y + 1) != '0')
		{
			border2[x - 1][y + 1] = MineCount(border1, x - 1, y + 1);
		}
		else
		{
			border2[x - 1][y + 1] = MineCount(border1, x - 1, y + 1);
			JudegeMineCount(border1, border2, x - 1, y + 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x, y + 1))
	{
		if (MineCount(border1, x, y + 1) != '0')
		{
			border2[x][y + 1] = MineCount(border1, x, y + 1);
		}
		else
		{
			border2[x][y + 1] = MineCount(border1, x, y + 1);
			JudegeMineCount(border1, border2, x, y + 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x + 1, y + 1))
	{
		if (MineCount(border1, x + 1, y + 1) != '0')
		{
			border2[x + 1][y + 1] = MineCount(border1, x + 1, y + 1);
		}
		else
		{
			border2[x + 1][y + 1] = MineCount(border1, x + 1, y + 1);
			JudegeMineCount(border1, border2, x + 1, y + 1);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x + 1, y))
	{
		if (MineCount(border1, x + 1, y) != '0')
		{
			border2[x + 1][y] = MineCount(border1, x + 1, y);
		}
		else
		{
			border2[x + 1][y] = MineCount(border1, x + 1, y);
			JudegeMineCount(border1, border2, x + 1, y);
		}
	}
	if (Judge == IsBlack(border2, ROWS, COLS, x + 1, y - 1))
	{
		if (MineCount(border1, x + 1, y - 1) != '0')
		{
			border2[x + 1][y - 1] = MineCount(border1, x + 1, y - 1);
		}
		else
		{
			border2[x + 1][y - 1] = MineCount(border1, x + 1, y - 1);
			JudegeMineCount(border1, border2, x + 1, y - 1);
		}
	}
}
//找雷
char FindMine(char border1[ROWS][COLS], char border2[ROWS][COLS], int row, int col,int *count)
{
	int x = 0;
	int y = 0;
	int x1 = 0;
	int y1 = 0;
	while (1)
	{
		printf("请输入要查找的坐标：");
		scanf("%d%d", &x, &y);
		if (x >= 1 && x < row - 1 && y >= 1 && y < col - 1)
		{
			if (border1[x][y] == '1'&&*count != 1)
			{
				return '1';
			}
			else
			{
				if ((*count) == 1 && border1[x][y] == '1')
				//重新产生雷
				{
					border1[x][y] = '0';
					while (*count)
					{
						x1 = rand() % (row - 2) + 1;
						y1 = rand() % (col - 2) + 1;
						if (border1[x1][y1] == '0')
						{
							border1[x1][y1] = '1';
							(*count)--;
						}
					}
				}
				(*count)--;
				if (border2[x][y] == '*')
				{
					if (MineCount(border1, x, y) != '0')
					{
						border2[x][y] = MineCount(border1, x, y);
					}
					else
					{
						border2[x][y] = MineCount(border1, x, y);
						JudegeMineCount(border1, border2, x, y);
					}
					return 0;
				}
				else
				{
					printf("该坐标已被判断！！\n");
				}
			}
		}
		else
		{
			printf("请输入合法坐标\n");
		}
	}
}

//未判断的数量
int BlackCount(char border[ROWS][COLS],int row,int col)
{
	int blackcount = 0;
	int i = 1;
	for (i = 1; i <= row; i++)
	{
		int j = 1;
		for (j = 1; j <= col; j++)
		{
			if (border[i][j] == '*')
				blackcount++;
		}
	
	}
	return blackcount;
}

main函数

#define  _CRT_SECURE_NO_WARNINGS
#include "game.h"




void game1()
{
	int count = 1;
	char border1[ROWS][COLS] = { '0' };
	char border2[ROWS][COLS] = { '0' };
	int blackcount = 0;
	
	//初始化棋盘
	InitiaBorder(border1, ROWS, COLS, '0');
	InitiaBorder(border2, ROWS, COLS, '*');
	blackcount = BlackCount(border2, ROW, COL);

	//产生雷
	CreateMine(border1, ROWS, COLS);
	//产生雷后的效果
	ShowBorder(border1, ROWS, COLS);
	ShowBorder(border2, ROWS, COLS);
	//找雷
	while (blackcount>EASY)
	{
		char result = FindMine(border1, border2, ROWS, COLS ,&count);
		//判断结果
		if (result == '1')
		{
			printf("很遗憾，您被炸死了！\n");
			ShowBorder(border1, ROWS, COLS);
			break;
		}
		system("cls");
		ShowBorder(border2, ROWS, COLS);
		blackcount = BlackCount(border2, ROW, COL);
		printf("当前未判断空格数：%d\n", blackcount);
	}
	if (blackcount == EASY)
		printf("恭喜您游戏胜利！！\n");
}

void game2()
{
	printf("qwe");
}
void game3()
{
	printf("qwe");
}









void menu()
{
	printf("*********  1、简    单   ****************\n");
	printf("*********  2、中    等   ****************\n");
	printf("*********  3、困    难   ****************\n");
	printf("*********  0、退出游戏   ****************\n");
}

void test()
{
	int input = 0;
	do
	{
		menu();
		printf("\n");
		printf("请选择模式：\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game1();
			break;
		case 2:
			game2();
			break;
		case 3:
			game3();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误！\n");
			break;
		}
	} while (input);
}






int main()
{
	system("color 2E");
	test();
	system("pause");
	return 0;
}

 


 

 

yangzhi_521
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言学习教程，用C语言编写扫雷游戏
C语言学习之家
10-26 3012
本文实例为大家分享了C语言实现扫雷游戏及其优化的具体代码，供大家参考，具体内容如下 关于扫雷优化 1.核心思想：使用两个二维数组进行设计，一个用于显示，一个用于后台雷的布置。 2.使用宏常量，后期可以任意修改游戏难度。 3.关于扫雷拓展模块，目前使用的方法比较low，若周围均没有，则全部显示。 4.剩余位置数使用全局变量count，必须考虑拓展之后count变化。 有待改进之处 1.需设计...
【C语言】扫雷游戏详解及完整代码
weixin_64499321的博客
11-24 2606
这篇文章将分享利用C语言实现扫雷的全过程讲解及其完整代码。初学C语言的朋友们也能看懂学会哦！这个简单的小游戏非常适合C语言新手小白操作。
C语言--扫雷游戏（结尾附源码）
最新发布
2303_80883523的博客
07-08 658
扫雷游戏在早年间是一款人尽皆知的电脑游戏，不仅内存小而且具有一定的挑战性，在我的童年时代对这个游戏的理解就是盲猜，即便不会玩也知道这个基本每台电脑必备的游戏，其游戏规则是玩家可以通过点击来翻开方块，如果是雷那么游戏就结束了，反之就会出现一个数字代表了其周围的8个方块中隐藏的雷的数目，通过计算可以排除剩下的安全区，全部排出即获得胜利。
用c语言写一个扫雷游戏
qq_41016462的博客
11-19 237
想要写出扫雷这个游戏，首先你得知道游戏规则。 当了解了游戏规则之后，开始构建这个游戏的大致结构。 首先游戏界面的格子我们可以由数组构成。 游戏底层应该有一层控制逻辑的格子，这个格子用来记雷的位置，我们用另一个数组来表示。 如果掀开的格子周围八个格子有雷我们要在掀开的格子上写上周围八个格子的雷数和 如果掀开的格子周围八个格子没有雷，我们要继续掀开它周围的格子，而这里也就是这个程序比较有意思的地方...
C语言基础：扫雷游戏的C语言实现（超详图解+源码）
linsc_05的博客
08-01 6283
友友们好，今天和大家一起做一个简单的——扫雷小游戏。如下：扫雷的规则很简单。盘面上有许多方格，方格中随机分布着一些雷。你的目标是避开雷，打开其他所有格子。一个非雷格中的数字表示其相邻8格中的雷数，你可以利用这个信息推导出安全格和雷的位置。打开所有安全格将被判定为胜利，打开雷将被判定为失败。
用c语言编写扫雷程序
weixin_44416545的博客
02-15 607
用c语言编写扫雷程序 test.c文件 1.头文件（本游戏所用到的头文件均一写入game.h中）： #include"game.h" void menu() { printf("***************************************************\n"); printf("************* 1.play 0.exist **...
小白C语言实现扫雷游戏
02-17
利用函数和数组的有关知识，C语言实现简单的扫雷游戏，有助于刚学习C语言的新手对于代码和逻辑结构的理解和运用，比较有价值
大一利用C语言+EasyX完成扫雷游戏
01-10
概要：仅利用C语言基础知识（数组，结构体，循环嵌套等），配合EasyX实现扫雷界面化，鼠标定位功能。 开发环境及工具：visual studio2019，EasyX（16.4.0）。注意版本，不同版本的EasyX所使用函数的方法不同。 阅读...
C语言结合Easyx库实现扫雷小游戏
03-26
本项目以“扫雷”为蓝本，利用C语言结合Easyx图形库来实现一个可视化的扫雷游戏。本文将深入探讨这个项目的核心知识点，包括C语言基础、Easyx库的使用以及游戏逻辑的设计。 首先，C语言是程序设计的基础，它以其...
【C语言】实现扫雷游戏（详解篇）
m0_63601181的博客
03-21 7024
大家好，我是Abert. 这篇文章将分享利用C语言实现扫雷的全过程及其讲解。 文章目录 1、进行程序环境的配置 2、各种功能的实现及逻辑关系的整理 2.1 创建游戏初始界面（进入\退出 游戏） 2.2创建并初始化二维数组board[][] mine[][] (board存放棋盘的信息 mine存放雷的信息) 2.3 初始化棋盘 2.4 打印棋盘 2.5 布置雷 2.6 排查雷 ...
C语言编写扫雷游戏程序（附代码）
03-08
这是一款经典的小游戏，支持鼠标 支持汉字。分三种游戏难度
用C语言实现扫雷
12-06
用C语言实现扫雷 让大家都能使用C++做扫雷，这就是我在空余时间编的扫雷，比其他人编的要好的多
用C语言编写的扫雷游戏
08-27
纯标准输出，没有使用任何图形库，用两天完成的。。
C语言实现扫雷游戏
L_R
07-23 548
实现功能要求： 1&amp;amp;amp;amp;gt;第一次下子，不炸死。 2&amp;amp;amp;amp;gt;坐标周围没雷，可以实现展开 游戏介绍： 　　可能有些人没有玩过扫雷，在这里先简单介绍一下扫雷游戏，系统会设置雷的个数并且随机放置，由玩家扫雷，没扫一次会显示周围雷的个数，一旦触碰到雷便会炸死，即游戏结束。 设计思路： 　　首先我们需要用二维数组来存放空位以及雷,即我们布置雷的过程; 　　其次我们还需要一个二维数组存
用C语言实现扫雷游戏（一）
nidie508的博客
03-25 443
所用编译器为vc++6.0，用到esayx图形库 #include<graphics.h> // 就是需要引用这个图形库 #include<conio.h> //void draw_box(int x,int y,int wh,int depth); int m_row=20,m_col=30,m_w=20,m_h=20; //m_row是行，m_col是列，m_w...
用C语言编写扫雷小游戏（详细介绍）
CDatreides的博客
04-21 2274
编写扫雷时，我们应该应该清楚地知道游戏规则：当选择不是雷时，显示周围雷的数目；当选择雷时，显示所有雷的数目，游戏结束。 定义头文件： 编写game(): 初始化数组： 打赢棋盘： 随机放入雷： 检查周围雷的个数： 游戏判定： 接下来定义一个菜单就可以玩游戏了： 测试： ...
用C语言实现扫雷小游戏
烟华的博客
05-20 1093
多文件实现扫雷游戏，并满足：第一次不被炸死 ，当坐标周围没雷，可以实现展开 创建两个12*12的数组，一个实现埋雷等操作mine[12][12]，另一个则是用户所见的界面board[12][12]。 在mine.h中进行一些文件引入和定义及声明 mine.h #ifndef _MINE_H_ #define _MINE_H_ #pragma warning (disable:4996) #inc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值