C语言：贪吃蛇游戏

这个项目需要用到Win32 API函数的知识，如果不了解的请看：Win32 API 和 类项-CSDN博客

一、游戏主逻辑

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

主逻辑分为3个过程：

• 游戏开始 GameStart，完成游戏的初始化
• 游戏运行 GameRun，实现游戏的运行
• 游戏结束 GameEnd，完成游戏结束的说明，并释放资源

创建三个文件：         test.c - 游戏的测试   

          snake.c - 游戏的实现            snake.h - 游戏函数的声明，类型的声明

贪吃蛇游戏图片展示：

二、创建蛇身和蛇的信息

使用链表来维护蛇的身体

typedef struct SnakeNode
{
    //坐标
    int x;
    int y;
    //指向下一个节点的指针
    struct SnakeNode* next
}SnakeNode,* pSnakeNode;

创建贪吃蛇信息（蛇头、食物、蛇的方向、状态等）结构体

//蛇的方向
enum DIRECTION
{
    UP = 1,
    DOWN,
    LEFT,
    RIGHT
};
//蛇的状态
enum GAME_STATUS
{
    OK,//正常
    KILL_BY_WALL,//撞墙
    KILL_BY_SELF,//撞到自己
    END_NORMAL//正常退出
};

typedef struct Snake
{
    pSnakeNode pSnake;//指向蛇头的指针
    pSnakeNode pFood;//指向食物节点的指针
    enum DIRECTION dir;//蛇的方向
    enum GAME_STATUS status;//蛇的状态
    int food_weight;//一个食物的分数
    int score;//总成绩
    int sleep_time;//休息时间，时间越短，速度越快，时间越长，速度越慢
}Snake,* pSnake;

三、游戏开始（GameStart）

在初始化游戏部分，首先设置控制台窗口大小（100列，32行），设置控制台名称；然后使用Win32 API函数中，GetStdHandle函数获取标准输出设备的句柄，进行光标的隐藏操作：通过CONSOLE_CURSOR_INFO创建光标信息结构体，使用GetConsoleCursorInfo函数获取控制台光标信息，将光标的bVsibile改为false，表示要将光标隐藏掉，最后通过SetConsoleCuesorInfo函数完成控制台光标的隐藏

接着打印游戏的界面和游戏功能介绍，然后绘制地图，即创建一个32行，100列的坐标图：在这个坐标图上我们需要四面墙，用“□”这个宽字符表示

完成上面这些后，开始创建蛇，初始时，蛇身默认有5个节点，用“●”表示蛇身的一个节点

最后创建一个食物，用“★”表示

整体代码：

//游戏初始化
void GameStart(pSnake ps)
{
    //0.先设置窗口的大小，再光标隐藏
    system("mode con cols=100 lines=32");
    system("title 贪吃蛇");
    HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    //隐藏光标操作
    CONSOLE_CURSOR_INFO CursorInfo;
    GetConsoleCursorInfo(houtput,&CursorInfo);//获取控制台的光标信息
    CursorInfo.bVsibile = false;//隐藏控制台光标
    SetConsoleCuesorInfo(houtput,&CursorInfo);//设置控制台光标状态

    //1.打印环境界面和功能介绍
	WelcomeToGame();
    //2.绘制地图
    CreateMap();
    //3.创建蛇
    InitSnake(ps);
    //4.创建食物
    CreateFood(ps);
}

WelcomeToGame打印游戏界面和功能介绍

SetPos定位光标位置函数

在完成打印游戏界面等的部分我们需要在指定位置，即定位光标的位置，进行操作

首先就是先获取标准输出设备的句柄，然后使用COORD结构体创建坐标，最后用SetConsloeCursorPosition函数完成光标定位

void Setpos(int x,int y)
{
    //获得标准输出设备的句柄
	HANDLE houtput = NULL;
	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    //定位光标的位置
    COORD pos = {x,y};
    SetConsoleCursorPositino(houtput,pos);
}

//1.打印环境界面和功能介绍
void WelcomeToGame()
{
    SetPos(38,13);
    wprintf(L"欢迎来到贪吃蛇游戏\n");
    SetPos(39,18);
    system("pause");
    system("cls");//清理屏幕，准备打印下一个界面
    SetPos(25,13);
    wprintf(L"用 ↑、↓、←、→ 来控制蛇的移动，按F3加速，按F4减速\n");
    SetPos(35,15);
    wprintf(L"**加速能够得到更高的分数**\n");

    SetPos(39, 18);
	system("pause");
	system("cls");
}

