devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言】实践：贪吃蛇小游戏（附源码）_c语言贪吃蛇研究现状及分析

作者：天景科技苑 | 2024-08-08 11:36:34

赞

踩

c语言贪吃蛇研究现状及分析

  欢迎光顾我的homepage

前言

        贪吃蛇小游戏想必大家都玩过吧，现在就要C语言代码来实现一下贪吃蛇小游戏

在实现之前，我们要对C语言结构体、指针、链表(单链表)有一定的基础

先来看一下预期运行效果

一、Win32 API

        这里实现贪吃蛇游戏会使用一些Win32 API的知识，这里简单学习一下

        Windows 这个多作业系统除了协调应用程序的执行、分配内存、管理资源之外，它也是一个很大的服务中心，调用这个服务中心的各种服务（每一种服务就是一个函数），可以帮应用程序达到开启视窗、绘制图形、使用周边设备等目的，由于这些函数服务的对象是应用程序，所以便称之为Appliccation Programming Interface，简称API。WIN32 API也就是Microsoft Windows32位平台的应用程序编程接口。

1.1 控制台程序

        在我们的电脑中，windows系统使用快捷键win + R可以打开一个窗口，然后输入cmd就可以打开一个控制台程序，这个控制台可以输入一些命令来控制我们的电脑，这里输入cmd即可打开一个控制台程序窗口

        1.1.1 设置控制台程序

        本次贪吃蛇小游戏是在VS2022上来实现的，平常我们运行起来的黑框程序就是控制台层序

在VS2022上运行默认是以下情况

这里就需要先修改一个控制台

调出控制台（这里可以使用Win+R，输入cmd调出窗口），点击设置

在默认终端应用程序这里设置成Windows 控制台主机（默认是Windows 终端），点击保存

设置完成后，就是以下这种界面了

        1.1.2 设置控制台程序大小

这里我们控制台程序是默认大小，这里我们自己设置控制台程序大小，这里使用cmd控制台程序设置窗口的大小（设置大小为行33，列100）

mode con cols=100 lines=33

        1.1.3 设置控制台程序名称

我们设置控制台名称为 贪吃蛇，使用title 指令

title 贪吃蛇

        当然，这些能够在控制台窗口执行的命令，也可以通过调用C语言的system函数在中来完成

这里再补充一个指令，暂停控制台程序

system("pause");

        这个指令可以暂停程序运行，并会提示按下任意键继续...

  1. int main()
  2. {
  3. 	system("mode con cols=100 lines=33");
  4. 	system("title 贪吃蛇");
  5. 	system("pause");
  6. 	return 0;
  7. }

        1.1.4 控制台屏幕上的坐标

COORD是Windows API中自定义的一个结构体，表示一个字符在控制台屏幕缓冲区的坐标，坐标（0，0）的原点位于缓冲区的顶部左侧单元格。

COORD类型声明

  1. typedef struct _COORD {
  2.     SHORT X;
  3.     SHORT Y;
  4. } COORD, *PCOORD;

给坐标赋值

 COORD pos = { 10, 15 };

GetStdHandle

        GetStdHandle是一个Windows API函数。它用于从一个特定的标准设备（标准输入、标准输出或标准错误）中取得一个句柄（用来标识不同设备的数值），这个句柄可以操作设备。

HANDLE WINAPI GetStdHandle(_In_ DWORD nStdHandle);

函数参数

函数使用

  1. 	HANDLE hOutput = NULL;
  2. 	//获取标准输出的句柄(用来标识不同设备的数值)
  3. 	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);

GetConsoleCursorInfo

        GetConsoleCursorInfo函数检索有关指定控制台屏幕缓冲区的光标的大小和可见性的信息

函数语法

  1. BOOL WINAPI GetConsoleCursorInfo(
  2.   _In_  HANDLE               hConsoleOutput,
  3.   _Out_ PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
  4. );
PCONSOLE_CURSOR_INFO 是指向 CONSOLE_CURSOR_INFO 结构的指针，该结构接收有关主机游标(光标)的信息

        CONSOLE_CURSOR_INFO结构体

        这个结构体包含了有关控制台光标的信息

  1. typedef struct _CONSOLE_CURSOR_INFO {
  2.  DWORD dwSize;
  3.  BOOL bVisible;
  4. } CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;

        dwSize 由光标填充的字符单元格的百分比。此值介于1到100之间。光标外观会变化，范围从完全填充单元格到单元格底部的水平线条

        bVisible 游标的可见性。如果光标可见，则此成员为true；如果不可见，此成员为false

函数参数

        这里就用到上面GetStdHandle函数获得的句柄了，还需要用到CONSOLE_CURSOR_INFO结构体（注意，这里第二个参数是指针）

函数使用

  1. HANDLE hOutput = NULL;
  2. //获取标准输出的句柄(⽤来标识不同设备的数值)
  3. hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  4. CONSOLE_CURSOR_INFO CursorInfo;
  5. GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息

SetConsoleCursorInfo

        SetConsoleCursorInfo函数设置指定控制台屏幕缓冲区的光标的大小和可见性

函数参数

  1. BOOL WINAPI SetConsoleCursorInfo(
  2.   _In_       HANDLE              hConsoleOutput,
  3.   _In_ const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
  4. );

        与GetConsoleCursorInfo函数参数相同         

函数使用

  1. HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  2. //影藏光标操作
  3. CONSOLE_CURSOR_INFO CursorInfo;
  4. GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
  5. CursorInfo.bVisible = false; //隐藏控制台光标
  6. SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态

SetConsoleCursorPosition

        SetConsoleCursorPosition函数设置指定控制台屏幕缓冲区的位置，我们将想要设置的坐标信息放在COORD类型的pos中，调用SetConsoleCursorPosition函数将光标位置设置到指定的位置。

  1. BOOL WINAPI SetConsoleCursorPosition(
  2.   _In_ HANDLE hConsoleOutput,
  3.   _In_ COORD  dwCursorPosition
  4. );

函数参数

函数使用

  1. 	HANDLE hOutput = NULL;
  2. 	//获取标准输出的句柄(用来标识不同设备的数值)
  3. 	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  4. 	COORD pos = { 10, 5 };
  5. 	//设置标准输出上光标的位置为pos
  6. 	SetConsoleCursorPosition(hOutput, pos);

