贪吃蛇小游戏---古法编程

YSL070124

最新推荐文章于 2026-10-26 11:08:57 发布

关注

VIP 从原理图到GDSII：Virtuoso+Pcell实战避坑指南（以TSMC65nm振荡器为例）本文以TSMC65nm工艺下的振荡器设计为例，详细解析了Virtuoso环境中Pcell的最佳实践方案，涵盖变量管理、版图设计、Calibre验证等关键环节。通过实战案例和避坑指南，帮助工程师高效完成从原理图到GDSII的转化，特别针对LVS验证和参数化单元设计提供了实用解决方案。 开通可读全文·896 阅读·25 点赞·15 收藏阅读全文

1. 简介

贪吃蛇是久负盛名的游戏，它也和俄罗斯⽅块，扫雷等游戏位列经典游戏的⾏列。

在编程语⾔的教学中，我们以贪吃蛇为例，从设计到代码实现来提升学⽣的编程能⼒和逻辑能⼒。

我们现在已经可以通过已学的知识来实现简易版的贪吃蛇小游戏。

2. 目标

使⽤C语⾔在Windows环境的控制台中模拟实现经典⼩游戏贪吃蛇。

实现基本的功能：

贪吃蛇地图绘制
蛇吃食物的功能（上、下、左、右方向键控制蛇的动作）
蛇撞墙死亡
蛇撞自身死亡
计算得分
蛇身加速、减速
暂停游戏

3. 技术要点

C语⾔函数、枚举、结构体、动态内存管理、预处理指令、链表、Win32API等。

这些知识我除了Win32API没讲其他的我都讲过，顺便我们可以通过这个小游戏来巩固一下我们的知识。

4. Win32API

4.1 Win32API概念

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

4.2 控制台程序

我们游戏的实现是在控制台上进行实现的，但是VS2022默认的是使用终端来执行程序，我们就要改成控制台执行。

终端就是这样的，我们该如何将终端改成控制台呢？

这里我们直接将终端换成控制台，记得保存！

之后我们执行程序就是显示控制台了。

我们怎么像这样子将控制台的名字改成贪吃蛇呢？

//设置控制台窗⼝的⻓宽：设置控制台窗⼝的⼤⼩，30⾏，100列
system("mode con cols=100 lines=30");
//设置cmd窗口名称
system("title 贪吃蛇");

我们只需要执行这串代码即可，system翻译过来就是系统的意思，我们执行代码就是直接在系统中执行语句才能更改我们控制台的名称，我们使用system要使用" "将要执行的内容框起来，注意·这个行和列的顺序，千万不要搞混了，其次我们这个行和列的比列是不一样的，你们可以将行和列改成一样的试试。

你会发现我们将两个都改成30，并不是我们想的是个正方形。

4.3 控制台屏幕上的坐标COORD

COORD是WindowsAPI中定义的⼀个结构体，表⽰⼀个字符在控制台屏幕幕缓冲区上的坐标，坐标系 (0，0) 的原点位于缓冲区的顶部左侧单元格。

COORD类型的声明：

typedef struct _COORD {
	SHORT X;
	SHORT Y;
} COORD, *PCOORD;

这里的x和y并不是我们学的坐标那样，

起始点是右上角。

4.4 GetStdHandle

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

这些函数都是在Windows官网都是可以看到的。

HANDLE hOutput = NULL;

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

4.5 GetConsoleCursorInfo

检索有关指定控制台屏幕缓冲区的光标⼤⼩和可⻅性的信息。

实例使用：

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

CONSOLE_CURSOR_INFO CursorInfo;

GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息

4.6 CONSOLE_CURSOR_INFO

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

语法：

#include <windows.h>

int main()
{
    HANDLE hOutput = NULL;
    hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO CursorInfo;
    GetConsoleCursorInfo(hOutput, &CursorInfo);
    CursorInfo.bVisible = FALSE;  // 设置为不可见
    SetConsoleCursorInfo(hOutput, &CursorInfo); // 应用设置
    return 0;
}

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

bVisible，游标的可见性。如果光标可见，则此成员为 TRUE。

隐藏光标:

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

4.7 SetConsoleCursorInfo

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

我们结合上面的各个函数就可以实现光标的隐藏了。

HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);

//影藏光标操作
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
CursorInfo.bVisible = false; //隐藏控制台光标
SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态

4.8 SetConsoleCursorPosition

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

实例使用：

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

