devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言-期末项目/项目实践】-贪吃蛇（两万五千字详解，手把手教程博文，期末答辩神助手）_c语言贪吃蛇

作者：小惠珠哦 | 2024-07-13 18:09:29

赞

踩

c语言贪吃蛇

重要：游戏逻辑设计图 

 

目录

1.游戏背景

2.项目效果展示 

3.项目实现要求

4.技能要求

5.技术要点

6.Win32 API介绍

6.1Win32API

6.2控制台程序

6.3控制台屏幕上的坐标COORD

6.4GetStdHandle

6.5GetConsoleCursorInfo

6.5.1 CONSOLE_CURSOR_ INFO

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

6.7 SetConsoleCursorPosition

6.8GetAsyncKeyState

7.游戏地图和游戏界面的设计

7.1地图

7.1.1 本地化

7.1.2类项

7.1.3 setlocale函数

7.1.4宽字符的打印

7.1.5 地图坐标

7.2 蛇⾝和⻝物

7.3数据结构设计

7.4（重要核心）游戏的流程设计

8.核心逻辑实现分析

8.1游戏主逻辑

8.2当游戏开始

8.2.1 欢迎界面设计实现

8.2.2 创建地图

8.2.3 初始化蛇⾝

8.2.4 创建第⼀个⻝物

8.3 游戏运⾏过程

8.3.1 上面的KEY_PRESS

8.3.2 打印侧边提示信息和分数变化

8.3.3 蛇⾝的移动

8.3.3.1 NextIsFood

8.3.3.2 EatFood

8.3.3.3 NoFood

8.3.3.4 KillByWall 判断蛇头是否撞墙

8.3.3.5 KillBySelf 判断蛇头的坐标是否和蛇⾝体的坐标冲突

8.4 游戏结束

9.参考源码

10.结语

 

1.游戏背景

1976年，Gremlin平台推出了一款经典街机游戏Blockade。游戏中，两名玩家分别控制一个角色在屏幕上移动，所经之处砌起围栏。角色只能向左、右方向90度转弯，游戏目标保证让对方先撞上屏幕或围栏。　听起来有点复杂，其实就是下面这个样子：

基本上就是两条每走一步都会长大的贪吃蛇比谁后完蛋，玩家要做的就是避免撞上障碍物和越来越长的身体。更多照片、视频可以看 GamesDBase 的介绍。

Blockade 很受欢迎，类似的游戏先后出现在 Atari 2600、TRS-80、苹果 2 等早期游戏机、计算机上。但真正让这种游戏形式红遍全球的还是21年后随诺基亚手机走向世界的贪吃蛇游戏——Snake。

2.项目效果展示 

贪吃蛇

3.项目实现要求

项目环境：Windows环境控制台（linux和Windows控制台不一样）

项目语言：C语言

项目要求：使用C语言在windows环境的控制台中模拟实现经典游戏贪吃蛇

功能要求：

1.贪吃蛇地图绘制

2.蛇吃食物的功能（上、下、左、右方向键控制蛇的动作）

3.蛇撞墙死亡

4.蛇撞自身死亡

5.计算所得分数并显示

6.蛇身的加速和减速

7.按键（比如空格）可以暂停游戏

4.技能要求

1.对C语言语法巩固

2.C语言学完并且具备一定代码能力

3.初步接触过数据结构中的链表

5.技术要点