这里为了方便后面定位屏幕坐标，单独封装一个函数来实现

  1. void SetPos(short x, short y)
  2. {
  3. 	COORD pos = { x, y };
  4. 	HANDLE hOutput = NULL;
  5. 	//获取标准输出的句柄(用来标识不同设备的数值)
  6. 	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  7. 	//设置标准输出上光标的位置为pos
  8. 	SetConsoleCursorPosition(hOutput, pos);
  9. }

GetAsyncKeyState

        GetAsyncKeyState函数获得按键情况

  1. SHORT GetAsyncKeyState(
  2.   [in] int vKey
  3. );

函数参数

        这里函数参数是虚拟键码。

这里仅列出一些在游戏中可能用到的按键的虚拟键码，可以点击查看详细虚拟键码

VK_UP0x26↑
VK_DOWN0x28↓
VK_LEFT0x25←
VK_RIGHT0x27→
VK_F30x72F3
VK_F40x73F4
VK_ESCAPE0x1BEsc
VK_SPACE0x20空格

函数返回值

        GetAsyncKeyState 函数返回值是short类型，在上一次调用 GetAsyncKeyState 函数后，如果返回的16位的short数据中，如果最高位是1，说明按键的状态是按下，如果最高位是0，说明按键的状态是抬起；如果最低位被置为1则说明，该按键被按过，否则为0。

        在游戏中我们需要检测一个按键是否被按过，就检测 GetAsyncKeyState 函数返回值的最低值是否是1，可以写一个宏来实现：

#define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )

二、<locale.h>本地化

在贪吃蛇游戏中，我们会涉及到墙体□ 和蛇的身体● 的打印，而在VS中我们输出出来的是?

这就是因为没有本地化设置，无法输出这些特殊字符（宽字符）。

        我们需要通过修改地区，让程序来适应不同的区域，我们就需要进行本地化设置

这里就要使用到C语言中的库函数  setlocale 函数

在C标准中，依赖地区的部分有以下几项

数字量的格式

货币量的格式

字符集

日期和时间的表示形式     

        通过修改地区，程序可以改变它的行为来适应世界的不同地域。但地区的改变可能会影响库的许多部分，其中一部分可能是我们不希望修改的。所以C语言支持针对不同的类型进行修改，下面的一个宏就指定一个类型。 

LC_COLLATE ：影响字符串表函数 strcoll  和strxfrm。

LC_CTYPE ： 影响字符处理函数的行为。

LC_MONETARY ： 影响货币格式。

LC_NUMERIC ： 影响 printf 的数字格式。

LC_TIME ： 影响时间格式 strftime 和 wcsftime  。

LC_ALL ： 针对所有类型修改，将以上所有类别设置为给定的语言环境。

每一个类别都有详细说明，这里就不一一讲解了

        2.1 setlocale 函数

setlocale 函数用于修改当前地区，可以针对一个类项进行修改，也可以针对所有类项

函数的第一个参数可以是前面类项中的一个，也可以是LC_ALL（影响所以的类项）

函数的第二个参数

        C标准给第二个参数仅定义了2种可能取值："C"（正常模式）和" "（本地化模式）

这里我们需要进行本地化设置

 setlocale(LC_ALL, " ");//切换到本地环境

        2.2 宽字符的打印

在屏幕中，我们需要打印宽字符        

        宽字符的字面量必须加上前缀“L”，否则C语言就会把字符量当成窄字符来处理。前缀“L”子啊单引号（或者双引号）的前面，表示宽字符，对于 wprintf 的占位符是 %lc；双引号的前面，对于wprintf 的占位符是 %ls。

可以看到，这里宽字符占两个窄字符的位置。

三、游戏分析和设计

        3.1 贪吃蛇数据结构设计

        在游戏运行的过程中，蛇每吃一次食物，蛇的身体就会变长；这样我们就可以使用链表来存储蛇的信息，蛇的每一个节身体其实就是链表的一个节点。每个节点只需记录蛇身节点在地图上的坐标就可以。

        蛇身节点的结构：

  1. typedef struct Snakenode
  2. {
  3. 	int x;
  4. 	int y;
  5. 	struct Snakenode* next;
  6. }Snakenode, * pSnakenode;
  7. //这里也可以写 typedef Snakenode* pSnakenode

        接下来，我们还需要记录游戏过程中的相关信息

贪吃蛇，食物的位置，蛇的方向，游戏状态，当前的分数，每一个食物的分数，蛇的速度等

而这里蛇的方向和游戏状态都可以一一列举出来，这里就使用枚举变量

  1. //蛇的方向
  2. enum DIRECT
  3. {
  4. 	UP = 1,
  5. 	DOWN,
  6. 	LEFT,
  7. 	RIGHT
  8. };
  9. //蛇的状态——游戏状态
  10. //正常、撞墙、撞到自己、正常退出
  11. enum GAME_STATE
  12. {
  13. 	OK,
  14. 	KILL_WALL,
  15. 	KILL_SELF,
  16. 	NORMAL_END
  17. };
  18. //贪吃蛇的相关信息
  19. typedef struct Snake
  20. {
  21. 	pSnakenode psnake; //指向蛇头部的指针
  22. 	pSnakenode pfood;   //指向食物的指针
  23. 	enum DIRECT dir;//蛇的方向
  24. 	enum GAME_STATE state;//蛇的状态
  25. 	int food_scores;//每个食物的分数
  26. 	int all_scores; //总分数
  27. 	int sleep_time;  //休息的时间 --即蛇的速度
  28. }Snake;
  29. typedef Snake* pSnake;

这样，我们就创建了一个Snake结构体来维护游戏相关信息（维护整条贪吃蛇）

        3.2 游戏流程分析

游戏大概分析如下

四、游戏逻辑实现

        程序开始就设置程序本地化，然后就进入到游戏的主逻辑当中

根据游戏大概分析，游戏可以分为三个阶段

阶段一：游戏开始 --- 完成游戏的初始化 

阶段二：游戏运行 --- 完成游戏运行逻辑的实现

阶段三：游戏结束 --- 完成游戏结束的说明，实现资源释放

        当然，这里我们玩完一局游戏后，可以选择继续或者结束（这里就以输入Y/N来判断游戏是否继续运行）

