贪吃蛇实现

-Rane

已于 2024-07-20 17:19:40 修改

阅读量609

点赞数 21

文章标签： c语言游戏程序

于 2024-07-20 17:18:30 首次发布

本文链接：https://blog.csdn.net/2302_80733101/article/details/140496691

版权

介绍

对于贪吃蛇这个游戏，想必大家都不陌生。这次我们就通过C语言来编写这一个小游戏

下面为游戏运行时一些截图：

相关Win32API介绍

有知晓相关知识的可以跳过这一部分直接进入主题

关于Win32API：

Windows 这个多作业系统除了协调应用程序的执行、分配内存、管理资源之外，它同时也是⼀个很大的服务中心，调用这个服务中心的各种服务（每⼀种服务就是⼀个函数），可以帮应用程序达到开启视窗、描绘图形、使用周边设备等目的，由于这些函数服务的对象是应用程序(Application)，所以便称之为 Application Programming Interface，简称 API 函数。WIN32 API也就是Microsoft Windows32位平台的应⽤程序编程接口。

控制台程序

我们代码运行起来的界面其实就是控制台程序

我们可以用命令来设置控制台窗口的大小（30行，100列）

mode con cols=100 lines=30

也可以通过命令设置控制台窗口的名字：

title 贪吃蛇

上面是能在控制台窗口执行的命令，也可以用C语言函数system来执行：

int main()
{
    //将控制台窗口大小设置为行30，列100
    system("mode con cols=100 lines=30");
    //将控制台窗口名字设置为贪吃蛇
    system("title 贪吃蛇");
    return 0;
}

控制台坐标

就如同数学中有直角坐标系来表示位置一般，控制台窗口也可以通过坐标来表示，只不过y轴的正方向与直角坐标系相反。

编写贪吃蛇游戏，我们要学会操控控制台窗口的坐标，而操控控制台窗口的坐标需要用到COORD类型，以下是其的定义：

COORD 是Windows API中定义的⼀个结构体，表示⼀个字符在控制台屏幕幕缓冲区上的坐标，坐标系(0，0) 的原点位于缓冲区的顶部左侧单元格。

为了更方便理解，这里放出COORD类型的声明：

typedef struct _COORD{
    SHORT X;
    SHORT Y;
}COORD,*PCOORD;

关于COORD给坐标赋值的用法：

COORD pos = { 10, 15 };

句柄的获得

关于句柄

句柄是用来标识不同设备的数值，使用句柄可以操作设备。大概可以将句柄看作一种权限，只有获取了这个权限才能对相关设备进行操作。

如果获得句柄

想要获得句柄，要运用GetStdHandle这个函数

GetStdHandle是⼀个Windows API函数。它用于从⼀个特定的标准设备（标准输入、标准输出或标准错误）中取得⼀个句柄（用来标识不同设备的数值），使用这个句柄可以操作设备。

 HANDLE GetStdHandle(DWORD nStdHandle);

如何运用

运用实例：

HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);

关于光标

在得知坐标与句柄的信息后，我们要用其来控制光标

控制光标的意图有两个：

1.由前面代码运行截图可知，图上并没有光标闪动

2.控制光标，我们可以在控制台窗口任意位置输出

获取光标信息

控制光标，首先要获得光标信息。需要使用GetConsoleCursorInfo来进行操作，这是用来检索有关指定控制台屏幕缓冲区的光标大小和可见性的信息

BOOL WINAPI GetConsoleCursorInfo(
 HANDLE hConsoleOutput,
 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo);
PCONSOLE_CURSOR_INFO 是指向 CONSOLE_CURSOR_INFO 结构的指针，该结构接收有关主机游标（光标）的信息

关于CONSOLE_CURSOR_INFO结构体，它包含有关控制台光标信息

typedef struct _CONSOLE_CURSOR_INFO {
 DWORD dwSize;
 BOOL bVisible;
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;

• dwSize，由光标填充的字符单元格的百分比。此值介于1到100之间。光标外观会变化，范围从完全填充单元格到单元底部的水平线条。

• bVisible，游标的可见性。如果光标可见，则此成员为 TRUE。

两者运用实例：

HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息

设置光标信息

SetConsoleCursorInfo

获取完光标信息后，便要设置光标

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);//设置控制台光标状态

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);

按键检测