CreateMap绘制地图

接着绘制地图，我们在一开始说要打印32行，100列的坐标图，设置游戏界面占26行，58列

(但实际上由于我们要打印的时宽字符，则横坐标要占两个坐标表示一个横坐标x，即29列)，要在游戏界面的四周打印墙体

定义一个宏WALL表示墙“□”

#define  WALL   L"□"

void CreateMap()
{
    int i = 0;
    //上
    for(i = 0;i < 29; i++)
    {
        wprintf(L"%lc",WALL);
    }
    //下
    SetPod(0,26);
    for(i = 0;i < 29; i++)
    {
        wprintf(L"%lc",WALL);
    }
    //左
    for(i = 1;i <= 25; i++)
    {
        SetPos(0,i);
        wprintf(L"%lc",WALL);
    }
    //右
    for(i = 1;i <= 25; i++)
    {
        SetPos(56,i);    
        wprintf(L"%lc",WALL);
    }
}

InitSnake初始化蛇

然后我们创建蛇，即初始化蛇身，首先先创建5个节点，然后一个个头插到蛇的头节点指针前，让这一个个节点变成蛇身的一部分，然后将蛇打印在屏幕上，蛇的初始位置从 (24,5) 开始

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

蛇出现的初始位置:

#define POS_X 24
#define POS_Y 5

蛇身打印的宽字符:

#define BODY L'●'

void InitSnake(pSnake ps)
{
    //创建蛇身
    int i = 0;
    pSnakeNode cur = NULL;
    for(i = 0;i < 5; i++)
    {
        cur = (pSnakeNode)malloc(sizeof(SnakeNode));
        if(cur == NULL)
        {
            perror("InitSnake-mall");
            return;
        }
        cur->x = POS_X + 2*i;
        cur->y = POS_Y;
        cur->next = NULL;

        //头插法插入链表
        if(ps->pSanke == NULL)//空链表
        {
            ps->pSnake = cur;
        }
        else
        {
            //非空
            cur->next = ps->pSnake;
            ps->pSnake = cur;
        }
    }
    //打印蛇身
    cur = ps->Snake;
    while(cur)
    {
        SetPos(cur->x,cur->y);
        wprintf(L"%lc",BODY);
        cur = cur->next;
    }
    //设置贪吃蛇的属性
    ps->dir = RIGHHT;//默认向右
    ps->score = 0;
    ps->food_weight = 10;
    ps->sleep_time = 200;//单位是毫秒
    ps->stataus = OK;
}

CreateFood创建食物

最后创建一个食物，先随机生成食物的坐标：使用rand函数，在使用之前要使用一个srand函数来设置随机数的生成器,srand函数需要一个头文件 #include <stdlib.h>，这个部分在之前的猜数字游戏中有详细的讲解，这里不再进行赘述

食物节点可随机出现的位置的坐标：x->2~54    y->1~25

而 rand() % N 生成 0 到 N - 1 的随机整数，那么要生成x坐标的范围在2~54内，则rand()%53 +2

要使y坐标的范围在1~25内，则rand()%25 +1

在生成随即坐标之前，还需对横坐标进行判断，确保2~54之间的随机数都是偶数，因为x横坐标必须是偶数（宽字符占两个字符的位置）

判断符合以上条件后，还需要再判断此坐标是否还与蛇身的坐标冲突，如果冲突，则重新生成一个随即坐标，直至全部条件都符合，才成功创建了一个食物坐标

食物打印的宽字符:

#define FOOD L'★'

void CreateFood(pSnake ps)
{
    int x;
    int y;

again:
    do
    {
        x = rand() % 53 + 2;
        y = ranf() % 25 + 1;

    }while(x % 2 != 0)//表示如果x是奇数继续循环，如果是偶数结束循环
    
    //x和y的坐标不能和蛇的身体坐标冲突
    pSnakeNode cur = ps->pSnake;
    while(cur)
    {
        if(x == cur->x && y == cur->y)
        {
            goto:again;
        }
        cur = cur->next;
    }
    
    //创建食物节点
    pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
    if (pFood == NULL)
	{
		perror("CreateFood-malloc");
		return;
	}
    pFood->x = x;
	pFood->y = y;
	pFood->next = NULL;

    SetPos(x, y);//确定位置
	wprintf(L"%lc", FOOD);

	ps->pFood = pFood;
}