这里我们在测试test.c文件开始就让程序本地化

  1. void test()
  2. {
  3. 	Snake snake = { 0 };
  4. 	int ch = 0;
  5. 	do
  6. 	{
  7. 		ch = 0;
  8. 		system("cls");
  9. 		//游戏初始化
  10. 		GameStart(&snake);
  11. 		//游戏运行
  12. 		GameRun(&snake);
  13. 		//游戏结束
  14. 		GameOver(&snake);
  15. 		KeyFun();
  16. 		SetPos(30, 20);
  17. 		wprintf(L"再来一局吗？ (Y/N)");
  18. 		ch = getchar();
  19. 		while (getchar() != '\n');
  20. 	} while (ch == 'Y' || ch == 'y');
  21. 	SetPos(0, 27);
  22. }
  23. int main()
  24. {
  25. 	//本地化
  26. 	setlocale(LC_ALL, "");
  27. 	srand((unsigned int)time(NULL));
  28. 	test();
  29. 	//KeyFun();
  30. 	return 0;
  31. }

测试大概框架就是这样，接下来就分别来实现这些框架的内容

        4.1 游戏开始（GameStart）

1. 设置控制台大小和名字

这里设置控制台大小，100列，33行；设置控制台名称为：贪吃蛇

  1. 	//设置窗口名称大小
  2. 	system("title 贪吃蛇");
  3. 	system("mode con cols=100 lines=33");

2. 隐藏屏幕光标

隐藏屏幕光标，这里就用到了前面Win32 API的知识

  1. 	//隐藏光标
  2. 	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  3. 	CONSOLE_CURSOR_INFO CursorInfo;
  4. 	GetConsoleCursorInfo(houtput, &CursorInfo);
  5.     //获得有关指定控制台屏幕缓冲区的光标大小和可见的信息
  6. 	CursorInfo.bVisible = false; //隐藏控制台光标
  7. 	SetConsoleCursorInfo(houtput, &CursorInfo);//设置控制台光标状态

3. 打印欢迎界面

输出欢迎界面，这里分装成函数WelcomeToGame

        我们观察欢迎界面，可以发现这里并不是在坐标为(0,0)处打印的，这里就要用到设置光标位置（这里单独写一个函数，设置光标位置）

设置光标位置

  1. //设置光标位置
  2. void SetPos(int x, int y)
  3. {
  4. 	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  5. 	COORD pos = { x,y };
  6. 	SetConsoleCursorPosition(houtput, pos);
  7. }

接下来就是游戏欢迎界面的打印，这里中间会用到 pause 和 cls（清理屏幕） 指令

  1. //欢迎界面打印
  2. void WelcomeToGame()
  3. {
  4. 	//设置光标位置
  5. 	SetPos(40, 15);
  6. 	printf("欢迎进入贪吃蛇小游戏\n");
  7. 	SetPos(42, 20);
  8. 	system("pause");
  9. 	system("cls");//清理屏幕
  10. 	SetPos(20, 11);
  11. 	printf("请使用↑ 、 ↓ 、 ← 、 → 来控制贪吃蛇的移动，按F3加速、F4减速 ");
  12. 	SetPos(20, 13);
  13. 	printf("加速可以获得更多的分数");
  14. 	SetPos(20, 15);
  15. 	system("pause");
  16. 	system("cls"); //清理屏幕
  17. }

这样就可以实现预期效果图那样了，接下来就是绘制我们贪吃蛇游戏的地图了。

4. 绘制地图

这里我们使用宽字符来打印地图，先来看一下预期效果

我们把地图分为上、下、左、右这四个部分，这样我们只需依次打印这些宽字符就可以了

  1. //地图绘制
  2. void CreatMap()
  3. {
  4. 	//上
  5. 	int i = 0;
  6. 	for (i = 0; i < 29; i++)
  7. 	{
  8. 		wprintf(L"%lc", WALL);
  9. 	}
  10. 	//下
  11. 	SetPos(0, 26);
  12. 	for(i = 0; i < 29; i++)
  13. 	{
  14. 		wprintf(L"%lc", WALL);
  15. 	}
  16. 	//左
  17. 	
  18. 	for (i = 1; i < 26; i++)
  19. 	{
  20. 		SetPos(0, i);
  21. 		wprintf(L"%lc", WALL);
  22. 	}
  23. 	//右
  24. 	for (i = 1; i < 26; i++)
  25. 	{
  26. 		SetPos(56, i);
  27. 		wprintf(L"%lc", WALL);
  28. 	}
  29. }

5. 初始化贪吃蛇

初始化贪吃蛇，也是创建贪吃蛇，贪吃蛇身体这里其实就是一个链表，里面存放着每个节点的坐标

        初始化贪吃蛇也要给上一些初始数据

初始长度为  --  5

初始方向  --  向右（RIGHT）

初始状态  --  正常（OK）

每个食物得分  --  10

初始总分  --  0

初始速度  --  这里设定眠时间为200毫秒

初始蛇的位置  --  这里就随机生成（也可以指定）

