C语言贪吃蛇详解
欢迎来到程序员餐厅
今日主菜：贪吃蛇小游戏，
主厨：邪王真眼
所属专栏： C语言知识点
主厨的主页：Chef‘s blog
前言：
好啦，学了这麽久的C语言也该给他画上一个句号了吧，一个400多行代码的贪吃蛇游戏显然是一个不错的选择，那么一起来学习吧！
1.游戏说明
使⽤C语⾔在Windows环境的控制台中模拟实现经典⼩游戏贪吃蛇实现基本的功能：• 贪吃蛇地图绘制• 蛇吃⻝物的功能 （上、下、左、右⽅向键控制蛇的动作）• 蛇撞墙死亡• 蛇撞⾃⾝死亡• 计算得分• 蛇⾝加速、减速• 暂停游戏
2.游戏效果展示
贪吃蛇
3.技术要点
- C语⾔函数
- 枚举
- 结构体
- 动态内存管理
- 预处理指令
- 链表
- Win32 API
4.Win32 API介绍
本次实现贪吃蛇会使⽤到的⼀些Win32 API知识，那么就学习⼀下
4.1 Win32 API
Windows 这个多作业系统除了协调应⽤程序的执⾏、分配内存、管理资源之外， 它同时也是⼀个很⼤ 的服务中⼼，调⽤这个服务中⼼的各种服务（每⼀种服务就是⼀个函数），可以帮应⽤程序达到开启 视窗、描绘图形、使⽤周边设备等⽬的，由于这些函数服务的对象是应⽤程序(Application)， 所以便 称之为 Application Programming Interface，简称 API 函数。WIN32 API也就是Microsoft Windows 32位平台的应⽤程序编程接⼝。
4.2 控制台程序
平常我们运行起来的黑框程序其实就是控制台程序
我们可以使⽤cmd命令来设置控制台窗⼝的⻓宽：设置控制台窗⼝的⼤小，30行，100列
mode con cols=100 lines=30能在控制台窗⼝执行的命令，也可以调用C语言函数system来执行。例如：
#include
int main()
{
//设置控制台窗⼝的⻓宽：设置控制台窗⼝的⼤⼩，30⾏，100列
system("mode con cols=100 lines=30");
//设置cmd窗⼝名称
system("title 贪吃蛇");
return 0;
} 4.3 控制台屏幕上的坐标COORD
COORD 是Windows API中定义的⼀个结构体，表⽰⼀个字符在控制台屏幕上的坐标
typedef struct _COORD {
SHORT X;
SHORT Y;
} COORD, *PCOORD; 给坐标赋值：
COORD pos = { 10, 15 };4.4 GetStdHandle
GetStdHandle是⼀个Windows API函数。它⽤于从⼀个特定的标准设备（标准输⼊、标准输出或标 准错误）中取得⼀个句柄（⽤来标识不同设备的数值），使⽤这个句柄可以操作设备。
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);4.5 CONSOLE_CURSOR_INFO
这个结构体，包含有关控制台光标的信息
typedef struct _CONSOLE_CURSOR_INFO {
DWORD dwSize;
BOOL bVisible;
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;
- dwSize，由光标填充的字符单元格的百分⽐。 此值介于1到100之间。 光标外观会变化，范围从完 全填充单元格到单元底部的⽔平线条。
- bVisible，游标的可⻅性。 如果光标可见，则此成员为 TRUE，如果光标不可见则为false
4.6 GetConsoleCursorInfo
检索有关指定控制台屏幕缓冲区的光标大小和可见性的信息
BOOL WINAPI SetConsoleCursorInfo(
HANDLE hConsoleOutput,
const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
);4.7 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);//设置控制台光标状态4.8 SetConsoleCursorPosition
设置指定控制台屏幕缓冲区中的光标位置，我们将想要设置的坐标信息放在COORD类型的pos中，调 ⽤SetConsoleCursorPosition函数将光标位置设置到指定的位置。
BOOL WINAPI SetConsoleCursorPosition(
HANDLE hConsoleOutput,
COORD pos
);示例：
COORD pos = { 10, 5};
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//设置标准输出上光标的位置为pos
SetConsoleCursorPosition(hOutput, pos);4.9 SetPos
封装⼀个设置光标位置的函数
//设置光标的坐标
void SetPos(short x, short y)
{
COORD pos = { x, y };
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//设置标准输出上光标的位置为pos
SetConsoleCursorPosition(hOutput, pos);
}4.10 GetAsyncKeyState
获取按键情况，GetAsyncKeyState的函数原型如下：
SHORT GetAsyncKeyState(
int vKey
); 将键盘上每个键的虚拟键值传递给函数，函数通过返回值来分辨按键的状态。GetAsyncKeyState 的返回值是short类型，在上⼀次调⽤ GetAsyncKeyState 函数后，如果
返回的16位的short数据中，最⾼位是1，说明按键的状态是按下，如果最⾼是0，说明按键的状态是抬 起；如果最低位被置为1则说明，该按键被按过，否则为0。
如果我们要判断⼀个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1.
#define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )5.贪吃蛇游戏设计与分析
5.1 地图
我们最终的贪吃蛇⼤纲要如下：
这⾥不得不讲⼀下控制台窗⼝的⼀些知识，如果想在控制台的窗⼝中指定位置输出信息，我们得知道 该位置的坐标，所以⾸先介绍⼀下控制台窗⼝的坐标知识。
控制台窗⼝的坐标如下所⽰，横向的是X轴，从左向右依次增⻓，纵向是Y轴，从上到下依次增⻓。要注意的是y轴的单位长度是x轴的两倍
在游戏地图上，我们打印墙体使⽤宽字符：□，打印蛇使⽤宽字符●，打印⻝物使⽤宽字符★
普通的字符是占⼀个字节的，这类宽字符是占⽤2个字节。
这⾥再简单的讲⼀下C语⾔的国际化特性相关的知识：
C语⾔最初假定字符都是但⾃⼰的。但是这些假定并不是在世界的任何地⽅都适⽤。
后来为了使C语⾔适应国际化，C语⾔的标准中不断加⼊了国际化的⽀持。⽐如：加⼊和宽字符的类型 wchar_t 和宽字符的输⼊和输出函数，加⼊和头⽂件，其中提供了允许程序员针对特定 地区（通常是国家或者说某种特定语⾔的地理区域）调整程序⾏为的函数。
5.1.1 本地化
在标准可以中，依赖地区的部分有以下⼏项：
- 数字量的格式
- 货币量的格式
- 字符集
- ⽇期和时间的表⽰形式
5.1.2 类项
通过修改地区，程序可以改变它的⾏为来适应世界的不同区域。但地区的改变可能会影响库的许多部 分，其中⼀部分可能是我们不希望修改的。所以C语⾔⽀持针对不同的类项进⾏修改
下⾯的⼀个宏，指定⼀个类项：
- LC_COLLATE
- LC_CTYPE
- LC_NUMERIC
- LC_TIME
- LC_ALL - 针对所有类项修改
5.1.3 setlocale函数
char* setlocale (int category, const char* locale); setlocale 函数⽤于修改当前地区，可以针对⼀个类项修改，也可以针对所有类项。
setlocale 的第⼀个参数可以是前⾯说明的类项中的⼀个，那么每次只会影响⼀个类项，如果第⼀个参 数是LC_ALL，就会影响所有的类项。
C标准给第⼆个参数仅定义了2种可能取值："C"和" "。
在任意程序执⾏开始，都会隐藏式执⾏调⽤:
setlocale(LC_ALL, "C"); 当地区设置为"C"时，库函数按正常⽅式执⾏，⼩数点是⼀个点。
当程序运⾏起来后想改变地区，就只能显⽰调⽤setlocale函数。⽤" "作为第2个参数，调用setlocale
函数就可以切换到本地模式，这种模式下程序会适应本地环境。⽐如：切换到我们的本地模式后就支持宽字符（汉字）的输出等
setlocale(LC_ALL, " ");//切换到本地环境5.1.4 宽字符的打印
那如果想在屏幕上打印宽字符，怎么打印呢？
#include
#include
int main() {
setlocale(LC_ALL, "");
wchar_t ch1 = L'●';
wchar_t ch2 = L'人';
printf("%c%c\n", 'a', 'b');
wprintf(L"%c\n", ch1);
wprintf(L"%c\n", ch2);
return 0;
} 效果展示：
从输出的结果来看，我们发现⼀个普通字符占⼀个字符的位置 但是打印⼀个汉字字符，占⽤2个字符的位置，那么我们如果 要在贪吃蛇中使⽤宽字符，就得处理好地图上坐标的计算。
5.1.5 地图坐标
我们假设实现⼀个棋盘27⾏，58列的棋盘（⾏和列可以根据⾃⼰的情况修改），再围绕地图画出墙， 效果展示：
5.2 蛇⾝和⻝物
初始化状态，假设蛇的⻓度是5，蛇⾝的每个节点是●，在固定的⼀个坐标处，⽐如(24, 5)处开始出现 蛇，连续5个节点。注意：蛇的每个节点的x坐标必须是2个倍数，否则可能会出现蛇的⼀个节点有⼀半出现在墙体中，另外⼀般在墙外的现象，坐标不好对⻬。
关于⻝物，就是在墙体内随机⽣成⼀个坐标（x坐标必须是2的倍数），坐标不能和蛇的⾝体重合，然后打印★。
效果展示：
5.3 数据结构设计
在游戏运⾏的过程中，蛇每次吃⼀个⻝物，蛇的⾝体就会变⻓⼀节，如果我们使⽤链表存储蛇的信 息，那么蛇的每⼀节其实就是链表的每个节点。每个节点只要记录好蛇⾝节点在地图上的坐标就⾏，
所以蛇节点结构如下：
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 _Socre;//当前获得分数
int _foodWeight;//默认每个⻝物10分
int _SleepTime;//每⾛⼀步休眠时间
}Snake, * pSnake; 蛇的⽅向和游戏状态，可以⼀⼀列举，使⽤枚举
//⽅向
enum DIRECTION
{
UP = 1,
DOWN,
LEFT,
RIGHT
};
//游戏状态
enum GAME_STATUS
{
OK,//正常运⾏
KILL_BY_WALL,//撞墙
KILL_BY_SELF,//咬到⾃⼰
END_NOMAL//正常结束
};5.4 游戏流程设计
6. 核⼼逻辑实现分析
6.1 游戏主逻辑
#include"snack.h"
void test(void)
{
char x = 'Y';
do
{
Snack snack = { 0 };
GameStart(&snack); //游戏开始前的初始化
GameRun(&snack);//游戏游玩过程
GameEnd(&snack);//游戏结束的善后
SetPos(20, 15);
printf("再来一局吗？（Y/N）:");
x=getchar();
getchar();
} while (x == 'Y' || x == 'y');
}
int main()
{
//配置本地环境
setlocale(LC_ALL, "");
test();
SetPos(0, 26);
return 0;
} 6.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);
}6.2.1 打印欢迎界⾯
在游戏正式开始之前，做⼀些功能提醒
void WelcomeToGame()
{
SetPos(40, 15);
printf("欢迎来到贪吃蛇⼩游戏");
让按任意键继续的出现的位置好看点
system("pause");
system("cls");
SetPos(25, 12);
printf("⽤ ↑ . ↓ . ← . → 分别控制蛇的移动， F3为加速，F4为减速\n");
SetPos(25, 13);
printf("加速将能得到更⾼的分数。\n");
SetPos(40, 25);//让按任意键继续的出现的位置好看点
system("pause");
system("cls");
}
6.2.2 创建地图
创建地图就是将墙打印出来，因为是宽字符打印，所有使⽤wprintf函数，打印格式串前使⽤L
打印地图的关键是要算好坐标，才能在想要的位置打印墙体。
墙体打印的宽字符：
#define WALL L'□'（1）创建地图函数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);
}
}（2）效果展示：
6.2.3 初始化蛇身
（1）要求
蛇最开始⻓度为5节，每节对应链表的⼀个节点，蛇⾝的每⼀个节点都有⾃⼰的坐标。
创建5个节点，然后将每个节点存放在链表中进⾏管理。创建完蛇⾝后，将蛇的每⼀节打印在屏幕上。
再设置当前游戏的状态，蛇移动的速度，默认的⽅向，初始成绩，蛇的状态，每个⻝物的分数。
（2）蛇⾝打印的宽字符：
#define BODY L'●'（3）初始化蛇⾝函数：InitSnake
void InitSnake(pSnake 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;
}
6.2.4 创建第⼀个⻝物
（1）要求
- 先随机⽣成⻝物的坐标
- x坐标必须是2的倍数
- ⻝物的坐标不能和蛇⾝每个节点的坐标重复
- 创建⻝物节点，打印⻝物
（2）⻝物打印的宽字符:
#define FOOD L'★'（3）创建⻝物的函数：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;
}
}
6.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);
}6.3.1 KEY_PRESS
检测按键状态，我们封装了⼀个宏
#define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1) ? 1 : 0)6.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：暂停游戏.");
SetPos(64, 20);
}6.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);
}6.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);
}6.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);
}6.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;
}6.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;
}效果展示：
6.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;
}效果展示：
6.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;
case KILL_BY_WALL:
printf("您撞墙了,游戏结束!\n");
break;
}
//释放蛇⾝的节点
while (cur)
{
pSnakeNode del = cur;
cur = cur->next;
free(del);
}
}7. 参考代码
完整代码实现，分3个⽂件实现
snack.c
#include"snack.h"
void SetPos(int x, int y)
{//获得设备句柄
COORD pos = { x, y };
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//设置标准输出上光标的位置为pos
SetConsoleCursorPosition(hOutput, pos);
}
void GameStart(pSnack snack)
{
//设置控制台信息，窗口大小，窗口名
system("mode con cols=100 lines=30");
system("title 贪吃蛇");
HANDLE handle= GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO cursorInfo;
GetConsoleCursorInfo(handle, &cursorInfo);
cursorInfo.bVisible = false;
SetConsoleCursorInfo(handle, &cursorInfo);
//打印欢迎界面
WelcomeTogame();
//绘制地图
CreatMap();
//初始化蛇
InitSnack(snack);
//创建食物
CreatFood(snack);
}
void WelcomeTogame(void)
{
//打印的是欢迎信息
SetPos(35, 10);
printf("欢迎来到贪吃蛇小游戏\n");
SetPos(38, 20);
system("pause");
system("cls");
//打印的是功能介绍信息
SetPos(15, 10);
printf("用 ↑ ↓ ← → 来表示蛇的移动方向，F3是加速，F4是减速\n");
SetPos(15, 11);
printf("加速可以获得更高的分数");
SetPos(38, 20);
system("pause");
system("cls");
}
void CreatMap(void)
{
//上
SetPos(0, 0);
int i = 0;
for(i;i<=56;i+=2)
wprintf(L"%lc", WALL);
//下
SetPos(0, 26);
for (i=0; i <= 56; i += 2)
wprintf(L"%lc", WALL);
//左
for (i = 0; i <= 25; i++)
{
SetPos(0, i);
wprintf(L"%lc", WALL);
}
//右
for (i = 0; i <= 25; i++)
{
SetPos(56,i);
wprintf(L"%lc",WALL);
}
}
void InitSnack(pSnack ps)
{
pSnackNode cur;
int i = 0;
for (int i = 0; i < 5; i++)
{
cur=(pSnackNode)malloc(sizeof(SnackNode));
if (!cur)
{
perror("malloc fail : ");
return;
}
cur->x = POS_X + i * 2;
cur->y = POS_Y;
cur->next = NULL;
//头插法
if (ps->pSnack == NULL)
ps->pSnack = cur;
else
{
cur->next = ps->pSnack;
ps->pSnack = cur;
}
}
//打印蛇身
cur = ps->pSnack;
while (cur)
{
SetPos(cur->x, cur->y);
wprintf(L"%lc", BODY);
cur = cur->next;
}
//贪吃蛇其他信息初始化
ps->dir = RIGHT;
ps->pFood = NULL;
ps->Socre = 0;
ps->FoodWeight = 10;
ps->SleepTime = 200;
ps->status = OK;
}
void CreatFood(pSnack ps)
{
srand((unsigned int)time(NULL));
int x = 0, y = 0;
again:
do
{
x = rand() % 53 + 2;
y = rand() % 24 + 1;
} while (x % 2);
//食物坐标与蛇的身体每个节点坐标比较
pSnackNode cur = ps->pSnack;
while (cur)
{
if (cur->x == x && cur->y == y)
goto again;
cur = cur->next;
}
pSnackNode food = (pSnackNode)malloc(sizeof(SnackNode));
if (!food)
{
perror("malloc fail : ");
return;
}
food->next = NULL;
food->x = x;
food->y = y;
ps->pFood = food;
SetPos(x, y);
wprintf(L"%lc", FOOD);
}
void GameRun(pSnack ps)
{
//打印帮助信息
PrintHelpInfo();
do
//打印得分
{
SetPos(60, 10);
printf("总分:%5d", ps->Socre);
SetPos(60, 12);
printf("食物的分值%2d", ps->FoodWeight);
//检测按键
//上下左右，空格，ESC，F3，F4
if (KEY_PESS(VK_UP) && ps->dir != DOWN)
ps->dir = UP;
else if (KEY_PESS(VK_DOWN) && ps->dir != UP)
ps->dir = DOWN;
else if (KEY_PESS(VK_LEFT) && ps->dir != RIGHT)
ps->dir = LEFT;
else if (KEY_PESS(VK_RIGHT) && ps->dir != LEFT)
ps->dir = RIGHT;
else if (KEY_PESS(VK_ESCAPE))
{
ps->status = ESC;
break;
}
else if (KEY_PESS(VK_SPACE))
pause();
else if (KEY_PESS(VK_F3))
{
if (ps->SleepTime >= 80)
{
ps->SleepTime -= 30;
ps->FoodWeight += 2;
}
}
else if (KEY_PESS(VK_F4))
{
if (ps->FoodWeight>2 )
{
ps->SleepTime += 30;
ps->FoodWeight -= 2;
}
}
//睡眠一下
Sleep(ps->SleepTime);
//走下一步
SnackMove(ps);
//是否撞墙
if (IsKillWall(ps))
ps->status = KILL_BY_WALL;
//是否咬到自己
if (IsKillSelf(ps))
ps->status = KILL_BY_SELF;
} while (ps->status==OK);
}
void PrintHelpInfo(void)
{
SetPos(60, 15);
printf("1.不能穿墙 不能咬到自己\n");
SetPos(60, 17);
printf("2.用 ↑ ↓ ← → 来表示蛇的移动方向\n");
SetPos(60, 19);
printf("3.按F3是加速，按F4是减速\n");
}
void pause(void)
{
while (1)
{
if (KEY_PESS(VK_SPACE))
break;
Sleep(100);
}
}
void SnackMove(pSnack ps)
{
pSnackNode p=(pSnackNode)malloc(sizeof(SnackNode));
if (p == NULL)
{
perror("malloc fail : ");
return;
}
p->next = NULL;
switch (ps->dir)
{
case UP:
p->x = ps->pSnack->x;
p->y = ps->pSnack->y-1;
break;
case DOWN:
p->x = ps->pSnack->x;
p->y = ps->pSnack->y + 1;
break;
case LEFT:
p->x = ps->pSnack->x-2;
p->y = ps->pSnack->y;
break;
case RIGHT:
p->x = ps->pSnack->x+2;
p->y = ps->pSnack->y;
break;
}
//下一个坐标是食物吗
if (NextIsFood(ps, p))
{
//吃掉食物
EatFood(ps,p);
}
//不吃食物
else
{
NotEatFood(ps, p);
}
}
bool NextIsFood(pSnack ps, pSnackNode p)
{
return ps->pFood->x == p->x&&p->y==ps->pFood->y;
}
void EatFood(pSnack ps,pSnackNode p)
{
p->next = ps->pSnack;
ps->pSnack = p;
//打印蛇身
pSnackNode cur = ps->pSnack;
while (cur)
{
SetPos(cur->x, cur->y);
wprintf(L"%lc", BODY);
cur = cur->next;
}
ps->Socre += ps->FoodWeight;
free(ps->pFood);
CreatFood(ps);
}
void NotEatFood(pSnack ps, pSnackNode p)
{
p->next = ps->pSnack;
ps->pSnack = p;
//寻找尾节点同时打印蛇身
while (p->next->next)//不对劲
{
SetPos(p->x, p->y);
wprintf(L"%lc",BODY);
p = p->next;
}
SetPos(p->x, p->y);
wprintf(L"%lc", BODY);
//把尾节点的位置打印为空白字符
SetPos(p->next->x, p->next->y);
printf(" ");
//释放尾节点
free(p->next);
p->next = NULL;
}
bool IsKillWall(pSnack ps)
{
if (ps->pSnack->x ==0 || ps->pSnack->x==56 || ps->pSnack->y ==0 || ps->pSnack->y==26)
return true;
return false;
}
bool IsKillSelf(pSnack ps)
{
pSnackNode cur = ps->pSnack->next;
while (cur)
{
if (ps->pSnack->x == cur->x && cur->y == ps->pSnack->y)
return true;
cur = cur->next;
}
return false;
}
void GameEnd(pSnack ps)//游戏结束的善后
{
SetPos(15, 12);
switch (ps->status)
{
case ESC:
printf("主动退出游戏退出成功\n");
break;
case KILL_BY_SELF:
printf("很遗憾，你咬到自己了,游戏结束\n");
break;
case KILL_BY_WALL:
printf("很遗憾，你撞墙了，游戏结束\n");
break;
}
//释放开辟的空间
pSnackNode cur = ps->pSnack;
while (cur)
{
pSnackNode new = cur;
cur = cur->next;
free(new);
}
free(ps->pFood);
ps->pFood = NULL;
ps = NULL;
}snack.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include
#include
#define WALL L'□'
#define BODY L'●'
#define FOOD L'★'
#define POS_X 24
#define POS_Y 5
#define KEY_PESS(VK) (GetAsyncKeyState(VK)&1)
//贪吃蛇蛇身节点的定义
typedef struct SnackNode
{
int x, y;
struct SnackNode* next;
}SnackNode,*pSnackNode;
//游戏状态
enum GAME_STATUS
{
OK=1,
ESC,
KILL_BY_WALL,
KILL_BY_SELF
};
enum DIRECTION
{
UP,
DOWN,
LEFT,
RIGHT
};
//贪吃蛇信息
typedef struct Snack
{
pSnackNode pSnack;//维护整条蛇
pSnackNode pFood;//指向食物的指针
int Socre;//当前分数
int FoodWeight;//单个食物分数
int SleepTime;//蛇的速度
enum GAME_STATUS status;//当前游戏状态
enum DIRECTION dir;//蛇运动方向
}Snack,*pSnack;
void SetPos(int x, int y);
void GameStart(pSnack snack);
void WelcomeTogame(void);
void CreatMap(void);
void pause(void);
void InitSnack(pSnack ps);
void CreatFood(pSnack ps);
void GameRun(pSnack ps);
void PrintHelpInfo(void);
void SnackMove(pSnack ps);
bool NextIsFood(pSnack ps, pSnackNode p);
void EatFood(pSnack ps, pSnackNode p);
void NotEatFood(pSnack ps, pSnackNode p);
bool IsKillWall(pSnack ps);
bool IsKillSelf(pSnack ps);
void GameEnd(pSnack ps);//游戏结束的善后 game.c
#include"snack.h"
void test(void)
{
int x = 0;
do
{
Snack snack = { 0 };
GameStart(&snack); //游戏开始前的初始化
GameRun(&snack);//游戏游玩过程
GameEnd(&snack);//游戏结束的善后
SetPos(20, 15);
printf("再来一局吗？（Y/N）:");
x = getchar();
getchar();
} while (x == 'Y' || x == 'y');
}
int main()
{
//配置本地环境
setlocale(LC_ALL, "");
test();
SetPos(0, 26);
return 0;
}好了，朋友，恭喜你看完了这~么长的博客，现在试试把它自己写写吧，我们数据结构再见！
C语言，完结撒花！