四、游戏运行（GameRun）

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

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

 如果游戏继续，就是检测按键情况(使用GetAsynKeyState函数)，确定蛇下⼀步的方向，或者是否加速减速，是否暂停或者退出游戏。

需要的虚拟按键：

• 上： VK_UP
• 下： VK_DOWN
• 左： VK_LEFT
• 右： VK_RIGHT
• 空格： VK_SPACE
• ESC： VK_ESCAPE  
• F3： VK_F3
• F4： VK_F4 

整体代码：

void PrintHelpInfo()
{
    SetPos(64,14);
    wprintf(L"%ls",L"*不能穿墙，不能咬到自己");
    SetPos(64,15);
    wprintf(L"%ls",L"*用 ↑、↓、←、→ 来控制蛇的移动");
    SetPos(64, 16);
	wprintf(L"%ls", L"*按F3加速，按F4减速");
	SetPos(64, 17);
	wprintf(L"%ls", L"*按ESC退出游戏，按空格暂停游戏");
}

#define KEY_PRESS(VK) ((GetAsynKeyState(VK) & 1) ? 1 : 0);

void GameRun(pSnake ps)
{
    //打印帮助信息
    PrintHelpInfo();
    do
    {
        //打印总分数和食物的分值
        SetPos(64,10);
        printf("总分数:%d\n",ps->score);
        SetPos(64,11);
        printf("当前食物的分数:%2d\n",ps->food_weight);// %2d 占用2个字符的宽度
        
        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->stataus = END_NORMAL;
        }
        else if(KEY_PRESS(VK_F3))
        {
            //加速
            if(ps->sleep_time > 80)
            {
                ps->sleep_time -= 30;
                ps->food_weight += 2;
            }
        }
        else if(KEY_PRESS(VK_F4))
        {
            //减速
            if(ps->sleep_time > 2)
            {
                ps->sleep_time += 30;
                ps->food_weight -= 2;
            }
        }

        SnakeMove(ps);//蛇走一步的过程
        Sleep(ps->sleep_time);//更新等待时间，加速/减速
        
    }while(ps->stataus == OK);
}

Pause暂停游戏

在主循环内检测到按了空格键，进入到Pause函数while(1)循环内，当在while循环内再次检测到按了空格键，就进入if循环，break跳出

主循环运行中
↓
检测到空格键 → 调用 Pause()
    ↓
    while(1) 暂停循环开始
    │
    ├→ 等待200ms
    │
    ├→ 检查空格键？否 → 继续循环
    │
    └→ [用户按下空格] → 检查空格键？是 → 执行 break
        ↓
跳出 while(1) 循环
↓
Pause() 函数结束
↓
返回到主循环，继续执行后续代码

void Pause()
{
    while(1)
    {
        Sleep(200);
        if(KEY_PRESS(VK_SPACE))
        {
            break;
        }
    }
}

SnakeMove蛇走一步的过程

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

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

NextIsFood判断下一个坐标处是否是食物

int NextIsFood(pSnakeNode pn,pSnake ps)
{
    return (ps->pFood->x == pn->x && ps->pFood->y == pn->y);
}

EatFood下一个位置是食物，就吃掉食物

如果下一个位置食物，就吃掉，即将食物节点变成蛇身的一部分（头插到蛇身节点上，使食物节点变成新的蛇头节点），而我们知道此时的下一个节点与食物节点是相同的，因此，我们只需要进行食物头插后，将下一个节点释放掉就可以，然后将新的蛇身及位置打印出来，不要忘记每吃一个食物要加上总分数，最后创建一个新的食物

void EatFood(pSnakeNode pn,pSnake ps)
{
    //头插法
    ps->pFood->next = ps->pSnake;
    ps->pSnake = ps->pFood;

    //释放下一个位置的节点
    free(pn);
    pn = NULL;
    //打印
    pSnakeNode cur = ps->pSnake;
    while(cur)
    {
        SetPos(cur->x,cur->y);
        wprintf(L"%lc",BODY);
        cur = cur->next;
    }
    ps->score += ps->food_weight;

    //重新创建食物
    CreateFood(ps);
}

NoFood下一个位置不是食物

如果下一个位置并不是食物，那么先使用头插法将下一个节点插入到蛇身节点中，变成新的头节点，要注意，由于并不是食物，因此需要头插完之后仍然将蛇身保持在5个节点，即初始时的节点个数：将蛇身的最后一个节点释放掉，在释放掉之前，还需要将宽字符置为2个空格。

