【C语言】贪吃蛇

游戏效果演示

实现基本的功能

• 贪吃蛇地图绘制

• 蛇吃食物的功能 （上、下、左、右⽅向键控制蛇的动作）

• 蛇撞墙死亡

• 蛇撞自身死亡

• 计算得分

• 蛇身加速、减速

• 暂停游戏

Win32 API

在制作贪吃蛇之前我们需要对Win32 API有一定程度的了解。

Win32 API

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

控制台程序

我们可以使⽤cmd命令来设置控制台窗⼝的⻓宽：设置控制台窗⼝的⼤⼩，30⾏，100列

mode con cols=100 lines=30

 

将其输入到一个默认打开的窗口上面在回车就会改变窗口的大小。

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

title 贪吃蛇

 

这些能在控制台窗口执行的命令，也可以调⽤C语⾔函数system来执行。例如：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	system("mode con cols=30 lines=30");
	system("title 贪吃蛇");
	return 0;
}

 

控制台屏幕上的坐标COORD

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

COORD类型的声明：

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

给坐标赋值：

COORD pos = { 10, 15 };

GetStdHandle

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

我们可以将句柄想象成为一个游戏手柄，只有获得这个手柄之后，我们才可以控制游戏界面。

int main()
{
	//获得标准输出设备的句柄
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	return 0;
}

GetConsoleCursorInfo

检索有关指定控制台屏幕缓冲区的光标大小和可见性的信息

BOOL WINAPI GetConsoleCursorInfo(
	HANDLE hConsoleOutput,
	PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
);
//PCONSOLE_CURSOR_INFO 是指向 CONSOLE_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。 

CursorInfo.bVisible = false; //隐藏控制台光标

SetConsoleCursorInfo

设置指定控制台屏幕缓冲区的光标的大小和可见性。

BOOL WINAPI SetConsoleCursorInfo(
	HANDLE hConsoleOutput,
	const CONSOLE_CURSOR_INFO * lpConsoleCursorInfo
);

函数的第一个参数是所要控制的句柄，第二个参数是是指向 CONSOLE_CURSOR_INFO 结构的指针，该结构接收有关主机游标。

接下来，我们就可以完成设置光标的信息了，代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<windows.h>
int main()
{
	//获得标准输出设备的句柄
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	
	//定义一个光标信息的结构体变量
	CONSOLE_CURSOR_INFO cursor_info = { 0 };
 
	//获取和houtput句柄相关的控制台上的光标信息，存放在cursor_info中
	GetConsoleCursorInfo(houtput, &cursor_info);
 
	//修改光标的占比
	cursor_info.bVisible = TRUE;
	cursor_info.dwSize = 50;
 
	//设置和houtput句柄相关的控制台上的光标信息
	SetConsoleCursorInfo(houtput, &cursor_info);
 
	system("pause");
	return 0;
}

SetConsoleCursorPosition

设置指定控制台屏幕缓冲区中的光标位置，我们将想要设置的坐标信息放在COORD类型的pos中，调 ⽤SetConsoleCursorPosition函数将光标位置设置到指定的位置。

语法：

BOOL WINAPI SetConsoleCursorPosition(
	HANDLE hConsoleOutput,
	COORD pos
);

 第一个参数是控制台屏幕缓冲区的句柄。第二个参数坐标是屏幕缓冲区字符单元的列和行。 坐标必须位于控制台屏幕缓冲区的边界以内。

#include<stdio.h>
#include<windows.h>
int main()
{
	COORD pos = { 10, 5 };
	HANDLE hOutput = NULL;
	//获取标准输出的句柄(⽤来标识不同设备的数值)
	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	//设置标准输出上光标的位置为pos
	SetConsoleCursorPosition(hOutput, pos);
	printf("hehe");
	return 0;
}

为了后续方便使用，我们可以直接将其分装成一个函数。

