(c语言+数据结构链表)项目：贪吃蛇

BOOL WINAPI GetConsoleCursorInfo (

HANDLE                                      hConsoleOutput,

PCONSOLE_CURSOR_INFO    lpConsoleCursorInfo

);

PCONSOLE_CURSOR_INFO是指向CONSOKE_CURSOR_INFO结构的指针，改活动接受关于主机游戏光标的信息

HANDLE hOutput = GetStdHandle (STD_OUTPUT_HANDLE);

// 获取标准输出的句柄 ( ⽤来标识不同设备的数值 )

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

为什么是取地址符，因为cursor_info是指针

5.6 SetConsoleCursorInfo

BOOL WINAPI SetConsoleCursorInfo (

HANDLE hConsoleOutput,

const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo

);

HANDLE hOutput = GetStdHandle (STD_OUTPUT_HANDLE);

// 影藏光标操作

CONSOLE_CURSOR_INFO CursorInfo;

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

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

SetConsoleCursorInfo (hOutput, &CursorInfo); // 设置控制台光标状态

5.7 SetConsoleCursorPosition

BOOL WINAPI SetConsoleCursorPosition (

HANDLE hConsoleOutput,

COORD pos

);

COORD pos = { 10 , 5 };

HANDLE hOutput = NULL ;

// 获取标准输出的句柄 ( ⽤来标识不同设备的数值 )

hOutput = GetStdHandle (STD_OUTPUT_HANDLE);

// 设置标准输出上光标的位置为 pos

SetConsoleCursorPosition (hOutput, pos);

// 设置光标的坐标

void SetPos ( short x, short y)

{

COORD pos = { x, y };

HANDLE hOutput = NULL ;

// 获取标准输出的句柄 ( ⽤来标识不同设备的数值 )

hOutput = GetStdHandle (STD_OUTPUT_HANDLE);

SetConsoleCursorPosition (hOutput, pos);

}

5.8 GetAsyncKeyState

SHORT GetAsyncKeyState (

int vKey

);

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

6. 贪吃蛇游戏设计与分析

6.1 地图

我们最终的贪吃蛇⼤纲要是这个样⼦，那我们的地图如何布置呢？

控制台窗⼝的⼀些知识，如果想在控制台的窗⼝中指定位置输出信息，我们得知道

该位置的坐标，所以⾸先介绍⼀下控制台窗⼝的坐标知识。

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

在游戏地图上，我们打印墙体使⽤宽字符：□，打印蛇使⽤宽字符●，打印⻝物使⽤宽字符★

普通的字符是占⼀个字节的，这类宽字符是占⽤2个字节。

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

宽字符是怎么使用的？

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

 

6.1.1 <locale.h>本地化

<locale.h>提供的函数⽤于控制C标准库中对于不同的地区会产⽣不⼀样⾏为的部分。

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

• 数字量的格式

• 货币量的格式

• 字符集

• ⽇期和时间的表⽰形式

6.1.2 setlocale函数

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

1. category:

   • 该参数指定要设置的区域设置类别。常用的类别有：
     • LC_ALL: 设置所有类别。
     • LC_COLLATE: 字符串排序。
     • LC_CTYPE: 字符类型和字符分类。
     • LC_MONETARY: 货币格式。
     • LC_NUMERIC: 数字格式。
     • LC_TIME: 日期和时间格式。

2. locale:

   • 这个参数是一个字符串，用于指定新的区域设置。如果传递 NULL，则该函数将返回当前的区域设置。
   • 使用特定格式，比如 "en_US.UTF-8" 表示美国英语，或使用 "zh_CN.UTF-8" 表示简体中文。

当程序运⾏起来后想改变地区，就只能显⽰调⽤setlocale函数。⽤" "作为第2个参数，调⽤setlocale函数就可以切换到本地模式，这种模式下程序会适应本地环境。⽐如：切换到我们的本地模式后就⽀持宽字符（汉字）的输出等。

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

6.1.3 宽字符的打印

# include <stdio.h>

# include <locale.h>

