C语言数据结构（7）贪吃蛇项目2.贪吃蛇项目实现

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. 扩展

---

完