我们为了后续的光标定位方便，我们可以直接封装一个函数，用于定位光标。

SetPos：封装⼀个设置光标位置的函数

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

4.9 GetAsyncKeyState

将键盘上每个键的虚拟键值传递给函数，函数通过返回值来分辨按键的状态。

如果我们要判断⼀个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1。

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

5. 贪吃蛇游戏设计和分析

5.1 地图的绘制

这是我们要达到的预期的地图效果，就是使用“■” 框出一块方格，食物和蛇我们先不看。

这里我们要知道我们打印的■是宽字符，我们平常打印的字符abc等都是只占一个字节，但是我们宽字符是占两个字节的。

这⾥不得不讲⼀下控制台窗⼝的⼀些知识，如果想在控制台的窗⼝中指定位置输出信息，我们得知道该位置的坐标，所以⾸先介绍⼀下控制台窗⼝的坐标知识。

控制台窗⼝的坐标如下所⽰，横向的是X轴，从左向右依次增⻓，纵向是Y轴，从上到下依次增⻓。

但是我们使用宽字符并不是可以直接使用的，我们要适配本地环境。

5.1.1 <local.h>本地化

<locale.h> 提供的函数用于控制 C 标准库中对于不同的地区会产生不一样行为的部分。

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

数字量的格式
货币量的格式
字符集
日期和时间的表示形式

5.1.2 类项

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

LC_COLLATE：影响字符串比较函数 strcoll () 和 strxfrm ()。
LC_CTYPE：影响字符处理函数的行为。
LC_MONETARY：影响货币格式。
LC_NUMERIC：影响 printf () 的数字格式。
LC_TIME：影响时间格式 strftime () 和 wcsftime ()。
LC_ALL - 针对所有类项修改，将以上所有类别设置为给定的语言环境。

5.1.3 setlocale函数

函数语法：

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

etlocale 函数⽤于修改当前地区，可以针对⼀个类项修改，也可以针对所有类项。

setlocale 的第⼀个参数可以是前⾯说明的类项中的⼀个，那么每次只会影响⼀个类项，如果第⼀个参数是LC_ALL，就会影响所有的类项。

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

当地区设置为"C"时，设置为C语⾔默认的模式，这时库函数按正常⽅式执⾏。

当程序运⾏起来后想改变地区，就只能显⽰调⽤setlocale函数。

⽤""作为第2个参数，调⽤setlocale函数就可以切换到本地模式，这种模式下程序会适应本地环境。

切换到我们的本地模式后就⽀持宽字符（汉字）的输出等:

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

5.1.4 宽字符的打印

那如果想在屏幕上打印宽字符，怎么打印呢？

宽字符的字面量必须加上前缀 L，否则 C 语言会把字面量当作窄字符类型处理。前缀 L 在单引号前面，表示宽字符，宽字符的打印使用 wprintf，对应 wprintf () 的占位符为 % lc；在双引号前面，表示宽字符串，对应 wprintf () 的占位符为 % ls。

void PrintHelpInfo()
{
    SetPos(64, 13);
    wprintf(L"%ls", L"不能撞墙，不能咬到自己\n");
    SetPos(64, 14);
    wprintf(L"%ls", L"用 ↑ . ↓ . ← . → 来控制蛇的移动\n");
    SetPos(64, 15);
    wprintf(L"%ls", L"按F3加速，按F4减速\n");
    SetPos(64, 16);
    wprintf(L"%ls", L"按ESC退出游戏，按空格暂停游戏\n");
}

5.2 地图坐标

我们加入实现一个棋盘27行，58列的棋盘，我们该怎么打印棋盘呢?

我们打印宽字符是占两个字符的位置，所以我们在打印列时需要除以2。

void CreateMap()
{
	//上
	for (int i = 0; i < 29; i++)
	{
		wprintf(L"%lc", L'■');
	}
	//下
	SetPos(0, 26);
	for (int i = 0; i < 29; i++)
	{
		wprintf(L"%lc", L'■');
	}
	//左
	for (int i = 1; i <= 25; i++)
	{
		SetPos(0, i);
		wprintf(L"%lc", L'■');
	}
	//右
	for (int i = 1; i <= 25; i++)
	{
		SetPos(56, i);
		wprintf(L"%lc", L'■');
	}
}

5.3 蛇身和食物的绘制

同样，我们的食物和蛇身也是使用宽字符，所以我们一定要确保其中的x坐标是2的倍数，否则可能出现一半卡在墙中的现象，其中食物是随机刷新的，我们一定要确保食物不予蛇身重合，蛇身的移动我们就直接使用链表的头插尾删即可完成。