int main () {

setlocale (LC_ALL, "" );

wchar_t ch1 = L' ● ' ;

wchar_t ch4 = L' ★ ' ;

wprintf ( L"%c\n" , ch1);

wprintf ( L"%c\n" , ch4);

return 0 ;

关于地图：

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

如下：

6.2 蛇⾝和⻝物

初始化状态，假设蛇的⻓度是5，蛇⾝的每个节点是●，在固定的⼀个坐标处，⽐如(24, 5)处开始出现 蛇，连续5个节点。注意：蛇的每个节点的x坐标必须是2个倍数，否则可能会出现蛇的⼀个节点有⼀半 ⼉出现在墙体中，另外⼀般在墙外的现象，坐标不好对⻬

关于⻝物，就是在墙体内随机⽣成⼀个坐标（x坐标必须是2的倍数），坐标不能和蛇的⾝体重合，然 后打印★。

6.3 数据结构设计

在游戏运⾏的过程中，蛇每次吃⼀个⻝物，蛇的⾝体就会变⻓⼀节，如果我们使⽤链表存储蛇的信

息，那么蛇的每⼀节其实就是链表的每个节点。每个节点只要记录好蛇⾝节点在地图上的坐标就⾏，

1.蛇节点结构

所以蛇节点结构如下：

typedef struct SnakeNode
2 {
3 int x;
4 int y;
5 struct SnakeNode* next;
6 }SnakeNode, * pSnakeNode;

这个结构体指针的名字叫pSnakeNode

2.Snake的结构来维护整条贪吃蛇

我们再封装⼀个Snake的结构来维护整条贪吃蛇：

typedef struct Snake
{
 pSnakeNode _pSnake;//维护整条蛇的指针
 pSnakeNode _pFood;//维护⻝物的指针
 enum DIRECTION _Dir;//蛇头的⽅向默认是向右
 enum GAME_STATUS _Status;//游戏状态
 int _Socre;//当前获得分数
 int _foodWeight;//默认每个⻝物10分
 int _SleepTime;//每⾛⼀步休眠时间
}Snake, * pSnake;

3.蛇的⽅向

蛇的⽅向，可以⼀⼀列举，使⽤枚举

enum GAME_STATUS
{
	OK=1,
	ESC,
	KILL_BY_WALL,
	KILL_BY_SELF
};

• OK 被赋值为 1。

• ESC 的值会是 OK 的值加 1，即 2。
• KILL_BY_WALL 的值会是 ESC 的值加 1，即 3。
• KILL_BY_SELF 的值会是 KILL_BY_WALL 的值加 1，即 4。

4.游戏状态

游戏状态，可以⼀⼀列举，使⽤枚举

//游戏状态
enum GAME_STATUS
{
 OK,//正常运⾏
 KILL_BY_WALL,//撞墙
 KILL_BY_SELF,//咬到⾃⼰
 END_NOMAL//正常结束
};

枚举的优点：

1. 可读性强：使用有意义的名称，使代码更易理解。
2. 类型安全：限制了可用值的范围，减少错误。
3. 易于维护：新增或修改枚举值时，代码影响较小。

适用场景：

• 使用数组：当需要处理动态数据集合时，例如存储用户输入的数据、处理列表等。
• 使用枚举：当需要表示固定的、有限的状态或选项时，例如定义状态机、错误码等。

枚举法：枚举是一组数据类型，用来表示一组相关的常量，用来表示游戏中的不同状态

7. 核⼼逻辑实现分析

7.1 游戏主逻辑

#include <locale.h>
void test()
{
 int ch = 0;
 srand((unsigned int)time(NULL));
 do
 {
 Snake snake = { 0 };
 GameStart(&snake);
 GameRun(&snake);
 GameEnd(&snake);
 SetPos(20, 15);
 printf("再来⼀局吗？(Y/N):");
 ch = getchar();
 getchar();//清理\n
 } while (ch == 'Y');
 SetPos(0, 27);
}
int main()
{
 //修改当前地区为本地模式，为了⽀持中⽂宽字符的打印
 setlocale(LC_ALL, "");
 //测试逻辑
 test();
 return 0;
}

cCopy Code

#include <stdlib.h> int main() { 
// 程序内容 
system("pause"); 
// 等待用户按任意键 
return 0; }

