C语言版扫雷小游戏

2024-08-17 07:28:01

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

一、游戏功能

1、显示该点周围雷的个数
2、第一次下子，不炸死
3、坐标周围没雷，可以实现展开

二、效果展示

三、设计思路

这里由于博主目前能力有限，所以这里就用输入坐标的形式来进行排雷。
要想实现上方游戏功能其实也不难，总体思路就是：我们用几个算法模块来模拟游戏规则，实现上方的功能，然后用函数来调用各个模块使游戏跑起来。
接下来我们就来看看如何用C语言代码来实现游戏吧！

四、游戏实现步骤

1、游戏菜单

首先我们需要打印一份游戏菜单界面，让玩家进行选择是否开始游戏，这里我们使用do…while循环语句，使的玩家不至于玩玩一次之后直接退出。

主函数部分：

int main()
{
 int input = 0;
 do
 {
  menu();//打印菜单的函数
  printf("请选择:>");
  scanf("%d", &input);
  switch (input)
  {
  case 1:
   printf("开始游戏\n");
   game();//游戏主体
   break;
  case 2:
   system("cls");//清屏选项
   break;
  case 0:
   printf("退出游戏\n");
   break;
  default:
   printf("输入错误，请重新选择\n");
   Sleep(1000);//1000毫秒--一秒
   system("cls");
   break;
  }

 } while (input);
 return 0;
}

这里我们用了Windows库函数清屏，如果屏幕上显示的东西太多了，我们可以选择2来清屏，还有一个睡眠函数，如果输出错误会短暂的提示你一秒，告诉你选择错误了，然后清屏。

菜单函数:

void menu()
{
 printf("**************************************************\n");
 printf("*******       Welcome to Minesweeper       *******\n");
 printf("**********          1. 开始游戏         **********\n");
 printf("**********          2. 清空屏幕         **********\n");
 printf("**********          0. 退出游戏         **********\n");
 printf("**************************************************\n");
}

效果如图：

2、创建初始化棋盘

我们在游戏菜单显示出来后，就可以进行选择开始游戏啦！
想玩扫雷就必须得有一个棋盘，这样我们就可以在上面进行排雷。
在这里我们需要用二维数组来创建两个棋盘，一个用于展示给玩家，并储存排雷信息；一个用于在后台随机生成雷并储存。假如我们要打印9X9的棋盘，那我们的二维数组大小也是9X9的吗？，不能，因为我们在设计算法时需要统计该坐标周围8个方位雷的个数，假如要统计边界坐标周围雷的个数，那么就会有数组越界的问题，那我们就要在9X9的边界多上一圈元素，也就要定义11X11的数组元素，这些多出来的一圈元素我们在打印棋盘的时候进行限制不要打印出来就行，如下图：

创建棋盘：

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

char mine[ROWS][COLS] = { 0 };//存放雷的信息
char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息

在创建完棋盘后，我们就要对两个棋盘进行初始化：

1、对于存放布置雷的棋盘我们用字符 ' 1 ' 表示雷，用字符 ‘ 0 ' 表示非雷，这里我们首先全部初始化为非雷，雷的排布我们在布雷的地方讲。
2、对于展示给玩家，并储存排雷信息的棋盘我们用 ‘ * ' 来初始化。

初始化棋盘函数：

InitBoard(mine, ROWS,COLS,'0');
InitBoard(show, ROWS,COLS,'*');

函数的定义：

void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
 int i = 0;
 for (i = 0; i < rows; i++)
 {
  int j = 0;
  for (j = 0; j < cols; j++)
  {
   board[i][j] = set;
  }
 }
}

3、布雷

我们将棋盘初始化完后，我们就要进行布雷的操作了。

雷的分布位置：我们在玩扫雷时知道，每次雷的分布的位置是不一样的，是随机分布的，所以我们在布雷操作的时候要调用随机函数rand(),在使用随机函数之前，我们要先在主函数中使用srand()函数生成随机起点，这样就可以保证每次雷的位置不一样了。关于这两个函数的使用，可以去MSDN或者cplusplus中去查询其作用。

然后就是雷的个数：每次分布一个就减少一个。