void SetPos(short x, short y)
{
	COORD pos = { x, y };
	HANDLE hOutput = NULL;
	//获取标准输出的句柄(⽤来标识不同设备的数值)
	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	//设置标准输出上光标的位置为pos
	SetConsoleCursorPosition(hOutput, pos);
}
int main()
{
	SetPos(30, 30);
	printf("hehe");
	return 0;
}

GetAsyncKeyState

GetAsyncKeyState的函数原型如下：

​
SHORT GetAsyncKeyState(
    int vKey
);
 
​

将键盘上每个键的虚拟键值传递给函数，函数通过返回值来分辨按键的状态。

GetAsyncKeyState 的返回值是short类型，在上⼀次调⽤ GetAsyncKeyState 函数后，如果 返回的16位的short数据中，最⾼位是1，说明按键的状态是按下，如果最⾼是0，说明按键的状态是抬 起；如果最低位被置为1则说明，该按键被按过，否则为0。

如果我们要判断⼀个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1.

GetAsyncKeyState函数的参数要参考下面的虚拟键码。

虚拟键码 (Winuser.h) - Win32 apps | Microsoft Learn

例：检测数字键

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<windows.h>
#define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&1)?1:0)
int main()
{
	while (1)
	{
		if (KEY_PRESS(0x30))
		{
			printf("0\n");
		}
		else if (KEY_PRESS(0x31))
		{
			printf("1\n");
		}
		else if (KEY_PRESS(0x32))
		{
			printf("2\n");
		}
		else if (KEY_PRESS(0x33))
		{
			printf("3\n");
		}
		else if (KEY_PRESS(0x34))
		{
			printf("4\n");
		}
		else if (KEY_PRESS(0x35))
		{
			printf("5\n");
		}
		else if (KEY_PRESS(0x36))
		{
			printf("6\n");
		}
		else if (KEY_PRESS(0x37))
		{
			printf("7\n");
		}
		else if (KEY_PRESS(0x38))
		{
			printf("8\n");
		}
		else if (KEY_PRESS(0x39))
		{
			printf("9\n");
		}
	}
	return 0;
}

地图

这⾥简单的看⼀下C语⾔的国际化特性相关的知识，过去C语⾔并不适合⾮英语国家（地区）使⽤。 C语⾔最初假定字符都是单字节的。但是这些假定并不是在世界的任何地⽅都适⽤。

C语⾔字符默认是采⽤ASCII编码的，ASCII字符集采⽤的是单字节编码，且只使⽤了单字节中的低7 位，最⾼位是没有使用的，可表示为0xxxxxxxx；可以看到，ASCII字符集共包含128个字符，在英语 国家中，128个字符是基本够⽤的，但是，在其他国家语⾔中，⽐如，在法语中，字⺟上⽅有注音符号，它就⽆法⽤ ASCII 码表示。于是，⼀些欧洲国家就决定，利⽤字节中闲置的最高位编入新的符号。比如，法语中的é的编码为130（⼆进10000010）。这样⼀来，这些欧洲国家使用的编码体系，可以表示最多256个符号。但是，这⾥⼜出现了新的问题。不同的国家有不同的字⺟，因此，哪 怕它们都使⽤256个符号的编码方式，代表的字母却不⼀样。比如，130在法语编码中代表了é，在希 伯来语编码中却代表了字⺟Gimel ，在俄语编码中⼜会代表另⼀个符号。但是不管怎样，所有这 些编码⽅式中，0--127表⽰的符号是⼀样的，不⼀样的只是128--255的这⼀段。

至于亚洲国家的⽂字，使⽤的符号就更多了，汉字就多达10万左右。⼀个字节只能表⽰256种符号， 肯定是不够的，就必须使⽤多个字节表达⼀个符号。⽐如，简体中⽂常⻅的编码⽅式是 GB2312，使 ⽤两个字节表示⼀个汉字，所以理论上最多可以表示 256 x 256 = 65536 个符号。

后来为了使C语⾔适应国际化，C语⾔的标准中不断加⼊了国际化的⽀持。⽐如：加⼊了宽字符的类型 wchar_t 和宽字符的输⼊和输出函数，加⼊了头⽂件，其中提供了允许程序员针对特定 地区（通常是国家或者说某种特定语⾔的地理区域）调整程序⾏为的函数。