获取按键情况，要运用GetAsyncKeyState

函数的原型：

SHORT GetAsyncKeyState(
 int vKey
);

它的运行原理为：

如果返回的16位的short数据中，最高位是1，说明按键的状态是按下，如果最高是0，说明按键的状态是抬起；如果最低位被置为1则说明，该按键被按过，否则为0。

所以说如果我们要检测一个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1

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

初始化游戏（GameStart)

界面设置

首先我们来进行贪吃蛇游戏初始化代码的编写，在一切操作之前，我们首先要把控制台窗口设置成自己需要的理想的标准，这里就要运用到上文所叙述的Win32API的知识

//设置控制台窗口的大小和名称
system("mode con cols=100 lines=30");
system("title 贪吃蛇");
HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出的句柄
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(houtput,&CursorInfo);//获取光标信息
CursorInfo.bVisible = false;//隐藏光标
SetConsoleCursorInfo(houtput,&CursorInfo);//设置光标信息

将控制台窗口信息设置好后，我们来编写欢迎界面，由游戏运行截图来看，可以看出欢迎界面打印出来的文字是处于界面正中间的，所以我们这里需要用到光标定位，因为光标定位在整个代码中运用的次数比较多，我们这里单独分装出一个函数SetPos：

void SetPos(short x, short y)
{
    HANDLE houtput = NULL;
    houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD pos = { x, y };
    GetConsoleCursorPosition(houtput, pos);
}

有了光标定位函数后，我们就来编写欢迎界面函数WelcomeToGame

void WelcomeToGame()
{
    //欢迎界面1
    SetPos(40, 14);
    wprintf(L"欢迎来到贪吃蛇小游戏\n");
    SetPos(42, 20);
    system("pause");//暂停，按任意键后继续
    system("cls");
    //欢迎界面2
    SetPos(25, 14);
    wprintf(L"用↑，↓，←，→来控制蛇的移动，按F3加速，F4减速\n");
    SetPos(25, 15);
    wprintf(L"加速能够得到更高的分数\n");
    SetPos(42, 20);
    system("pause");
    system("cls");
}

地图绘制

打印完欢迎界面后，我们便要进行游戏地图的绘制（行27，列58）因为我们用的字符□为宽字符要占用两个字节，而控制台窗口对应坐标的y的长度为x长度的两倍，所以我们行打印27个该符号，列打印29个

void CreateMap()
{
    int i=0;
    //打印地图的顶部
    SetPos(0,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<26;i++)
    {
        SetPos(0,i);
        wprintf(L"%lc",WALL);
    }
    //打印地图的右部
    for(i=1;i<26;i++)
    {
        SetPos(56,i):
        wprintf(L"%lc",Wall);
    }
}

为了方便代码的编写，我们将要用的宽字符进行重定义：

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

蛇身的创建

1.建立结构体（蛇身的节点类型）

为了找到蛇头我们要设置一个指向蛇头的指针

typedef struct SnakeNode
{
    int x;
    int y;
    struct SnakeNode* next
}SnakeNode,*pSnakeNode;

2.建立存储贪吃蛇信息的结构体

不仅要找到头还要找到蛇的速度、蛇的方向、食物、食物的分数、总分数、贪吃蛇的状态，这些都为贪吃蛇的信息，而维护游戏中的贪吃蛇就是在维护这些信息

再创建一个贪吃蛇信息的结构体

参数1	指向蛇头的指针
参数2	指向食物节点的指针
参数3	蛇的方向（枚举类型外设置）
参数4	蛇的状态：正常、撞墙、撞到自己、正常退出（也是枚举类型）
参数5	单个食物的分数
参数6	总得分
参数7	休息时间（时间越短，速度越快，时间越长，速度越慢）

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;
    int _score;
    int _food_weight;
    int sleep_time;
    enum DIRECTION _dir;
    enum GAME_STATUS _status;
}

进行完所需的准备后，开始进行蛇身创建的代码的编写

#define POS_X 24
#define POS_Y 5