而在进行释放操作之前，先打印出新的蛇身，只需打印原来蛇身的前4个节点（最后一个节点需进行释放）,即新的蛇身的前5个节点，最后把倒数第二个节点的next指针置为NULL，它变成新的尾节点

void NoFood(pSnakeNode pn,pSnake ps)
{
    //头插法
    pn->next = ps->pSnake;
    ps->pSnake = pn;
    
    //打印
    pSnakeNode cur = ps->pSnake;
    while(cur->next->next != NULL)//只打印到蛇身的前5个节点
    {
        SetPos(cur->x,cur->y);
        wprintf(L"%lc",BODY);
        cur = cur->next
    }
    
    //蛇身最后一个节点的圆圈变为两个空格
    SetPos(cur->next->x,cur->next->y);
    printf("  ");

    //释放蛇身最后一个节点
    free(cur->next);
    //把倒数第二个节点的next指针置为NULL，它变成新的尾节点
    cur->next = NULL;
}

KillByWall检测是否撞墙

如果走到下一个位置，蛇头的x的坐标是0或者56，y的坐标是0或者26，就说明撞墙了

void KillByWall(pSnake ps)
{
    if(ps->pSnake->x == 0 || ps->pSnake->x == 56 || ps->pSnake->y == 0 || ps->pSnake->y == 26)
    {
        ps->stataus = KILL_BY_WALL;
        return;
    }
}

KillBySelf检测蛇是否撞到自己

如果走到下一个位置，蛇头的坐标位置是它自身节点的任何一个坐标位置，说明撞到了自己

void KillBySelf(pSnake ps)
{
    pSnakeNode cur = ps->pSnake->next;
    while(cur)
    {
        if(cur->x == ps->pSnake->x && cur->y == ps->pSnake->y)
        {
            ps->stataus = KILL_BY_SELF;
            return;
        }
        cur = cur->next;
    }
}

五、游戏结束（GameEnd）

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

void GameEnd(pSnake ps)
{
    SetPos(20, 12);
    switch(ps->stataus)
    {
    case END_NORMAL:
        printf("您主动退出游戏\n");
        break;
    case KILL_BY_WALL:
        printf("您撞到墙上了，游戏结束\n");
		break;
	case KILL_BY_SELF:
		printf("您撞到了自己，游戏结束\n");
		break;
    }

    //释放蛇身的链表
    pSnakeNode cur = ps->pSnake;
    while(cur)
    {
        pSnakeNode del = cur;
        cur = cur->next;
        free(del);
        del = NULL;
    }
}

六、游戏测试

到了这一步，我们已经完成了贪吃蛇游戏的编写，接下来进行最后一步，让这个游戏可以重复玩，前面我们说过，要在第一步的时候设置适配本地环境，然后再进行一系列的测试

在test.c中

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "snake.h"

void test()
{
    int ch = 0;
    do
    {
        system("cls");//在每一次游戏前进行屏幕清理

        //创建贪吃蛇
        Snake snake = {0};
        //游戏开始
        GameStart(&snake);
        //游戏运行
        GameRun(&snake);
        //游戏结束
        GameEnd(&snake);

        SetPos(20,15);
        printf("再来一局吗?(Y/N):");
        
        ch = getchar();
        while(ch == ' ' || ch == '\n')
            ch = getchar();

        getchar();//清理\n
    
    }while(ch == 'Y' || ch == 'y');
    
    SetPos(0,27);
}
int main()
{
    //设置适配本地环境
    setlocale(LC_ALL,"");
    //使用rand之前使用srand函数来设置随机数的生成器
    srand((unsigned int)time(NULL));
    
    test();

    return 0;
}

七、完整代码

snake.h

#include <stdio.h>
#include <locale.h>
#include <windows.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>

#define WALL L'□'
#define BODY L'●'
#define FOOD L'★'

//蛇出现的初始位置
#define POS_X 24
#define POS_Y 5

//类型的声明

//蛇身的节点类型
typedef struct SnakeNode
{
	//坐标
	int x;
	int y;
	//指向下一个节点的指针
	struct SnakeNode* next;
}SnakeNode, * pSnakeNode;
//typedef struct SnakeNode* pSnakeNode;

//蛇的方向
enum DIRECTION
{
	UP = 1,
	DOWN,
	LEFT,
	RIGHT
};

//蛇的状态
//正常 撞墙 撞到自己 正常退出
enum GAME_STATUS
{
	OK, //正常
	KILL_BY_WALL,//撞墙
	KILL_BY_SELF,//撞到自己
	END_NORMAL//正常退出
};