本地化

提供的函数⽤于控制C标准库中对于不同的地区会产⽣不⼀样⾏为的部分。 在标准中，依赖地区的部分有以下⼏项：

• 数字量的格式

• 货币量的格式

• 字符集

• 日期和时间的表示形式

类项

通过修改地区，程序可以改变它的⾏为来适应世界的不同区域。但地区的改变可能会影响库的许多部 分，其中⼀部分可能是我们不希望修改的。所以C语⾔⽀持针对不同的类项进⾏修改，下⾯的⼀个宏， 指定⼀个类项，具体类项可以参考已下链接：

setlocale，_wsetlocale | Microsoft Learn

setlocale函数

char* setlocale (int category, const char* locale);

setlocale 函数⽤于修改当前地区，可以针对⼀个类项修改，也可以针对所有类项。 setlocale 的第⼀个参数可以是前⾯说明的类项中的⼀个，那么每次只会影响⼀个类项，如果第⼀个参 数是LC_ALL，就会影响所有的类项。

C标准给第⼆个参数仅定义了2种可能取值："C"（正常模式）和" "（本地模式）。 在任意程序执⾏开始，都会隐藏式执行调用: 

setlocale(LC_ALL, "C");

当地区设置为"C"时，库函数按正常方式执行，小数点是⼀个点。 当程序运行起来后想改变地区，就只能显示调⽤setlocale函数。⽤" "作为第2个参数，调⽤setlocale 函数就可以切换到本地模式，这种模式下程序会适应本地环境。 比如：切换到我们的本地模式后就支持宽字符（汉字）的输出等。

setlocale(LC_ALL, " ");//切换到本地环境

宽字符的打印

宽字符的字⾯量必须加上前缀“L”，否则 C 语⾔会把字⾯量当作窄字符类型处理。前缀“L”在单引 号前⾯，表⽰宽字符，对应 wprintf() 的占位符为 %lc ；在双引号前⾯，表⽰宽字符串，对应 wprintf() 的占位符为 %ls 。

int main()
{
	setlocale(LC_ALL, "");
	char ch1 = 'a';
	char ch2 = 'b';
	printf("%c%c\n", ch1, ch2);
	wchar_t ch3 =L'呵';
	wchar_t ch4 =L'呵';
	wprintf(L"%lc\n",ch3);
	wprintf(L"%lc\n",ch4);
 
	return 0;
}

地图坐标

我们假设实现⼀个棋盘27⾏，58列的棋盘（⾏和列可以根据⾃⼰的情况修改），再围绕地图画出墙

核心逻辑实现分析

程序开始就设置程序⽀持本地模式，然后进⼊游戏的主逻辑。 主逻辑分为3个过程：

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

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

• 游戏结束（GameEnd）完成游戏结束的说明，实现资源释放

游戏开始

这个模块完成游戏的初始化任务：

• 控制台窗⼝大小的设置

• 控制台窗⼝名字的设置

• 鼠标光标的隐藏

• 打印欢迎界⾯

• 创建地图

• 初始化第蛇

• 创建第⼀个⻝物

打印欢迎界面：

void Welcome()
{
	SetPos(40, 10);
	printf("欢迎来到贪吃蛇小游戏！");
	SetPos(40, 25);
	system("pause");
	system("cls");
	SetPos(30, 10);
	printf("用 ↑. ↓ . ← . → 来控制蛇的移动，按F3加速，F4减速\n");
	SetPos(30, 11);
	printf("加速能够得到更高的分数\n");
	SetPos(40, 25);
	system("pause");
	system("cls");
}

创建地图：

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

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

#define WALL L'■'

创建地图函数CreateMap：