void CreateSnake(pSnake ps)
{
    for(int i=0;i<5;i++)
    {
        //创建蛇身节点
        pSnakeNode snake=(pSnakeNode)malloc(sizeof(SnakeNode);
        if(snake==NULL)
        {
            perror("CreateSnake::malloc");
            return;
        }
        snake->next = NULL;
        snake->x = POS_X + 2 * i;
        snake->y = POS_Y;
        //采用头插法将节点连接
        if(ps->_pSnake==NULL)
        {
            ps->_pSnake=snake;
        }
        else
        {
            snake->next=ps->_pSnake;
            ps->_pSnake=snake;
        }
    }
    //在屏幕上打印蛇身
    pSnakeNode cur=ps->_pSnake;
    while(cur)
    {
        SetPos(cur->x,cur->y);
        wprintf(L"%lc",BODY);
        cur=cur->next;
    }
    //初始化蛇的数值
    ps->_dir=RIGHT;
    ps->_status=OK;
    ps->_score=0;
    ps->_food_weight=10;
    ps->_sleep_time=200;
}

食物的创建

void CreateFood(pSnake ps)
{
    //创建食物节点
    pSnakeNode food=(pSnakeNode)malloc(sizeof(SnakeNode));
    if(food==NULL)
    {
        perror("CreateFood::malloc");
        return;
    }
    int x;
    int y;
    //限制食物的坐标在地图内
again:
    do
    {
        x=rand()%53+2;
        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;
    }
    food->x=x;
    food->y=y;
    food->next=NULL;
    //在屏幕上打印食物
    SetPos(x,y);
    wprintf(L"%lc",FOOD);
    ps->_pFood=food;
}

代码展示(GameStart)

void GameStart(pSnake ps)
{
	system("mode con cols=100 lines=30");
	system("title 贪吃蛇");
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO CursorInfo;
	GetConsoleCursorInfo(houtput, &CursorInfo);
	CursorInfo.bVisible = false;
	SetConsoleCursorInfo(houtput, &CursorInfo);
	WelcomeToGame();
	CreateMap();
	CreateSnake(ps);
	CreateFood(ps);
}

游戏的运行

将游戏的初始值设定完后，我们就要进入游戏运行的代码的编写（GameRun)

进入主题之前，我们要注意到在游戏运行界面的地图旁边有帮助说明，我们先把这个比较无关紧要的代码先解决掉

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

按键判断

因为该游戏需要玩家用到键盘上的按键，所以我们要编写一个能检测按键的宏，这在上文Win32API中进行过讲解，这里就直接放出

#define KEY_PRESS(vk) ((GetAsyncKeyState(vk)&1)?1: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;
    pSnakeNode cur=ps->_pSnake;
    while(cur)
    {
        SetPos(cur->x,cur->y);
        wprintf(L"%lc",BODY);
        cur=cur->next;
    }
    free(pn);
    pn=NULL;
    ps->_score+=ps->_food_weight;
    CreateFood(ps);
}

void NoFood(pSnakeNode pn,Snake ps)
{
    pn->next=ps->_pSnake;
    ps->_pSnake=pn;
    pSnakeNode cur=ps->_pSnake;
    while(cur->next->next!=NULL)
    {
        SetPos(cur->x,cur->y);
        wprintf(L"%lc",BODY);
        cur=cur->next;
    }
    SetPos(cur->next->x,cur->next->y);
    wprintf("  ");
    free(cur->next);
    cur->next=NULL;
}

void SnakeMove(pSnake ps)
{
    pSnakeNode next=(pSnakeNode)malloc(sizeof(SnakeNode));
    if(next==NULL)
    {
        perror("SnakeMove::malloc")
        return;
    }
    switch(ps->_dir)
    {
    case UP:
        next->x=ps->_pSnake->x;
        next->y=ps->_pSnake->y-1;
        break;
    case DOWN:
        next->x=ps->_pSnake->x;
        next->y=ps->_pSnake->y+1;    
        break;
    case LEFT:
        next->x=ps->_pSnake->x-2;
        next->y=ps->_pSnkae->y;
    case RIGHT:
        next->x=ps->_pSnake->x+2;
        next->y=ps->_pSnake->y;
    }
    //有食物的情况
    if(NextIsFood(next,ps)
    {
        EatFood(next,ps);
    }
    //无食物的情况
    else
    {
        NoFood(next,ps);
    }
    //状态判定，在下一块编写
    KillByWall(ps);
    KillBySelf(ps);
}

状态判定

这里主要写两种判定，一种为蛇撞到墙死亡，另一种为蛇撞到自己死亡

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

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;
            break;
        }
        cur=cur->next;
    }
}