当然初始指向食物的指针置为NULL(因为这里还未创建食物）

  1. //创建贪吃蛇
  2. void InitSnake(pSnake ps)
  3. {
  4. 	//创建蛇的身体
  5. 	pSnakenode pcur = NULL;
  6. 	int i = 0;
  7. 	int x, y;//蛇初始位置
  8. 	do
  9. 	{
  10. 		x = rand() % 31 + 4; //x: 4 - 34
  11. 		y = rand() % 20 + 2; //y: 1 - 25
  12. 	} while (x % 2 != 0);
  13. 	for (i = 0; i < 5; i++)
  14. 	{
  15. 		pcur = (pSnakenode)malloc(sizeof(Snakenode));
  16. 		if (pcur == NULL)
  17. 		{
  18. 			perror("InitSnake()::malloc()");
  19. 			return;
  20. 		}
  21. 		pcur->next = NULL;
  22. 		//pcur->x = SNAKE_X + i * 2;
  23. 		//pcur->y = SNAKE_Y;
  24. 		pcur->x = x + i * 2;
  25. 		pcur->y = y;
  26. 		//头插到贪吃蛇链表中
  27. 		if (ps->psnake == NULL) //链表为空
  28. 		{
  29. 			ps->psnake = pcur;
  30. 		}
  31. 		else
  32. 		{
  33. 			pcur->next = ps->psnake;
  34. 			ps->psnake = pcur;
  35. 		}
  36. 	}
  37. 	//输出蛇的初始位置
  38. 	pcur = ps->psnake;
  39. 	while (pcur)
  40. 	{
  41. 		SetPos(pcur->x, pcur->y);
  42. 		wprintf(L"%lc", SNAKENODE);
  43. 		pcur = pcur->next;
  44. 	}
  45. 	//初始化贪吃蛇的信息
  46. 	ps->dir = RIGHT; //蛇的方向
  47. 	ps->pfood = NULL; //指向食物 --NULL  
  48. 	ps->state = OK;  //状态
  49. 	ps->food_scores = 10; //每个食物的得分
  50. 	ps->all_scores = 0;  //总分
  51. 	ps->sleep_time = 200;//速度，即休息时间 单位是毫秒
  52. 	//getchar();
  53. }

6. 创建食物

        创建完贪吃蛇，接下来就是创建食物了，其实食物和贪吃蛇身体节点一样，都存放着坐标；所以这里就创建一个结构体，再随机生成坐标
        这里需要注意：

        坐标x必须是偶数

        坐标必须在地图内

        生成食物的坐标不能与蛇的身体重复

  1. //创建食物
  2. void CreatFood(pSnake ps)
  3. {
  4. 	int x, y;//随机生成坐标 x , y 
  5. 	//x 2-54
  6. 	//y 1-25
  7.  
  8. 	again:
  9. 	do {
  10. 		x = rand() % 53 + 2;
  11. 		y = rand() % 25 + 1;
  12. 	} while (x % 2 != 0);
  13. 	//x y 不能与贪吃蛇身体重复
  14. 	pSnakenode pcur = ps->psnake;
  15. 	while (pcur)
  16. 	{
  17. 		if (x == pcur->x && y == pcur->y)
  18. 		{
  19. 			goto again;
  20. 		}
  21. 		pcur = pcur->next;
  22. 	}	
  23. 	pSnakenode food = (pSnakenode)malloc(sizeof(pSnakenode));
  24. 	if (food == NULL)
  25. 	{
  26. 		perror("CreatFood()::malloc");
  27. 		return;
  28. 	}
  29.  
  30. 	food->x = x;
  31. 	food->y = y;
  32. 	food->next = NULL;
  33. 	ps->pfood = food;
  34. 	SetPos(x, y);
  35. 	wprintf(L"%lc", FOOD);
  36. 	//getchar();
  37. }

这样我们的初始化就完成了

        4.2 游戏运行（GameRun）

1.输出右侧提示信息和分数详情

看预期效果图，我们在地图的右侧输出一些提示信息，并且输出当前得分详情

  1. void Printgame(pSnake ps) {
  2. 	SetPos(60, 15);
  3. 	printf("请使用↑ 、 ↓ 、 ← 、 → 来控制贪吃蛇");
  4. 	SetPos(60, 16);
  5. 	printf("按F3加速、F4减速 ");
  6. 	SetPos(60, 18);
  7. 	printf("加速可以获得更高的分数 ");
  8. 	SetPos(60, 20);
  9. 	printf("ESC:退出游戏  space:暂停 ");
  10. 	SetPos(60, 10);
  11. 	printf("当前总得分:%d", ps->all_scores);
  12. 	SetPos(60, 12);
  13. 	printf("当前每个食物得分:%d", ps->food_scores);
  14. 	SetPos(60, 22);
  15. 	printf("努力学习的小廉");
  16. }

2. 获取按键情况

现在就要获取我们键盘按键的信息了，这里写一个宏来判断按键是否被按过

#define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )

这里把获取按键信息直接写到游戏运行这个函数内，顺便看一下游戏运行都需要实现哪些东西？

  1. //游戏运行
  2. void GameRun(pSnake ps)
  3. {
  4. 	do
  5. 	{
  6. 		Printgame(ps);
  7. 		//判断按键是否被按过
  8. 		if (KEY_PRESS(VK_UP) && ps->dir != DOWN)
  9. 		{
  10. 			ps->dir = UP;
  11. 		}
  12. 		else if(KEY_PRESS(VK_DOWN) && ps->dir != UP){
  13. 			ps->dir = DOWN;
  14. 		}
  15. 		else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT) {
  16. 			ps->dir = LEFT;
  17. 		}
  18. 		else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT) {
  19. 			ps->dir = RIGHT;
  20. 		}
  21. 		else if (KEY_PRESS(VK_SPACE)) //空格 -- 暂停
  22. 		{
  23. 			Pause();
  24. 		}
  25. 		else if (KEY_PRESS(VK_ESCAPE)) //游戏正常退出
  26. 		{
  27. 			ps->state = NORMAL_END;
  28. 			break;
  29. 		}
  30. 		else if (KEY_PRESS(VK_F3))
  31. 		{
  32. 			if (ps->sleep_time >= 100)
  33. 			{
  34. 				ps->sleep_time -= 50;
  35. 				ps->food_scores += 5;//设定食物分数最高25
  36. 			}
  37. 		}
  38. 		else if (KEY_PRESS(VK_F4))
  39. 		{
  40. 			if (ps->sleep_time < 300)
  41. 			{
  42. 				ps->sleep_time += 100;
  43. 				ps->food_scores -= 5;//⼀个⻝物分数最低是5分
  44. 			}
  45. 		}
  46. 		Sleep(ps->sleep_time);
  47. 		//贪吃蛇的移动
  48. 		SnakeMove(ps);
  49. 		//判断贪吃蛇是否撞墙
  50. 		KillByWall(ps);
  51. 		//判断贪吃蛇是否撞到自己
  52. 		KillBySelf(ps);
  53.  
  54. 	} while (ps->state == OK);
  55.  
  56. }

这里当游戏状态不是正常运行时，就结束了循环（即游戏结束）