接着就是布雷的范围：因为我们玩家进行排雷是在9X9的棋盘内进行的，所以我们需限定布雷的范围也在9X9的范围内。

接下来我们来看看到底如何实现的吧！

主函数：

int main()
{
 int input = 0;
 srand((unsigned int)time(NULL));
 do
 {
  menu();//打印菜单
  printf("请选择:>");
  scanf("%d", &input);
  switch (input)
  {
  case 1:
   game();//游戏主体
   break;
  case 2:
   system("cls");//清屏选项
   break;
  case 0:
   printf("退出游戏\n");
   break;
  default:
   printf("输入错误，请重新选择\n");
   Sleep(1000);
   system("cls");
   break;
  }

 } while (input);
 return 0;
}

布雷函数：

#define EASY_COUNT 10  //雷的个数

SetMine(mine, ROW, COL);

函数的定义：

void SetMine(char board[ROWS][COLS], int row, int col)
{
 int x = 0;
 int y = 0;
 int count = EASY_COUNT;//雷的个数
 while (count)
 {
  //生成随机下标(1~9)
  x = rand() % row + 1;
  y = rand() % col + 1;

  if (board[x][y] != '1')
  {
   board[x][y] = '1';
   count--;
  }

 }
}

4、打印棋盘

我们将上方操作完成之后，就需要在屏幕上打印出棋盘了，但这里一共有两个棋盘，我们需要打印的棋盘是专门展示给玩家，并储存排雷信息的棋盘即用 ‘ * ' 初始化的棋盘。
还有就是我们需打印的大小是9X9的范围，而不是全部范围11X11的。
还有我们需要打印棋盘的行数和列数，以便玩家看坐标。

打印棋盘函数：

DisplayBoard(show, ROW, COL);

函数定义：

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

  }
  printf("\n");
 }
 printf("----------------\n");
}

5、排雷

完成上方所有操作后，就到我们最精彩，也是最重要的部分了。
要求：
1、输入排查坐标要在打印的棋盘范围内；
2、统计排查坐标周边八个位置的雷的个数；
3、保证第一次输入坐标绝对安全，不炸死；
4、坐标周围无雷则进行自动展开

排雷主逻辑函数：

FindMine(mine, show, ROW, COL);

统计排查坐标周边八个位置的雷的个数的函数：

GetMineCount(char mine[ROWS][COLS], int x, int y)

第一次安全函数：

safe(char mine[ROWS][COLS], int row,int col,int x, int y)

展开函数

OpenMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)

函数定义（从上往下）：

排雷主逻辑函数：

//主逻辑函数
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
 int x = 0;
 int y = 0;
 int win = 0;//统计排雷的个数
 int count = 0;// 统计雷的个数
 while (win<row*col-EASY_COUNT)
 {
  printf("请输入要排查的坐标");
  scanf("%d %d", &x, &y);
  if (x >= 1 && x <= row && y >= 1 && y <= col)  //输入坐标是否合法
  {
   if (mine[x][y] == '1')
   {
    if (0 == win)//第一次踩到雷，重新布雷
    {
     safe(mine, ROW,COL,x, y);
     //DisplayBoard(mine, ROW, COL);
     count = GetMineCount(mine, x, y);

     if (count == 0)
     {
      show[x][y] = ' ';
      win++;
      OpenMine(mine, show, ROW, COL, x, y,&win);//如果周围没有雷，进行扩展
      DisplayBoard(show, row, col);
     }
     else
     {
      show[x][y] = count + '0';
      DisplayBoard(show, row, col);
     }
    }
    else
    {
     printf("很遗憾，你被炸死了\n");
     DisplayBoard(mine, ROW, COL);
     break;
    }

   }
   else
   {
    count = GetMineCount(mine, x, y);
    if (count == 0)
    {
     show[x][y] = ' ';
    }
    else
    {
     show[x][y] = count + '0';
    }
    win++;
    OpenMine(mine, show, ROW, COL, x, y,&win);
    DisplayBoard(show, ROW, COL);
   }
  }
  else
  {
   printf("坐标不在范围内，请重新输入\n");
  }
 }
 if (win == row*col - EASY_COUNT)
 {
  printf("恭喜你，排雷成功\n");
 }
}