void CreateMap()
{
	int i = 0;
	for (i = 0; i < 29; i++)
	{
		wprintf(L"%c", WALL);
	}
	SetPos(0, 27);
	for (i = 0; i < 29; i++)
	{
		wprintf(L"%c",WALL);
	}
	for (i = 1; i < 27; i++)
	{
		SetPos(0, i);
		wprintf(L"%c", WALL);
	}
	for (i = 1; i < 27; i++)
	{
		SetPos(56, i);
		wprintf(L"%c", WALL);
	}
	
}

初始化蛇⾝ 蛇最开始⻓度为5节，每节对应链表的⼀个节点，蛇⾝的每⼀个节点都有⾃⼰的坐标。 创建5个节点，然后将每个节点存放在链表中进⾏管理。创建完蛇⾝后，将蛇的每⼀节打印在屏幕上。

• 蛇的初始位置从 (24,5) 开始。 再设置当前游戏的状态，蛇移动的速度，默认的方向，初始成绩，每个食物的分数。

• 游戏状态是：OK

• 蛇的移动速度：200毫秒

• 蛇的默认方向：RIGHT

• 初始成绩：0

• 每个食物的分数：10

蛇⾝打印的宽字符：

#define BODY L'●'

初始化蛇⾝函数：

void CreatSnake(Snake* ps)
{
	SnakeNode* cur = NULL;
	for (int i = 0; i < 5; i++)
	{
		cur = (SnakeNode*)malloc(sizeof(SnakeNode));
		if (cur == NULL)
		{
			perror("CreatSnake():malloc");
			exit(1);
		}
		cur->next = NULL;
		cur->x = POS_X+i*2;
		cur->y = POS_Y;
		if (cur == NULL)
		{
			ps->pSnake = cur;
		}
		else
		{
			cur->next = ps->pSnake;
			ps->pSnake = cur;
		}
	}
	cur = ps->pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%c", BODY);
		cur = cur->next;
	}
	ps->Dir = RIGHT;
	ps->foodWeight = 10;
	ps->SleepTime = 200;
	ps->Socre = 0;
	ps->Status = NORMAL;
}

创建第⼀个食物

• 先随机⽣成⻝物的坐标

    ◦ x坐标必须是2的倍数

    ◦ ⻝物的坐标不能和蛇⾝每个节点的坐标重

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

打印的宽字符:

#define FOOD L'★'

创建食物的函数：CreateFood

void CreateFood(Snake* ps)
{
	int x = 0;
	int y = 0;
again:
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 26 + 1;
	} while (x % 2 != 0);
	SnakeNode* cur = ps->pSnake;
	while (cur)
	{
		if (cur->x == x && cur->y == y)
		{
			goto again;
		}
		cur = cur->next;
	}
	SnakeNode* Food = (SnakeNode*)malloc(sizeof(SnakeNode));
	if (Food == NULL)
	{
		perror("CreatFood():malloc");
		return;
	}
	else
	{
		Food->x = x;
		Food->y = y;
		SetPos(x, y);
		wprintf(L"%c", FOOD);
		ps->pFood = Food;
	}
}

游戏运行

游戏运⾏期间，右侧打印帮助信息，提⽰玩家，坐标开始位置(64, 15)

根据游戏状态检查游戏是否继续，如果是状态是NORMAL，游戏继续，否则游戏结束。 如果游戏继续，就是检测按键情况，确定蛇下⼀步的⽅向，或者是否加速减速，是否暂停或者退出游 戏。 需要的虚拟按键的罗列：

• 上：VK_UP

• 下：VK_DOWN

• 左：VK_LEFT

• 右：VK_RIGHT

• 空格：VK_SPACE

• ESC：VK_ESCAPE

• F3：VK_F3

• F4：VK_F4

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