5.4 数据结构设计

在游戏运⾏的过程中，蛇每次吃⼀个⻝物，蛇的⾝体就会变⻓⼀节，如果我们使⽤链表存储蛇的信息，那么蛇的每⼀节其实就是链表的每个节点。每个节点只要记录好蛇⾝节点在地图上的坐标就⾏，所以蛇节点结构如下:

typedef struct SnakeNode
{
	int x;
	int y;
	struct SnakeNode* next;
}SnakeNode,*pSnakeNode;

要管理整条贪吃蛇的各个元素，我们再封装⼀个Snake的结构来维护整条贪吃蛇：

typedef struct Snake
{
	pSnakeNode _pSnake;  //指向蛇头的指针
	pSnakeNode _pFood;   //指向食物的指针
	enum DIRECTION _dir;   //使用枚举来列举蛇的方向
	enum GAME_STATUS _status;  //游戏的状态
	int _food_weight;      //一个食物的分数
	int _score;             //总分数
	int _sleep_time;         //休息时间
}Snake,*pSnake;

其中，蛇的方向和游戏的状态我们可以直接使用枚举的方式来完成。

蛇的方向：

//蛇的方向
enum DIRECTION
{
	UP = 1,//上
	DOWN,//下
	LEFT,//左
	RIGHT//右
	
};

蛇的状态：

//游戏的状态
enum GAME_STATUS
{
	OK,            //正常运行
	KILL_BY_WALL,  //撞墙
	KILL_BY_SELF,  //自己撞自己
	EMD_NORMAL    //正常退出
};

6. 核心逻辑实现分析

6.1 主逻辑

程序开始就设置程序支持本地模式，然后进入游戏的主逻辑。

主逻辑分为 3 个过程：

游戏开始（GameStart）完成游戏的初始化
游戏运行（GameRun）完成游戏运行逻辑的实现
游戏结束（GameEnd）完成游戏结束的说明，实现资源释放

//完成游戏的测试逻辑
void test()
{
	int ch = 0;
	int c = 0;
	do
	{
		system("cls");
		//创建贪吃蛇
		Snake snake = { 0 };
		//初始化游戏
		//1. 打印欢迎界面
		//2. 功能介绍
		//3. 绘制地图
		//4. 创建蛇
		//5. 创建食物
		GameStart(&snake);

		//运行游戏
		GameRun(&snake);
		//结束游戏--善后工作
		GameEnd(&snake);

		SetPos(20, 15);
		printf("再来一局吗?(Y/N):");
		ch = getchar();
		//清行尾 + 防 EOF 死循环
		while ((c = getchar()) != '\n' && c != EOF);
	} while (ch == 'Y' || ch == 'y');
	SetPos(0, 27);
}

int main()
{
	//设置适配本地环境，这样我们就可以打印宽字符。
	setlocale(LC_ALL, "");
	srand((unsigned int)time(NULL));
	test();
	return 0;
}

这里我们设置了一个随机数种子，可以保证食物的随机性。

6.2 游戏开始

这个模块完成游戏的初始化任务：

控制台窗口大小的设置
控制台窗口名字的设置
鼠标光标的隐藏
打印欢迎界面
创建地图
初始化蛇
创建第一个食物

void GameStart(pSnake ps)
{
	//0. 设置窗口的大小
	//设置控制台窗⼝的⻓宽：设置控制台窗⼝的⼤⼩，30⾏，100列
	system("mode con cols=100 lines=30");
	//设置cmd窗口名称
	system("title 贪吃蛇");

	//1. 光标隐藏
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);   //创建句柄
	CONSOLE_CURSOR_INFO CursorInfo;    //创建光标结构体
	GetConsoleCursorInfo(houtput, &CursorInfo);//获取控制台光标信息
	CursorInfo.bVisible = false; //隐藏控制台光标
	SetConsoleCursorInfo(houtput, &CursorInfo);//设置控制台光标状态

	//2. 打印欢迎界面和功能介绍
	WelcomeToGame();

	//3. 地图绘制
	CreateMap();

	//4. 初始化蛇身
	InitSnake(ps);

	//5. 创建食物
	CreateFood(ps);
}

这其中的光标的隐藏部分是知道就信，没有需要完全掌握的必要。

6.2.1 打印欢迎界面

我们要实现这两个欢迎界面：