统计周围雷的个数：

//统计排查坐标周边八个位置的雷的个数
int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
 return (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');
}

第一次下子，不炸死，则重新布雷：

//第一次安全
void safe(char mine[ROWS][COLS], int row,int col,int x, int y)
{
 mine[x][y] = '0';
 int count = 1;
 while (count)
 {
  //生成随机下标(1~9)
  int i = rand() % row + 1;
  int j = rand() % col + 1;
  if ((mine[i][j] != '1') && i != x && j != y)
  {
   mine[i][j] = '1';
   count--;
  }
 }
}

坐标周围没雷，可以实现展开：

//展开函数
void OpenMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y,int* p)
{
 int i = -1;
 int j = -1;
 for (i = -1; i < 2; i++)//边界
 {
  for (j = -1; j < 2; j++)
  {
   if (i != 0 || j != 0) // 避免排到自己注意此处的逻辑关系
   {
    if (x + i >= 1 && x + i <= row && y + j >= 1 && y + j <= col)
    {
     if (show[x + i][y + j] == '*' && mine[x + i][y + j] != '1')
     {
      int count = GetMineCount(mine, x + i, y + j);
      if (count != '0')
      {
       show[x + i][y + j] = count + '0';
       (*p)++;
      }
      else
      {
       show[x + i][y + j] = ' ';
       (*p)++;
       OpenMine(mine, show,ROW,COL, x + i, y + j, p);
      }
     }
    }
   }
  }
 }
}

五、总结

和三子棋一样，将整个工程分为game.c,game.h和test.c三个文件。如下图

1、在头文件game.h主要包括各个函数的声明还有调用库函数所需的头文件以及棋盘行数列数的宏定义，方便以后我们如果想修改行或者列数目，直接修改宏定义的内容即可。
2、源文件game.c中则包括各种函数的实现，该文件中要引用头文件game.h
3、test.c中则包括游戏开始菜单的打印和调用game.c中的函数

game.h内容

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include<Windows.h>

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

//雷的个数
#define EASY_COUNT 10

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);

//布置雷
void SetMine(char board[ROWS][COLS], int row, int col);

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

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

//第一次安全
void safe(char mine[ROWS][COLS], int row, int col, int x, int y);

//统计排查坐标周边八个位置的雷的个数
int GetMineCount(char mine[ROWS][COLS], int x, int y);

//坐标周围展开函数
void OpenMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y,int* p);

game.c内容

#include "game.h"
//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
 int i = 0;
 for (i = 0; i < rows; i++)
 {
  int j = 0;
  for (j = 0; j < cols; j++)
  {
   board[i][j] = set;
  }
 }
}

//布置雷
void SetMine(char board[ROWS][COLS], int row, int col)
{
 int x = 0;
 int y = 0;
 int count = EASY_COUNT;
 while (count)
 {
  //生成随机下标(1~9)
  x = rand() % row + 1;
  y = rand() % col + 1;

  if (board[x][y] != '1')
  {
   board[x][y] = '1';
   count--;
  }

 }
}

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

  }
  printf("\n");
 }
 printf("----------------\n");
}

//排雷主逻辑
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
 int x = 0;
 int y = 0;
 int win = 0;//统计排雷的个数
 int count = 0;// 统计雷的个数
 while (win<row*col-EASY_COUNT)
 {
  printf("请输入要排查的坐标");
  scanf("%d %d", &x, &y);
  if (x >= 1 && x <= row && y >= 1 && y <= col)  //输入坐标是否合法
  {
   if (mine[x][y] == '1')
   {
    if (0 == win)//第一次踩到雷，重新布雷
    {
     safe(mine, ROW,COL,x, y);
     //DisplayBoard(mine, ROW, COL);
     count = GetMineCount(mine, x, y);

     if (count == 0)
     {
      show[x][y] = ' ';
      win++;
      OpenMine(mine, show, ROW, COL, x, y,&win);//如果周围没有雷，进行扩展
      DisplayBoard(show, row, col);
     }
     else
     {
      show[x][y] = count + '0';
      DisplayBoard(show, row, col);
     }
    }
    else
    {
     printf("很遗憾，你被炸死了\n");
     DisplayBoard(mine, ROW, COL);
     break;
    }

   }
   else
   {
    count = GetMineCount(mine, x, y);
    if (count == 0)
    {
     show[x][y] = ' ';
    }
    else
    {
     show[x][y] = count + '0';
    }
    win++;
    OpenMine(mine, show, ROW, COL, x, y,&win);
    DisplayBoard(show, ROW, COL);
   }
  }
  else
  {
   printf("坐标不在范围内，请重新输入\n");
  }
 }
 if (win == row*col - EASY_COUNT)
 {
  printf("恭喜你，排雷成功\n");
 }
}