void GameRun(Snake* ps)
{
	//• 上：VK_UP
	//• 下：VK_DOWN
	//• 左：VK_LEFT
	//• 右：VK_RIGHT
	//• 空格：VK_SPACE
	//• ESC：VK_ESCAPE
	//• F3：VK_F3
	//• F4：VK_F4
	do
	{
		SetPos(64, 0);
		printf("总分数:%d\n", ps->Socre);
		SetPos(64, 1);
		printf("当前食物的分数:%2d\n", ps->foodWeight);
		if (KET_PRESS(VK_UP) && ps->Dir != DOWN)
		{
			ps->Dir = UP;
		}
		else if (KET_PRESS(VK_DOWN) && ps->Dir != UP)
		{
			ps->Dir = DOWN;
		}
		else if (KET_PRESS(VK_LEFT) && ps->Dir != RIGHT)
		{
			ps->Dir = LEFT;
		}
		else if (KET_PRESS(VK_RIGHT) && ps->Dir != LEFT)
		{
			ps->Dir = RIGHT;
		}
		else if (KET_PRESS(VK_SPACE))
		{
			pause();
		}
		else if (KET_PRESS(VK_ESCAPE))
		{
			ps->Status = ENDNORMAL;
		}
		else if (KET_PRESS(VK_F3))
		{
			//按F3加速
			if (ps->SleepTime > 80)
			{
				ps->SleepTime -= 30;
				ps->foodWeight += 2;
			}
		}
		else if (KET_PRESS(VK_F4))
		{
			//按F4减速
			if (ps->foodWeight > 2)
			{
				ps->SleepTime += 30;
				ps->foodWeight -= 2;
			}
		}
 
		SnakeMove(ps);//蛇走一步的过程
 
		Sleep(ps->SleepTime);
	} while (ps->Status == NORMAL);
	
}

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

#define KET_PRESS(VK) ((GetAsyncKeyState(VK)&1)?1:0)//判断是否按过指定按键​

蛇⾝移动（SnakeMove）：

void SnakeMove(Snake* ps)
{
	SnakeNode* pNextNode = (SnakeNode*)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);
}

NextIsFood函数

检查蛇头下一个节点是否为食物

int NextIsFood(SnakeNode* pNextNode, Snake* ps)
{
	return (ps->pFood->x == pNextNode->x && ps->pFood->y == pNextNode->y);
}

EatFood函数

蛇头下一个节点是食物的情况

void EatFood(SnakeNode* pNextNode, Snake* ps)
{
	//头插法
	ps->pFood->next = ps->pSnake;
	ps->pSnake = ps->pFood;
	//释放掉下一个节点
	free(pNextNode);
	pNextNode = NULL;
	//打印蛇
	SnakeNode* cur = ps->pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%c", BODY);
		cur = cur->next;
	}
	ps->Socre += ps->foodWeight;
 
	//重新创建食物
	CreateFood(ps);
}

NoFood函数

蛇头下一个节点不是食物的情况

void NoFood(SnakeNode* pNextNode, Snake* ps)
{
	//头插法将下一个节点插进去
	pNextNode->next = ps->pSnake;
	ps->pSnake = pNextNode;
	//打印蛇
	SnakeNode* cur = ps->pSnake;
	while (cur->next->next != NULL)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%c", BODY);
		cur = cur->next;
	}
	//把最后一个结点打印成空格
	SetPos(cur->next->x, cur->next->y);
	printf("  ");
 
	//释放最后一个结点
	free(cur->next);
 
	//把倒数第二个节点的地址置为NULL
	cur->next = NULL;
}

KillByWall

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

void KillByWall(Snake* ps)
{
	if (ps->pSnake->x == 0 || ps->pSnake->x == 56 ||ps->pSnake->y == 0 || ps->pSnake->y == 26)
	{
		ps->Status = KILLBYWALL;
	}
}

KillBySelf

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

游戏结束

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

void GameEnd(Snake* ps)
{
	SetPos(24, 12);
	switch (ps->Status)
	{
	case ENDNORMAL:
		wprintf(L"您主动结束游戏\n");
		break;
	case KILLBYWALL:
		wprintf(L"您撞到墙上，游戏结束\n");
		break;
	case KILLBYSELF:
		wprintf(L"您撞到了自己，游戏结束\n");
		break;
	}
 
	//释放蛇身的链表
 
	SnakeNode* cur = ps->pSnake;
	while (cur)
	{
		SnakeNode* del = cur;
		cur = cur->next;
		free(del);
	}
	SetPos(0, 28);
}