//贪吃蛇
typedef struct Snake
{
	pSnakeNode pSnake;//指向蛇头的指针
	pSnakeNode pFood;//指向食物节点的指针
	enum DIRECTION dir;//蛇的方向
	enum GAME_STATUS stataus;//蛇的状态
	int food_weight;//一个食物的分数
	int score;//总成绩
	int sleep_time;//休息时间，时间越短，速度越快，时间越长，速度越慢
}Snake, * pSnake;

//函数声明
//游戏的初始化
void GameStart(pSnake ps);

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

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

//创建地图
void CreateMap();

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

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

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

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

//判断下一个坐标处是否是食物
int NextIsFood(pSnakeNode pn, pSnake ps);

//下一个位置是食物，就吃掉食物
void EatFood(pSnakeNode pn, pSnake ps);

//下一个位置不是食物
void NoFood(pSnakeNode pn, pSnake ps);

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

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

//游戏的善后工作
void GameEnd(pSnake ps);

snake.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "snake.h"

void SetPos(int x, int y)
{
	//获得标准输出设备的句柄
	HANDLE houtput = NULL;
	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	//定位光标的位置
	COORD pos = { x,y };
	SetConsoleCursorPosition(houtput, pos);
}
void WelcomeToGame()
{
	SetPos(38, 13);
	wprintf(L"欢迎来到贪吃蛇游戏\n");
	SetPos(39, 18);
	system("pause");
	system("cls");
	SetPos(25, 13);
	wprintf(L"用 ↑、↓、←、→ 来控制蛇的移动，按F3加速，按F4减速\n");
	SetPos(35, 15);
	wprintf(L"**加速能够得到更高的分数**\n");
	
	SetPos(39, 18);
	system("pause");
	system("cls");
}

void CreateMap()
{
	//上
	int i = 0;
	for (i = 0; i < 29; i++)
	{
		wprintf(L"%lc", WALL);
	}
	//下
	SetPos(0, 26);
	for (i = 0; i < 29; i++)
	{
		wprintf(L"%lc", WALL);
	}
	//左
	for (i = 1; i <= 25; i++)
	{
		SetPos(0, i);
		wprintf(L"%lc", WALL);
	}
	//右
	for (i = 1; i <= 25; i++)
	{
		SetPos(56, i);
		wprintf(L"%lc", WALL);
	}
}

//初始化蛇身
void InitSnake(pSnake ps)
{
	//创建蛇身
	int i = 0;
	pSnakeNode cur = NULL;

	for (i = 0; i < 5; i++)
	{
		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
		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;
			ps->pSnake = cur;
		}
	}
	//打印蛇身
	cur = ps->pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%lc", BODY);
		cur = cur->next;
	}
	//设置贪吃蛇的属性
	ps->dir = RIGHT;//默认向右
	ps->score = 0;
	ps->food_weight = 10;
	ps->sleep_time = 200;//单位是毫秒
	ps->stataus = OK;

}

void CreateFood(pSnake ps)
{
	int x;
	int y;

	//生成x是2的倍数
	//x:2~54
	//y:1~25
again:
	do
	{
		x = rand() % 53 + 2;   //rand() % N 生成 0 到 N - 1 的随机整数
		y = rand() % 25 + 1;
	} while (x % 2 != 0); //确保2~54之间的随机数都是偶数，因为x横坐标必须是偶数（宽字符占两个字符的位置）

	//x和y的坐标不能和蛇的身体坐标冲突
	pSnakeNode cur = ps->pSnake;
	while (cur)
	{
		if (x == cur->x && y == cur->y)
		{
			goto again;
		}
		cur = cur->next;
	}

	//创建食物节点
	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
	if (pFood == NULL)
	{
		perror("CreateFood()-malloc()");
		return;
	}
	pFood->x = x;
	pFood->y = y;
	pFood->next = NULL;

	SetPos(x, y);//确定位置
	wprintf(L"%lc", FOOD);

	ps->pFood = pFood;
}

//游戏的初始化
void GameStart(pSnake ps)
{
	//0.先设置窗口的大小，再光标隐藏
	system("mode con cols=100 lines=32");
	system("title 贪吃蛇");
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	//隐藏光标操作
	CONSOLE_CURSOR_INFO CursorInfo;
	GetConsoleCursorInfo(houtput, &CursorInfo);//获取控制台的光标信息
	CursorInfo.bVisible = false;//隐藏控制台光标
	SetConsoleCursorInfo(houtput, &CursorInfo);//设置控制台光标状态

	//1.打印环境界面和功能介绍
	WelcomeToGame();
	//2.绘制地图
	CreateMap();
	//3.创建蛇
	InitSnake(ps);
	//4.创建食物
	CreateFood(ps);
	
}