代码展示(GameRun)

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

void GameRun(pSnake ps)
{
    PrintHelpInfo();
    do
    {
        SetPos(64, 10);
        printf("总分数:%d\n", ps->_score);
        SetPos(64, 11);
        printf("当前食物的分数:%2d\n", ps->_food_weight);
        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_NORMAL;
		}
		else if (KEY_PRESS(VK_F3))
		{
			if (ps->_sleep_time > 80)
			{
				ps->_food_weight += 2;
				ps->_sleep_time -= 30;
			}
		}
		else if (KEY_PRESS(VK_F4))
		{
			if (ps->_food_weight > 2)
			{
				ps->_sleep_time += 30;
				ps->_food_weight -= 2;
			}
		}
		SnakeMove(ps);
		Sleep(ps->_sleep_time);
	} while (ps->_status == OK);
}

游戏的结束

游戏结束判定

到这里游戏已经编写的差不多了，到了收尾的阶段，在这里游戏结束后我们要提示玩家游戏已经结束且要告知结束原因，为了方便玩家继续游玩可再增加一个让玩家是否继续重开一局的选项，而且要释放前一局游戏中申请的空间。

void GameEnd(pSnake ps)
{
	SetPos(24, 12);
	switch (ps->_status)
	{
	case END_NORMAL:
		wprintf(L"您主动结束游戏\n");
		break;
	case KILL_BY_WALL:
		wprintf(L"您撞到墙上，游戏结束\n");
		break;
	case KILL_BY_SELF:
		wprintf(L"您撞到了自己，游戏结束\n");
		break;
	}
	pSnakeNode cur = ps->_pSnake;
	while (cur)
	{
		pSnakeNode del = cur;
		cur = cur->next;
		free(del);
	}
}

收尾

void test()
{
	int ch = 0;
	do
	{
		system("cls");
		Snake snake = { 0 };
		GameStart(&snake);
		GameRun(&snake);
		GameEnd(&snake);
		SetPos(20, 15);
		printf("再来一局吗？(Y/N)\n");
		ch = getchar();
		while (getchar() != '\n');
	} while (ch=='Y'||ch=='y');
	SetPos(0, 27);
}

参考代码

test.c

#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)\n");
		ch = getchar();
		while (getchar() != '\n');
	} while (ch=='Y'||ch=='y');
	SetPos(0, 27);
}

int main()
{
	setlocale(LC_ALL, "");
	srand((unsigned int)time(NULL));
	test();
	return 0;
}

snake.c

#include "snake.h"

void SetPos(short x,short y)
{
	HANDLE houtput = NULL;
	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD pos = { x,y };
	SetConsoleCursorPosition(houtput, pos);
}

void WelcomeToGame()
{
	SetPos(40, 14);
	wprintf(L"欢迎来到贪吃蛇小游戏\n");
	SetPos(42, 20);
	system("pause");
	system("cls");
	SetPos(25, 14);
	wprintf(L"用↑，↓，←，→来控制蛇的移动，按F3加速，F4减速\n");
	SetPos(25, 15);
	wprintf(L"加速能够得到更高的分数\n");
	SetPos(42, 20);
	system("pause");
	system("cls");
}