参考代码

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"snake.h"
 
void test()
{
 
	//创建贪吃蛇
	Snake snake = { 0 };
	int ch = 0;
	do
	{
		system("cls");
    	//初始化游戏
	    //1. 打印环境界面
	    //2. 功能介绍
	    //3. 绘制地图
	    //4. 创建蛇
	    //5. 创建食物
	    //6. 设置游戏的相关信息
	    GameStart(&snake);
 
	    //运行游戏
	    GameRun(&snake);
 
	    //结束游戏
	    GameEnd(&snake);
		printf("再来一局吗？（Y/y）");
		ch = getchar();
		getchar();
	} while (ch == 'Y' || ch == 'y');
}
int main()
{
    setlocale(LC_ALL, "");//切换到本地环境
	srand((unsigned int)time(NULL));
	test();
 
	return 0;
}

Snake.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"snake.h"
 
void SetPos(int x, int y)
{
	COORD pos = { x,y };
	HANDLE pOutPut = GetStdHandle(STD_OUTPUT_HANDLE);
	//创建一个句柄
	SetConsoleCursorPosition(pOutPut, pos);
}
 
 
void GameStart(Snake* snake)
{
	//隐藏光标
	system("mode con cols=100 lines=32");
	system("title 贪吃蛇");
	HANDLE pOutPut = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO CursorInfo = { 0 };//定义一个结构体变量信息
	GetConsoleCursorInfo(pOutPut, &CursorInfo);//获得控制台光标信息
	CursorInfo.bVisible = false;//隐藏控制台光标
	SetConsoleCursorInfo(pOutPut, &CursorInfo);//设置控制台光标信息
 
	//打印欢迎界面
	Welcome();
 
	//绘制地图
	CreateMap();
 
	//创建蛇
	CreatSnake(snake);
 
	//创建食物
	CreateFood(snake);
 
	//打印游戏的提示信息
	PrintHelpInfo();
 
}
 
void Welcome()
{
	SetPos(40, 10);
	printf("欢迎来到贪吃蛇小游戏！");
	SetPos(40, 25);
	system("pause");
	system("cls");
	SetPos(30, 10);
	printf("用 ↑. ↓ . ← . → 来控制蛇的移动，按F3加速，F4减速\n");
	SetPos(30, 11);
	printf("加速能够得到更高的分数\n");
	SetPos(40, 25);
	system("pause");
	system("cls");
}
void CreateMap()
{
	int i = 0;
	for (i = 0; i < 29; i++)
	{
		wprintf(L"%c", WALL);
	}
	SetPos(0, 27);
	for (i = 0; i < 29; i++)
	{
		wprintf(L"%c",WALL);
	}
	for (i = 1; i < 27; i++)
	{
		SetPos(0, i);
		wprintf(L"%c", WALL);
	}
	for (i = 1; i < 27; i++)
	{
		SetPos(56, i);
		wprintf(L"%c", WALL);
	}
	
}
 
void CreatSnake(Snake* ps)
{
	SnakeNode* cur = NULL;
	for (int i = 0; i < 5; i++)
	{
		cur = (SnakeNode*)malloc(sizeof(SnakeNode));
		if (cur == NULL)
		{
			perror("CreatSnake():malloc");
			exit(1);
		}
		cur->next = NULL;
		cur->x = POS_X+i*2;
		cur->y = POS_Y;
		if (cur == NULL)
		{
			ps->pSnake = cur;
		}
		else
		{
			cur->next = ps->pSnake;
			ps->pSnake = cur;
		}
	}
	cur = ps->pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%c", BODY);
		cur = cur->next;
	}
	ps->Dir = RIGHT;
	ps->foodWeight = 10;
	ps->SleepTime = 200;
	ps->Socre = 0;
	ps->Status = NORMAL;
}
 