//统计排查坐标周边八个位置的雷的个数
int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
 return (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');
}

//保证第一次下子安全
void safe(char mine[ROWS][COLS], int row,int col,int x, int y)
{
 mine[x][y] = '0';
 int count = 1;
 while (count)
 {
  //生成随机下标(1~9)
  int i = rand() % row + 1;
  int j = rand() % col + 1;
  if ((mine[i][j] != '1') && i != x && j != y)
  {
   mine[i][j] = '1';
   count--;
  }
 }
}

//展开函数
void OpenMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y,int* p)
{
 int i = -1;
 int j = -1;
 for (i = -1; i < 2; i++)//边界
 {
  for (j = -1; j < 2; j++)
  {
   if (i != 0 || j != 0) // 避免排到自己注意此处的逻辑关系
   {
    if (x + i >= 1 && x + i <= row && y + j >= 1 && y + j <= col)
    {
     if (show[x + i][y + j] == '*' && mine[x + i][y + j] != '1')
     {
      int count = GetMineCount(mine, x + i, y + j);
      if (count != '0')
      {
       show[x + i][y + j] = count + '0';
       (*p)++;
      }
      else
      {
       show[x + i][y + j] = ' ';
       (*p)++;
       OpenMine(mine, show,ROW,COL, x + i, y + j, p);
      }
     }
    }
   }
  }
 }
}

test.c内容

#include "game.h"
void menu()
{
 printf("**************************************************\n");
 printf("*******       Welcome to Minesweeper       *******\n");
 printf("**********          1. 开始游戏         **********\n");
 printf("**********          2. 清空屏幕         **********\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,'*');

 //布置雷
 SetMine(mine, ROW, COL);
 //打印棋盘
 //DisplayBoard(mine, ROW, COL);
 DisplayBoard(show, ROW, COL);
 //排查雷
 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 2:
   system("cls");//清屏选项
   break;
  case 0:
   printf("退出游戏\n");
   break;
  default:
   printf("输入错误，请重新选择\n");
   Sleep(1000);
   system("cls");
   break;
  }

 } while (input);
 return 0;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

C语言实现扫雷小游戏

本文实例为大家分享了C语言实现扫雷游戏的具体代码,供大家参考,具体内容如下主函数:main.c #include "game.h" void Menu() { printf("##########################\n"); printf("##1.play 0.exit##########\n"); printf("##########################\n"); printf("##
C语言实现扫雷小游戏（适合初学者）

扫雷小游戏作为初学c语言的小白有很大的帮助,其中用到了函数的定义,函数的声明,循环语句,数组思想等等知识,对于代码理解和设计代码思路有很大的帮助,本文就详细介绍了代码的各个步骤和运行结果.希望给到和我一样的小白一点帮助. //game.h头文件 #include<stdio.h> #include<stdlib.h> #include<time.h> #define ROW 9//定义了界面的长宽,可以直更改ROW,COL的值,避免了程序中数字重复出现 #define
C语言快速实现扫雷小游戏

本文实例为大家分享了C语言扫雷小游戏的具体实现代码,供大家参考,具体内容如下一.分析游戏步骤: 具体步骤如图: 二.代码实现: 游戏步骤想好之后,就是用代码把步骤一步一步的实现.具体代码如下: 1.游戏主要实现: game.c #define _CRT_SECURE_NO_WARNINGS 1 #include"game.h" void game() { char mine[ROW + 2][COL + 2]; //记录地雷的数组 char show[ROW + 2][COL + 2
C语言扫雷程序的实现

