扫雷——利用GPT写的程序说明

1. 前言

《扫雷》是一款大众类的益智小游戏，于1992年发行。游戏目标是在最短的时间内根据点击格子出现的数字找出所有非雷格子，同时避免踩雷，踩到一个雷即全盘皆输。

2. 主函数部分

2.1 头文件部分

#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 DER 10//雷数

#define JI '-'


//初始化棋盘
void IninBoard(char mine[ROWS][COLS], int row, int col, char o);
//打印棋盘
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);
//递归排雷
void FindMinedi(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);

GPT 解读

#include"game.h"：这是包含自身头文件的指令。在该头文件中包含自身的目的是为了确保在包含该头文件的源文件中可以使用头文件中定义的函数和常量。

常量定义：

1. ROW和COL：定义了棋盘的行数和列数，分别为9。

2. ROWS和COLS：定义了包括边界的棋盘行数和列数，分别为ROW + 2和COL + 2。这是因为在实际游戏中，棋盘周围会有边界，用于判断边界条件。

3. DER：定义了雷的数量，为10。

4. JI：定义了一个字符常量’-’，具体用途未在代码中使用到。 函数声明：

5. void IninBoard(char mine[ROWS][COLS], int row, int col, char o)：初始化棋盘函数的声明，用于将棋盘数组初始化为指定的字符。

6. void DisplayBoard(char board[ROWS][COLS], int row, int col)：打印棋盘函数的声明，用于打印棋盘数组。

7. void SetMine(char board[ROWS][COLS], int row, int col)：随机生成雷区函数的声明，用于在棋盘数组中随机生成指定数量的雷。

8. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)：排查雷区函数的声明，是游戏的核心逻辑，用于根据用户的输入排查雷区。

9. void FindMinedi(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)：递归排查雷函数的声明，用于递归地排查周围的雷区。

通过头文件中的声明，可以让其他源文件在包含该头文件后，可以使用这些函数和常量，而不需要重复定义或声明。头文件的作用是提供函数和常量的接口，让其他源文件可以共享和使用这些功能。

2.2 主函数部分

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"

//打印菜单
void menu()
{
	printf("**************************\n");
	printf("********  1.play  ********\n");
	printf("********  0.exit  ********\n");
	printf("**************************\n");
}


void game()
{
	char mine[ROWS][COLS];//电脑生成雷区
	char show[ROWS][COLS];//给人看到的排雷

	//初始化雷区
	IninBoard(mine, ROWS, COLS, '0');
	IninBoard(show, ROWS, COLS, '*');

	//布置地雷
	SetMine(mine, ROW, COL);
	
	//打印
	//DisplayBoard(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);

	//排雷
	FindMine(mine, show, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//DisplayBoard(show, ROW, COL);
	
}


int main()
{
	int input = 0;

	srand((unsigned int)time(NULL));

	//循环选择函数
	//1.play 0.exit
	do { 
		printf("       欢迎来到扫雷  \n");
		menu();
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("进入游戏\n\n");
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误,请重新选择\n\n");
			break;
		}
	} while (input);


	return;
}

GPT 解析

2.3 游戏函数部分

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"


//初始化数组
//把mine全设置为 '0'
//把show全设置为 '*'
void IninBoard(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)
{

	printf(" --------扫雷--------\n");
	for (int 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");
	}
}

//随机生成DER个雷
void SetMine(char board[ROWS][COLS], int row, int col)
{
	//横纵坐标
	int x = 0;
	int y = 0;
	//雷数
	int count = DER;
	while(count)
	{
		x = rand() % ROW + 1;
		y = rand() % COL + 1;
		if (board[x][y] != '1')
		{
			board[x][y] = '1';
			count--;
		}
	}
}


//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	//排查坐标
	int x = 0;
	int y = 0;

	//排雷次数计数器
	int win = 1;
	
	//判断胜利条件
	while (win)
	{
		printf("请输入要排查坐标(x x)\n ");
		printf("输入0 0标记雷区,再次输入取消标记> ");
		scanf("%d %d", &x, &y);

		//标记雷区
		if (x == y && y == 0)
		{
			printf("请输入要标记坐标");
			scanf("%d %d", &x, &y);
			if (x >= 1 && x <= row && y >= 1 && y <= col)
			{
				if (show[x][y] == '*')
				{
					show[x][y] = '?';
					system("cls");
					DisplayBoard(show, ROW, COL);
					win = Win(show, mine, ROW, COL);
					continue;
				}
				else if(show[x][y] == '?')
				{
					show[x][y] = '*';
					system("cls");
					DisplayBoard(show, ROW, COL);
					win = Win(show, mine ,ROW, COL);
					continue;
				}
			}
		}
		//判断坐标合法
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//如果为1被炸死
			//如果被标记重新输入
			//不为1且合法且没被标记进入选择分支
			if (mine[x][y] != '1')
			{
				//计算该坐标周围雷数
				//如果计算过从新输入
				if (show[x][y] == '*')
				{
					//计算出该坐标周边有几个雷存入 count
					int count = GetMineCount(mine, x, y);
					show[x][y] = count + '0';
				
					FindMinedi(mine, show, x, y);
					system("cls");
					DisplayBoard(show, ROW, COL);
				}
				else
				{
					printf("该位置已排过，请从新排\n");
				}
			}
			else if (show[x][y] == '?')
			{
				printf("该处已被排查，请重新输入\n");
			}
			else
			{
				system("cls");
				printf("很遗憾你被炸死了\n");
				DisplayBoard(mine, ROW, COL);
				return;
			}
		}
		else
		{
			printf("坐标不合法，重新输入\n");
		}	
		win = Win(show, mine ,ROW, COL);
	}
	printf("恭喜你，获得胜利\n");
}

//判断是否获胜
int Win(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{

	//计算总格子减雷数  一共需要显示的个数
	int win = row * col - DER;
	for (int i = 1; i <= row; i++)
	{
		for (int j = 1; j <= col; j++)
		{

			//判断如果该位置不为 * （排除过）  进入判断
			if (mine[i][j] != '*' && mine[i][j] != '?')
			{
				if (show[i][j] == '0')
				{
					win--;
				}
			
			}
		}
	}
	if (win == 0)
	{
		return 0;
	}
	return 1;
}


//通过递归排查雷
void FindMinedi(char mine[ROWS][COLS], char show[ROWS][COLS],int x,int y )
{
	if (GetMineCount(mine, x, y) == 0)
	{
		show[x][y] = ' ';
		for (int i = x - 1; i <= x + 1; i++)
		{
			for (int j = y - 1; j <= y + 1; j++)
			{
				if (i > 0 && i <= ROW && j > 0 &&
					j <= COL && mine[i][j] != '1' && show[i][j] == '*')
				{
					FindMinedi(mine, show, i, j);
				}
			}
		}
	}
	else
		show[x][y] = '0' + GetMineCount(mine, x, y);
}

//算出该坐标周围有几个雷
int GetMineCount(char mine[ROWS][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][y + 1] + mine[x + 1][y - 1] +
		mine[x + 1][y] + mine[x + 1][y + 1]) - ('0' * 8);
}

GPT解读

3. 总结

GPT对代码的评价