void CreateFood(Snake* ps)
{
	int x = 0;
	int y = 0;
again:
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 26 + 1;
	} while (x % 2 != 0);
	SnakeNode* cur = ps->pSnake;
	while (cur)
	{
		if (cur->x == x && cur->y == y)
		{
			goto again;
		}
		cur = cur->next;
	}
	SnakeNode* Food = (SnakeNode*)malloc(sizeof(SnakeNode));
	if (Food == NULL)
	{
		perror("CreatFood():malloc");
		return;
	}
	else
	{
		Food->x = x;
		Food->y = y;
		SetPos(x, y);
		wprintf(L"%c", FOOD);
		ps->pFood = Food;
	}
}
 
void PrintHelpInfo()
{
	//打印提⽰信息
	SetPos(64, 10);
	printf("不能穿墙，不能咬到自己\n");
	SetPos(64, 11);
	printf("用↑.↓.←.→分别控制蛇的移动.");
	SetPos(64, 12);
	printf("F3 为加速，F4 为减速\n");
	SetPos(64, 14);
	printf("ESC ：退出游戏.space：暂停游戏.");
}
 
void GameRun(Snake* ps)
{
	//• 上：VK_UP
	//• 下：VK_DOWN
	//• 左：VK_LEFT
	//• 右：VK_RIGHT
	//• 空格：VK_SPACE
	//• ESC：VK_ESCAPE
	//• F3：VK_F3
	//• F4：VK_F4
	do
	{
		SetPos(64, 0);
		printf("总分数:%d\n", ps->Socre);
		SetPos(64, 1);
		printf("当前食物的分数:%2d\n", ps->foodWeight);
		if (KET_PRESS(VK_UP) && ps->Dir != DOWN)
		{
			ps->Dir = UP;
		}
		else if (KET_PRESS(VK_DOWN) && ps->Dir != UP)
		{
			ps->Dir = DOWN;
		}
		else if (KET_PRESS(VK_LEFT) && ps->Dir != RIGHT)
		{
			ps->Dir = LEFT;
		}
		else if (KET_PRESS(VK_RIGHT) && ps->Dir != LEFT)
		{
			ps->Dir = RIGHT;
		}
		else if (KET_PRESS(VK_SPACE))
		{
			pause();
		}
		else if (KET_PRESS(VK_ESCAPE))
		{
			ps->Status = ENDNORMAL;
		}
		else if (KET_PRESS(VK_F3))
		{
			//按F3加速
			if (ps->SleepTime > 80)
			{
				ps->SleepTime -= 30;
				ps->foodWeight += 2;
			}
		}
		else if (KET_PRESS(VK_F4))
		{
			//按F4减速
			if (ps->foodWeight > 2)
			{
				ps->SleepTime += 30;
				ps->foodWeight -= 2;
			}
		}
 
		SnakeMove(ps);//蛇走一步的过程
 
		Sleep(ps->SleepTime);
	} while (ps->Status == NORMAL);
	
}
 
void pause()
{
	while (1)
	{
		Sleep(200);
		if (KET_PRESS(VK_SPACE))
		{
			break;
		}
	}
}
 
void SnakeMove(Snake* ps)
{
	SnakeNode* pNextNode = (SnakeNode*)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);
}
 
int NextIsFood(SnakeNode* pNextNode, Snake* ps)
{
	return (ps->pFood->x == pNextNode->x && ps->pFood->y == pNextNode->y);
}
 
void EatFood(SnakeNode* pNextNode, Snake* ps)
{
	//头插法
	ps->pFood->next = ps->pSnake;
	ps->pSnake = ps->pFood;
	//释放掉下一个节点
	free(pNextNode);
	pNextNode = NULL;
	//打印蛇
	SnakeNode* cur = ps->pSnake;
	while (cur)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%c", BODY);
		cur = cur->next;
	}
	ps->Socre += ps->foodWeight;
 
	//重新创建食物
	CreateFood(ps);
}
 