void PrintHelpInfo()
{
	SetPos(64, 14);
	wprintf(L"%ls", L"*不能穿墙，不能咬到自己");
	SetPos(64, 15);
	wprintf(L"%ls", L"*用 ↑、↓、←、→ 来控制蛇的移动");
	SetPos(64, 16);
	wprintf(L"%ls", L"*按F3加速，按F4减速");
	SetPos(64, 17);
	wprintf(L"%ls", L"*按ESC退出游戏，按空格暂停游戏");

}

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

void Pause()
{
	while (1)
	{
		Sleep(200);
		if (KEY_PRESS(VK_SPACE))
		{
			break;
		}
	}
}

//判断下一个坐标处是否是食物
//int NextIsFood(pSnakeNode pn, pSnake ps)
//{
//	if (ps->pFood->x == pn->x && ps->pFood->y == pn->y)
//		return 1;
//	else
//		return 0;
//}
int NextIsFood(pSnakeNode pn, pSnake ps)
{
	return (ps->pFood->x == pn->x && ps->pFood->y == pn->y);
}

//下一个位置是食物，就吃掉食物
void EatFood(pSnakeNode pn, pSnake ps)
{
	//头插法
	ps->pFood->next = ps->pSnake;
	ps->pSnake = ps->pFood;

	//释放下一个位置的节点
	free(pn);
	pn = NULL;
	pSnakeNode cur = ps->pSnake;
	//打印
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%lc", BODY);
		cur = cur->next;
	}
	ps->score += ps->food_weight;

	//重新创建食物
	CreateFood(ps);
}

//下一个位置不是食物
void NoFood(pSnakeNode pn, pSnake ps)
{
	//头插法
	pn->next = ps->pSnake;
	ps->pSnake = pn;

	pSnakeNode cur = ps->pSnake;
	while (cur->next->next != NULL) //只打印到蛇身的前4个节点
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%lc", BODY);
		cur = cur->next;
	}

	//蛇身最后一个节点的圆圈变为两个空格
	SetPos(cur->next->x, cur->next->y);
	printf("  ");

	//释放蛇身最后一个节点
	free(cur->next);
	//把倒数第二个节点的next指针置为NULL，它变成新的尾节点
	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->stataus = KILL_BY_WALL;
		return;
	}
}

//检测蛇是否撞到自己
void KillBySelf(pSnake ps)
{
	pSnakeNode cur = ps->pSnake->next;
	while (cur)
	{
		if (cur->x == ps->pSnake->x && cur->y == ps->pSnake->y)
		{
			ps->stataus = KILL_BY_SELF;
			break;
		}
		cur = cur->next;
	}
}

//蛇的移动-走一步
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);
}

//游戏运行的逻辑
void GameRun(pSnake ps)
{
	//打印帮助信息
	PrintHelpInfo();
	do
	{
		//打印总分数和食物的分值
		SetPos(64, 10);
		printf("总分数:%d\n", ps->score);
		SetPos(64, 11);
		printf("当前食物的分数:%2d\n", ps->food_weight);// %2d 占用2个字符的宽度
		
		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->stataus = END_NORMAL;
		}
		else if (KEY_PRESS(VK_F3))
		{
			//加速
			if (ps->sleep_time > 80)
			{
				ps->sleep_time -= 30;
				ps->food_weight += 2;
			}
		}
		else if (KEY_PRESS(VK_F4))
		{
			//减速
			if (ps->sleep_time > 2)
			{
				ps->sleep_time += 30;
				ps->food_weight -= 2;
			}
		}

		SnakeMove(ps);//蛇走一步的过程
		Sleep(ps->sleep_time);

	} while (ps->stataus == OK);
}

//游戏的善后工作
void GameEnd(pSnake ps)
{
	SetPos(20, 12);
	switch(ps->stataus)
	{
	case END_NORMAL:
		printf("您主动结束游戏\n");
		break;
	case KILL_BY_WALL:
		printf("您撞到墙上了，游戏结束\n");
		break;
	case KILL_BY_SELF:
		printf("您撞到了自己，游戏结束\n");
		break;
	}

	//释放蛇身的链表
	pSnakeNode cur = ps->pSnake;
	while (cur)
	{
		pSnakeNode del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
}