void WelcomeToGame()
{
	SetPos(40, 14);
	wprintf(L"欢迎来到贪吃蛇小游戏\n");
	SetPos(42, 15);
	system("pause");  //暂停
	system("cls");   //清空屏幕
	SetPos(25, 14);
	wprintf(L"用↑.↓.←.→来控制蛇的移动，按F3加速，按F4减速\n");
	SetPos(25, 15);
	wprintf(L"加速能够得到更高的分数\n");
	SetPos(42, 20);
	system("pause");
	system("cls");
}

这里我们使用了将之前光标定位时封装的函数拿过来了，这里的pause就是停下等待，等我们按下任意一个键之后，程序就可以继续往下执行了。但是要引进头文件stdlib.h；cls就是清空屏幕，这个就是为了可以下一次打印。这样我们就完成了欢迎界面的打印，注意：这个光标定位，你们可以根据自己的审美来调整打印语句的位置。

6.2.2 创建地图

这个创建地图我们刚刚已经提到了，但是我们一定要好好思考一下，为什么我们的坐标是这样的。

易错点：就是坐标的计算上： (0,0) 到 (56,0) 下： (0,26) 到 (56,26) 左： (0,1) 到 (0,25) 右： (56,1) 到 (56,25)

我们为了能够更加方便的更改地图的边框图形，我们可以使用一个宏定义来方便更改。

#define WALL L'□'

void CreateMap()
{
	//上
	for (int i = 0; i < 29; i++)
	{
		wprintf(L"%lc", WALL);
	}
	//下
	SetPos(0, 26);
	for (int i = 0; i < 29; i++)
	{
		wprintf(L"%lc", WALL);
	}
	//左
	for (int i = 1; i <= 25; i++)
	{
		SetPos(0, i);
		wprintf(L"%lc", WALL);
	}
	//右
	for (int i = 1; i <= 25; i++)
	{
		SetPos(56, i);
		wprintf(L"%lc", WALL);
	}
}

6.2.3 初始化蛇身

我们打印蛇身同样使用宏定义的方式来定义蛇身的图案。

蛇最开始长度为 5 节，每节对应链表的一个节点，蛇身的每一个节点都有自己的坐标。

创建 5 个节点，然后将每个节点存放在链表中进行管理。创建完蛇身后，将蛇的每一节打印在屏幕上。

蛇的初始位置从 (24,5) 开始。

再设置当前游戏的状态，蛇移动的速度，默认的方向，初始成绩，每个食物的分数。

游戏状态是：OK
蛇的移动速度：200 毫秒
蛇的默认方向：RIGHT
初始成绩：0
每个食物的分数：10

void InitSnake(pSnake ps)
{
	pSnakeNode cur = NULL;
	for (int i = 0; i < 5; i++)
	{
		//开辟空间
		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
		if (cur == NULL)
		{
			perror("InitSnake()::malloc()");
			return;
		}
		//设置坐标
		cur->next = NULL;
		cur->x = POS_X + 2 * i;
		cur->y = POS_Y;

		//头插法
		if (ps->_pSnake == NULL)
		{
			ps->_pSnake = cur;
		}
		else
		{
			cur->next = ps->_pSnake;
			ps->_pSnake = cur;
		}
	}

	//遍历打印蛇身
	cur = ps->_pSnake;
	while (cur)
	{
		//定位蛇头
		SetPos(cur->x, cur->y);
		wprintf(L"%lc",BODY);
		cur = cur->next;
	}

	//初始化蛇的属性
	ps->_sleep_time = 200;//毫秒
	ps->_food_weight = 10;
	ps->_score = 0;
	ps->_status = OK;
	ps->_dir = RIGHT;
}

6.2.4 创建第一个食物

先随机生成食物的坐标
- x 坐标必须是 2 的倍数
- 食物的坐标得在墙体内部
- 食物的坐标不能和蛇身每个节点的坐标重复
创建食物节点，打印食物

我们食物的宽字符也使用宏的定义的方式。

void CreateFood(pSnake ps)
{
	//先确定范围
	int x = 0;
	int y = 0;
again:
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 25 + 1;
	} while (x % 2 != 0);

	//蛇身和食物不冲突
	pSnakeNode cur = ps->_pSnake;
	while (cur)
	{
		if (cur->x == x && cur->y == y)
		{
			goto again;
		}
		cur = cur->next;
	}

	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));//创建食物结点
	if (pFood == NULL)
	{
		perror("CreateFood::malloc()");
		return;
	}
	else
	{
		pFood->x = x;
		pFood->y = y;
		SetPos(pFood->x, pFood->y);
		wprintf(L"%c", FOOD);
		ps->_pFood = pFood;
	}
}

