8. 核心逻辑实现分析

8.1 游戏主逻辑

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

主逻辑分为3个过程：

• 游戏开始（GameStart）完成游戏的初始化。

• 游戏运行（GameRun）完成游戏运行逻辑的实现。

• 游戏运行（GameEnd）完成游戏结束的说明、资源的释放。

#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;
}

8.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);
}

8.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");
}

8.2.2 创建地图

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

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

墙体打印的宽字符：

#define WALL L'□'

易错点：就是坐标的运算。

• 上：（0,0）到（56,0）

• 下：（0,26）到（56,26）

• 左：（0,1）到（0,25）

• 右：（56,1）到（56,25）

创建地图函数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);}
}

8.2.3 初始化蛇身

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

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

• 规定蛇的初始位置从（24,5）开始。

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

• 游戏状态时OK

• 蛇的移动速度：200ms

• 蛇的默认方向：RIGHT

• 初始成绩：0

• 每个食物的分数：10

蛇身打印的宽字符：

#define BODY L'●'

初始化蛇身函数：InitSnake

//初始化蛇
void InitSnake(pSnake ps)
{//创建5个蛇身的结点pSnakeNode cur = NULL;int i = 0;//创建蛇身结点，并初始化坐标//头插法for (i = 0; i < 5; i++){//创建蛇身结点cur = (pSnakeNode)malloc(sizeof(SnakeNode));                                                                 //一次循环开始，cur先赋值指向下一块空间if (cur == NULL){perror("InitSnake():malloc()");return;}//设置坐标——从左向右创建cur->x = POS_X + 2 * i;cur->y = POS_Y;cur->next = NULL;//头插法——一开始以右为蛇头，链表从右向左，右边新创建的是头if (ps->pSnake == NULL){ps->pSnake = cur;}else{cur->next = ps->pSnake;//给新头的next赋值——旧头地址赋给新next，让新头指向旧身ps->pSnake = cur;//把新创建的作为蛇头                                                                    //一次循环结束，cur和pSnake指向同一}}//打印蛇身（遍历）cur = ps->pSnake;//继续使用遍历变量while (cur){SetPos(cur->x, cur->y);wprintf(L"%lc", BODY);cur = cur->next;}//初始化贪吃蛇的数据ps->dir = RIGHT;ps->FoodWeight = 10;ps->pFood = NULL;ps->Score = 0;ps->SleepTime = 200;//Windows中Sleep函数的单位是：ms(毫秒)ps->status = OK;
}

8.2.4 创建第一个食物

• 先随机生成食物的坐标。

◦ x坐标必须是2的倍数。

◦ 食物的坐标不能和蛇身每个节点的坐标重复。

• 创建食物节点，打印食物。

食物打印的宽字符：

#define FOOD L'★'

创建食物的函数：CreateFood

//创建食物
void CreateFood(pSnake ps)
{int x = 0;int y = 0;again://x为奇数执行一次以上的循环//产生的x坐标应该是2的倍数，这样才可能和蛇头坐标对齐。do{x = rand() % 53 + 2;                                                                                 //1.随机坐标 //y = rand() % 24 + 1;  y = rand() % 25 + 1;                                 } while (x % 2 != 0);//生成指定范围内的随机数：x（2-54且2的倍数），y（1-25）                             //2./在墙内//坐标和蛇的身体的每个节点的做坐标比较（遍历）pSnakeNode cur = ps->pSnake;    //获取指向蛇头的指针//食物不能和蛇身冲突while (cur){if (x == cur->x && y == cur->y){goto again;}cur = cur->next;}                                                                                                        //3.不在蛇身上//创建食物——类型：蛇身结点类型pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));//创建食物if (pFood == NULL){perror("CreateFood()::malloc()");return;}pFood->x = x;pFood->y = y;ps->pFood = pFood;SetPos(x, y);wprintf(L"%lc", FOOD);}

8.3 游戏运行

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

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

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

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

//游戏运行
void GameRun(pSnake ps)
{//打印帮助信息PrintHelpInfo();do{//当前的分数情况SetPos(62, 10);printf("总分:%5d\n", ps->Score);SetPos(62, 11);printf("食物的分值:%02d\n", ps->FoodWeight);//没有02则由10变8会显示由10变80 //检测按键//上、下、左、右、ESC、空格、F3、F4if (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_ESCAPE)){ps->status = ESC;break;}else if (KEY_PRESS(VK_SPACE)){//游戏要暂定pause();//暂定和回复暂定}else if (KEY_PRESS(VK_F3)){if (ps->SleepTime >= 80){ps->SleepTime -= 30;ps->FoodWeight += 2;}}else if (KEY_PRESS(VK_F4)){if (ps->FoodWeight > 2){ps->SleepTime += 30;ps->FoodWeight -= 2;}}//蛇每次⼀定之间要休眠的时间，时间短，蛇移动速度就快//走一步SnakeMove(ps);//睡眠一下Sleep(ps->SleepTime);} while (ps->status == OK);//正常状态下是死循环，一直执行
}

8.3.1 KEY_PRESS

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

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

8.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);printf("⽐特就业课@版权");
}