3. 贪吃蛇移动

        看上述游戏运行代码，可以看到贪吃蛇的移动还有判断蛇是否撞到墙和自己，这些的实现在贪吃蛇移动当中。

        1> 蛇身的移动

        蛇身的移动，其实就是根据当前蛇的方向，找到下一个节点，再判断下一个节点是否是食物，和判断是否撞到墙和自己

        2> 判断是否吃到食物

        判断蛇的下一个节点是否是食物，就是判断下一个位置的坐标和实物的坐标是否重复

如果重复，就让蛇身变长一节，如果不是，就让蛇往前走

这里蛇移动还有一些知识，就是直接为蛇下一个位置创建一个新的节点

        再判断下一个位置是否是食物，如果是就将节点头插到蛇身链表中，不删除尾节点；如果不是就直接将节点头插到蛇身链表中，删除尾节点（这里还需在蛇的尾部输出两个空格"  "）

  1. //下一个位置是食物
  2. void IsFood(pSnakenode next, pSnake ps)
  3. {
  4. 	//把下一个位置的节点头插到贪吃蛇中
  5. 	next->next = ps->psnake;
  6. 	ps->psnake = next;
  7. 	//打印贪吃蛇
  8. 	pSnakenode cur = ps->psnake;
  9. 	while (cur)
  10. 	{
  11. 		SetPos(cur->x, cur->y);
  12. 		wprintf(L"%lc", SNAKENODE);
  13. 		cur = cur->next;
  14. 	}
  15. 	ps->all_scores += ps->food_scores;
  16. 	CreatFood(ps);
  17. 	//SetPos(ps->pfood->x, ps->pfood->y);
  18. 	//wprintf(L"%lc", FOOD);
  19. }
  20. //下一个位置不是食物
  21. void NoFood(pSnakenode next, pSnake ps)
  22. {
  23. 	//把下一个位置的节点头插到贪吃蛇中
  24. 	next->next = ps->psnake;
  25. 	ps->psnake = next;
  26.  
  27. 	pSnakenode cur = ps->psnake;
  28. 	while (cur->next->next != NULL)
  29. 	{
  30. 		SetPos(cur->x, cur->y);
  31. 		wprintf(L"%lc", SNAKENODE);
  32. 		cur = cur->next;
  33. 	}
  34. 	SetPos(cur->next->x, cur->next->y);
  35. 	wprintf(L"%ls", L"  ");
  36.  
  37. 	free(cur->next);
  38. 	cur->next = NULL;
  39. }
  40. //贪吃蛇的移动
  41. void SnakeMove(pSnake ps)
  42. {
  43. 	pSnakenode next = (pSnakenode)malloc(sizeof(Snakenode));
  44. 	if (next == NULL)
  45. 	{
  46. 		perror("SnakeMove():malloc()");
  47. 		exit(1);
  48. 	}
  49. 	switch (ps->dir)
  50. 	{
  51. 	case UP:
  52. 		next->x = ps->psnake->x;
  53. 		next->y = ps->psnake->y - 1;
  54. 		break;
  55. 	case DOWN:
  56. 		next->x = ps->psnake->x;
  57. 		next->y = ps->psnake->y + 1;
  58. 		break;
  59. 	case LEFT:
  60. 		next->x = ps->psnake->x - 2;
  61. 		next->y = ps->psnake->y;
  62. 		break;
  63. 	case RIGHT:
  64. 		next->x = ps->psnake->x + 2;
  65. 		next->y = ps->psnake->y;
  66. 		break;
  67. 	}
  68. 	//判断下一个位置是不是食物
  69. 	if (NextIsFood(next, ps))
  70. 	{
  71. 		IsFood(next, ps);
  72. 	}
  73. 	else {
  74. 		NoFood(next, ps);
  75. 	}
  76. }
        3> 判断是否撞到墙和自己

判断蛇是否撞墙，就是判断蛇身节点的坐标是否超出地图的范围

  1. //判断贪吃蛇是否撞墙
  2. void KillByWall(pSnake ps)
  3. {
  4. 	if (ps->psnake->x == 0 || ps->psnake->x == 56
  5. 		|| ps->psnake->y == 0 || ps->psnake->y == 26)
  6. 		ps->state = KILL_WALL;
  7. }

判断蛇是否撞到自己，就遍历链表，判断蛇身的头结点是否和身体其他节点重复

  1. //判断贪吃蛇是否撞到自己
  2. void KillBySelf(pSnake ps)
  3. {
  4. 	pSnakenode pcur = ps->psnake->next;
  5. 	while (pcur)
  6. 	{
  7. 		if (pcur->x == ps->psnake->x && pcur->y == ps->psnake->y)
  8. 		{
  9. 			ps->state = KILL_SELF;
  10. 			break;
  11. 		}
  12. 		pcur = pcur->next;
  13. 	}
  14. }

到这里，代码就已经实现的差不多了，接下来就是游戏结束后的一些善后工作

        4.3 游戏结束（GameOver）

1. 打印游戏结束的原因

        游戏结束，打印出来游戏结束的原因，是撞到墙了呢？还是撞到自己了呢？还是按Esc正常退出了呢？

2. 释放蛇身节点

        因为我们蛇身的节点是动态申请的内存，我们需要手动释放掉内存（养成好习惯！）

  1. //游戏结束
  2. void GameOver(pSnake ps)
  3. {
  4. 	SetPos(8, 12);
  5. 	switch(ps->state)
  6. 	{
  7. 		case KILL_WALL:
  8. 			wprintf(L"Sorry,game over because you hit the wall !\n");
  9. 			break;
  10. 		case KILL_SELF:
  11. 			wprintf(L"Sorry,game over because you hit youself !\n");
  12. 			break;
  13. 		case NORMAL_END:
  14. 			wprintf(L"Game exits normally !");
  15. 			break;
  16. 	}
  17. 	
  18. 	//释放贪吃蛇的节点内存
  19. 	pSnakenode pcur = ps->psnake;
  20. 	while (pcur)
  21. 	{
  22. 		pSnakenode del = pcur;
  23. 		pcur = pcur->next;
  24. 		free(del);
  25. 	}
  26. 	ps->psnake = NULL;
  27. }

到这里我们游戏的代码就已经全部实现了。

源代码