6.3 游戏运行

游戏运⾏期间，右侧打印帮助信息，提⽰玩家，坐标开始位置(64,15)

根据游戏状态检查游戏是否继续，如果是状态是OK，游戏继续，否则游戏结束。

如果游戏继续，就是检测按键情况，确定蛇下⼀步的⽅向，或者是否加速减速，是否暂停或者退出游戏。

我们检测按键需要使用到一些虚拟按键:

上：VK_UP
下：VK_DOWN
左：VK_LEFT
右：VK_RIGHT
空格：VK_SPACE
ESC：VK_ESCAPE
F3：VK_F3
F4：VK_F4

确定了蛇的⽅向和速度，蛇就可以移动了。

打印帮助信息：

void PrintHelpInfo()
{
	
	SetPos(64, 13);
	wprintf(L"%ls", L"不能撞墙，不能咬到自己\n");
	SetPos(64, 14);
	wprintf(L"%ls", L"用↑.↓.←.→来控制蛇的移动\n");
	SetPos(64, 15);
	wprintf(L"%ls", L"按F3加速，按F4减速\n");
	SetPos(64, 16);
	wprintf(L"%ls", L"按ESC退出游戏，按空格暂停游戏\n");
}

void GameRun(pSnake ps)
{
	//打印帮助信息
	PrintHelpInfo();
	//按键状态
	do
	{
		SetPos(64, 10);
		printf("总得分：%d", ps->_score);
		SetPos(64, 11);
		printf("一个食物的分数：%2d", ps->_food_weight);
		if (KEY_PRESS(VK_UP) && ps->_dir != DOWN)
		{
			ps->_dir = UP;
		}
		else if (KEY_PRESS(VK_DOWN) && ps->_dir != UP)
		{
			ps->_dir = DOWN;
		}
		else if (KEY_PRESS(VK_LEFT) && ps->_dir != RIGHT)
		{
			ps->_dir = LEFT;
		}
		else if (KEY_PRESS(VK_RIGHT) && ps->_dir != LEFT)
		{
			ps->_dir = RIGHT;
		}
		else if (KEY_PRESS(VK_SPACE))
		{
			//暂停
			pause();
		}
		else if (KEY_PRESS(VK_ESCAPE))
		{
			ps->_status = EMD_NORMAL;
			break;
		}
		else if (KEY_PRESS(VK_F3))
		{
			//加速
			if (ps->_sleep_time > 80)
			{
				ps->_sleep_time -= 30;
				ps->_food_weight += 2;
			}
		}
		else if (KEY_PRESS(VK_F4))
		{
			//减速
			if (ps->_food_weight > 2)
			{
				ps->_food_weight -= 2;
				ps->_sleep_time += 30;
			}
		}
		Sleep(ps->_sleep_time);//休息时间
		SnakeMove(ps);//走一步

	} while (ps->_status == OK);
}

这里我们将检测按键状态，封装一个宏：

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

6.3.1 蛇身的移动

我们蛇身的移动本质上就是蛇的头插尾删。

所以先创建下一个节点，根据移动方向和蛇头的坐标，蛇移动到下一个位置的坐标。

确定了下一个位置后，看下一个位置是否是食物（NextIsFood），是食物就做吃食物处理（EatFood），如果不是食物则做前进一步的处理（NoFood）。

蛇身移动后，判断此次移动是否会造成撞墙（KillByWall）或者撞上自己蛇身（KillBySelf），从而影响游戏的状态。

void SnakeMove(pSnake ps)
{
	pSnakeNode pNextNode = (pSnakeNode)malloc(sizeof(SnakeNode));
	if (pNextNode == NULL)
	{
		perror("SnakeMove()::malloc()");
		return;
	}
	switch (ps->_dir)
	{
	case UP:
		pNextNode->x = ps->_pSnake->x;
		pNextNode->y = ps->_pSnake->y - 1;
		break;
	case DOWN:
		pNextNode->x = ps->_pSnake->x;
		pNextNode->y = ps->_pSnake->y + 1;
		break;
	case LEFT:
		pNextNode->x = ps->_pSnake->x - 2;
		pNextNode->y = ps->_pSnake->y;
		break;
	case RIGHT:
		pNextNode->x = ps->_pSnake->x + 2;
		pNextNode->y = ps->_pSnake->y;
		break;
	}

	//如果下一个结点是食物
	if (NextIsFood(pNextNode, ps))
	{
		//吃掉食物
		EatFood(pNextNode, ps);
	}
	else
	{
		NoFood(pNextNode, ps);
	}
	
	//每走一步都需要检测是否撞墙或者是撞到自己
	//撞墙
	KILLBYWALL(ps);

	//撞到自己
	KILLBYSELF(ps);
}