8.3.3 蛇身移动SnakeMove（重难点）

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

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

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

//蛇的移动
void SnakeMove(pSnake ps)
{//创建下⼀个节点pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));if (pNext == NULL){perror("SnakeMove()::malloc()");return;}pNext->next = NULL;//根据按键·反馈蛇的下一个结点的坐标//确定下⼀个节点的坐标，下⼀个节点的坐标根据，蛇头的坐标和⽅向确定switch (ps->dir){case UP:pNext->x = ps->pSnake->x;pNext->y = ps->pSnake->y - 1;//——纵减一break;case DOWN:pNext->x = ps->pSnake->x;pNext->y = ps->pSnake->y + 1;break;case LEFT:pNext->x = ps->pSnake->x - 2;//——横减二pNext->y = ps->pSnake->y;break;case RIGHT:pNext->x = ps->pSnake->x + 2;pNext->y = ps->pSnake->y;break;}//如果下一个坐标处是食物if (NextIsFood(ps, pNext)){//是食物就吃掉EatFood(ps, pNext);}else{//不是食物就正常一步NotEatFood(ps, pNext);}//检测撞墙KillByWall(ps);//检测撞到自己KillBySelf(ps);
}

8.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);
}

8.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);
}

8.3.3.3 NoFood

将下一个节点头插入蛇的身体，并将之前蛇身最后一个节点打印为空格，释放掉蛇身的最后一个节点。

易错点：这里最容易错误的是，释放掉最后一个结点之后，还需要将指向在最后一个结点的指针改为NULL，保证蛇尾打印可以正常结束，不会越界访问。

//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
//不是食物就正常进一步（1.头插；2.打印新蛇；3.留白旧尾；4.释放旧尾）
void NotEatFood(pSnake ps, pSnakeNode pNext)
{//头插法pNext->next = ps->pSnake;ps->pSnake = pNext;//打印新蛇，留白蛇尾，释放尾结点——先找到尾结点的前驱结点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;//易错
}

8.3.3.4 KillByWall

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

//pSnake ps 维护蛇的指针
//检测是否撞墙
void 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;}
}//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;
//}

8.3.3.5 KillBySelf

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

1 //pSnake ps 维护蛇的指针
//检测是否撞自己
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;return;}cur = cur->next;}
}//int 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;
//			return 1;
//		}
//		cur = cur->next;
//	}
//  return 0;
//}

这两个函数建议写成返回值void的形式——足以实现预定的功能，通过修改贪吃蛇结构体的状态参数。

写成int返回值类型，没必要接收返回值，而且和其他大部分的函数接口没有保持统一性——其他大部分都是void的返回值类型。

保持接口的一致性有利于对这些函数的使用，不用去记哪些函数应该怎么用，都是一样的用法。

8.4 游戏结束

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