Snake.h

  1. #pragma once
  2. #define _CRT_SECURE_NO_WARNINGS
  3.  
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<locale.h>
  7. #include<windows.h>
  8. #include<stdbool.h>
  9. #include<wchar.h> 
  10. #include<time.h>
  11. #include<conio.h>
  12.  
  13. //初始数据
  14. #define SNAKE_X 24
  15. #define SNAKE_Y 5
  16. #define WALL L'□'
  17. #define SNAKENODE L'●'
  18. #define FOOD L'★'
  19.  
  20. //蛇的节点
  21. typedef struct Snakenode
  22. {
  23. 	int x;
  24. 	int y;
  25. 	struct Snakenode* next;
  26. }Snakenode;
  27. typedef Snakenode* pSnakenode;
  28.  
  29. //蛇的方向
  30. enum DIRECT
  31. {
  32. 	UP = 1,
  33. 	DOWN,
  34. 	LEFT,
  35. 	RIGHT
  36. };
  37. //蛇的状态——游戏状态
  38. //正常、撞墙、撞到自己、正常退出
  39. enum GAME_STATE
  40. {
  41. 	OK,
  42. 	KILL_WALL,
  43. 	KILL_SELF,
  44. 	NORMAL_END
  45. };
  46.  
  47. //贪吃蛇的相关信息
  48. typedef struct Snake
  49. {
  50. 	pSnakenode psnake; //指向蛇头部的指针
  51. 	pSnakenode pfood;   //指向食物的指针
  52. 	enum DIRECT dir;//蛇的方向
  53. 	enum GAME_STATE state;//蛇的状态
  54. 	int food_scores;//每个食物的分数
  55. 	int all_scores; //总分数
  56. 	int sleep_time;  //休息的时间 --即蛇的速度
  57. }Snake;
  58. typedef Snake* pSnake;
  59.  
  60. //设置光标位置
  61. void SetPos(int x, int y);
  62. //游戏初始化
  63. void GameStart(pSnake ps);
  64. //欢迎界面的输出
  65. void WelcomeToGame();
  66. //地图绘制
  67. void CreatMap();
  68. //创建贪吃蛇
  69. void InitSnake(pSnake ps);
  70. //创建食物
  71. void CreatFood(pSnake ps);
  72.  
  73. //游戏运行
  74. void GameRun(pSnake ps);
  75. //贪吃蛇的移动
  76. void SnakeMove(pSnake ps);
  77. //判断下一个位置是不是食物
  78. int NextIsFood(pSnakenode next , pSnake ps);
  79. //下一个位置是食物，吃掉食物 
  80. void IsFood(pSnakenode next, pSnake ps);
  81. //下一个位置不是食物
  82. void NoFood(pSnakenode next, pSnake ps);
  83. //判断贪吃蛇是否撞墙
  84. void KillByWall(pSnake ps);
  85. //判断贪吃蛇是否撞到自己
  86. void KillBySelf(pSnake ps);
  87. //游戏结束
  88. void GameOver(pSnake ps);
  89.  
  90. void KeyFun();