1. system("cls"):

   • 作用：在 Windows 操作系统上执行 cls 命令，用来清除终端窗口的所有内容。这样，终端窗口中的所有文本将被清空，使得屏幕上只显示清理后的内容。
   • 示例：通常在程序运行时使用来清理输出，使用户界面看起来更整洁。

   cCopy Code
   
   #include <stdlib.h> int main() {
    // 程序内容 
   system("cls");
    // 清除终端窗口内容
    return 0; }

注意事项

• 平台依赖：system("pause") 和 system("cls") 是 Windows 特有的命令。在其他操作系统，如 Linux 或 macOS 上，这些命令将不起作用。相应地，在这些平台上你可能需要使用其他命令（如 clear）或用代码模拟相同功能。

• 安全性：使用 system() 函数可能会引入安全隐患，因为它会调用操作系统的命令解释器。尽管 system() 在简单应用中很常见，但在实际的应用程序中，应尽量避免或小心使用，因为它会受到系统环境的影响，并可能引发安全问题。

• 替代方法：

  • system("pause") 的替代方法：可以通过 getchar() 等方法实现类似的功能，等待用户输入。
  • system("cls") 的替代方法：可以通过使用跨平台的库（如 ncurses）或标准库来实现屏幕清除。

7.2 游戏开始

void GameStart(pSnake ps)
{
 //设置控制台窗⼝的⼤⼩，30⾏，100列
 //mode 为DOS命令
 system("mode con cols=100 lines=30");
 //设置cmd窗⼝名称
 system("title 贪吃蛇"); 
 //获取标准输出的句柄(⽤来标识不同设备的数值)
 HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
 //影藏光标操作
 CONSOLE_CURSOR_INFO CursorInfo;
 GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
 CursorInfo.bVisible = false; //隐藏控制台光标
 SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
 //打印欢迎界⾯
 WelcomeToGame();
 //打印地图
 CreateMap();
 //初始化蛇
 InitSnake(ps);
 //创造第⼀个⻝物
 CreateFood(ps);
}

7.2.1 打印欢迎界⾯

在游戏正式开始之前，做⼀些功能提醒

void WelcomeToGame()
{
 SetPos(40, 15);
 printf("欢迎来到贪吃蛇⼩游戏");
 SetPos(40, 25);//让按任意键继续的出现的位置好看点
 system("pause");
 system("cls");
 SetPos(25, 12);
 printf("⽤ ↑ . ↓ . ← . → 分别控制蛇的移动， F3为加速，F4为减速\n");
 SetPos(25, 13);
 printf("加速将能得到更⾼的分数。\n");
 SetPos(40, 25);//让按任意键继续的出现的位置好看点
 system("pause");
 system("cls");
}

7.2.2 创建地图

创建地图就是将墙打印出来，因为是宽字符打印，所有使⽤wprintf函数，打印格式串前使⽤L

打印地图的关键是要算好坐标，才能在想要的位置打印墙体。

墙体打印的宽字符：

# define WALL L' □ '

创建地图函数CreateMap

void CreateMap()
{
 int i = 0;
 //上(0,0)-(56, 0)
 SetPos(0, 0);
 for (i = 0; i < 58; i += 2)
 {
 wprintf(L"%c", WALL);
 }
 //下(0,26)-(56, 26)
 SetPos(0, 26);
 for (i = 0; i < 58; i += 2)
 {
 wprintf(L"%c", WALL);
 }
 //左
 //x是0，y从1开始增⻓
 for (i = 1; i < 26; i++)
 {
 SetPos(0, i);
 wprintf(L"%c", WALL);
 }
 //x是56，y从1开始增⻓
 for (i = 1; i < 26; i++)
 {
 SetPos(56, i);
 wprintf(L"%c", WALL);
 }
}

• 加了getchar()主要作用是使程序在结束之前暂停，等待用户输入。这在终端应用程序中尤其有用，因为它防止程序运行完毕后立即关闭，让用户有时间查看屏幕上的输出结果。如果没有这个暂停，程序可能会迅速结束，特别是在命令行环境下，这会使你错过重要的调试信息或输出内容。

• 如果不加程序在完成绘制地图后会立即结束。如果你在命令行终端中运行程序，这可能导致你没有时间查看输出结果，因为程序会在瞬间完成执行并关闭。getchar() 让程序在结束之前暂停，给你时间查看输出。