void NoFood(SnakeNode* pNextNode, Snake* ps)
{
	//头插法将下一个节点插进去
	pNextNode->next = ps->pSnake;
	ps->pSnake = pNextNode;
	//打印蛇
	SnakeNode* cur = ps->pSnake;
	while (cur->next->next != NULL)
	{
		SetPos(cur->x, cur->y);
		wprintf(L"%c", BODY);
		cur = cur->next;
	}
	//把最后一个结点打印成空格
	SetPos(cur->next->x, cur->next->y);
	printf("  ");
 
	//释放最后一个结点
	free(cur->next);
 
	//把倒数第二个节点的地址置为NULL
	cur->next = NULL;
}
 
void KillByWall(Snake* ps)
{
	if (ps->pSnake->x == 0 || ps->pSnake->x == 56 ||ps->pSnake->y == 0 || ps->pSnake->y == 26)
	{
		ps->Status = KILLBYWALL;
	}
}
 
void KillBySelf(Snake* ps)
{
	SnakeNode* cur = ps->pSnake->next;
	while (cur)
	{
		if (cur->x == ps->pSnake->x && cur->y == ps->pSnake->y)
		{
			ps->Status = KILLBYSELF;
			break;
		}
		cur = cur->next;
	}
}
 
void GameEnd(Snake* ps)
{
	SetPos(24, 12);
	switch (ps->Status)
	{
	case ENDNORMAL:
		wprintf(L"您主动结束游戏\n");
		break;
	case KILLBYWALL:
		wprintf(L"您撞到墙上，游戏结束\n");
		break;
	case KILLBYSELF:
		wprintf(L"您撞到了自己，游戏结束\n");
		break;
	}
 
	//释放蛇身的链表
 
	SnakeNode* cur = ps->pSnake;
	while (cur)
	{
		SnakeNode* del = cur;
		cur = cur->next;
		free(del);
	}
	SetPos(0, 28);
}

Snake.h

#pragma once
#include<stdio.h>
#include<windows.h>
#include<locale.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#define KET_PRESS(VK) ((GetAsyncKeyState(VK)&1)?1:0)//判断是否按过指定按键​
#define POS_X 24
#define POS_Y 5
#define WALL L'■'
#define BODY L'●'
#define FOOD L'★'
//蛇的方向
enum DIRECTION
{
	UP=1,
	DOWN,
	LEFT,
	RIGHT
};
//蛇的状态
//正常，撞墙，撞到自己，手动退出
enum GAME_STATUS
{
	NORMAL=1,
	KILLBYWALL,
	KILLBYSELF,
	ENDNORMAL
};
typedef struct SnakeNode
{
	int x;
	int y;
	struct SnakeNode* next;
}SnakeNode;
 
 
 
typedef struct Snake
{
	SnakeNode* pSnake;//指向蛇头的指针
	SnakeNode*  pFood;//指向食物的指针
	enum DIRECTION Dir;//蛇头的⽅向默认是向右
	enum GAME_STATUS Status;//游戏状态
	int Socre;//当前获得分数
	int foodWeight;//默认每个⻝物10分
	int SleepTime;//每⾛⼀步休眠时间
}Snake;
 
 
void SetPos(int x, int y);//设置坐标位置
 
void GameStart(Snake* snake);//游戏开始界面
 
void Welcome();//打印环境界面
 
void CreateMap();//创建地图
 
void CreatSnake(Snake* ps);//创建蛇
 
void CreateFood(Snake* ps);//创建食物节点
 
void PrintHelpInfo();//打印游戏的提示信息
 
void GameRun(Snake* snake);//游戏运行界面
 
void pause();//暂停游戏
 
void SnakeMove(ps);//蛇移动一步的变化
 
int NextIsFood(pNextNode, ps);//判断下一个节点是否为食物
 
void EatFood(SnakeNode* pNextNode, Snake* p);//下一个节点是食物的情况
 
void NoFood(SnakeNode* pNextNode, Snake* ps);//下一个节点不是食物的情况
 
void KillByWall(Snake* ps);//蛇撞墙死亡
 
void KillBySelf(Snake* ps);//蛇撞到自己死亡