精华内容
下载资源
问答
  • C语言设计扫雷游戏

    2019-08-29 15:18:17
    扫雷可以分成4步: (1)初始化棋盘, (2)打印出棋盘 (3)布雷 (4)扫雷(核心) game.h #define _CRT_SECURE_NO_WARNINGS 1 #ifndef __GAME_H__ #define __GAME_H__ #include<stdio.h> #include<...

    扫雷可以分成4步:
    (1)初始化棋盘,
    (2)打印出棋盘
    (3)布雷
    (4)扫雷(核心)

    game.h

    #define _CRT_SECURE_NO_WARNINGS 1
    
    #ifndef  __GAME_H__
    #define  __GAME_H__
    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #define MINE_NUM 10   //设置所放置的地雷个数。
    
    #define ROW 9
    #define COL 9
    
    #define ROWS  ROW+2
    #define COLS    COL+2
    
    void InitBoard(char board[][COLS], int rows, int cols, char set); //初始化棋盘
    
    void ShowBoard(char board[][COLS], int row, int col);  //打印棋盘
    
    void SetMine(char mine[][COLS], int row, int col); //布雷
    
    void FindMine(char mine[][COLS], char mineInfo[][COLS], int row, int col);//扫雷
    
    #endif// __GAME_H__
    
    
    

    game.c

    #define _CRT_SECURE_NO_WARNINGS 1
    #include "game.h"
    
    void InitBoard(char board[][COLS], int rows, int cols, char set)
    {
    	int i = 0;
    	int j = 0;
    	for (i = 0; i < rows; i++)
    	{
    		for (j = 0; j < cols; j++)
    		{
    			board[i][j] = set;
    		}
    	}
    	//memset(board,set,rows*cols*sizeof(char));
    }
    void ShowBoard(char board[][COLS], int row, int col)
    {
    	int i = 0;
    	int j = 0;
    	printf("===================\n");
    	for (i = 0; i <= row; i++)
    	{
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (i = 1; i <= row; i++)
    	{
    		printf("%d ", i);
    		for (j = 1; j <= col; j++)
    		{
    			printf("%c ", board[i][j]);
    		}
    		printf("\n");
    	}
    	printf("===================\n");
    }
    
    void SetMine(char mine[][COLS], int row, int col)
    {
    	int x;
    	int y;
    	int count = 0;
    	while (count < MINE_NUM)
    	{
    		x = rand() % row + 1;//[1-10)
    		y = rand() % col + 1;
    		if (mine[x][y] == '0')
    		{
    			mine[x][y] = '1';
    			count++;
    		}
    	}
    }
    
    static int GetMineCount(char mine[][COLS], int x, int y)
    {
    	return mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] +
    		mine[x][y + 1] + mine[x + 1][y + 1] + mine[x + 1][y] +
    		mine[x + 1][y - 1] + mine[x][y - 1] - 8 * '0';
    	//数字字符---》整型数字   '1'--->1
    	//'1' - '0' = 1
    }
    //递归
    void FindMine(char mine[][COLS], char mineInfo[][COLS], int row, int col)
    {
    	int count = 0;
    	int x = 0;
    	int y = 0;
    	while (count < row * col - MINE_NUM)
    	{
    		printf("请输入坐标:");
    		scanf("%d%d", &x, &y);
    		//坐标的合法性
    		if (x >= 1 && x <= 9 && y >= 1 && y <= 9)
    		{
    			if (mine[x][y] == '1')
    			{
    				printf("你被炸死了\n");
    				ShowBoard(mine, row, col);
    				break;
    			}
    			else
    			{
    				//统计当前位置的周围 有几颗雷
    				// 1 3   
    				int ret = GetMineCount(mine, x, y);
    				//4   整型数字4
    				//整型数字--》数字字符  4+'0' = '4'
    				mineInfo[x][y] = ret + '0';
    				ShowBoard(mineInfo, row, col);
    				count++;
    			}
    		}
    		else
    		{
    			printf("坐标不合法\n");
    		}
    	}
    }
    
    
    
    

    test.c

    #define _CRT_SECURE_NO_WARNINGS 1
    
    
    #include "game.h"
    void menu()
    {
    	printf("**********************\n");
    	printf("******0.exit***********\n");
    	printf("******1.play**********\n");
    	printf("***********************\n");
    }
    void game()
    {
    	//存放雷    1代表是雷
    	char mine[ROWS][COLS] = { 0 };
    	//排查雷     *
    	char mineInfo[ROWS][COLS] = { 0 };
    
    	InitBoard(mine, ROWS, COLS, '0');
    
    	InitBoard(mineInfo, ROWS, COLS, '*');
    
    	ShowBoard(mineInfo, ROW, COL);
    
    	SetMine(mine, ROW, COL);
    
    	//ShowBoard(mine,ROW,COL);
    	FindMine(mine, mineInfo, ROW, COL);
    }
    int main()
    {
    	int input = 0;
    	srand((unsigned int)time(NULL));
    	do
    	{
    		menu();
    		printf("请输你的操作:");
    		scanf("%d", &input);
    		switch (input)
    		{
    		case 1:
    			game();
    			break;
    		case 0:
    			printf("游戏退出\n");
    			break;
    		default:
    			printf("请输入正确的数字\n");
    			break;
    		}
    	} while (input);
    	return 0;
    }
    
    
    
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 接下来介绍一下C语言设计扫雷小游戏。所实现的功能是随机分布雷,玩家输入坐标,可显示该位置周围都多少雷 涉及知识: 一定的编程逻辑 数组-二维数组 函数设计 循环 效果图 图中有0和1的是给设计者看的雷分布情况。...

    扫雷大家应该都玩过。接下来介绍一下C语言设计扫雷小游戏。所实现的功能是随机分布雷,玩家输入坐标,可显示该位置周围都多少雷
    涉及知识:

    • 一定的编程逻辑
    • 数组-二维数组
    • 函数设计
    • 循环
      效果图
      在这里插入图片描述图中有0和1的是给设计者看的雷分布情况。全是‘ * ’的棋盘是给玩家扫雷的。
      那我们就需要用二维数组来打印两个棋盘,假如我们要打印9 * 9的棋盘,二维数组元素也要为9 * 9吗?,不能,因为我们在设计算法时需要统计坐标周围8个方位雷的个数,假如要统计边界坐标周围雷的个数,那么就会有数组越界的问题,那我们就要在9 * 9的边界多上一圈元素,也就要定义11 * 11的数组元素,这些元素我们不需要打印出来,心里有数就行,如下:
      在这里插入图片描述我们需要建立两个源文件,一个头文件
      在这里插入图片描述一 我们打印设计者棋盘要用数组mine,打印玩家棋盘要用数组show,两个数组在开始必须要初始化,在设计者棋盘中字符’0’代表不是雷,字符1代表雷,先初始化两个数组
    void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    {
    	int i = 0;
    	int j = 0;
    	for (i = 0; i < rows; i++)
    	{
    		for (j = 0; j < cols; j++)
    			board[i][j] = set;
    	}
    }
    

    二 打印两个雷阵(不要忘了打印横竖序号以便确定坐标)

    void DisplayBoard(char board[ROWS][COLS], int row, int col)
    {
    	int i = 0;
    	int j = 0;
    	//打印列号
    	for (i = 0; i <= col; i++)
    		printf("%d ", i);
    	printf("\n");
    	for (i = 1; i <= row; i++)
    	{
    		//打印行号
    		printf("%d ", i);
    		for (j = 1; j <= col; j++)
    			printf("%c ", board[i][j]);
    		printf("\n");
    	}
    
    }
    

    三 我们在每一次玩的时候设计者棋盘中的雷分布都必须不相同,使用随机数生成横竖坐标确定布雷坐标,这里用到rand()函数。代码如下

    void SetMine(char board[ROWS][COLS], int row, int col)
    {
    	//随机找坐标布置
    	//布置雷的个数
    	int count = num;
    	while (count)
    	{
    		int x = rand() % row + 1;
    		int y = rand() % col + 1;
    		if (board[x][y] == '0')
    		{
    			board[x][y] = '1';
    			count--;       //布置成功count--
    		}
    
    	}
    }
    

    四 为了统计当前坐标周围雷的个数,定义一个函数实现

    int MineCount(char mine[ROWS][COLS], int x, int y)
    {
    	int ret = 0;
    	ret = mine[x - 1][y] +
    		mine[x - 1][y - 1] +
    		mine[x][y - 1] +
    		mine[x + 1][y - 1] +
    		mine[x + 1][y] +
    		mine[x + 1][y + 1] +
    		mine[x][y + 1] +
    		mine[x - 1][y + 1]-8*'0';
    	return ret;
    
    }
    

    因为该函数返回的是该坐标周围雷的个数,但是我们存放的时候是以字符类型存储的。字符‘1’与字符‘0’的差值是数字1。可以很巧妙的统计出来该坐标周围雷的个数。
    五 扫雷函数是一个重要的模块,代码如下

    //扫雷游戏结束
    //1 踩雷,炸死了
    //2 排除所有雷
    void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    {
    	int x = 0;
    	int y = 0;
    	int win = 0;
    	while (win < row*col - num)
    	{
    		printf("请输入要排查的坐标:");
    		scanf("%d%d", &x, &y);
    		//判断坐标是否合法
    		if (x >=1 && x <= row && y>=1 && y <= col)
    		{
    			//判断x,y坐标处是否是雷
    			if (mine[x][y] == '1')
    			{
    				printf("踩雷,你被炸死了!\n");
    				DisplayBoard(mine, row, col);
    				break;
    			}
    			else
    			{
    				//统计x,y周围有几个雷
    				int count = MineCount(mine, x, y);
    				show[x][y] = count + '0';
    				DisplayBoard(show, ROW, COL);
    				win++;
    			}
    		}
    		else
    		{
    			printf("坐标非法\n");
    		}
    	}
    	if (win == row * col - num)
    	{
    		printf("恭喜你!排雷成功!\n");
    		DisplayBoard(mine, row, col);
    	}
    }
    

    我们将以上函数的定义放在 game2.c 文件中

    以上就是我们要实现扫雷的函数模块,要想把这些模块联系起来,就需要一个游戏执行函数来调用这些模块,定义个game()函数实现,代码如下:

    #include"game2.h"
    
    void menu()
    {
    	printf("************************************\n");
    	printf("********     1.开始游戏    *********\n");
    	printf("********     0.退出游戏    *********\n");
    	printf("************************************\n");
    }
    
    void game()
    {
    	//真正的扫雷过程
    	//创建一个二维数组
    	//存放布置好的雷
    	char mine[ROWS][COLS] = { 0 };
    	//布置排查出来的雷
    	char show[ROWS][COLS] = { 0 };
    	//初始化二维数组
    	InitBoard(mine, ROWS, COLS, '0');
    	InitBoard(show, ROWS, COLS, '*');
    	//打印
    	/*DisplayBoard(mine, ROW, COL)*/; //布置好的雷分布一般不打印
    	DisplayBoard(show, ROW, COL);
    	printf("\n");
    	//1布置雷
    	SetMine(mine, ROW, COL);
    	DisplayBoard(mine, ROW, COL);
    	//2扫雷
    	FindMine(mine,show, ROW, COL);
    }
    int main()
    {
    	int input = 0;
    	srand((unsigned int)time(NULL));
    	do 
    	{
    		menu();
    		printf("请选择->");
    		scanf("%d", &input);
    		switch (input)
    		{
    		case 1:
    			//扫雷游戏
    			game();
    			break;
    		case 0:
    			//退出游戏
    			printf("退出游戏\n");
    			break;
    		default:
    			//重新选择
    			printf("输入错误,请重新选择\n");
    			break;
    		}	
    	} while (input);
    	return 0;
    }
    
    

    在头文件game2.h中声明各种函数:
    game2.h

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    
    #define ROWS ROW+2
    #define COLS COL+2
    
    #define ROW 9
    #define COL 9
    
    #define num 10
    
    //声明函数
    //初始化
    void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    //打印棋盘
    void DisplayBoard(char board[ROWS][COLS], int row, int col);
    //布置雷
    void SetMine(char board[ROWS][COLS], int row, int col);
    //扫雷
    void FindMine(char mine[ROWS][COLS],char show[ROWS][COLS], int row, int col);
    
    
    

    附game2.c文件源码:

    #define _CRT_SECURE_NO_WARNINGS 1
    #include"game2.h"
    
    void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    {
    	int i = 0;
    	int j = 0;
    	for (i = 0; i < rows; i++)
    	{
    		for (j = 0; j < cols; j++)
    			board[i][j] = set;
    	}
    }
    void DisplayBoard(char board[ROWS][COLS], int row, int col)
    {
    	int i = 0;
    	int j = 0;
    	//打印列号
    	for (i = 0; i <= col; i++)
    		printf("%d ", i);
    	printf("\n");
    	for (i = 1; i <= row; i++)
    	{
    		//打印行号
    		printf("%d ", i);
    		for (j = 1; j <= col; j++)
    			printf("%c ", board[i][j]);
    		printf("\n");
    	}
    
    }
    
    void SetMine(char board[ROWS][COLS], int row, int col)
    {
    	//随机找坐标布置
    	//布置雷的个数
    	int count = num;
    	while (count)
    	{
    		int x = rand() % row + 1;
    		int y = rand() % col + 1;
    		if (board[x][y] == '0')
    		{
    			board[x][y] = '1';
    			count--;       //布置成功count--
    		}
    
    	}
    }
    
    int MineCount(char mine[ROWS][COLS], int x, int y)
    {
    	int ret = 0;
    	ret = mine[x - 1][y] +
    		mine[x - 1][y - 1] +
    		mine[x][y - 1] +
    		mine[x + 1][y - 1] +
    		mine[x + 1][y] +
    		mine[x + 1][y + 1] +
    		mine[x][y + 1] +
    		mine[x - 1][y + 1]-8*'0';
    	return ret;
    
    }
    //扫雷游戏结束
    //1 踩雷,炸死了
    //2 排除所有雷
    void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    {
    	int x = 0;
    	int y = 0;
    	int win = 0;
    	while (win < row*col - num)
    	{
    		printf("请输入要排查的坐标:");
    		scanf("%d%d", &x, &y);
    		//判断坐标是否合法
    		if (x >=1 && x <= row && y>=1 && y <= col)
    		{
    			//判断x,y坐标处是否是雷
    			if (mine[x][y] == '1')
    			{
    				printf("踩雷,你被炸死了!\n");
    				DisplayBoard(mine, row, col);
    				break;
    			}
    			else
    			{
    				//统计x,y周围有几个雷
    				int count = MineCount(mine, x, y);
    				show[x][y] = count + '0';
    				DisplayBoard(show, ROW, COL);
    				win++;
    			}
    		}
    		else
    		{
    			printf("坐标非法\n");
    		}
    	}
    	if (win == row * col - num)
    	{
    		printf("恭喜你!排雷成功!\n");
    		DisplayBoard(mine, row, col);
    	}
    }
    
    展开全文
  • 本文实例为大家分享了C语言实现扫雷游戏的具体代码,供大家参考,具体内容如下 功能设计 扫雷大家应该都玩过,这是一个十分经典的游戏,今天我将给大家讲解如何用C语言实现扫雷,我的这个扫雷有如下几个功能: ...

    本文实例为大家分享了C语言实现扫雷游戏的具体代码,供大家参考,具体内容如下

     

    功能设计

    扫雷大家应该都玩过,这是一个十分经典的游戏,今天我将给大家讲解如何用C语言实现扫雷,我的这个扫雷有如下几个功能:

     

    1、显示该点周围雷的个数

    2、第一次下子,不炸死

    3、坐标周围没雷,可以实现展开

    4、游戏结束后展示玩家用时

    效果展示

    话不多说,先附上效果图:

     

     

     

     

     

     

     

    设计思路

    我们只要输入坐标就可以扫雷了,是不是很有趣?

     

    其实要想实现这也不难,我们要用几个算法模块来模拟游戏规则,需要用函数来调用各个模块使游戏跑起来。

    那么第一步我们就要构思一个棋盘,看见上面第一张图没,在开始游戏的界面我打印了两个棋盘,有0和1的棋盘是给我们设计者看的,它可以显示出当前雷的真实分布,这有利于我们测试代码的正确性,而全是 * 的棋盘是给玩家扫雷用的。

     

    那我们就需要用二维数组来打印两个棋盘,假如我们要打印10X10的棋盘,那我们的二维数组元素也要为10X10个吗?,不能,因为我们在设计算法时需要统计坐标周围8个方位雷的个数,假如要统计边界坐标周围雷的个数,那么就会有数组越界的问题,那我们就要在10X10的边界多上一圈元素,也就要定义12X12的数组元素,这些元素我们不要打印出来,心里有数就行,如下图:

     

    1

    2

    3

    4

    #define row 12

    #define col 12

    show_mine[row][col];//玩家数组

    real_mine[row][col];//设计者数组

     

     

    我们在一个项目里建立三个源文件,如下:

     

     

     

    1、我们打印设计者棋盘要用数组real_mine,打印玩家棋盘要用数组show_mine,两个数组在开始必须要初始化,在设计者棋盘中字符0代表不是雷,字符1代表雷,先初始化两个数组

     

    代码如下:

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    void init_mine()//初始化两个雷阵

    {

     int i = 0;

     int j = 0;

     for (int i = 0; i < row; i++) 

     {

     for (j = 0; j < col; j++)

     {

     show_mine[i][j] = '*';

     real_mine[i][j] = '0';

     }

     }

    }

    2、打印两个雷阵(不要忘了打印横竖序号以便确定坐标)

     

    1

    2

    展开全文
  • C语言实现扫雷游戏

    2021-04-26 14:09:32
    今天,我们来使用C语言,来完成扫雷游戏的设计。电脑里面的扫雷大家都见过叭,在一个10x10的格子内,随机位置生成若干个地雷,踩到地雷即游戏失败,没踩中则在玩家选中的格子中显示这个格子周围八个格子内地雷的总数...

    C语言实现扫雷游戏

    简略说明:

       今天,我们来使用C语言,来完成扫雷游戏的设计。电脑里面的扫雷大家都见过叭,在一个10x10的格子内,随机位置生成若干个地雷,踩到地雷即游戏失败,没踩中则在玩家选中的格子中显示这个格子周围八个格子内地雷的总数,直到选完所有格子将地雷排除即算胜利,这样的一个游戏该如何用代码实现呢,咱们现在就来一步一步设计一下。
    

    实现思路:

        首先,在上面我们提到了这是个10x10的棋盘(简称棋盘,我也不知道该如何形容蛤蛤蛤),当然也可以不是10x10,但是从这里可以得知,我们需要使用一个**二维数组**来完成棋盘的建立,这个棋盘可以随意改变大小,并且需要提供玩家选择坐标的标识,详细请见下方代码讲解。
        然后我们需要考虑地雷的放置,那么我们来思考一下,地雷和玩家进行游戏的棋盘可以是一个棋盘吗,显然是不行的,数组不能在一个位置存放两个数据,那么我们就需要建立一个地雷棋盘,它的作用是存放地雷的位置,那么地雷的生成和放置的位置都是需要我们去考虑的。
        其次,就是玩家的棋盘,玩家在进行游戏时,选择某一个位置,我们需要显示该位置周围**八个格子**的地雷数,但是这个时候就出现了一个问题,选在棋盘中央还比较简单,如果玩家选在了棋盘的边边角角怎么办,大家需要好好思考一下这个问题。
        这些说完,差不多就是整个游戏如何建立的大概了,那么下面我们来用C语言代码将其实现!!有思路并且想自己亲自试试的同学可以自己先去实践一下,遇见问题了可以参考一下我下面的代码,看看是否有所帮助。
    

    游戏的实现:

    这里的game.h在下面有解释,是引用了一下自己建立的头文件。这样可以减少代码量,很方便的一个写代码的方法,当然,是建立在你有一定数量的代码上再使用这个方式。

    函数调用模块:

    #include "game.h"
    void game()
    {
    	//雷的信息存储
    	//1.布置雷的位置
    	char board[ROWs][COLs] = { 0 };
    	//2.排查雷的信息
    	char show[ROWs][COLs] = { 0 };
    	//初始化
    	Initboard(board, ROWs, COLs,'0');
    	Initboard(show, ROWs, COLs,'*');
    	//打印棋盘
    	Displayboard(show, ROW, COL);
    	//布置地雷
    	SetMine(board, ROW, COL);
    	//扫雷
    	FindMine(board,show, ROW, COL);
    }
    void menu()
    {
    	printf("****************************\n");
    	printf("*       1.开始游戏         *\n");
    	printf("*       0.退出游戏         *\n");
    	printf("****************************\n");
    }
    void test()
    {
    	int input = 0;
    	srand((unsigned int)time(NULL));
    	do {
    		menu();
    		printf("请玩家选择:");
    		scanf("%d", &input);
    		switch (input)
    		{
    		case 1:
    			game();
    			break;
    		case 0:
    			break;
    		default:
    			printf("输入错误请重新选择!\n");
    				break;
    		}
    	} while (input);
    }
    int main()
    {
    	test();
    	return 0;
    }
    

    其中的srand在后面使用rand函数时我们需要提前将其声明,来借助时间戳随机生成随机的地雷位置。这个在后面会有解释,这里先解释一下。其次我们可以看到我们使用do while循环,这里主要是为了实现游戏选择的菜单选择,再使用switch选择来实现游戏的开始和结束。while后面的括号内我们选择使用input作为循环条件有许多处,首先我们只有再选择为0时,判断为假才会跳出循环,其他非零整数都为真就可以循环显示我们的菜单,防止玩家选择错误出现BUG。其中的奥妙还需要大家自己体会(滑稽)。
    然后我们可以当看到,除了菜单函数我们还有,有一个game函数,这里就是我们的游戏实现的细节啦!我们定义了两个二维数组,二维数组的元素内为什么不是常数而是ROW和COL呢,等一下会为大家解释,如果不知道为什么要建立两个棋盘的同学,动用你们的小手,翻到上面去看一下咱们的实现思路就知道啦!那么,我们来看一下我们的头文件!

    头文件模块:

    #define ROW 9
    #define COL 9
    #define ROWs ROW + 2
    #define COLs COL + 2
    #define EASY_CONUT 10
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    void Initboard(char board[ROWs][COLs],int rows,int cols, char set);
    void Displayboard(char board[ROWs][COLs],int row,int col);
    void Displayshow(char show[ROWs][COLs],int row,int col);
    void SetMine(char board[ROWs][COLs], int row, int col);
    void FindMine(char board[ROWs][COLs],char show[ROWs][COLs],int row,int col);
    

    #define是用来定义的(宏的讲解请去看往期博客,有解答的奥,后续会加上链接的!),也可以简单的说,就是程序猿自己为某一个单词或者什么东西赋予它特定的意思,比如这里ROW 9的意思就是,ROW以后就是数字9,表示9的意思,然后ROWs ROW + 2的意思为ROWs = ROW + 2 ,也就是11,那么为什么要加2,咱等一下也会为大家解释。
    上面提到了,二维数组定义时我们为什么没有使用整型常数表达式,而是使用了ROWCOL呢,那么这里的宏就可以为大家解释啦,这里我们ROW和COL其实就是数字9,就是一个整形常数表达式,不是未知数,所以才可以这样定义,那么这样定义好处是什么呢,那么上面提到的也可以不是10x10棋盘那句话大家还记得吗,这里就是为了它准备的,如果玩家不满意10x10怎么办,觉得太简单了,我们不得给他扩大棋盘多放几个地雷弄死他!假如我们是用board[9][9]定义的棋盘,那么我们再修改棋盘的时候,是不是需要将每一个9都改成某一个数,实在是太过于繁琐,那么用现在这种定义方法,我们只需要在头文件中将9改成我们需要改的数字,那么代码中的所有ROW和COL都会变成我们所更改的数字,大大节省了时间。下方都是函数的声明,就不做过多的解释。
    那么解析来我们来看一下这些函数是如何实现的扫雷这个功能的!

    函数定义模块:

    Initboard(board, ROWs, COLs,'0');
    Initboard(show, ROWs, COLs,'*');
    
    #define _CRT_SECURE_NO_WARNINGS 1
    #include "game.h"
    
    void Initboard(char board[ROWs][COLs], int rows, int cols,char set)
    {
    	for (int i = 0; i < rows; i++)
    	{
    		for (int j = 0; j < cols; j++)
    		{
    			board[i][j] = set;
    		}
    	}
    }
    

    这里是我们对棋盘进行初始化,这函数Intiboard里面形参char board[ROWs][COLs]是咱图省事没有改名字,希望大家理解一下下!!!咳咳,那咱们继续,实现的目标是将,放置地雷的棋盘里面的元素都初始化为0(为什么要初始化为0,等下会有解释!),将供玩家进行游戏的棋盘初始化为‘ * ’,你问我为什么要星号?这样显得神秘!!!!因为是二维数组,所以我们采用双循环来初始化!!!

    void Displayboard(char board[ROWs][COLs],int row,int col)
    {
    	int i = 0;
    	for (i = 0; i <= col; i++)
    	{
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (int i = 1; i <= row; i++)
    	{
    		printf("%d ", i);
    		for (int j = 1; j <= col; j++)
    		{
    			printf("%c ", board[i][j]);
    		}
    		printf("\n");
    	}
    }
    
    void Displayshow(char show[ROWs][COLs], int row, int col)
    {
    	int i = 0;
    	for (i = 0; i <= col; i++)
    	{
    		printf("%d ", i);
    	}
    	for (i = 1; i <= row; i++)
    	{
    		printf("%d ", i);
    		for (int j = 1; j <= col; j++)
    		{
    			printf("%c ", show[i][j]);
    		}
    		printf("\n");
    	}
    }
    
    

    这里,是我们来打印咱的棋盘,首先!我们为什么里面最开始有个循环呢,可以看出来我们是打印的1到9这几个数字,我们是不是得方便玩家选择坐标啊,不然一堆星号看的眼睛都花了,不得被玩家骂死!对吧!所以我们在棋盘的第一行和第一列都打印一排1到9数字来方便玩家选择坐标,第二个循环就是我们来把咱们的棋盘打印一下,printf里面跟了空格大家要注意!这样会显得美观!那么咱们来看一下成品!
    在这里插入图片描述
    这是玩家看到棋盘!
    在这里插入图片描述
    这是咱们放地雷的棋盘!
    如果不加空格的话!!!这密密麻麻的不把人看的眼花!!好嘞!咱们继续!

    void SetMine(char board[ROWs][COLs], int row, int col)
    {
    	int count = EASY_CONUT;
    	while (count)
    	{
    		int x = rand() % row + 1;
    		int y = rand() % col + 1;
    		if (board[x][y] == '0')
    		{
    			board[x][y] = '1';
    			count--;
    		}
    	}
    }
    

    现在呢!咱们到丢地雷的时候了!!!!(丧心病狂!!!!)
    这里就到了咱们前面说的srand函数和rand配套使用的地方了,首先我先来解释一下rand函数,它会随机生成随机整数!但是!!有一个明显的缺点!就是它虽然会随机生成,但是每次重新运行,他都会生成和上次顺序与一样的随机数序列!就导致它确实随机了但是没完全随机哈哈哈哈,那么我们就需要使用srand,来设置一个emmm随机种子(后面会有文章进行详细说明),然后咱们使用time(NULL)来获取时间戳(时间戳?这玩应又是个啥!大家去百度,不过这里你可以理解成一个无时无刻都在变化的数字),这样就可让rand函数的返回值具有随机性这样就是真随机了,这样我们也可以实现随机在棋盘中布置地雷啦!那么为什么要跟row取模呢因为这个随机数并不是1到10而是0-32767之间的一个数,所以我们需要模row,因为row是9所以结果都是1-9但是咱们是10x10的棋盘,所以要加一。后面的判断是如果棋盘位置为0咱们就扔个地雷,然后地雷减一个直到减为零为止,咱们的while判断为假,循环结束,地雷也布置完毕。EASY_CONUT是什么请见头文件说明框!

    int Getmain(char board[ROWs][COLs], int x, int y)
    {
    	return board[x - 1][y] + 
    		   board[x - 1][y - 1] + 
    		   board[x][y - 1] + 
    		   board[x + 1][y - 1] + 
    		   board[x + 1][y] + 
    		   board[x + 1][y + 1]+
    		   board[x][y + 1] + 
    		   board[x - 1][y + 1] - 8 * '0';
    }
    

    这里呢,是咱们判断条件啦,也要填一下前面的坑!为什么咱们再棋盘传参和定义都是ROWs,并且为什么要用0初始化放置地雷的棋盘和用1来表示地雷,咱们这里就有解释啦,咱们计算一个坐标周围八个格子内有几个雷时,因为时用1表示地雷,所以只需要将这八个格子加起来,有一个就是1有两个就是2,(但是大家注意,这里面时字符0和字符1不是数字奥!),这样可以更直观的表示,咱们计算的是个八个格子内的地雷数,字符0和字符1的ASCII码分别是48和49所以最后得出的答案就是0-8。那么继续解释,为什么不用ROW而是用ROWs呢,大家想一下如果时边边角角,那么你每一个格子它周围的坐标都不一样,那么你再计算地雷数定义的函数,那就是很多种了,但是如果你给他扩大一圈把它变成11x11的棋盘,你只打印中间的9x9但是再计算每一个坐标地雷数时,是不是都只需要同一个函数就可以完成,节省了代码量并且节约了很多步骤,这里需要大家好好体会! (这里是重点,一定要好好思考!!!!!!) 那么现在再去看一下函数调用模块中打印函数和初始化函数区别,大家就可以理解啦!
    好的继续!!!!!!!!!!!!!!!!!!

    void FindMine(char board[ROWs][COLs], char show[ROWs][COLs], int row, int col)
    {
    	int x = 0;
    	int y = 0;
    	int win = 0;
    	while (win < row * col - EASY_CONUT)
    	{
    		printf("请输入坐标:");
    		scanf("%d %d",&x,&y);
    		if (x >= 1 && x <= row && y >= 1 && y <= col)
    		{
    			if (board[x][y] == '1')
    			{
    				printf("很遗憾,You lose!\n");
    				Displayboard(board, ROW, COL);
    				break;
    			}
    			else
    			{
    			    int count = Getmain(board, x, y);
    				show[x][y] = count + '0';
    				Displayboard(show, ROW, COL);
    				win++;
    			}
    		}
    		else
    			printf("输入坐标不合法,请重新输入!\n");
    	}
    	if (win == row * col - EASY_CONUT)
    	{
    		printf("恭喜你!You Win!\n");
    		Displayboard(board, ROW, COL);
    	}
    }
    

    这里是咱们最后的函数啦,也是给大家讲解,如何将两个棋盘联系到一起并且如何进行游戏的!从参数咱们可以看出来,咱们将放置地雷的棋盘和玩家扫雷的棋盘都传了进来(注意参数是ROWs) 判断条件可能大家不太明白,< 右边表示除了放置了地雷以外的格子,也就是说,如果玩家选择的坐标数小于该格子数那么游戏继续,如果等于格子数,则游戏胜利,在 while循环内我们可以看到,第一个 if 语句的判断条件,为什么是从1开始,上面加粗的字,因为咱们传参传的是ROWs,那么现在就是一个11x11的数组,但是咱们显示的数组,是中间的10x10的数组,所以要要从1开始9结束,这样才是有效输入,咱们也可以在棋盘上显示出来。避免玩家输入错误,这要是为什么要在第一行和第一列设置坐标的原因。第二个if语句,显而易见,是判断是否踩到地雷。如果为1那么就是踩到地雷,游戏结束,跳出循环。 打印放置地雷的棋盘,如果不是1那么我们在该坐标填入周围地雷的信息,再次打印玩家棋盘,继续游戏。直到玩家走的坐标数win等于除了放置了地雷以外的格子数,游戏胜利!
    这样我们就实现了,用C语言实现扫雷游戏,说难不难,说简单不简单,这其中主要是对数组的应用,希望大家多多练习,多多体会。
    源代码在下方会有整合,感谢大家的阅读!!!!!!!!!!

    #pragma once
    #define ROW 9
    #define COL 9
    #define ROWs ROW + 2
    #define COLs COL + 2
    #define EASY_CONUT 10
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    void Initboard(char board[ROWs][COLs],int rows,int cols, char set);
    void Displayboard(char board[ROWs][COLs],int row,int col);
    void Displayshow(char show[ROWs][COLs],int row,int col);
    void SetMine(char board[ROWs][COLs], int row, int col);
    void FindMine(char board[ROWs][COLs],char show[ROWs][COLs],int row,int col);
    
    #define _CRT_SECURE_NO_WARNINGS 1
    #include "game.h"
    void game()
    {
    	//雷的信息存储
    	//1.布置雷的位置
    	char board[ROWs][COLs] = { 0 };
    	//2.排查雷的信息
    	char show[ROWs][COLs] = { 0 };
    	//初始化
    	Initboard(board, ROWs, COLs,'0');
    	Initboard(show, ROWs, COLs,'*');
    	//打印棋盘
    	Displayboard(show, ROW, COL);
    	//布置雷
    	SetMine(board, ROW, COL);
    	//扫雷
    	FindMine(board,show, ROW, COL);
    }
    void menu()
    {
    	printf("****************************\n");
    	printf("*       1.开始游戏         *\n");
    	printf("*       0.退出游戏         *\n");
    	printf("****************************\n");
    }
    void test()
    {
    	int input = 0;
    	srand((unsigned int)time(NULL));
    	do {
    		menu();
    		printf("请玩家选择:");
    		scanf("%d", &input);
    		switch (input)
    		{
    		case 1:
    			game();
    			break;
    		case 0:
    			break;
    		default:
    			printf("输入错误请重新选择!\n");
    				break;
    		}
    	} while (input);
    }
    int main()
    {
    	test();
    	return 0;
    }
    
    #define _CRT_SECURE_NO_WARNINGS 1
    #include "game.h"
    
    void Initboard(char board[ROWs][COLs], int rows, int cols,char set)
    {
    	for (int i = 0; i < rows; i++)
    	{
    		for (int j = 0; j < cols; j++)
    		{
    			board[i][j] = set;
    		}
    	}
    }
    
    void Displayboard(char board[ROWs][COLs],int row,int col)
    {
    	int i = 0;
    	for (i = 0; i <= col; i++)
    	{
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (int i = 1; i <= row; i++)
    	{
    		printf("%d ", i);
    		for (int j = 1; j <= col; j++)
    		{
    			printf("%c ", board[i][j]);
    		}
    		printf("\n");
    	}
    }
    
    void Displayshow(char show[ROWs][COLs], int row, int col)
    {
    	int i = 0;
    	for (i = 0; i <= col; i++)
    	{
    		printf("%d ", i);
    	}
    	for (i = 1; i <= row; i++)
    	{
    		printf("%d ", i);
    		for (int j = 1; j <= col; j++)
    		{
    			printf("%c ", show[i][j]);
    		}
    		printf("\n");
    	}
    }
    
    void SetMine(char board[ROWs][COLs], int row, int col)
    {
    	int count = EASY_CONUT;
    	while (count)
    	{
    		int x = rand() % row + 1;
    		int y = rand() % col + 1;
    		if (board[x][y] == '0')
    		{
    			board[x][y] = '1';
    			count--;
    		}
    	}
    }
    int Getmain(char board[ROWs][COLs], int x, int y)
    {
    	return board[x - 1][y] + 
    		   board[x - 1][y - 1] + 
    		   board[x][y - 1] + 
    		   board[x + 1][y - 1] + 
    		   board[x + 1][y] + 
    		   board[x + 1][y + 1]+
    		   board[x][y + 1] + 
    		   board[x - 1][y + 1] - 8 * '0';
    }
    
    void FindMine(char board[ROWs][COLs], char show[ROWs][COLs], int row, int col)
    {
    	int x = 0;
    	int y = 0;
    	int win = 0;
    	while (win < row * col - EASY_CONUT)
    	{
    		printf("请输入坐标:");
    		scanf("%d %d",&x,&y);
    		if (x >= 1 && x <= row && y >= 1 && y <= col)
    		{
    			if (board[x][y] == '1')
    			{
    				printf("很遗憾,You lose!\n");
    				Displayboard(board, ROW, COL);
    				break;
    			}
    			else
    			{
    			    int count = Getmain(board, x, y);
    				show[x][y] = count + '0';
    				Displayboard(show, ROW, COL);
    				win++;
    			}
    		}
    		else
    			printf("输入坐标不合法,请重新输入!\n");
    	}
    	if (win == row * col - EASY_CONUT)
    	{
    		printf("恭喜你!You Win!\n");
    		Displayboard(board, ROW, COL);
    	}
    }
    
    
    展开全文
  • 本文实例为大家分享了C语言实现扫雷游戏及其优化的具体代码,供大家参考,具体内容如下 关于扫雷优化 1.核心思想:使用两个二维数组进行设计,一个用于显示,一个用于后台雷的布置。 2.使用宏常量,后期可以任意...
  • C语言实现扫雷

    2021-05-02 10:26:18
    C语言实现 简易版扫雷(Mine Sweeper) 游戏规则 在一个9*9的地图上会随机出现10个地雷,我们只需要把除这10个地雷之外的其他位置全部打开即为胜利!打开一个位置如果是不是地雷,则该位置会显示以该位置为中心,...
  • C语言——扫雷

    千次阅读 多人点赞 2018-10-26 21:02:55
    扫雷大家应该都应该玩过,这是电脑上一个十分经典的游戏,今天我将给大家讲解如何用C语言来实现扫雷,这个扫雷有如下几个功能: 1.第一次下子,不炸死。 2.坐标周围没雷,可以实现展开。 3.显示该点周围雷的个数。 ...
  • C语言扫雷

    万次阅读 2018-03-20 17:52:26
    C语言写出一个扫雷程序。像大家熟悉的电脑扫雷一样,如果选的位置有雷就结束游戏;如果没有雷,就标记出来周围格子雷的数量。这里写出来的扫雷不能用鼠标点击,也没有提供标记雷的功能,只在CMD黑框框里展示出来,...
  • 本文实例为大家分享了C语言实现扫雷游戏及其优化的具体代码,供大家参考,具体内容如下 关于扫雷优化 1.核心思想:使用两个二维数组进行设计,一个用于显示,一个用于后台雷的布置。 2.使用宏常量,后期可以任意...
  • C语言实现扫雷小游戏

    2019-04-08 12:17:56
    这是我们的童年记忆,今天就带大家用C语言实现扫雷程序的设计。 //1.二维数组表示地图 (1)show_map玩家看到的地图 数字表示已翻开和*表示未翻开(2)mine_map地雷布局图 每个位置标记是否是地雷 0、1 //2.初始化 ...
  • C语言设计-扫雷游戏

    2020-11-30 19:59:40
    #include #include #include #include #include #define row 12 #define col 12 char show[row][col]; char real[row][col]; int main() { void muen(); void init_mine(); void print_player();...
  • c语言扫雷程序设计

    2012-11-14 12:52:01
    c语言扫雷程序设计
  • 本文实例为大家分享了C语言实现扫雷游戏及其优化的具体代码,供大家参考,具体内容如下 关于扫雷优化 1.核心思想:使用两个二维数组进行设计,一个用于显示,一个用于后台雷的布置。 2.使用宏常量,后期可以任意修改...
  • 简单的基于C语言扫雷地图设计
  • 扫雷游戏 设计思路: 1.设计两个数组,设计者数组和玩家数组。 设计者数组比玩家数组大两行两列。 用来装布置的地雷数据,但只用1-(row-2)来存储,0和(row-1)什么也不放,只是为了方便扫雷时对周围8个数据的便利 2....
  • C语言实现 扫雷小游戏

    多人点赞 2021-04-27 15:37:18
    文章目录一、游戏规则二、设计思路三、程序设计+分段解析游戏基本流程+功能函数1.创建地图并初始化 init函数两个二维数组 ShowMap&MineMap2.打印地图 Print函数3.玩家确认要排查的位置4.判断是否踩雷5.更新排查...
  • [C/C++]C语言实现扫雷小游戏

    千次阅读 2021-03-04 21:50:45
    设计目标:通过C语言实现扫雷小游戏,能够判断胜负以及简单的人机交互。 成果如图: 代码: game.h #include<stdio.h> #include<time.h> #include <stdlib.h> #define ROW 11 //展示时...
  • 关于c语言实现扫雷游戏的课程设计报告,可用于学生实训参考。

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 182
精华内容 72
关键字:

c语言设计扫雷

c语言 订阅