C语言函数（功能封装）、枚举、结构体、动态内存管理、预处理指令、链表、Win32API(下面补充讲解）

6.Win32 API介绍

6.1Win32API

windows这个多作业（完成某一种任务）系统除了协调应用程序的执行、分配内存、管理资源之外，它同时也是一个很大的服务中心，调用这个服务中心的各种服务（每一种服务就是一个函数），可以帮助应用程序达到开启视窗，描绘图形、使用周边设备等目的，（当前的操作系统，除了完成当前任务，我们肉眼能看到的功能之外还提供了后面很大的服务中心，是通过函数提供给用户，合适调用，可以帮用户完成各种各样的操作，通俗的讲就是每一种操作系统在完成正常的操作系统该有的功能如文件管理、内存管理等等功能之外还提供了一些接口（函数），这些函数提供给程序员，让程序员自己调用能实现自己想要的功能，将这些接口叫做API,以Windows为列，这些接口通用叫做WIN32 API）由于这些函数服务的对象是应用程序（Application），所以便称之为Application Programming Interface,简称API函数，WIN32 API也就是Microsoft Windows 32位平台的应用程序编译接口。

6.2控制台程序

平常我们运行起来的黑框程序起始就是我们的控制台程序（cmd程序也常称为终端，linux直接称为终端）

当我们使用vstudio创建新项目的时候也是创建的控制台项目：

我们可以使用cmd指令来打开控制台或者设置控制台的长宽：

那么，当我们打开控制台，就可以通过mode命令来设置控制台的长宽或者设置控制台窗口的名字：

比如我们设置控制台窗口的大小为：20行（宽度），10列（长度），可以这样调用命令：

mode con cols=10 lines = 20

con是控制台英文单词consle的缩写

可以通过title来改变我们的控制台窗口名字：

那么当我们在运行代码的时候可以设置我们的控制台端口的这些属性呢?

第一个方式如下，设置属性：

如图右键窗口设置属性：

2.通过系统操作函数system来进行代码设置

system函数就可以执行系统命令

  1. int main()
  2. {
  3. 	system("mode con cols=30 lines=20");
  4. 	system("title snake");
  5.  
  6. 	//printf("hehe\n");
  7. 	return 0;
  8. }

补充，有很多伙伴可能设置大小不起作用或者只有显示的内存行列变短但是黑框框大小没有改变，这是Win11系统的原因，解决办法如下：

然后重新运行就解决了：

恢复方法：

6.3控制台屏幕上的坐标COORD

COORD是windows API中定义的一个结构体，表示一个字符在控制台屏幕缓冲区上的坐标，坐标系原点（0,0）位于缓冲区的顶部左侧单元格。当有了这个我们就可以设置我们蛇要吃的食物随机出现的坐标。头文件包含：《windows.h》

具体的定义为：
 

  1. typedef struct _COORD
  2. {
  3.  
  4. SHORT x;
  5. SHORT y;
  6. }COORD,*PCOORD;

想指定一个坐标就可以这样：

COORD pos = {3,5};

之所以不自己定义，是因为COORD是我们WIN32 API自己的类型，和别人的项目具有更好弟弟兼容性。

6.4GetStdHandle

GetStdHandle是一个Windows API函数，它用于一个特定的标准设备（标准输入、标准输出或标准错误）中获得一个句柄（用来标识不同设备的数值），使用这个句柄就可以操作设备。简单来说就是获控制权限。（我们要操控蛇，或者要隐藏我们的鼠标，就要控制控制台，控制台也是设备，控制设备前首先要获得设备就要用到这个函数）

函数：

HANDLE WINAPI GetStdHandle(_In_ DWORD nStdHandle);

nStdHandle参数：标准设备，此参数的取值可为下列值之一

STD-INPUT-HANDLE      表示获得的是标准输入设备就是键盘的操作句柄

STD-OUTPUT-HANDLE   表示获得的是标准输出设备就是屏幕的操作句柄

STD-OUTPUT-HANDLE     表示标准错误设备

返回值：如果函数成功，则返回值为指定设备的句柄，或为由先前对SetStdHandle的调用设置的重定向句柄，除非应用程序已使用SetStdHandle来设置具有较少访问权限的标准句柄，否则该句柄具有GENERIC_READ和GENERIC_WRITE访问权限

如果函数失败，则返回值为 INVALID_HANDLE_VALUE,如果应用程序没有关联的标准语句炳（例如在交互式桌面上运行的服务），并且尚未重定向这些句柄，则返回值为NULL.

   

具体使用范例：

  1. HANDLE houput = NULL;
  2. //获取标准输出的句柄
  3. houput = GetStdHandle(STD_OUTPUT_HANDLE）；

6.5GetConsoleCursorInfo

检索有关指定控制台屏幕缓冲区的光标大小和可见性的信息（比如做到隐藏光标，先获得光标，再操作光标）

  1. BOOL WINAPI GetConsoleCursorInfo(
  2. HANDLE
  3. hConsoleoutput,
  4. PCONSOLE_CURSOR_INFO lpConsoleCursorInfo)
  5. PCONSOLE_CURSOR_INFO 是指向 CONSOLE_CURSOR_INFO（光标信息，光标的高宽等）结构的指针，该结构接收有关主机游标（光标）的信息

使用示范：

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

6.5.1 CONSOLE_CURSOR_ INFO

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

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

  dwSize，由光标填充的字符单元格的百分比，光标宽度。 此值介于1到100之间。 光标外观会变化，范围从完全填充单元格到单元底部的水平线条。
  bVisible，游标的可见性。 如果光标可见，则此成员为 TRUE。

CursorInfo.bVisible = false；//隐藏控制台光标

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

  1. 1 BOOL WINAPI SetConsoleCursorInfo(
  2. 2
  3. HANDLE hConsoleOutput,
  4. 3
  5. const CONSOLE_CURSOR_INFO *IpConsoleCursorInfo
  6. 4);


实例:

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


 

6.7 SetConsoleCursorPosition

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

  1. BOOL WINAPI SetConsoleCursorPosition(
  2. HANDLE hConsoleOutput,COORD pos）;

下面是使用实例和效果：

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

为了方便操作，我们可以利用上面的知识设置封装一个设置光标位置的函数，设置如下：

  1. void SetPos(int x, int y)
  2. {
  3. 	COORD pos = { x,y };
  4. 	HANDLE houtput = NULL;//获取标准输出也就是屏幕的控制句柄
  5. 	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  6. 	//设置标准输出上光标的位置为pos
  7. 	SetConsoleCursorPosition(houtput, pos);
  8. }

使用的时候这里直接在主函数中传入我们的横纵坐标就好了。

6.8GetAsyncKeyState

获取按键情况（比如使用上下左右键控制蛇的移动），GetAsyncKeyState的函数原型如下:

  1. SHORT GetAsyncKeyState(
  3. int vKey
  4.  );

将键盘上每个键的虚拟键值传递给函数，函数通过返回值来分辨按键的状态。WIN32API给键盘上的每一个键都编号了。虚拟键码


GetAsyncKeystate的返回值是short类型，在上一次调用GetAsyncKeyState 函数后，如果返回的16位的short数据中，最高位是1，说明按键的状态是按下（还没有抬起），如果最高是0，说明按键的状态是抬起；如果最低位被置为1则说明，该按键被按过，否则为0。
如果我们要判断一个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1.

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

采用按位与的方式，按过返回1，没按过返回0.

接下来我们设计一个实例：我们可以对别人的键盘进行监控，那么就可以做到窃取别人的密码，比如我们判断别人按下的按键后就将对应按键的内容放入一个文件夹，就可以达到目的（注意技术向善哈哈）下面我们实现一下按下对应按键就打印对应按键内容：

  1. #define KEY_PRESS(vk) ((GetAsyncKeyState(vk)&0x1)? 1:0)
  2.  
  3. int main()
  4. {
  5. 	while (1)
  6. 	{
  7. 		if (KEY_PRESS(0x30))
  8. 		{
  9. 			printf("0\n");
  10.  
  11. 		}
  12. 		else if (KEY_PRESS(0x31))
  13. 		{
  14. 			printf("1\n");
  15. 		}
  16. 		else if (KEY_PRESS(0x32))
  17. 		{
  18. 			printf("2\n");
  19. 		}
  20. 		else if (KEY_PRESS(0x33))
  21. 		{
  22. 			printf("3\n");
  23. 		}
  24. 	}
  25. 	return 0;
  26. }

7.游戏地图和游戏界面的设计

7.1地图

这⾥不得不讲⼀下控制台窗⼝的⼀些知识，如果想在控制台的窗⼝中指定位置输出信息，我们得知道 该位置的坐标，所以⾸先介绍⼀下控制台窗⼝的坐标知识。 控制台窗⼝的坐标如下所⽰，横向的是X轴，从左向右依次增⻓，纵向是Y轴，从上到下依次增⻓。

在游戏地图上，我们打印墙体使用宽字符：口，打印蛇使用宽字符•，打印食物使用宽字符★
普通的字符是占一个字节的，这类宽字符是占用2个字节。

这⾥再简单的讲⼀下C语⾔的国际化特性相关的知识，过去C语⾔并不适合⾮英语国家（地区）使⽤。 C语⾔最初假定字符都是但⾃⼰的。但是这些假定并不是在世界的任何地⽅都适⽤。

ACSII码值的取值范围0~127

char ----普通字符

wchar----------宽字符

    C语言字符默认是采用ASCII编码的，ASCII字符集采用的是单字节编码，且只使用了单字节中的低7位，最高位是没有使用的，可表示为0xxxxxxxx；可以看到，ASCII字符集共包含128个字符，在英语国家中，128个字符是基本够用的，但是，在其他国家语言中，比如，在法语中，字母上方有注音符号，它就无法用 ASCII码表示。于是,一些欧洲国家就决定，利用字节中闲置的最高位编入新的符号。比如，法语中的e的编码为130（二进制10000010）。这样一来，这些欧洲国家使用的编码体系，可以表示最多256个符号。但是，这里又出现了新的问题。不同的国家有不同的字母，因此，哪怕它们都使用256个符号的编码方式，代表的字母却不一样。比如，130在法语编码中代表了e，在希伯来语编码中却代表了字母Gimel(入)，在俄语编码中又会代表另一个符号。但是不管怎样，所有这些编码方式中，0--127表示的符号是一样的，不一样的只是128--255的这一段。至于亚洲国家的文字，使用的符号就更多了汉字就多达10万左右。一个字节只能表示256种符号，肯定是不够的，就必须使用多个字节表达一个符号。比如,简体中文常见的编码方式是GB2312，使用两个字节表示一个汉字，所以理论上最多可以表示 256×256=65536个符号。

  后来为了使C语言适应国际化，C语言的标准中不断加入了国际化的支持。比如：加入了宽字符的类型 wchar_t 和宽字符的输入和输出函数，加入了<locale.h>头文件，其中提供了允许程序员针对特定地区（通常是国家或者说某种特定语言的地理区域）调整程序行为的函数。

7.1.1 <locale.h>本地化

<locale.h>提供的函数用于控制C标准库中对于不同的地区会产生不一样行为的部分.
在标准可以中，依赖地区的部分有以下几项:

  • 数字量的格式
  • 货币量的格式。（比如英文环境中表示钱币使用符号和我们中文使用表示钱币的符号是不一样的）
  • 字符集
  • 日期和时间的表示形式
     

7.1.2类项

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

• LC_COLLATE：影响字符串比较函数 strcol1()和 strxfrm()
·LC_CTYPE：影响字符处理函数的行为。

•LC_MONETARY：影响货币格式。

• LC_NUMERIC：影响 printf()的数字格式。
• LC_TIME：影响时间格式strftime()和wcsftime(）。
•LC_ALL-针对所有类项修改，将以上所有类别设置为给定的语言环境。

每个类项的详细声明，可以参考

7.1.3 setlocale函数

1 char* setlocale (int category, const char* locale)

setlocale 函数用于修改当前地区，可以针对一个类项修改，也可以针对所有类项。
setlocale 的第一个参数可以是前面说明的类项中的一个，那么每次只会影响一个类项，如果第一个参数是LC_ALL，就会影响所有的类项。

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

在任意程序执行开始，都会隐藏式执行调用：

1 setlocale(LC ALL,"C");

当地区设置为“C"时，库函数按正常方式执行，小数点是一个点。
当程序运行起来后想改变地区，就只能显示调用setlocale函数。用”“作为第2个参数，调用setlocale函数就可以切换到本地模式，这种模式下程序会适应本地环境。
比如：切换到我们的本地模式后就支持宽字符（汉字）的输出等。

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

当我们支持本地化之后就支持我们宽字符的打印了。

7.1.4宽字符的打印

那如果想在屏幕上打印宽字符，怎么打印呢?
宽字符的字面量必须加上前缀”"，否则C语言会把字面量当作窄字符类型处理。前缀”"在单引号前面，表示宽字符，对应wprintf(）的占位符为%lc；在双引号前面，表示宽字符串，对应wprintf(）的占位符为%ls。

  1. #include<locale.h>
  2.  
  3. int main()
  4.  
  5. {
  6. 	setlocale(LC_ALL, "");
  7. 	wchar_t ch1 = L'比';
  8. 	
  9. 	printf("%c%c\n", 'b','c');
  10. 	wprintf(L"%lc\n", ch1);
  11. 	return 0;
  12. }

从输出的结果来看，我们发现一个普通字符占一个字符的位置，但是打印一个汉字字符，占用两个字符的位置，那么如果我们要在贪吃蛇中使用宽字符，就得处理好地图上坐标的计算。

7.1.5 地图坐标

我们假设实现⼀个棋盘27⾏，58列的棋盘（⾏和列可以根据⾃⼰的情况修改），再围绕地图画出墙， 如下：

7.2 蛇⾝和⻝物

初始化状态，假设蛇的⻓度是5，蛇⾝的每个节点是●，在固定的⼀个坐标处，⽐如(24, 5)处开始出现 蛇，连续5个节点。注意：蛇的每个节点的x坐标必须是2个倍数，否则可能会出现蛇的⼀个节点有⼀半 ⼉出现在墙体中，另外⼀般在墙外的现象，坐标不好对⻬。 关于⻝物，就是在墙体内随机⽣成⼀个坐标（x坐标必须是2的倍数），坐标不能和蛇的⾝体重合，然 后打印★。

7.3数据结构设计

在游戏运行过程中，蛇每次吃一个食物，蛇的身体就会变长一节，如果我能使用链表来存储蛇的信息，那么蛇的每一节其实也就是链表的每个节点，每个节点只要记录好蛇身体在地图上的坐标就好，所以可以设计蛇节点结构体如下：

  1. typedef struct SnakeNode
  2. {
  3. 	//描述坐标的信息
  4. 	int x;
  5. 	int y;
  6. 	struct SnakeNode* next;
  7. }SnakeNode,*pSnakeNOde;

顺带创建一个指针。整个游戏都在维护蛇也就是多个节点构成的这个链表，那要管理整条蛇，我们就可以再封装一个Snake的结构来维护整条蛇：

  1. //贪吃蛇蛇的描述
  2. typedef struct snake
  3. {
  4. 	//需要指向这个蛇第一个节点的指针，方便找到整条蛇
  5. 	pSnakeNode _psnake;
  6. 	pSnakeNode _pFood;//这个指针指向的是食物节点，因为食物也可以看做是一个节点类型
  7. 	int _Score;//当前累计的分数，可以理解为当前有多少节点
  8. 	int _FoodWeight;//一个食物的分数是多少
  9. 	int _SleepTime;//定义每走一步休息的时间，我们定义的休息的时间越短，速度就越快，时间越长，速度就越慢
  10. 	enum DIRECTION _Dir;//描述蛇的方向
  11. 	enum GAME_STATUS _Status;//描述游戏的状态：正常退出，撞墙，吃到自己
  12. }Snake,*pSnake;

蛇前进的方向不过上下左右，可以使用枚举类型来列举，也方便我们后面书写不同方向移动的情况代码：

  1. enum DIRECTION
  2. {
  3. 	UP = 1,
  4. 	DOWN,
  5. 	LEFT,
  6. 	RIGHT
  7. };

在蛇内定义游戏状态就是为了判断蛇的移到会导致的游戏结束会有的情况比如用户自己退出，或者蛇撞到墙或者蛇吃到自身，就这几种情况，同样可以使用枚举类型。

  1. enum GAME_STATUS
  2. {
  3. 	OK,//正常运行
  4. 	END_NORMAL,//按ESC正常退出
  5. 	KILL_BY_WALL,
  6. 	KILL_BY_SELF
  7. };

7.4（重要核心）游戏的流程设计

8.核心逻辑实现分析

8.1游戏主逻辑

  1. void test()
  2. {
  3. 	int ch = 0;
  4. 	do
  5. 	{
  6. 		Snake snake = { 0 };//首先创建一条贪吃蛇
  7. 		//游戏开始，游戏初始化：地图的打印和蛇 食物的打印
  8. 		GameStart(&snake);
  9.  
  10. 		//2.游戏运行-游戏正常运行
  11. 		GameRun(&snake);
  12.  
  13. 		//3.游戏结束，游戏善后，链表要释放资源
  14. 		GameEnd(&snake);
  15. 		SetPos(20, 18);
  16. 		printf("要再来一局吗？(Y/N):");
  17. 		ch = getchar();
  18. 		getchar();//清理回车
  19.  
  20. 	} while (ch=='Y'||ch=='y');
  21. 	SetPos(0, 27);
  22. }
  23.  
  24.  
  25.  
  26.  
  27.  
  28. int main()
  29. {
  30. 	//设置程序适应本地环境，后面打印各种宽字符，蛇身体和食物墙等
  31. 	setlocale(LC_ALL ,"");
  32. 	srand((unsigned int)time(NULL));//随机生成食物坐标
  33.  
  34. 	test();
  35. 	return 0;
  36. }

8.2当游戏开始

游戏游戏开始，根据上面的流程图，游戏开始涉及操作有界面的设计，包括欢迎界面和地图，还要将我们的蛇的身体创建出来，打印我们的食物，所以我们封装为一个大的函数

  1. void GameStart(pSnake ps)
  2. {
  3. 	//控制台窗口大小的设置
  4. 	system("mode con cols=110 lines=30");
  5. 	system("title SNAKE");
  6. 	//将光标隐藏
  7. 	 //获取标准输出的句柄(⽤来标识不同设备的数值)
  8. 	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  9. 	//影藏光标操作
  10. 	CONSOLE_CURSOR_INFO CursorInfo;
  11. 	GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
  12. 	CursorInfo.bVisible = false; //隐藏控制台光标
  13. 	SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
  14. 	//打印欢迎界面
  15. 	WelComeToGame();
  16. 	//创建地图
  17. 	CreateMap();
  18. 	//初始化贪吃蛇
  19. 	InitSnake(ps);
  20. 	//创建食物
  21. 	CreatFood(ps);
  22.  
  23. }

8.2.1 欢迎界面设计实现

在进入游戏的时候我们需要设计一下欢迎的界面来美化我们的程序或者提示我们的玩家一些基本的操作流程

为了让我们的文字等等居中显示，我们使用了win32的一些知识，COORD封装为了函数来实现我们随时设置光标的位置然后打印的功能：

  1. void SetPos(int x, int y)
  2. {
  3. 	COORD pos = { x,y };
  4. 	HANDLE houtput = NULL;//获取标准输出也就是屏幕的控制句柄
  5. 	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  6. 	//设置标准输出上光标的位置为pos
  7. 	SetConsoleCursorPosition(houtput, pos);
  8. }

然后打印我们的欢迎初始界面：

  1. void 	WelComeToGame()
  2. {
  3. 	//定位光标
  4. 	SetPos(40, 14);
  5. 	printf("欢迎来到贪吃蛇小游戏");
  6. 	SetPos(40, 25);//再次定位坐标
  7. 	system("pause");//暂停命令，执行到此处暂停)
  8.  
  9.    //来到下一个界面，我们把当前界面内容全部清理重新打印实现换屏效果
  10. 	system("cls");//清理屏幕
  11. 	SetPos(20, 14);
  12. 	printf("使用↑↓← →，分别控制蛇的上下左右移动，使用F3加速，F4减速");
  13. 	SetPos(40, 25);//再次定位坐标
  14. 	system("pause");//暂停命令，执行到此处暂停)
  15. 	system("cls");//清理屏幕
  16.  
  17. }

看一下实现效果：

8.2.2 创建地图

创建地图就是将墙打印出来，因为是宽字符打印，所有使⽤wprintf函数，打印格式串前使⽤L 打印地图的关键是要算好坐标，才能在想要的位置打印墙体。 墙体打印的宽字符：

为了使用方便我们直接将墙体，食物，蛇身等宽字符使用宏定义转换为我们键盘常打的字符这样方便我们写代码：

 

  1. #define WALL L'□'
  2. #define BODY L'●'
  3. #define FOOD L'★'

墙体的打印就是将我们的光标首先定位在纵坐标为0的地方然后利用横坐标增加的办法就打印了我们的上面的墙，然后定位光标纵坐标到我们的下面的墙的坐标同样的方式打印我们下面的墙就好，左右的墙就保持横坐标不变，纵坐标增加就可以实现。

  1. void CreateMap()
  2. {
  3. 	//上
  4. 	SetPos(0, 0);//重新定位光标位置
  5. 	int i = 0;
  6. 	for (i = 0; i <= 56; i += 2)
  7. 	{
  8. 		wprintf(L"%lc", WALL);
  9. 	}
  10. 	//下
  11. 	SetPos(0, 26);//重新定位光标位置
  12. 	for (i = 0; i <= 56; i += 2)
  13. 	{
  14. 		wprintf(L"%lc", WALL);
  15. 	}
  16. 	//左
  17. 	for (i = 1; i <= 25; i++)
  18. 	{
  19. 		SetPos(0, i);
  20. 		wprintf(L"%lc", WALL);
  21. 	}
  22. 	//右
  23. 	for (i = 1; i <= 25; i++)
  24. 	{
  25. 		SetPos(56, i);
  26. 		wprintf(L"%lc", WALL);
  27. 	}
  28. 	//getchar();//测试最后一行的打印
  29.  
  30. }

8.2.3 初始化蛇⾝

如果我们最开始设置蛇最开始⻓度为5节，每节对应链表的⼀个节点，蛇⾝的每⼀个节点都有⾃⼰的坐标。 创建5个节点，然后将每个节点存放在链表中进⾏管理。创建完蛇⾝后，将蛇的每⼀节打印在屏幕上。再设置当前游戏的状态，蛇移动的速度，默认的⽅向，初始成绩，蛇的状态，每个⻝物的分数。 蛇⾝打印的宽字符，就完成了蛇的初始化。

  1. void InitSnake(pSnake ps)
  2. {
  3. 	pSnakeNode cur = NULL;//为了实现复用就定义在外边
  4. 	int i = 0;
  5. 	for (i = 0; i < 5; i++)
  6. 	{
  7. 		 cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  8. 		if (cur == NULL)
  9. 		{
  10. 			perror("malloc");
  11. 			return;
  12. 		}
  13. 		cur->x = POS_X+2*i;
  14. 		cur->y = POS_Y;
  15. 		cur->next = NULL;
  16. 		//头插法
  17. 		if (ps->_psnake == NULL)
  18. 		{
  19. 			ps->_psnake = cur;//第一个位置就给了蛇的第一块
  20. 		}
  21. 		else
  22. 		{
  23. 			cur->next = ps->_psnake;
  24. 			ps->_psnake = cur;
  25.  
  26. 		}
  27. 	}
  28. 	//打印蛇，就是遍历链表
  29. 	cur = ps->_psnake;
  30. 	while (cur)
  31. 	{
  32. 		SetPos(cur->x, cur->y);//得到每个节点的横纵坐标，然后定位光标打印身体
  33. 		wprintf(L"%lc", BODY);
  34.  
  35. 		cur = cur->next;
  36.  
  37. 	}
  38. 	ps->_Status = OK;
  39. 	ps->_Score = 0;
  40. 	ps->_pFood = NULL;
  41. 	ps->_SleepTime = 200;
  42. 	ps->_FoodWeight = 10;
  43. 	ps->_Dir = RIGHT;
  44.  
  45. 	//getchar();//测试打印结果因为会被最后一句话打乱
  46.  
  47.  
  48. }

头插法图解：

8.2.4 创建第⼀个⻝物

• 先随机⽣成⻝物的坐标

        ◦ x坐标必须是2的倍数

        ◦ ⻝物的坐标不能和蛇⾝每个节点的坐标重复

• 创建⻝物节点，打印⻝物 

  1. void CreatFood(pSnake ps)
  2. {
  3. 	//分析：1.坐标应该是随机生成的,但是应该有下面的约束
  4. 	// 2.食物的坐标不能够在墙外
  5. 	// 3.食物的坐标最好是2的倍数，这样方便和我们的蛇身挂钩不出墙
  6. 	// 4.食物的坐标不能和蛇的身体冲突1
  7. 	// x>=2,x<=54
  8. 	// y>=1y<=25
  9. 	// 
  10. 	//
  11. 	int x = 0;
  12. 	int y = 0;
  13. again:
  14. 	do
  15. 	{
  16. 		x = rand() % 53 + 2;//余数0~52+2
  17. 		y = rand() % 25 + 1;
  18. 	} while (x%2 != 0);//x的坐标必须是2的倍数
  19. 	//坐标不能和蛇身冲突
  20. 	pSnakeNode cur = ps->_psnake;
  21. 	while (cur)//五个坐标蛇身的所有坐标不可与食物重复
  22. 	{
  23. 		//比较坐标
  24. 		if (cur->x == x && cur->y == y)
  25. 		{
  26. 			goto again;
  27. 		}
  28. 		cur = cur->next;
  29. 	}
  30. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  31. 	if (pFood == NULL)
  32. 	{
  33. 		perror("CreateFood():malloc");
  34. 		return;
  35. 	}
  36. 	//节点创建成功
  37. 	pFood->x = x;
  38. 	pFood->y = y;
  39. 	ps->_pFood = pFood;
  40. 	//打印
  41. 	SetPos(x, y);
  42. 	wprintf(L"%lc", FOOD);
  43. 	//getchar();//测试打印结果因为会被最后一句话打乱
  44. }
  45.

8.3 游戏运⾏过程

游戏运⾏期间，右侧打印帮助信息，提⽰玩家 根据游戏状态检查游戏是否继续，如果是状态是OK，游戏继续，否则游戏结束。 如果游戏继续，就是检测按键情况，确定蛇下⼀步的⽅向，或者是否加速减速，是否暂停或者退出游 戏。 确定了蛇的⽅向和速度，蛇就可以移动了。

（判断方向的依据是蛇头朝向，比如当我们蛇头正在朝右移动，那么我们蛇头后面就有身体，此时我们不能向左移动，原地掉头就矛盾，只能右上下三键，那么换个思想，就是当我们按下左键的时候，此时我们的蛇头朝向不能是向右，那么就将我们蛇头朝向改为左，就可以实现）当我们的游戏状态为OK，是不是就要一直判断玩家按键，那么我们就可以使用我们都 while循环来实现。

  1. void GameRun(pSnake ps)
  2. {
  3. 	PrintHelpInfo();
  4. 	do
  5. 	{
  6. 	
  7. 		SetPos(64, 9);
  8. 		printf("得分：%5d", ps->_Score);
  9. 		SetPos(64, 10);
  10. 		printf("每个食物分数为：%2d", ps->_FoodWeight);
  11. 		if( KEY_PRESS(VK_UP) && ps->_Dir != DOWN)
  12. 		{
  13. 			//如果我们按下向上键，此时我们的蛇头的方向不向上，就调整为向上移动
  14. 			ps->_Dir = UP;
  15. 		}
  16. 		else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP)
  17. 		{
  18. 			ps->_Dir = DOWN; 
  19. 		}
  20. 		else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT)
  21. 		{
  22. 			ps->_Dir = LEFT;
  23. 		}
  24. 		else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT)
  25. 		{
  26. 			ps->_Dir = RIGHT;
  27. 		}
  28. 		else if (KEY_PRESS(VK_ESCAPE))
  29. 		{
  30. 			ps->_Status = END_NORMAL;
  31. 			break;
  32. 		}
  33. 		else if (KEY_PRESS(VK_SPACE))
  34. 		{
  35. 			//由于暂停程序并不结束，并且还要可以继续唤醒程序，我们封装一个函数
  36. 			Pause();//死循环休眠检测休眠
  37. 		}
  38. 		//加速
  39. 		else if (KEY_PRESS(VK_F3))
  40. 		{
  41. 			if (ps->_SleepTime >= 80)//设置加速门款
  42. 			{
  43. 				ps->_SleepTime -= 30;
  44. 				//速度越快，越容易树，风浪越大鱼越贵，我们把分数调高一些
  45. 				ps->_FoodWeight += 5;
  46. 			}
  47. 		}
  48. 		//减速
  49. 		else if (KEY_PRESS(VK_ESCAPE))
  50. 		{
  51. 			if (ps->_SleepTime <=320)//设置减速最低门坎
  52. 			{
  53. 				ps->_SleepTime += 30;
  54. 				//速度越快，越容易树，风浪越大鱼越贵，我们把分数调高一些
  55. 				ps->_FoodWeight -= 2;
  56. 			}
  57. 		}
  58. 		Sleep(ps->_SleepTime);
  59. 		//蛇动起来
  60. 		SnakeMove(ps);
  61.  
  62. 	} while (ps->_Status==OK);
  63.  
  64. }

8.3.1 上面的KEY_PRESS

是上面补充知识中win32api知识中检查我们按键状态讲过，我们封装一个宏来进行检查

#define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1)? 1:0)//宏用于判断虚拟键有没有被用过

8.3.2 打印侧边提示信息和分数变化

由于分数要变化：比如我们吃掉一个食物或者加速减速吃掉一个食物，所以要一直检测我们蛇目前的状态，我们就将分数显示写入上面的循环，对于侧边信息的提示是固定的，我们直接打印就好：

  1. void PrintHelpInfo()
  2. {
  3. 	SetPos(64, 15);
  4. 	printf("1.不能穿墙，不可以咬到自己");
  5. 	SetPos(64, 16);
  6. 	printf("2.使用↑↓← →，分别控制蛇的上下左右移动");
  7. 	SetPos(64, 17);
  8. 	printf("3.使用F3加速蛇的移动，F4减速");
  9. 	SetPos(64, 18);
  10. 	printf("4.ESC退出，点击空格暂停游戏");
  11.  
  12. 	SetPos(64, 20);
  13. 	printf("CSDN-Nicn版权");
  14. 	//getchar();
  15.  
  16. }
  17.

8.3.3 蛇⾝的移动

我们实现的思想是，无论蛇身怎么移动，蛇头都会1去到下一个位置，那么我们就先创建下⼀个节点，根据移动⽅向和蛇头的坐标，比如当前状态蛇头向上，那么下一个点的坐标是不是x不变，y坐标-1，蛇移动到下⼀个位置的坐标。 确定了下⼀个位置后，看下⼀个位置是否是⻝物（NextIsFood），是⻝物就做吃⻝物处理 （EatFood），如果不是⻝物则做前进⼀步的处理（NoFood）。 蛇⾝移动后，判断此次移动是否会造成撞墙（KillByWall）或者撞上⾃⼰蛇⾝（KillBySelf），从⽽影 响游戏的状态。

整体实现代码为：

 

  1. void SnakeMove(pSnake ps)//蛇移动
  2. {
  3. 	//移动即是通过蛇头的方向判断下一个位置的坐标，然后我们就根据按键创建这个方向上的节点，然后再连接起来
  4. 	//那我们就先为未来可能走的这个节点创建一下
  5. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
  6. 	//判断一下是否申请成功
  7. 	if (pNext == NULL)
  8. 	{
  9. 		perror("SnakeMove():malloc()");
  10. 		return;
  11. 	}
  12. 	pNext->next = NULL;//迅速将这个节点的指向下一个节点的指针置空，否则有些许凌乱，后续使用再修改
  13.  
  14. 	
  15. 	
  16. 	switch (ps->_Dir)
  17. 	{
  18. 	case UP:
  19. 		//x不变，y-1
  20. 		pNext->x = ps->_psnake->x;
  21. 		pNext->y = ps->_psnake->y - 1;
  22. 		break;
  23. 	case DOWN:
  24. 		pNext->x = ps->_psnake->x;
  25. 		pNext->y = ps->_psnake->y + 1;
  26. 		break;
  27. 	case LEFT://x-1,y不变
  28. 		pNext->x = ps->_psnake->x-1;
  29. 		pNext->y = ps->_psnake->y ;
  30. 		break;
  31. 	case RIGHT:
  32. 		pNext->x = ps->_psnake->x+1;
  33. 		pNext->y = ps->_psnake->y;
  34. 		break;
  35. 	}
  36. 	//判断下一个位置是否是食物，是食物我们蛇身长度就要变，不是食物我们目前蛇的尾部就不应该显示
  37. 	//写一个判断函数
  38. 	if (NextIsFood(ps, pNext))
  39. 	{
  40. 		//吃掉食物，封装函数
  41. 		EatFood(ps,pNext);
  42. 	}
  43. 	else
  44. 	{
  45. 		//
  46. 		NotFood(ps, pNext);
  47. 	}
  48. 	//检测蛇是否撞墙（判断坐标）
  49. 	KillByWall( ps);
  50. 	//检测蛇是否吃到自身（判断坐标）
  51. 	KillBySelf(ps);
  52. }
8.3.3.1 NextIsFood

当根据蛇头的方向我们确定了下一个点的坐标的时候，由于游戏开始我们就生成了一个食物，我们就要判断一下蛇头方向的下一个坐标是不是食物也就是坐标是否与我们的食物坐标相同：
 

  1. int NextIsFood(pSnake ps, pSnakeNode pnext)
  2. {
  3. 	if (ps->_pFood->x == pnext->x && ps->_pFood->y == pnext->y)
  4. 	{
  5. 		return 1;//是食物就返回1
  6. 	}
  7. 	else
  8. 	{
  9. 		return 0;//不是食物返回0
  10. 	}
  11. }
8.3.3.2 EatFood

如果蛇头的下一个坐标是食物，那我们就要将食物吃掉

，如何吃掉食物，我们将这个节点的next指针指向我们的蛇，让后再用蛇指针来维护我们原先的蛇和这个食物这个新的空间，就是头插法。那么我们最开始为我们的食物申请了一个空间，现在我又为我蛇头的下一个节点又申请了空间，两块空间现在重叠使用一份，就将原来申请的空间释放掉。吃掉一个食物为了游戏能够继续应该还要生成一个随机食物，所以再次调用我们的食物生成函数。

  1. //下一个节点是食物
  2. void EatFood(pSnake ps, pSnakeNode pnext)
  3. {
  4. 	//头插法，注意和前面蛇身连接联系起来
  5. 	pnext->next = ps->_psnake;
  6. 	ps->_psnake = pnext;//节点变成蛇头我们就将这个节点的指针作为我们蛇的指针，方便找到蛇
  7. 	pSnakeNode cur = ps->_psnake;
  8. 	while (cur)
  9. 	{
  10. 		SetPos(cur->x, cur->y);
  11. 		wprintf(L"%lc", BODY);
  12. 		cur = cur->next;
  13. 		
  14. 	}
  15. 	//原先创建食物的时候我们为食物节点申请过一次空间，那么这里就释放掉那一次申请的空间
  16. 	free(ps->_pFood);
  17. 	//得分增加
  18. 	ps->_Score += ps->_FoodWeight;
  19. 	//我们还得生成食物
  20. 	CreatFood(ps);
  21.  
  22. }

8.3.3.3 NoFood

当我们蛇头朝向的下一个坐标不是食物，此时我们使用头插法将将下⼀个节点头插⼊蛇的⾝体，但是要维持我们蛇身体长度不变，我们就不打印我们的蛇尾巴，就是让cur只移动到我们的蛇尾巴后面一节，并将之前蛇⾝最后⼀个节点打印为空格，放弃掉蛇⾝的最后⼀个节点

  1. //下一个节点不是食物
  2. void NotFood(pSnake ps, pSnakeNode pnext)
  3. {
  4. 	//头插法，注意和前面蛇身连接联系起来
  5. 	pnext->next = ps->_psnake;
  6. 	ps->_psnake = pnext;//节点变成蛇头我们就将这个节点的指针作为我们蛇的指针，方便找到蛇
  7. 	//打印应该打印蛇身的长度，但是现在我们蛇挂上了下一个节点，我们就可以
  8. 	//将最后一个位置节点释放，并把到时第二个的next指针置空
  9. 	pSnakeNode cur = ps->_psnake;
  10. 	while (cur->next->next)
  11. 	{
  12. 		SetPos(cur->x, cur->y);
  13. 		wprintf(L"%lc", BODY);
  14. 		cur = cur->next;
  15. 	}
  16. 	SetPos(cur->next->x, cur->next->y);
  17. 	printf("  ");//将最后一个蛇节点打印空格
  18. 	//释放掉最后一个节点
  19. 	free(cur->next);
  20. 	cur->next = NULL;
  21. 	
  22. }
8.3.3.4 KillByWall 判断蛇头是否撞墙

这个很简单就是通过蛇头的横纵坐标不能和墙的行列重合进行判断就可以了

  1. void KillByWall(pSnake ps)
  2. {
  3. 	//横坐标不能是0和56，左右墙，蛇头坐标
  4. 	if (ps->_psnake->x == 0 || ps->_psnake->x == 56
  5. 		||ps->_psnake->y==0||ps->_psnake->y==26)
  6. 	{
  7. 		ps->_Status = KILL_BY_WALL;
  8.  
  9. 	}
  10.  
  11.  
  12. }

8.3.3.5 KillBySelf 判断蛇头的坐标是否和蛇⾝体的坐标冲突

我们的蛇不能吃到自己，也就是说蛇头坐标不能和蛇第二个节点以后的坐标有重合，我们获得指向蛇第二个节点的坐标遍历蛇身体然后和蛇头坐标比对就可以实现：

  1. void KillBySelf(pSnake ps)
  2. {
  3. 	//遍历蛇头下一个坐标节点不能是自身
  4. 	//首先找到我们蛇的第二个节点，蛇头不能触碰第二个节点以后的坐标
  5. 	pSnakeNode cur = ps->_psnake->next;
  6. 	while (cur)
  7. 	{
  8. 		if (ps->_psnake->x == cur->x&&ps->_psnake->y==cur->y)
  9. 		{
  10. 			ps->_Status = KILL_BY_SELF;
  11. 		}
  12. 		cur = cur->next;
  13. 	}
  14.  
  15. }

8.4 游戏结束

游戏状态不再是OK（游戏继续）的时候，要告知游戏技术的原因，并且释放蛇⾝节点。 

  1. void GameEnd(pSnake ps)
  2. {
  3. 	SetPos(20, 12);
  4. 	switch (ps->_Status)
  5. 	{
  6. 	case END_NORMAL:
  7. 		printf("玩家自己退出游戏\n");
  8. 		break;
  9. 	case KILL_BY_SELF:
  10. 		printf("不好意思，您咬到了自己，中毒身亡了\n");
  11. 		break;
  12. 	case KILL_BY_WALL:
  13. 		printf("不好意思，您撞到墙了\n");
  14. 		break;
  15. 	}
  16. 	
  17. 	//释放蛇身的节点
  18. 	pSnakeNode cur = ps->_psnake;
  19. 	while (cur)
  20. 	{
  21. 		pSnakeNode det = cur;
  22. 		cur = cur->next;
  23. 		free(det);
  24. 	}
  25. 	ps->_psnake = NULL;
  26. }

9.参考源码

分三个文件

test.c

  1. #include"snake.h"
  2.  
  3.  
  4.  
  5.  
  6.  
  7. void test()
  8. {
  9. 	int ch = 0;
  10. 	do
  11. 	{
  12. 		Snake snake = { 0 };//首先创建一条贪吃蛇
  13. 		//游戏开始，游戏初始化：地图的打印和蛇 食物的打印
  14. 		GameStart(&snake);
  15.  
  16. 		//2.游戏运行-游戏正常运行
  17. 		GameRun(&snake);
  18.  
  19. 		//3.游戏结束，游戏善后，链表要释放资源
  20. 		GameEnd(&snake);
  21. 		SetPos(20, 18);
  22. 		printf("要再来一局吗？(Y/N):");
  23. 		ch = getchar();
  24. 		getchar();//清理回车
  25.  
  26. 	} while (ch=='Y'||ch=='y');
  27. 	SetPos(0, 27);
  28. }
  29.  
  30.  
  31.  
  32.  
  33.  
  34. int main()
  35. {
  36. 	//设置程序适应本地环境，后面打印各种宽字符，蛇身体和食物墙等
  37. 	setlocale(LC_ALL ,"");
  38. 	srand((unsigned int)time(NULL));//随机生成食物坐标
  39.  
  40. 	test();
  41. 	return 0;
  42. }

snake.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<locale.h>
  4. #include<stdlib.h>  //使用system函数
  5. #include<windows.h>//使用Win32函数
  6. #include<stdbool.h>//folse
  7. #include<time.h>
  8.  
  9. #define WALL L'□'
  10. #define BODY L'●'
  11. #define FOOD L'★'
  12.  
  13. #define POS_X  24
  14. #define POS_Y   5
  15.  
  16. #define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1)? 1:0)//宏用于判断虚拟键有没有被用过
  17.  
  18. enum DIRECTION
  19. {
  20. 	UP = 1,
  21. 	DOWN,
  22. 	LEFT,
  23. 	RIGHT
  24. };
  25. enum GAME_STATUS
  26. {
  27. 	OK,//正常运行
  28. 	END_NORMAL,//按ESC正常退出
  29. 	KILL_BY_WALL,
  30. 	KILL_BY_SELF
  31. };
  32. //贪吃蛇节点描述
  33. typedef struct SnakeNode
  34. {
  35. 	//描述坐标的信息
  36. 	int x;
  37. 	int y;
  38. 	struct SnakeNode* next;
  39. }SnakeNode,*pSnakeNode;
  40.  
  41. //贪吃蛇蛇的描述
  42. typedef struct snake
  43. {
  44. 	//需要指向这个蛇第一个节点的指针，方便找到整条蛇
  45. 	pSnakeNode _psnake;
  46. 	pSnakeNode _pFood;//这个指针指向的是食物节点，因为食物也可以看做是一个节点类型
  47. 	int _Score;//当前累计的分数，可以理解为当前有多少节点
  48. 	int _FoodWeight;//一个食物的分数是多少
  49. 	int _SleepTime;//定义每走一步休息的时间，我们定义的休息的时间越短，速度就越快，时间越长，速度就越慢
  50. 	enum DIRECTION _Dir;//描述蛇的方向
  51. 	enum GAME_STATUS _Status;//描述游戏的状态：正常退出，撞墙，吃到自己
  52. }Snake,*pSnake;
  53.  
  54.  
  55.  
  56. void GameStart(pSnake ps);
  57. void SetPos(int x, int y);//定位坐标
  58. void InitSnake(pSnake ps);//初始化蛇
  59. //创建食物
  60. void CreatFood(pSnake ps);
  61.  
  62.  
  63. void GameRun(pSnake ps);//游戏的运行过程
  64. void PrintHelpInfo();//打印帮助信息
  65.  
  66. void Pause();//死循环休眠检测
  67.  
  68. void SnakeMove(pSnake ps);//蛇移动起来
  69.  
  70. int NextIsFood(pSnake ps, pSnakeNode pnext);//判断下一个节点是否是食物
  71.  
  72. //当下一个节点是食物，我们执行操作
  73. void EatFood(pSnake ps, pSnakeNode pnext);
  74. void NotFood(pSnake ps, pSnakeNode pnext);
  75.  
  76.  
  77. void KillByWall(pSnake ps);
  78. void KillBySelf(pSnake ps);
  79.  
  80. void GameEnd(pSnake ps);//游戏结束后的一些处理

snake.c

  1. #include "snake.h"
  2.  
  3. void SetPos(int x, int y)
  4. {
  5. 	COORD pos = { x,y };
  6. 	HANDLE houtput = NULL;//获取标准输出也就是屏幕的控制句柄
  7. 	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
  8. 	//设置标准输出上光标的位置为pos
  9. 	SetConsoleCursorPosition(houtput, pos);
  10. }
  11. void 	WelComeToGame()
  12. {
  13. 	//定位光标
  14. 	SetPos(40, 14);
  15. 	printf("欢迎来到贪吃蛇小游戏");
  16. 	SetPos(40, 25);//再次定位坐标
  17. 	system("pause");//暂停命令，执行到此处暂停)
  18.  
  19.    //来到下一个界面，我们把当前界面内容全部清理重新打印实现换屏效果
  20. 	system("cls");//清理屏幕
  21. 	SetPos(20, 14);
  22. 	printf("使用↑↓← →，分别控制蛇的上下左右移动，使用F3加速，F4减速");
  23. 	SetPos(40, 25);//再次定位坐标
  24. 	system("pause");//暂停命令，执行到此处暂停)
  25. 	system("cls");//清理屏幕
  26.  
  27. }
  28.  
  29. void CreateMap()
  30. {
  31. 	//上
  32. 	SetPos(0, 0);//重新定位光标位置
  33. 	int i = 0;
  34. 	for (i = 0; i <= 56; i += 2)
  35. 	{
  36. 		wprintf(L"%lc", WALL);
  37. 	}
  38. 	//下
  39. 	SetPos(0, 26);//重新定位光标位置
  40. 	for (i = 0; i <= 56; i += 2)
  41. 	{
  42. 		wprintf(L"%lc", WALL);
  43. 	}
  44. 	//左
  45. 	for (i = 1; i <= 25; i++)
  46. 	{
  47. 		SetPos(0, i);
  48. 		wprintf(L"%lc", WALL);
  49. 	}
  50. 	//右
  51. 	for (i = 1; i <= 25; i++)
  52. 	{
  53. 		SetPos(56, i);
  54. 		wprintf(L"%lc", WALL);
  55. 	}
  56. 	//getchar();//测试最后一行的打印
  57.  
  58. }
  59.  
  60. void InitSnake(pSnake ps)
  61. {
  62. 	pSnakeNode cur = NULL;//为了实现复用就定义在外边
  63. 	int i = 0;
  64. 	for (i = 0; i < 5; i++)
  65. 	{
  66. 		 cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  67. 		if (cur == NULL)
  68. 		{
  69. 			perror("malloc");
  70. 			return;
  71. 		}
  72. 		cur->x = POS_X+2*i;
  73. 		cur->y = POS_Y;
  74. 		cur->next = NULL;
  75. 		//头插法
  76. 		if (ps->_psnake == NULL)
  77. 		{
  78. 			ps->_psnake = cur;//第一个位置就给了蛇的第一块
  79. 		}
  80. 		else
  81. 		{
  82. 			cur->next = ps->_psnake;
  83. 			ps->_psnake = cur;
  84.  
  85. 		}
  86. 	}
  87. 	//打印蛇，就是遍历链表
  88. 	cur = ps->_psnake;
  89. 	while (cur)
  90. 	{
  91. 		SetPos(cur->x, cur->y);//得到每个节点的横纵坐标，然后定位光标打印身体
  92. 		wprintf(L"%lc", BODY);
  93.  
  94. 		cur = cur->next;
  95.  
  96. 	}
  97. 	ps->_Status = OK;
  98. 	ps->_Score = 0;
  99. 	ps->_pFood = NULL;
  100. 	ps->_SleepTime = 200;
  101. 	ps->_FoodWeight = 10;
  102. 	ps->_Dir = RIGHT;
  103.  
  104. 	//getchar();//测试打印结果因为会被最后一句话打乱
  105.  
  106.  
  107. }
  108.  
  109. void CreatFood(pSnake ps)
  110. {
  111. 	//分析：1.坐标应该是随机生成的,但是应该有下面的约束
  112. 	// 2.食物的坐标不能够在墙外
  113. 	// 3.食物的坐标最好是2的倍数，这样方便和我们的蛇身挂钩不出墙
  114. 	// 4.食物的坐标不能和蛇的身体冲突1
  115. 	// x>=2,x<=54
  116. 	// y>=1y<=25
  117. 	// 
  118. 	//
  119. 	int x = 0;
  120. 	int y = 0;
  121. again:
  122. 	do
  123. 	{
  124. 		x = rand() % 53 + 2;//余数0~52+2
  125. 		y = rand() % 25 + 1;
  126. 	} while (x%2 != 0);//x的坐标必须是2的倍数
  127. 	//坐标不能和蛇身冲突
  128. 	pSnakeNode cur = ps->_psnake;
  129. 	while (cur)//五个坐标蛇身的所有坐标不可与食物重复
  130. 	{
  131. 		//比较坐标
  132. 		if (cur->x == x && cur->y == y)
  133. 		{
  134. 			goto again;
  135. 		}
  136. 		cur = cur->next;
  137. 	}
  138. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  139. 	if (pFood == NULL)
  140. 	{
  141. 		perror("CreateFood():malloc");
  142. 		return;
  143. 	}
  144. 	//节点创建成功
  145. 	pFood->x = x;
  146. 	pFood->y = y;
  147. 	ps->_pFood = pFood;
  148. 	//打印
  149. 	SetPos(x, y);
  150. 	wprintf(L"%lc", FOOD);
  151. 	//getchar();//测试打印结果因为会被最后一句话打乱
  152. }
  153.  
  154.  
  155. void GameStart(pSnake ps)
  156. {
  157. 	//控制台窗口大小的设置
  158. 	system("mode con cols=110 lines=30");
  159. 	system("title SNAKE");
  160. 	//将光标隐藏
  161. 	 //获取标准输出的句柄(⽤来标识不同设备的数值)
  162. 	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  163. 	//影藏光标操作
  164. 	CONSOLE_CURSOR_INFO CursorInfo;
  165. 	GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
  166. 	CursorInfo.bVisible = false; //隐藏控制台光标
  167. 	SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
  168. 	//打印欢迎界面
  169. 	WelComeToGame();
  170. 	//创建地图
  171. 	CreateMap();
  172. 	//初始化贪吃蛇
  173. 	InitSnake(ps);
  174. 	//创建食物
  175. 	CreatFood(ps);
  176.  
  177. }
  178.  
  179. void PrintHelpInfo()
  180. {
  181. 	SetPos(64, 15);
  182. 	printf("1.不能穿墙，不可以咬到自己");
  183. 	SetPos(64, 16);
  184. 	printf("2.使用↑↓← →，分别控制蛇的上下左右移动");
  185. 	SetPos(64, 17);
  186. 	printf("3.使用F3加速蛇的移动，F4减速");
  187. 	SetPos(64, 18);
  188. 	printf("4.ESC退出，点击空格暂停游戏");
  189.  
  190. 	SetPos(64, 20);
  191. 	printf("CSDN-Nicn版权");
  192. 	//getchar();
  193.  
  194. }
  195.  
  196.  
  197.  
  198. void Pause()
  199. {
  200. 	while (1)
  201. 	{
  202. 		Sleep(100);//一直睡眠
  203. 		if (KEY_PRESS(VK_SPACE))
  204. 		{
  205. 			break;//按空格跳出
  206. 		}
  207. 	}
  208.  
  209. }
  210.  
  211. int NextIsFood(pSnake ps, pSnakeNode pnext)
  212. {
  213. 	if (ps->_pFood->x == pnext->x && ps->_pFood->y == pnext->y)
  214. 	{
  215. 		return 1;//是食物就返回1
  216. 	}
  217. 	else
  218. 	{
  219. 		return 0;//不是食物返回0
  220. 	}
  221. }
  222.  
  223. //下一个节点是食物
  224. void EatFood(pSnake ps, pSnakeNode pnext)
  225. {
  226. 	//头插法，注意和前面蛇身连接联系起来
  227. 	pnext->next = ps->_psnake;
  228. 	ps->_psnake = pnext;//节点变成蛇头我们就将这个节点的指针作为我们蛇的指针，方便找到蛇
  229. 	pSnakeNode cur = ps->_psnake;
  230. 	while (cur)
  231. 	{
  232. 		SetPos(cur->x, cur->y);
  233. 		wprintf(L"%lc", BODY);
  234. 		cur = cur->next;
  235. 		
  236. 	}
  237. 	//原先创建食物的时候我们为食物节点申请过一次空间，那么这里就释放掉那一次申请的空间
  238. 	free(ps->_pFood);
  239. 	//得分增加
  240. 	ps->_Score += ps->_FoodWeight;
  241. 	//我们还得生成食物
  242. 	CreatFood(ps);
  243.  
  244. }
  245. //下一个节点不是食物
  246. void NotFood(pSnake ps, pSnakeNode pnext)
  247. {
  248. 	//头插法，注意和前面蛇身连接联系起来
  249. 	pnext->next = ps->_psnake;
  250. 	ps->_psnake = pnext;//节点变成蛇头我们就将这个节点的指针作为我们蛇的指针，方便找到蛇
  251. 	//打印应该打印蛇身的长度，但是现在我们蛇挂上了下一个节点，我们就可以
  252. 	//将最后一个位置节点释放，并把到时第二个的next指针置空
  253. 	pSnakeNode cur = ps->_psnake;
  254. 	while (cur->next->next)
  255. 	{
  256. 		SetPos(cur->x, cur->y);
  257. 		wprintf(L"%lc", BODY);
  258. 		cur = cur->next;
  259. 	}
  260. 	SetPos(cur->next->x, cur->next->y);
  261. 	printf("  ");//将最后一个蛇节点打印空格
  262. 	//释放掉最后一个节点
  263. 	free(cur->next);
  264. 	cur->next = NULL;
  265. 	
  266. }
  267. void KillByWall(pSnake ps)
  268. {
  269. 	//横坐标不能是0和56，左右墙，蛇头坐标
  270. 	if (ps->_psnake->x == 0 || ps->_psnake->x == 56
  271. 		||ps->_psnake->y==0||ps->_psnake->y==26)
  272. 	{
  273. 		ps->_Status = KILL_BY_WALL;
  274.  
  275. 	}
  276.  
  277.  
  278. }
  279. void KillBySelf(pSnake ps)
  280. {
  281. 	//遍历蛇头下一个坐标节点不能是自身
  282. 	//首先找到我们蛇的第二个节点，蛇头不能触碰第二个节点以后的坐标
  283. 	pSnakeNode cur = ps->_psnake->next;
  284. 	while (cur)
  285. 	{
  286. 		if (ps->_psnake->x == cur->x&&ps->_psnake->y==cur->y)
  287. 		{
  288. 			ps->_Status = KILL_BY_SELF;
  289. 		}
  290. 		cur = cur->next;
  291. 	}
  292.  
  293. }
  294.  
  295. void SnakeMove(pSnake ps)//蛇移动
  296. {
  297. 	//移动即是通过蛇头的方向判断下一个位置的坐标，然后我们就根据按键创建这个方向上的节点，然后再连接起来
  298. 	//那我们就先为未来可能走的这个节点创建一下
  299. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
  300. 	//判断一下是否申请成功
  301. 	if (pNext == NULL)
  302. 	{
  303. 		perror("SnakeMove():malloc()");
  304. 		return;
  305. 	}
  306. 	pNext->next = NULL;//迅速将这个节点的指向下一个节点的指针置空，否则有些许凌乱，后续使用再修改
  307.  
  308. 	
  309. 	
  310. 	switch (ps->_Dir)
  311. 	{
  312. 	case UP:
  313. 		//x不变，y-1
  314. 		pNext->x = ps->_psnake->x;
  315. 		pNext->y = ps->_psnake->y - 1;
  316. 		break;
  317. 	case DOWN:
  318. 		pNext->x = ps->_psnake->x;
  319. 		pNext->y = ps->_psnake->y + 1;
  320. 		break;
  321. 	case LEFT://x-1,y不变
  322. 		pNext->x = ps->_psnake->x-1;
  323. 		pNext->y = ps->_psnake->y ;
  324. 		break;
  325. 	case RIGHT:
  326. 		pNext->x = ps->_psnake->x+1;
  327. 		pNext->y = ps->_psnake->y;
  328. 		break;
  329. 	}
  330. 	//判断下一个位置是否是食物，是食物我们蛇身长度就要变，不是食物我们目前蛇的尾部就不应该显示
  331. 	//写一个判断函数
  332. 	if (NextIsFood(ps, pNext))
  333. 	{
  334. 		//吃掉食物，封装函数
  335. 		EatFood(ps,pNext);
  336. 	}
  337. 	else
  338. 	{
  339. 		//
  340. 		NotFood(ps, pNext);
  341. 	}
  342. 	//检测蛇是否撞墙（判断坐标）
  343. 	KillByWall( ps);
  344. 	//检测蛇是否吃到自身（判断坐标）
  345. 	KillBySelf(ps);
  346. }
  347.  
  348.  
  349.  
  350. void GameRun(pSnake ps)
  351. {
  352. 	PrintHelpInfo();
  353. 	do
  354. 	{
  355. 	
  356. 		SetPos(64, 9);
  357. 		printf("得分：%5d", ps->_Score);
  358. 		SetPos(64, 10);
  359. 		printf("每个食物分数为：%2d", ps->_FoodWeight);
  360. 		if( KEY_PRESS(VK_UP) && ps->_Dir != DOWN)
  361. 		{
  362. 			//如果我们按下向上键，此时我们的蛇头的方向不向上，就调整为向上移动
  363. 			ps->_Dir = UP;
  364. 		}
  365. 		else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP)
  366. 		{
  367. 			ps->_Dir = DOWN; 
  368. 		}
  369. 		else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT)
  370. 		{
  371. 			ps->_Dir = LEFT;
  372. 		}
  373. 		else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT)
  374. 		{
  375. 			ps->_Dir = RIGHT;
  376. 		}
  377. 		else if (KEY_PRESS(VK_ESCAPE))
  378. 		{
  379. 			ps->_Status = END_NORMAL;
  380. 			break;
  381. 		}
  382. 		else if (KEY_PRESS(VK_SPACE))
  383. 		{
  384. 			//由于暂停程序并不结束，并且还要可以继续唤醒程序，我们封装一个函数
  385. 			Pause();//死循环休眠检测休眠
  386. 		}
  387. 		//加速
  388. 		else if (KEY_PRESS(VK_F3))
  389. 		{
  390. 			if (ps->_SleepTime >= 80)//设置加速门款
  391. 			{
  392. 				ps->_SleepTime -= 30;
  393. 				//速度越快，越容易树，风浪越大鱼越贵，我们把分数调高一些
  394. 				ps->_FoodWeight += 5;
  395. 			}
  396. 		}
  397. 		//减速
  398. 		else if (KEY_PRESS(VK_ESCAPE))
  399. 		{
  400. 			if (ps->_SleepTime <=320)//设置减速最低门坎
  401. 			{
  402. 				ps->_SleepTime += 30;
  403. 				//速度越快，越容易树，风浪越大鱼越贵，我们把分数调高一些
  404. 				ps->_FoodWeight -= 2;
  405. 			}
  406. 		}
  407. 		Sleep(ps->_SleepTime);
  408. 		//蛇动起来
  409. 		SnakeMove(ps);
  410.  
  411. 	} while (ps->_Status==OK);
  412.  
  413. }
  414.  
  415.  
  416.  
  417. void GameEnd(pSnake ps)
  418. {
  419. 	SetPos(20, 12);
  420. 	switch (ps->_Status)
  421. 	{
  422. 	case END_NORMAL:
  423. 		printf("玩家自己退出游戏\n");
  424. 		break;
  425. 	case KILL_BY_SELF:
  426. 		printf("不好意思，您咬到了自己，中毒身亡了\n");
  427. 		break;
  428. 	case KILL_BY_WALL:
  429. 		printf("不好意思，您撞到墙了\n");
  430. 		break;
  431. 	}
  432. 	
  433. 	//释放蛇身的节点
  434. 	pSnakeNode cur = ps->_psnake;
  435. 	while (cur)
  436. 	{
  437. 		pSnakeNode det = cur;
  438. 		cur = cur->next;
  439. 		free(det);
  440. 	}
  441. 	ps->_psnake = NULL;
  442. }

10.结语

这个项目的实现逻辑相对于通讯录较为复杂，但是对于C语言学完的伙伴来说还是比较容易掌握，新知识只有WIN32API的知识补充，但是也不是很难，大家可以结合参考资料理解，特别是我们的流程图。以上就是本期的所有内容，知识含量蛮多，大家可以配合解释和原码运行理解。创作不易，大家如果觉得还可以的话，欢迎大家三连，有问题的地方欢迎大家指正，一起交流学习，一起成长，我是Nicn，正在c++方向前行的奋斗者，感谢大家的关注与喜欢。

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

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

  

闽ICP备14008679号