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、F4
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_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;//下一个坐标处是食物
else
return 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、F4
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_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
10. 扩展
完