判断是否是食物：

int NextIsFood(pSnakeNode pNextNode, pSnake ps)
{
	if (ps->_pFood->x == pNextNode->x && ps->_pFood->y == pNextNode->y)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

吃掉食物：

void EatFood(pSnakeNode pNextNode, pSnake ps)
{
	//头插法
	pNextNode->next = ps->_pSnake;
	ps->_pSnake = pNextNode;

	//打印蛇身
	pSnakeNode cur = ps->_pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%lc", BODY);
		cur = cur->next;
	}
	ps->_score += ps->_food_weight;
	//释放食物结点
	free(ps->_pFood);
	ps->_pFood = NULL;
	//创建新的食物
	CreateFood(ps);
}

撞墙：

void KILLBYWALL(pSnake ps)
{
	pSnakeNode cur = ps->_pSnake;
	if (cur->x == 0 || cur->x == 56 || cur->y == 0 || cur->y == 26)
	{
		ps->_status = KILL_BY_WALL;
	}
}

撞到自己：

void KILLBYSELF(pSnake ps)
{
	pSnakeNode cur = ps->_pSnake->next;
	while (cur)
	{
		if (cur->x == ps->_pSnake->x && cur->y == ps->_pSnake->y)
		{
			ps->_status = KILL_BY_SELF;
			break;
		}
		cur = cur->next;
	}
}

没有碰到食物：

void NoFood(pSnakeNode pNextNode, pSnake ps)
{
	//头插
	pNextNode->next = ps->_pSnake;
	ps->_pSnake = pNextNode;

	//打印蛇身
	pSnakeNode cur = ps->_pSnake;
	while (cur->next->next)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%lc", BODY);
		cur = cur->next;
	}
	//最后一个结点位置打印空格，并释放结点
	SetPos(cur->next->x, cur->next->y);
	printf("  ");
	free(cur->next);
	cur->next = NULL;

}

易错点：这⾥最容易错误的是，释放最后⼀个结点后，还得将倒数第2个节点的next指针改为NULL，保证蛇尾打印可以正常结束，不会越界访问。

判断蛇头的坐标是否和墙的坐标冲突:

void KILLBYWALL(pSnake ps)
{
	pSnakeNode cur = ps->_pSnake;
	if (cur->x == 0 || cur->x == 56 || cur->y == 0 || cur->y == 26)
	{
		ps->_status = KILL_BY_WALL;
	}
}

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

void KILLBYSELF(pSnake ps)
{
	pSnakeNode cur = ps->_pSnake->next;
	while (cur)
	{
		if (cur->x == ps->_pSnake->x && cur->y == ps->_pSnake->y)
		{
			ps->_status = KILL_BY_SELF;
			break;
		}
		cur = cur->next;
	}
}

6.4 游戏结束

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

void GameEnd(pSnake ps)
{
	SetPos(24, 14);
	switch (ps->_status)
	{
	case KILL_BY_SELF:
		printf("你撞到自己了，游戏结束\n");
		break;
	case KILL_BY_WALL:
		printf("你撞到墙了，游戏结束\n");
		break;
	case EMD_NORMAL:
		printf("你主动结束游戏\n");
		break;
	}

	//释放蛇身链表
	pSnakeNode cur = ps->_pSnake;
	while (cur)
	{
		pSnakeNode del = cur->next;
		free(cur);
		cur = del;
	}
	ps->_pSnake = NULL;
	free(ps->_pFood);
	ps->_pFood = NULL;
}

7. 总结

至此这个贪吃蛇小游戏就结束了，通过这个小游戏，我们可以对之前学过的知识进行一个比较全面的复习，同时我们也真正的应用上了链表，后续我还会出一期使用opencode，实现贪吃蛇小游戏，那个就比较精美了，我们这个使用的是简单的宽字符没够美观，但是基本实现了，小游戏的运行逻辑，如果你们需要完全的代码可以去我的GitHub上找完整代码。