C语言扫雷程序的实现这个游戏可以实现根据选择坐标后所显示无雷区范围的不同分为简单 ,普通和困难游戏程序中,实现了游戏的计时(分钟)功能,实现了扫雷游戏的最基础功能. 定义了一个9*9的棋盘,玩家只要根据提示选择游戏,和难度: 根据提示输入合法的坐标,如输入不合法则会进行提示: 扫雷结束则会提示:如触雷则游戏自动结束: 整个游戏设计中主要的函数为: 1.初始化地雷棋盘和显示棋盘 2.棋盘打印函数 3.扫雷函数的实现 4.游戏主函数大家可以在宏定义中改变棋盘大小,雷的个数,以及显示的无雷区
C语言代码实现扫雷游戏

本文实例为大家分享了C语言实现扫雷游戏的具体代码,供大家参考,具体内容如下该游戏我们也是利用数组完成,设置俩个数组一个mine数组,一个show数组. mine数组存放雷,show数组显示棋盘并且显示该位置是否有雷或者显示该位置周围有几个雷. 数组大小有讲究,我们宏定义变量 ROW COL 为9 定义ROWS COLS为11,我们显示的是9X9的棋盘,也是将雷设置在9X9的位置内,但是我们设置数组是设置11X11,因为这样方便我们遍历9X9棋盘四边位置上某位置四周雷的数目,不然的话会发生越界错
基于C语言实现的扫雷游戏代码

本文详细讲述了基于C语言实现的扫雷游戏代码,代码中备有比较详细的注释,便于读者阅读和理解.希望对学习游戏开发的朋友能有一点借鉴价值. 完整的实例代码如下: /* 模拟扫雷游戏 */ #include <graphics.h> #include <math.h> #include <stdio.h> #include <dos.h> #include <stdlib.h> #include <conio.h> #include <
C语言实现简单扫雷小游戏

本文实例为大家分享了C语言实现扫雷小游戏的具体代码,供大家参考,具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <windows.h> #include <time.h> /* 用 C 语言写一个简单的扫雷游戏 */ // 1.写一个游戏菜单 Menu() // 2.开始游戏 // 1.初始化二维数组 Init_Interface() // 2.打印游戏界面 Print_Interfa
C语言实现扫雷程序

使用C语言实现简单的扫雷程序,主要是对二维数组的运用,我们需要一个头文件,两个源文件来实现. game.h //包含函数的声明,宏定义 test.c //包含主函数,函数调用 game.c //包含函数的定义整体思路 1.要完成一个简单的扫雷程序,我们需要创建两个二维数组,一个保存我们随机生成的雷,另外一个向外界展示. //使用宏定义定义常量,方便之后对数组的使用 #define ROW 11 //雷 #define COL 11 #define ROWS 9 //棋盘 #define COL
C语言实现简单扫雷小程序

扫雷是一款大众类的益智小游戏.游戏目标是在最短的时间内根据点击格子出现的数字找出所有非雷格子,同时避免踩雷,踩到一个雷即全盘皆输. 首先带大家简单来了解一下扫雷的游戏机制: 随便点一个格子,会有一块,上面的数字就代表数字周围八个格子会有几个雷,是1他周围就只有1个雷,2就有两个雷,以此类推,直到找出全部没有雷的格子就算玩家赢.只要点到一个有雷的格子就判定玩家输. 了解了机制之后就来编写程序.将程序分为test.c.game.c和game.h三个部分.其中test.c中编写主函数,game.c中
C语言开发简易版扫雷小游戏

前言: 想起来做这个是因为那时候某天知道了原来黑框框里面的光标是可以控制的,而且又经常听人说起这个,就锻炼一下好了. 之前就完成了那1.0的版本,现在想放上来分享却发现有蛮多问题的,而且最重要的是没什么注释[果然那时候太年轻]!现在看了也是被那时候的自己逗笑了,就修改了一些小bug,增加了算是详尽而清楚的注释,嗯,MSDN上面对各种函数的解释很详细的[又锻炼一下英语],顺便让开头和结尾的展示"动"了起来,就当作1.5的版本好了. 这个只是给出了一个实现的思路,其中肯定也有很多不合理的地