Snake.c

  1. #include"Snake.h"
  2.  
  3.  
  4. //设置光标位置
  5. void SetPos(int x, int y)
  6. {
  7. 	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  8. 	COORD pos = { x,y };
  9. 	SetConsoleCursorPosition(houtput, pos);
  10. }
  11.  
  12. //欢迎界面打印
  13. void WelcomeToGame()
  14. {
  15. 	//设置光标位置
  16. 	SetPos(40, 15);
  17. 	printf("欢迎进入贪吃蛇小游戏\n");
  18. 	SetPos(42, 20);
  19. 	system("pause");
  20. 	system("cls");//清理屏幕
  21. 	SetPos(20, 11);
  22. 	printf("请使用↑ 、 ↓ 、 ← 、 → 来控制贪吃蛇的移动，按F3加速、F4减速 ");
  23. 	SetPos(20, 13);
  24. 	printf("加速可以获得更多的分数");
  25. 	SetPos(20, 15);
  26. 	system("pause");
  27. 	system("cls"); //清理屏幕
  28. }
  29. //地图绘制
  30. void CreatMap()
  31. {
  32. 	//上
  33. 	
  34. 	int i = 0;
  35. 	for (i = 0; i < 29; i++)
  36. 	{
  37. 		wprintf(L"%lc", WALL);
  38. 	}
  39. 	//下
  40. 	SetPos(0, 26);
  41. 	for(i = 0; i < 29; i++)
  42. 	{
  43. 		wprintf(L"%lc", WALL);
  44. 	}
  45. 	//左
  46. 	
  47. 	for (i = 1; i < 26; i++)
  48. 	{
  49. 		SetPos(0, i);
  50. 		wprintf(L"%lc", WALL);
  51. 	}
  52. 	//右
  53. 	for (i = 1; i < 26; i++)
  54. 	{
  55. 		SetPos(56, i);
  56. 		wprintf(L"%lc", WALL);
  57. 	}
  58. 	//system("pause");
  59. }
  60. //创建贪吃蛇
  61. void InitSnake(pSnake ps)
  62. {
  63. 	//创建蛇的身体
  64. 	pSnakenode pcur = NULL;
  65. 	int i = 0;
  66. 	int x, y;//蛇初始位置
  67. 	do
  68. 	{
  69. 		x = rand() % 31 + 4; //x: 4 - 34
  70. 		y = rand() % 20 + 2; //y: 1 - 25
  71. 	} while (x % 2 != 0);
  72. 	for (i = 0; i < 5; i++)
  73. 	{
  74. 		pcur = (pSnakenode)malloc(sizeof(Snakenode));
  75. 		if (pcur == NULL)
  76. 		{
  77. 			perror("InitSnake()::malloc()");
  78. 			return;
  79. 		}
  80. 		pcur->next = NULL;
  81. 		//pcur->x = SNAKE_X + i * 2;
  82. 		//pcur->y = SNAKE_Y;
  83. 		pcur->x = x + i * 2;
  84. 		pcur->y = y;
  85. 		//头插到贪吃蛇链表中
  86. 		if (ps->psnake == NULL) //链表为空
  87. 		{
  88. 			ps->psnake = pcur;
  89. 		}
  90. 		else
  91. 		{
  92. 			pcur->next = ps->psnake;
  93. 			ps->psnake = pcur;
  94. 		}
  95. 	}
  96. 	//输出蛇的初始位置
  97. 	pcur = ps->psnake;
  98. 	while (pcur)
  99. 	{
  100. 		SetPos(pcur->x, pcur->y);
  101. 		wprintf(L"%lc", SNAKENODE);
  102. 		pcur = pcur->next;
  103. 	}
  104. 	//初始化贪吃蛇的信息
  105. 	ps->dir = RIGHT; //蛇的方向
  106. 	ps->pfood = NULL; //指向食物 --NULL  
  107. 	ps->state = OK;  //状态
  108. 	ps->food_scores = 10; //每个食物的得分
  109. 	ps->all_scores = 0;  //总分
  110. 	ps->sleep_time = 200;//速度，即休息时间 单位是毫秒
  111. 	//getchar();
  112. }
  113. //创建食物
  114. void CreatFood(pSnake ps)
  115. {
  116. 	int x, y;//随机生成坐标 x , y 
  117. 	//x 2-54
  118. 	//y 1-25
  119.  
  120. 	again:
  121. 	do {
  122. 		x = rand() % 53 + 2;
  123. 		y = rand() % 25 + 1;
  124. 	} while (x % 2 != 0);
  125. 	//x y 不能与贪吃蛇身体重复
  126. 	pSnakenode pcur = ps->psnake;
  127. 	while (pcur)
  128. 	{
  129. 		if (x == pcur->x && y == pcur->y)
  130. 		{
  131. 			goto again;
  132. 		}
  133. 		pcur = pcur->next;
  134. 	}	
  135. 	pSnakenode food = (pSnakenode)malloc(sizeof(pSnakenode));
  136. 	if (food == NULL)
  137. 	{
  138. 		perror("CreatFood()::malloc");
  139. 		return;
  140. 	}
  141.  
  142. 	food->x = x;
  143. 	food->y = y;
  144. 	food->next = NULL;
  145. 	ps->pfood = food;
  146. 	SetPos(x, y);
  147. 	wprintf(L"%lc", FOOD);
  148. 	//getchar();
  149. }
  150.  
  151. //游戏初始化
  152. void GameStart(pSnake ps)
  153. {
  154. 	//设置窗口名称大小，隐藏光标
  155. 	system("title 贪吃蛇");
  156. 	system("mode con cols=100 lines=33");
  157.  
  158. 	//隐藏光标
  159. 	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  160. 	CONSOLE_CURSOR_INFO CursorInfo;
  161. 	GetConsoleCursorInfo(houtput, &CursorInfo);//获得有关指定控制台屏幕缓冲区的光标大小和可见的信息
  162. 	CursorInfo.bVisible = false; //隐藏控制台光标
  163. 	SetConsoleCursorInfo(houtput, &CursorInfo);//设置控制台光标状态	
  164. 	
  165. 	//打印欢迎界面和功能介绍
  166. 	WelcomeToGame();
  167. 	//绘制地图
  168. 	CreatMap();
  169. 	//创建贪吃蛇
  170. 	InitSnake(ps);
  171. 	//创建食物
  172. 	CreatFood(ps);
  173. 	//system("pause");
  174. }
  175. #define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )
  176. //暂停
  177. void Pause()
  178. {
  179. 	while (1)
  180. 	{
  181. 		Sleep(200);
  182. 		if (KEY_PRESS(VK_SPACE))
  183. 			break;
  184. 	}
  185. }
  186. //判断下一个位置是不是食物
  187. int NextIsFood(pSnakenode next, pSnake ps)
  188. {
  189. 	return (next->x == ps->pfood->x && next->y == ps->pfood->y);
  190. }
  191. //下一个位置是食物
  192. void IsFood(pSnakenode next, pSnake ps)
  193. {
  194. 	//把下一个位置的节点头插到贪吃蛇中
  195. 	next->next = ps->psnake;
  196. 	ps->psnake = next;
  197. 	//打印贪吃蛇
  198. 	pSnakenode cur = ps->psnake;
  199. 	while (cur)
  200. 	{
  201. 		SetPos(cur->x, cur->y);
  202. 		wprintf(L"%lc", SNAKENODE);
  203. 		cur = cur->next;
  204. 	}
  205. 	ps->all_scores += ps->food_scores;
  206. 	CreatFood(ps);
  207. 	//SetPos(ps->pfood->x, ps->pfood->y);
  208. 	//wprintf(L"%lc", FOOD);
  209. }
  210. //下一个位置不是食物
  211. void NoFood(pSnakenode next, pSnake ps)
  212. {
  213. 	//把下一个位置的节点头插到贪吃蛇中
  214. 	next->next = ps->psnake;
  215. 	ps->psnake = next;
  216.  
  217. 	pSnakenode cur = ps->psnake;
  218. 	while (cur->next->next != NULL)
  219. 	{
  220. 		SetPos(cur->x, cur->y);
  221. 		wprintf(L"%lc", SNAKENODE);
  222. 		cur = cur->next;
  223. 	}
  224. 	SetPos(cur->next->x, cur->next->y);
  225. 	wprintf(L"%ls", L"  ");
  226.  
  227. 	free(cur->next);
  228. 	cur->next = NULL;
  229. }
  230.  
  231. //贪吃蛇的移动
  232. void SnakeMove(pSnake ps)
  233. {
  234. 	pSnakenode next = (pSnakenode)malloc(sizeof(Snakenode));
  235. 	if (next == NULL)
  236. 	{
  237. 		perror("SnakeMove():malloc()");
  238. 		exit(1);
  239. 	}
  240. 	switch (ps->dir)
  241. 	{
  242. 	case UP:
  243. 		next->x = ps->psnake->x;
  244. 		next->y = ps->psnake->y - 1;
  245. 		break;
  246. 	case DOWN:
  247. 		next->x = ps->psnake->x;
  248. 		next->y = ps->psnake->y + 1;
  249. 		break;
  250. 	case LEFT:
  251. 		next->x = ps->psnake->x - 2;
  252. 		next->y = ps->psnake->y;
  253. 		break;
  254. 	case RIGHT:
  255. 		next->x = ps->psnake->x + 2;
  256. 		next->y = ps->psnake->y;
  257. 		break;
  258. 	}
  259. 	//判断下一个位置是不是食物
  260. 	if (NextIsFood(next, ps))
  261. 	{
  262. 		IsFood(next, ps);
  263. 	}
  264. 	else {
  265. 		NoFood(next, ps);
  266. 	}
  267. }
  268.  
  269. //
  270. void Printgame(pSnake ps) {
  271. 	SetPos(60, 15);
  272. 	printf("请使用↑ 、 ↓ 、 ← 、 → 来控制贪吃蛇");
  273. 	SetPos(60, 16);
  274. 	printf("按F3加速、F4减速 ");
  275. 	SetPos(60, 18);
  276. 	printf("加速可以获得更高的分数 ");
  277. 	SetPos(60, 20);
  278. 	printf("ESC:退出游戏  space:暂停 ");
  279. 	SetPos(60, 10);
  280. 	printf("当前总得分:%d", ps->all_scores);
  281. 	SetPos(60, 12);
  282. 	printf("当前每个食物得分:%d", ps->food_scores);
  283. 	SetPos(60, 22);
  284. 	printf("努力学习的小廉");
  285. }
  286. //判断贪吃蛇是否撞墙
  287. void KillByWall(pSnake ps)
  288. {
  289. 	if (ps->psnake->x == 0 || ps->psnake->x == 56
  290. 		|| ps->psnake->y == 0 || ps->psnake->y == 26)
  291. 		ps->state = KILL_WALL;
  292. }
  293. //判断贪吃蛇是否撞到自己
  294. void KillBySelf(pSnake ps)
  295. {
  296. 	pSnakenode pcur = ps->psnake->next;
  297. 	while (pcur)
  298. 	{
  299. 		if (pcur->x == ps->psnake->x && pcur->y == ps->psnake->y)
  300. 		{
  301. 			ps->state = KILL_SELF;
  302. 			break;
  303. 		}
  304. 		pcur = pcur->next;
  305. 	}
  306. }
  307. //游戏运行
  308. void GameRun(pSnake ps)
  309. {
  310. 	do
  311. 	{
  312. 		Printgame(ps);
  313. 		//判断按键是否被按过
  314. 		if (KEY_PRESS(VK_UP) && ps->dir != DOWN)
  315. 		{
  316. 			ps->dir = UP;
  317. 		}
  318. 		else if(KEY_PRESS(VK_DOWN) && ps->dir != UP){
  319. 			ps->dir = DOWN;
  320. 		}
  321. 		else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT) {
  322. 			ps->dir = LEFT;
  323. 		}
  324. 		else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT) {
  325. 			ps->dir = RIGHT;
  326. 		}
  327. 		else if (KEY_PRESS(VK_SPACE)) //空格 -- 暂停
  328. 		{
  329. 			Pause();
  330. 		}
  331. 		else if (KEY_PRESS(VK_ESCAPE)) //游戏正常退出
  332. 		{
  333. 			ps->state = NORMAL_END;
  334. 			break;
  335. 		}
  336. 		else if (KEY_PRESS(VK_F3))
  337. 		{
  338. 			if (ps->sleep_time >= 100)
  339. 			{
  340. 				ps->sleep_time -= 50;
  341. 				ps->food_scores += 5;//设定食物分数最高25
  342. 			}
  343. 		}
  344. 		else if (KEY_PRESS(VK_F4))
  345. 		{
  346. 			if (ps->sleep_time < 300)
  347. 			{
  348. 				ps->sleep_time += 100;
  349. 				ps->food_scores -= 5;//⼀个⻝物分数最低是5分
  350. 			}
  351. 		}
  352. 		Sleep(ps->sleep_time);
  353. 		//贪吃蛇的移动
  354. 		SnakeMove(ps);
  355. 		//判断贪吃蛇是否撞墙
  356. 		KillByWall(ps);
  357. 		//判断贪吃蛇是否撞到自己
  358. 		KillBySelf(ps);
  359.  
  360. 	} while (ps->state == OK);
  361.  
  362. }
  363. //游戏结束
  364. void GameOver(pSnake ps)
  365. {
  366. 	SetPos(8, 12);
  367. 	switch(ps->state)
  368. 	{
  369. 		case KILL_WALL:
  370. 			wprintf(L"Sorry,game over because you hit the wall !\n");
  371. 			break;
  372. 		case KILL_SELF:
  373. 			wprintf(L"Sorry,game over because you hit youself !\n");
  374. 			break;
  375. 		case NORMAL_END:
  376. 			wprintf(L"Game exits normally !");
  377. 			break;
  378. 	}
  379. 	
  380. 	//释放贪吃蛇的节点内存
  381. 	pSnakenode pcur = ps->psnake;
  382. 	while (pcur)
  383. 	{
  384. 		pSnakenode del = pcur;
  385. 		pcur = pcur->next;
  386. 		free(del);
  387. 	}
  388. 	ps->psnake = NULL;
  389. }
  390.  
  391. void KeyFun()
  392. {
  393. 	while (_kbhit())
  394. 	{
  395. 		int key = _getch();
  396. 	}
  397. }

test.c

  1. #include"Snake.h"
  2.  
  3. void test()
  4. {
  5. 	Snake snake = { 0 };
  6. 	int ch = 0;
  7. 	do
  8. 	{
  9. 		ch = 0;
  10. 		system("cls");
  11. 		//游戏初始化
  12. 		GameStart(&snake);
  13. 		//游戏运行
  14. 		GameRun(&snake);
  15. 		//游戏结束
  16. 		GameOver(&snake);
  17. 		KeyFun();
  18. 		SetPos(30, 20);
  19. 		wprintf(L"再来一局吗？ (Y/N)");
  20. 		ch = getchar();
  21. 		while (getchar() != '\n');
  22. 	} while (ch == 'Y' || ch == 'y');
  23. 	SetPos(0, 27);
  24. }
  25. int main()
  26. {
  27. 	//本地化
  28. 	setlocale(LC_ALL, "");
  29. 	srand((unsigned int)time(NULL));
  30. 	test();
  31. 	//KeyFun();
  32. 	return 0;
  33. }

制作不易，如果本篇内容对你有帮助，可以一键三连支持一下！！！

        如有错误的地方，也请各位大佬们指出纠正

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/947917
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号