7.2.3 初始化蛇⾝

蛇最开始⻓度为5节，每节对应链表的⼀个节点，蛇⾝的每⼀个节点都有⾃⼰的坐标。

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

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

蛇⾝打印的宽字符：

1 # define BODY L' ● '

初始化蛇⾝函数：InitSnake

void InitSnake(pSnake ps)
//pSnake ps: ps是一个指向贪吃蛇结构体的指针，结构体中包含了蛇的相关信息（如头节点、方向等）。
{
 pSnakeNode cur = NULL;
 int i = 0;
 //创建蛇⾝节点，并初始化坐标
 //头插法
 for (i = 0; i < 5; i++)
 {
 //创建蛇⾝的节点
 cur = (pSnakeNode)malloc(sizeof(SnakeNode));
 if (cur == NULL)
 {
 perror("InitSnake()::malloc()");
 return;
 }
 //设置坐标
 cur->next = NULL;
 cur->x = POS_X + i * 2;
 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"%c", BODY);
cur = cur->next;
}

//初始化贪吃蛇数据
ps->_SleepTime = 200;
ps->_Socre = 0;
ps->_Status = OK;
ps->_Dir = RIGHT;
ps->_foodWeight = 10;
}

7.2.4 创建第⼀个⻝物

• 先随机⽣成⻝物的坐标

◦ x坐标必须是2的倍数

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

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

⻝物打印的宽字符:

# define FOOD L' ★ '

创建⻝物的函数：CreateFood

void CreateFood(pSnake ps)
{
 int x = 0;
 int y = 0;
again:
 //产⽣的x坐标应该是2的倍数，这样才可能和蛇头坐标对⻬。
 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;
 }
}

7.3 游戏运⾏

游戏运⾏期间，右侧打印帮助信息，提⽰玩家

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

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

戏。

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

void GameRun(pSnake ps)
{
 //打印右侧帮助信息
 PrintHelpInfo();
 do
 {
 SetPos(64, 10);
 printf("得分：%d ", ps->_Socre);
 printf("每个⻝物得分：%d分", ps->_foodWeight);
 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 = END_NOMAL;
 break;
 }
 else if (KEY_PRESS(VK_F3))
 {
 if (ps->_SleepTime >= 50)
 {
 ps->_SleepTime -= 30;
 ps->_foodWeight += 2;
 }
 }
 else if (KEY_PRESS(VK_F4))
 {
 if (ps->_SleepTime < 350)
 {
 ps->_SleepTime += 30;
 ps->_foodWeight -= 2;
 if (ps->_SleepTime == 350)
 {
 ps->_foodWeight = 1;
 }
 }
 }
 //蛇每次⼀定之间要休眠的时间，时间短，蛇移动速度就快
 Sleep(ps->_SleepTime);
 SnakeMove(ps);
 } while (ps->_Status == OK);
}

7.3.1 KEY_PRESS

检测按键状态，我们封装了⼀个宏

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

7.3.2 PrintHelpInfo

void PrintHelpInfo()
{
 //打印提⽰信息
 SetPos(64, 15);
 printf("不能穿墙，不能咬到⾃⼰\n");
 SetPos(64, 16);
 printf("⽤↑.↓.←.→分别控制蛇的移动.");
 SetPos(64, 17);
 printf("F1 为加速，F2 为减速\n");
 SetPos(64, 18);
 printf("ESC ：退出游戏.space：暂停游戏.");
}

7.3.3 蛇⾝移动

先创建下⼀个节点，根据移动⽅向和蛇头的坐标，蛇移动到下⼀个位置的坐标。

确定了下⼀个位置后，看下⼀个位置是否是⻝物（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);
}

7.3.3.1 NextIsFood

//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnakeNode psn, pSnake ps)
{
 return (psn->x == ps->_pFood->x) && (psn->y == ps->_pFood->y);
}

7.3.3.2 EatFood