//结束判定
void GameEnd(pSnake ps)	
{SetPos(15, 12);switch (ps->status){case ESC:printf("主动退出游戏，正常退出\n");break;case KILL_BY_WALL:printf("很遗憾，您撞墙了，游戏结束\n");break;case KILL_BY_SELF:printf("很遗憾，您咬到自己了，游戏结束\n");break;}//释放贪吃蛇的链表资源pSnakeNode cur = ps->pSnake;pSnakeNode del = NULL;//释放蛇⾝的节点while (cur){del = cur;cur = cur->next;free(del);}free(ps->pFood);ps = NULL;
}

9. 参考代码

完整代码实现，分3个文件实现

test.c

test.c——贪吃蛇游戏的测试。

#include "Snake.h"
#include <locale.h>//大BUG：搞了一个小时没搞懂
//诱因：输入Y / y程序直接结束？
//因为只有两个“按任意键继续……”，按完两下空格键，但是进入游戏界面还要按一下空格键蛇才能动（而且只有按空格键才行，不像之前两次任意键）
//所以导致需要先清理游戏一开始的空格字符才能重开循环
//getchar();//清理缓冲区的换行符\n
//ch = getchar();
//getchar();//清理缓冲区的换行符\n
//发现两个任意键中其中任何一个使用了空格键，在游戏一开始都需要多按一下空格键（唯一可行键）void test()
{//创建变量，接收用户输入的“进行/退出”选项int ch = 0;            //getchar()的返回值是int类型，但是用char ch来接收也行；但是getchar()接收失败返回的EOF是int类型，故此最好使用int类型的变量来接收返回值//srand((unsigned int)time(NULL));加不加这一句，取决于用户希望每次运行游戏是希望同样的进程（食物出现的位置、顺序都和上一次玩的时候一模一样），还是不同的进程。do{//用贪吃蛇类型，创建贪吃蛇Snake snake = { 0 };GameStart(&snake);//游戏开始前的初始化——需要改变局部变量的值——传址调用//getchar();为了测试前面代码功能的时候，程序执行到这里能够停下来GameRun(&snake);//玩游戏的过程（开始——进行——结束判定）GameEnd(&snake);//善后的工作(资源释放……)SetPos(20, 15);printf("再来一局吗？(Y/N):");ch = getchar();//返回值为int，读取成功没事，读取失败返回EOF（-1），所以最好将ch设置为int类型getchar();//清理缓冲区的换行符\n——如果没有第二个getchar()，如果后续代码再次调用 getchar()，它会直接读到 \n，而不是等待用户新输入。} while (ch == 'Y' || ch == 'y');//SetPos(0, 27);
}int main()
{//修改当前地区为本地模式，为了支持中文宽字符的打印setlocale(LC_ALL, "");//测试逻辑test();//程序退出的提示语，从(0,27)开始打印出来（不加这句代码，退出语的打印会破坏游戏界面）SetPos(0, 27);return 0;
}

snake.h

snake.h——贪吃蛇游戏中类型的声明、函数的声明。

#pragma once#define _CRT_SECURE_NO_WARNINGS 1#include <locale.h>
#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
{OK = 1,                       //正常运行ESC,                          //退出KILL_BY_WALL,                 //撞墙死KILL_BY_SELF                  //撞蛇死
};//方向
enum DIRECTION
{UP = 1,DOWN,LEFT,RIGHT
};//定义·蛇身结点类型
typedef struct SnakeNode
{int x;int y;                        //每个蛇结点在控制台中都有一个地址（坐标），是连续的。struct SnakeNode* next;       //每个蛇结点在内存（堆）中都有一个地址，  不是连续的。
}SnakeNode, * pSnakeNode;
//typedef struct SnakeNode* pSnakeNode;//贪吃蛇——维护整个游戏的状态
typedef struct Snake
{pSnakeNode pSnake;    //维护整条蛇的指针（链表——全结点(利用头结点维护整个链表)）pSnakeNode pFood;     //指向食物的指针——和蛇身节点是同一个类型，因为它是未来的蛇身结点，而且均是依靠（x,y）坐标来维护int Score;            //当前累积的分数int FoodWeight;       //一个食物的分数int SleepTime;        //蛇休眠的时间，休眠的时间越短，蛇的速度越快，休眠的时间越长，蛇的速度越慢enum GAME_STATUS status;//游戏当前的状态（进行 / 暂停 / 结束），暂停可以归类为正常运行enum DIRECTION dir;   //蛇当前走的方向（当前向上就不能立刻向下，当前向左就不能立刻向右）//...
}Snake, * pSnake;        //坏处就是容易造成混乱——pSnake* phead到底是—级指针还是二级指针很混乱//定位控制台的光标位置
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);