void CreateMap()
{
	SetPos(0, 0);
	int i = 0;
	for (i = 0; i <= 28; i++)
	{
		wprintf(L"%lc", WALL);
	}
	SetPos(0, 26);
	for (i = 0; i <= 28; 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 CreateSnake(pSnake ps)
{
	for (int i = 0; i < 5; i++)
	{
		pSnakeNode snake = (pSnakeNode)malloc(sizeof(SnakeNode));
		if (snake == NULL)
		{
			perror("CreateSnake::malloc:");
			return;
		}
		snake->next = NULL;
		snake->x = POS_X + 2 * i;
		snake->y = POS_Y;
		if (ps->_pSnake == NULL)
		{
			ps->_pSnake = snake;
		}
		else
		{
			snake->next = ps->_pSnake;
			ps->_pSnake = snake;
		}
	}
	pSnakeNode cur = ps->_pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%lc", BODY);
		cur = cur->next;
	}
	ps->_dir = RIGHT;
	ps->_food_weight = 10;
	ps->_score = 0;
	ps->_sleep_time = 200;
	ps->_status = OK;
}

void CreateFood(pSnake ps)
{
	int x = 0;
	int y = 0;
again:
	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 food = (pSnakeNode)malloc(sizeof(SnakeNode));
	if (food == NULL)
	{
		perror("CreateFood::malloc::");
		return;
	}
	food->next = NULL;
	food->x = x;
	food->y = y;
	SetPos(x, y);
	wprintf(L"%lc", FOOD);
	ps->_pFood = food;
}

void GameStart(pSnake ps)
{
	system("mode con cols=100 lines=30");
	system("title 贪吃蛇");
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO CursorInfo;
	GetConsoleCursorInfo(houtput, &CursorInfo);
	CursorInfo.bVisible = false;
	SetConsoleCursorInfo(houtput, &CursorInfo);
	WelcomeToGame();
	CreateMap();
	CreateSnake(ps);
	CreateFood(ps);
}

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

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

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

int NextFood(pSnakeNode next, pSnake ps)
{
	return (ps->_pFood->x == next->x && ps->_pFood->y == next->y);
}

void EatFood(pSnakeNode next, pSnake ps)
{
	ps->_pFood->next = ps->_pSnake;
	ps->_pSnake = ps->_pFood;

	free(next);
	next = 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)
	{
		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;
	}
}

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;
			break;
		}
		cur = cur->next;
	}
}

void SnakeMove(pSnake ps)
{
	pSnakeNode NextSnake = (pSnakeNode)malloc(sizeof(SnakeNode));
	if (NextSnake == NULL)
	{
		perror("SnakeMove::malloc::");
		return;
	}
	switch (ps->_dir)
	{
	case UP:
		NextSnake->x = ps->_pSnake->x;
		NextSnake->y = ps->_pSnake->y - 1;
		break;
	case DOWN:
		NextSnake->x = ps->_pSnake->x;
		NextSnake->y = ps->_pSnake->y + 1;
		break;
	case LEFT:
		NextSnake->x = ps->_pSnake->x - 2;
		NextSnake->y = ps->_pSnake->y;
		break;
	case RIGHT:
		NextSnake->x = ps->_pSnake->x + 2;
		NextSnake->y = ps->_pSnake->y;
		break;
	}
	if (NextFood(NextSnake, ps))
	{
		EatFood(NextSnake, ps);
	}
	else
	{
		NoFood(NextSnake, 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);
		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_NORMAL;
		}
		else if (KEY_PRESS(VK_F3))
		{
			if (ps->_sleep_time > 80)
			{
				ps->_food_weight += 2;
				ps->_sleep_time -= 30;
			}
		}
		else if (KEY_PRESS(VK_F4))
		{
			if (ps->_food_weight > 2)
			{
				ps->_sleep_time += 30;
				ps->_food_weight -= 2;
			}
		}
		SnakeMove(ps);
		Sleep(ps->_sleep_time);
	} while (ps->_status == OK);
}

void GameEnd(pSnake ps)
{
	SetPos(24, 12);
	switch (ps->_status)
	{
	case END_NORMAL:
		wprintf(L"您主动结束游戏\n");
		break;
	case KILL_BY_WALL:
		wprintf(L"您撞到墙上，游戏结束\n");
		break;
	case KILL_BY_SELF:
		wprintf(L"您撞到了自己，游戏结束\n");
		break;
	}
	pSnakeNode cur = ps->_pSnake;
	while (cur)
	{
		pSnakeNode del = cur;
		cur = cur->next;
		free(del);
	}
}

snake.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

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

#define POS_X 24
#define POS_Y 5

enum DIRECTION
{
	UP = 1,
	DOWN,
	LEFT,
	RIGHT
};

enum GAME_STATUS
{
	OK,
	KILL_BY_WALL,
	KILL_BY_SELF,
	END_NORMAL
};

typedef struct SnakeNode
{
	int x;
	int y;
	struct SnakeNode* next;
}SnakeNode,*pSnakeNode;

typedef struct Snake
{
	pSnakeNode _pSnake;
	pSnakeNode _pFood;
	enum DIRECTION _dir;
	enum GAME_STATUS _status;
	int _food_weight;
	int _score;
	int _sleep_time;
}Snake,*pSnake;

//主体区
void GameStart(pSnake ps);
void GameRun(pSnake ps);
void GameEnd(pSnake ps);

void SetPos(short x,short y);