//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
void EatFood(pSnakeNode psn, pSnake ps)
{
 //头插法
 psn->next = ps->_pSnake;
 ps->_pSnake = psn;
 pSnakeNode cur = ps->_pSnake;
 //打印蛇
 while (cur)
 {
 SetPos(cur->x, cur->y);
 wprintf(L"%c", BODY);
 cur = cur->next;
 }
 ps->_Socre += ps->_foodWeight;
 
 //释放⻝物节点
 free(ps->_pFood);
 //创建新的⻝物
 CreateFood(ps);
}

7.3.3.3 NoFood

将下⼀个节点头插⼊蛇的⾝体，并将之前蛇⾝最后⼀个节点打印为空格，放弃掉蛇⾝的最后⼀个节点

 //pSnakeNode psn 是下⼀个节点的地址
 //pSnake ps 维护蛇的指针
 void NoFood(pSnakeNode psn, pSnake ps)
 {
 //头插法
 psn->next = ps->_pSnake;
 ps->_pSnake = psn;
 pSnakeNode cur = ps->_pSnake;
 //打印蛇
 while (cur->next->next)
 {
 SetPos(cur->x, cur->y);
 wprintf(L"%c", BODY);
cur = cur->next;

 }
 //最后⼀个位置打印空格，然后释放节点
 SetPos(cur->next->x, cur->next->y);
 printf(" ");
 free(cur->next);
 cur->next = NULL;
}

7.3.3.4 KillByWall

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

//pSnake ps 维护蛇的指针
int KillByWall(pSnake ps)
{
 if ((ps->_pSnake->x == 0)
 || (ps->_pSnake->x == 56)
 || (ps->_pSnake->y == 0)
 || (ps->_pSnake->y == 26))
 {
 ps->_Status = KILL_BY_WALL;
 return 1;
 }
 return 0;
}

7.3.3.5 KillBySelf

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

//pSnake ps 维护蛇的指针
int KillBySelf(pSnake ps)
{
 pSnakeNode cur = ps->_pSnake->next;
 while (cur)
 {
 if ((ps->_pSnake->x == cur->x)
 && (ps->_pSnake->y == cur->y))
 {
 ps->_Status = KILL_BY_SELF;
 return 1;
 }
 cur = cur->next;
 }
 return 0;
}

7.4 游戏结束

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

void GameEnd(pSnake ps)
{
 pSnakeNode cur = ps->_pSnake;
 SetPos(24, 12);
 switch (ps->_Status)
 {
 case END_NOMAL:
 printf("您主动退出游戏\n");
 break;
 case KILL_BY_SELF:
 printf("您撞上⾃⼰了 ,游戏结束!\n");
 break;

 printf("您撞墙了,游戏结束!\n");
 break;
 }
 //释放蛇⾝的节点
 while (cur)
 {
 pSnakeNode del = cur;
 cur = cur->next;
 free(del);
 }
}

头文件

包含头文件”的一种方式，引入标准库
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <stdbool.h>

类定义

#define WALL L'□'
#define BODY L'●'
#define FOOD L'★'
//蛇默认的起始坐标
#define POS_X 24
#define POS_Y 5

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

函数的定义

enum GAME_STATUS

enum DIRECTION

typedef struct Snake

函数的声明

//定位控制台光标位置
void SetPos(int x, int y);

//游戏开始前的准备 
void GameStart(pSnake ps);

//打印欢迎界面
void WelcomeToGame();

//绘制地图
void CreateMap();

//初始化贪吃蛇
void InitSnake(pSnake ps);

//创建食物
void CreateFood(pSnake ps);

//游戏运行的整个逻辑
void GameRun(pSnake ps);

//打印帮助信息
void PrintHelpInfo();

//蛇移动的函数- 每次走一步
void SnakeMove(pSnake ps);

//判断蛇头的下一步要走的位置处是否是食物
int NextIsFood(pSnake ps, pSnakeNode pNext);

//下一步要走的位置处就是食物，就吃掉食物
void EatFood(pSnake ps, pSnakeNode pNext);

//下一步要走的位置处不是食物，不吃食物
void NotEatFood(pSnake ps, pSnakeNode pNext);

//检测是否撞墙
void KillByWall(pSnake ps);

//检测是否撞自己
void KillBySelf(pSnake ps);

//游戏结束的资源释放
void GameEnd(pSnake ps);