snake.c

snake.c——贪吃蛇游戏的相关函数的实现。

//getchar();为了测试前面代码功能的时候，程序执行到这里能够停下来

#include "snake.h"//定位控制台的光标位置
void SetPos(int x, int y)
{//获得设备句柄HANDLE hanlde = GetStdHandle(STD_OUTPUT_HANDLE);//根据句柄设置光标的位置COORD pos = { x, y };SetConsoleCursorPosition(hanlde, pos);
}//打印欢迎信息
void WelcomeToGame()
{//欢迎信息SetPos(38, 10);printf("欢迎来到贪吃蛇小游戏\n");SetPos(40, 20);    //让按任意键继续的出现的位置好看点system("pause");    system("cls");//功能介绍信息SetPos(15, 10);printf("用 ↑ . ↓ . ← . → 来控制蛇的移动，F3是加速，F4是减速");SetPos(15, 11);printf("加速能得到更高的分数");SetPos(38, 20);    //让按任意键继续的出现的位置好看点system("pause");system("cls");
}//打印地图
void CreateMap()
{//定位一次，打印一排坐标int i = 0;//上排墙壁：（0,0）-（56,0）SetPos(0, 0);for (i = 0; i <= 56; i += 2){wprintf(L"%lc", WALL);}//下排墙壁：（0,26）-（56,26）SetPos(0, 26);for (i = 0; i <= 56; i += 2){wprintf(L"%lc", WALL);}//定位一次，打印一个坐标//左排墙壁：x是0，y从1开始增长for (i = 1; i <= 25; i++){SetPos(0, i);wprintf(L"%lc", WALL);}//右排墙壁：x是56，y从1开始增长for (i = 1; i <= 25; i++){SetPos(56, i);wprintf(L"%lc", WALL);}//getchar();为了测试这个功能的时候，程序执行到这里能够停下来
}//初始化蛇
void InitSnake(pSnake ps)
{//创建5个蛇身的结点，并初始化坐标//头插法pSnakeNode cur = NULL;int i = 0;for (i = 0; i < 5; i++){//创建蛇身结点cur = (pSnakeNode)malloc(sizeof(SnakeNode));        //一次循环开始，cur先赋值指向下一块空间if (cur == NULL){perror("InitSnake():malloc()");return;}//设置每个结点的坐标——从左向右创建cur->x = POS_X + 2 * i;cur->y = POS_Y;cur->next = NULL;//头插法——一开始以右为蛇头，链表从右向左，右边新创建的是头if (ps->pSnake == NULL){ps->pSnake = cur;}else{cur->next = ps->pSnake;//给新头的next赋值——旧头地址赋给新next，让新头指向旧身ps->pSnake = cur;//把新创建的作为蛇头          //一次循环结束，cur和pSnake指向同一}}//打印蛇身（遍历）cur = ps->pSnake;//继续使用遍历变量while (cur){SetPos(cur->x, cur->y);wprintf(L"%lc", BODY);cur = cur->next;}//贪吃蛇的其他信息初始化ps->dir = RIGHT;ps->FoodWeight = 10;ps->pFood = NULL;ps->Score = 0;ps->SleepTime = 200;//Windows中Sleep函数的单位是：ms(毫秒)ps->status = OK;//getchar();为了测试这个功能的时候，程序执行到这里能够停下来
}//创建食物
void CreateFood(pSnake ps)
{int x = 0;int y = 0;again://产生的x坐标应该是2的倍数，这样才可能和蛇头坐标对齐。//x为奇数执行一次以上的循环do{//1.随机坐标//2.在墙内——生成指定范围内的随机数x = rand() % 53 + 2;                  //x（2-54且2的倍数） ，则先生成0-52的随机数          //y = rand() % 24 + 1;                //y（1-25），则先生成0-24的随机数  y = rand() % 25 + 1;                 } while (x % 2 != 0);         //坐标和蛇的身体的每个节点的做坐标比较（遍历）pSnakeNode cur = ps->pSnake;while (cur){if (x == cur->x && y == cur->y){goto again;}cur = cur->next;}                                             //3.不在蛇身上//创建食物，直接复用“蛇身结点类型”pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));if (pFood == NULL){perror("CreateFood()::malloc()");return;}pFood->x = x;pFood->y = y;ps->pFood = pFood;    //把食物的地址，给到贪吃蛇结构体内部对应的指针，进行维护SetPos(x, y);wprintf(L"%lc", FOOD);//getchar();为了测试这个功能的时候，程序执行到这里能够停下来
}//游戏初始化
void GameStart(pSnake ps)
{//设置控制台的信息，窗口大小，窗口名system("mode con cols=100 lines=31");    //贪吃蛇游戏框58列、27行system("title 贪吃蛇");//获取标准输出的句柄(用来标识不同设备的数值)HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);//隐藏光标CONSOLE_CURSOR_INFO CursorInfo;GetConsoleCursorInfo(handle, &CursorInfo);    //获取控制台光标信息CursorInfo.bVisible = false;                  //隐藏控制台光标SetConsoleCursorInfo(handle, &CursorInfo);    //设置控制台光标状态//打印欢迎界面WelcomeToGame();//绘制地图CreateMap();//初始化蛇——需要对参数进行操作，所以：1.需要参数；2.传址调用InitSnake(ps);//创建食物——需要对参数进行操作，所以：1.需要参数；2.传址调用CreateFood(ps);
}//打印帮助信息
void PrintHelpInfo()
{SetPos(62, 15);printf("1.不能穿墙，不能咬到自己");SetPos(62, 16);printf("2.用 ↑.↓.←.→ 来控制蛇的移动");SetPos(62, 17);printf("3.F3是加速，F4是减速");SetPos(64, 18);printf("4.ESC ：退出游戏.space：暂停游戏.");SetPos(62, 20);printf("版权@比特就业课");
}//暂停状态
void pause()
{while (1){Sleep(100);if (KEY_PRESS(VK_SPACE)){break;}}
}//判定行进方向的下一个坐标是否是食物
//pSnakeNode pNext 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnake ps, pSnakeNode pNext)
{if (ps->pFood->x == pNext->x && ps->pFood->y == pNext->y)return 1;//下一个坐标处是食物elsereturn 0;
}//是食物就吃掉        （1.头插；2.打印新蛇；3.释放食物；4.创建食物）
//pSnakeNode pNext 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
void EatFood(pSnake ps, pSnakeNode pNext)
{pNext->next = ps->pSnake;//新头的next指向旧头ps->pSnake = pNext;//新头赋值给旧头//打印蛇（遍历）pSnakeNode cur = ps->pSnake;while (cur){SetPos(cur->x, cur->y);wprintf(L"%lc", BODY);cur = cur->next;}ps->Score += ps->FoodWeight;//释放旧的食物——因为“移动下一步”这个函数中创建了“下一格结点”——其坐标恰好与食物结点坐标重合，将其头插入贪吃蛇链表//而在食物创建函数中也创建了一个结点，该结点需要被释放free(ps->pFood);//新建食物CreateFood(ps);
}//不是食物就正常进一步——头插+尾删
//1.头插；2.打印新蛇；3.留白旧尾；4.释放旧尾
//pSnakeNode pNext 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
void NotEatFood(pSnake ps, pSnakeNode pNext)
{//头插法//1.改变新结点的指针域指向//2.改变维护链表的指针的指向pNext->next = ps->pSnake;ps->pSnake = pNext;//打印新蛇，留白蛇尾+释放尾结点——先找到尾结点的前驱结点pSnakeNode cur = ps->pSnake;while (cur->next->next)        //确实是没有打印最后一个结点——即上一步的倒数第2个结点，相当于直接复用了上一步的打印结果{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;        //这一句容易漏写，易错
}//检测是否撞墙
void 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;}
}//检测是否撞自己
//pSnake ps 维护蛇的指针
void KillBySelf(pSnake ps)
{//从第二个节点开始——由于不接收上立刻下、左立刻右的指令，理论上从第3个结点开始也可以pSnakeNode cur = ps->pSnake->next;while (cur){//走完之后，蛇身的某一点和蛇头重合if (cur->x == ps->pSnake->x && cur->y == ps->pSnake->y){ps->status = KILL_BY_SELF;return;}cur = cur->next;}
}//蛇的移动
//pSnake ps 维护蛇的指针
void SnakeMove(pSnake ps)
{//创建下一结点pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));if (pNext == NULL){perror("SnakeMove()::malloc()");return;}pNext->next = NULL;//确定下⼀个节点的坐标，下⼀个节点的坐标根据——蛇头的坐标和方向确定switch (ps->dir){case UP:pNext->x = ps->pSnake->x;pNext->y = ps->pSnake->y - 1;//——纵减一break;case DOWN:pNext->x = ps->pSnake->x;pNext->y = ps->pSnake->y + 1;break;case LEFT:pNext->x = ps->pSnake->x - 2;//——横减二pNext->y = ps->pSnake->y;break;case RIGHT:pNext->x = ps->pSnake->x + 2;pNext->y = ps->pSnake->y;break;}//移动到的下一个结点有4种情况：1.啥也没有；2.食物；3.墙壁；4.蛇身//下一个坐标处是否是食物if (NextIsFood(ps, pNext)){//是食物就吃掉EatFood(ps, pNext);}else{//不是食物就正常一步NotEatFood(ps, pNext);}//走完之后再检测//检测撞墙——只需要改变状态，不需要返回值KillByWall(ps);//检测撞到自己——只需要改变状态，不需要返回值KillBySelf(ps);//走一步函数结束，休眠一下，立刻进行下一次循环的条件判定——贪吃蛇的现态
}//游戏运行
//基本逻辑：1.睡眠一下；2.走一步 或者 1.走一步；2.睡眠一下
//过程中还要：打印帮助信息、检测按键
void GameRun(pSnake ps)
{//打印帮助信息PrintHelpInfo();do{//打印当前的分数情况SetPos(62, 10);printf("总分:%5d\n", ps->Score);SetPos(62, 11);printf("食物的分值:%02d\n", ps->FoodWeight);//没有02则由10变8会显示由10变80 //检测按键//上、下、左、右、ESC、空格、F3、F4if (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_ESCAPE)){ps->status = ESC;break;}else if (KEY_PRESS(VK_SPACE)){//游戏要暂定pause();//暂定和回复暂定}else if (KEY_PRESS(VK_F3)){if (ps->SleepTime >= 80){ps->SleepTime -= 30;ps->FoodWeight += 2;}}else if (KEY_PRESS(VK_F4)){if (ps->FoodWeight > 2){ps->SleepTime += 30;ps->FoodWeight -= 2;}}//走一步SnakeMove(ps);//睡眠一下Sleep(ps->SleepTime);} while (ps->status == OK);//正常状态下是死循环，一直执行
}//结束判定
void GameEnd(pSnake ps)	
{SetPos(15, 12);switch (ps->status){case ESC:printf("主动退出游戏，正常退出\n");break;case KILL_BY_WALL:printf("很遗憾，撞墙了，游戏结束\n");break;case KILL_BY_SELF:printf("很遗憾，咬到自己了，游戏结束\n");break;}//释放贪吃蛇的链表资源pSnakeNode cur = ps->pSnake;pSnakeNode del = NULL;while (cur){del = cur;//释放本结点之前，先保存下一结点；否则找不到cur = cur->next;free(del);}free(ps->pFood);ps = NULL;    //就不用再ps->pSnake=NULL、ps->pFood=NULL
}

参考：汉字字符集编码查询;中文字符集编码:GB2312、BIG5、GBK、GB18030、Unicode