C语言--贪吃蛇

1. 实现目标

使用C语言在Windows 环境的控制台中模拟实现经典小游戏贪吃蛇

实现的基本功能：

贪吃蛇的地图绘制
蛇吃食物的功能（上、下、左、右方向键控制蛇的动作）
蛇撞墙死亡
蛇撞自身死亡
计算得分
蛇身加速、减速
暂停游戏

2. 需掌握的技术

C语言函数、枚举、结构体、动态内存管理、预处理指令、链表、Win32 API等

3. Win32 API介绍

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

控制台程序

平常我们运行起来的程序其实就是控制台程序

我们可以可以使用cmd命令设置控制台窗口的长度：设置控制台窗口的大小，30行，100列

mode con cols=100 lines=30

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

title 贪吃蛇

这些能在控制台窗口执行的命令，也可以调用C语言函数system来执行

//设置控制台的显示大小、名称
int main()
{
	//设置控制台窗⼝的⻓宽：设置控制台窗⼝的⼤⼩，30⾏，100列
	system("mode con cols=100 lines=30");
	//设置cmd窗⼝名称
	system("title 贪吃蛇");
	//getchar();//输入一个字符程序再往下走
	system("pause");//程序暂停
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

控制台屏幕上的坐标COORD

COORD是Windows API中定义的一个结构体，表示一个字符在控制台屏幕上的坐标

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

#include 
int main()
{
	COORD pos = { 40,10 };//给坐标赋值
	return 0;
}
1
2
3
4
5
6

GetStdHandle

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

HANDLE GetStdHandle (DWORD nStdHandle);

#include 
#include 
int main()
{
	//获取标准输出的句柄（用来标识不同设备的数值）
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	return 0;
}

1
2
3
4
5
6
7
8
9

GetConsoleCursorinfo

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

BOOL WINAP GetConsoleCursorInfo(
HANDLE hConsoleOutput,
PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
);

实例：

#include 
#include 
int main()
{
	//获取标准输出的句柄（用来标识不同设备的数值）
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);

	CONSOLE_CURSOR_INFO cursor_info = {0};
	GetConsoleCursorInfo(handle,&cursor_info);//获取控制台光标信息
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

CONSOLE_CURSOR_INFO

这个结构体，包含有关控制台光标的信息

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

dwSize,由光标填充的字符单元格的百分比。此值介于1到100之间。光标外观会变化，返回从完全填充单元格到单元底部的水平线条。
bVisible,游标的可见性。如果光标可见，则此成员为TRUE

#include 
#include 
int main()
{
	//cursor_info.dwSize = 100;
	cursor_info.bVisible = false;//隐藏控制台光标
}
1
2
3
4
5
6
7

SetConsoleCursorInfo

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

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

例子：

#include 
#include 
int main()
{
	CONSOLE_CURSOR_INFO cursor_info = {0};
	
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	GetConsoleCursorInfo(handle,&cursor_info);//获取控制台光标信息
	//cursor_info.dwSize = 100;
	cursor_info.bVisible = false;//隐藏控制台光标
	SetConsoleCursorInfo(handle, &cursor_info);//设置控制台光标状态
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

SetConsoleCursorPosition

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

BOOL WINAPI SetConsoleCursorPosition(
HANDLE hConsoleOutput,
COORD pos
);

#include 
#include 
int main()
{
	//获得设备句柄
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	//根据句柄设置光标的位子
	COORD pos = { 20,5 };
	//设置标准输出上光标的位置为pos
	SetConsoleCursorPosition(handle, pos);
	printf("hehe");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

SetPos:分装一个设置光标位置的函数

#include 
#include 

SetPos(int x, int y)
{
	//获得设备句柄
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	//根据句柄设置光标的位子
	COORD pos = { x,y };
	SetConsoleCursorPosition(handle, pos);
}
int main()
{
	SetPos(20, 5);
	printf("hehe");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GetAsyncKeyState

获取按键情况，GetAsyncKeyState的函数原型如下：

SHORT GetAsyncKeyState(
int vKey
);

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

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

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

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

4. 贪吃蛇游戏设计与分析

地图

最终实现的效果：

在这里插入图片描述

如果想在控制台的窗口中指定位置输出信息，我们得知道该位置的坐标，所以首先介绍一下控制台窗口的坐标知识。

控制台窗口的坐标如下所示，横向是X轴，从左向右依次增长，纵向是Y轴，从上大下依次增长。

在这里插入图片描述

在游戏地图上，我打印墙体使用宽字符：□，打印蛇只用宽字符●，打印食物使用宽字符★

普通的字符是占一个字节的，这类宽字符是占2个字节的

为了使C语言适应国际化，C语言的标准中不断加入了国际化的支持。比如：加入和宽字符的类型wchar_t和宽字符的输入和输出函数，加入和头文件，其中提供了允许程序员针对特定地区调整程序行为的函数。

本地化

提供的函数用于控制C标准库中对于不同的地区会产生不一样行为的部分。
在标准可以，依赖地区的部分有以下几项

数字量的格式
货币量的格式
字符集
日期和时间的表示形式

类项

通过修改地区，程序可以改变它的行为来适用世界的不同区域。但地区的改变可能会影响库的许多部分，其中一部分可能是我们不希望修改的。所以C语言支持针对不同的类项进行修改。下面的一个宏，指定一个类项：

LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
LC_ALL-针对所有类项修改

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," ");//切换到本地环境

宽字符打印

如果想在屏幕上打印宽字符，怎么打印呢？

#include
int main()
{
	setlocale(LC_ALL, "");
	wchar_t ch1 = L'●';
	wchar_t ch2 = L'哈';
	printf("%c%c\n", 'a', 'b');
	wprintf(L"%lc\n", ch1);
	wprintf(L"%lc\n", ch2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

在这里插入图片描述

从输出的结果来看，我们发现一个不同字符占一个字符的位置但是打印一个汉字字符，占用2个字符的位置，那么我们如果要在贪吃蛇中使用宽字符，就得处理好地图上坐标的计算。

地图坐标

设计实现一个棋盘27行，58列
在这里插入图片描述

蛇身和食物

初始化状态，假设蛇的长度是5，蛇身的每个节点是●，在固定的一个坐标处，开始出现蛇，连续5个节点。注意：蛇的每个节点的X坐标必须是2个倍数，否则可能会出现蛇的一个节点由一半出现在墙体中，另外一半出现在墙外的现象，坐标不好对齐。

关于食物，就是在墙体内随机生成一个坐标（X坐标必须是2的倍数），坐标不能和蛇的身体重合，然后打印★。

5. 数据结构设计

在游戏运行的过程中，蛇每次吃一个食物，蛇的身体就会变长一节，如果我们使用链表存储蛇的信息，那么蛇的每一节点其实就是hi链表的每个节点。每个节点只需要记录好蛇身节点在地图上的坐标就行，所以蛇节点结构如下：

//贪吃蛇，蛇身节点的定义
typedef struct SnakeNode
{
	int x;
	int y;
	struct SnakeNode* next;
}SnakeNode, * pSnakeNode;
1
2
3
4
5
6
7

要管理整条贪吃蛇，我们要再分装一个Snake结构来维护整条贪吃蛇

//贪吃蛇
typedef struct Snake
{
	pSnakeNode pSnake;//维护整条蛇的指针
	pSnakeNode pFood;//指向食物的指针
	int Score;//当前累积的分数
	int FoodWeight;//一个食物的分数
	int SleepTime;//蛇休眠的时间，时间越短，速度越快
	enum GAME_STATUS status;//游戏的当前状态
	enum DIRECTION dir;//蛇当前走的方向
}Snake,*pSnake;

1
2
3
4
5
6
7
8
9
10
11
12

蛇的方向，可以一一列举，使用枚举

//蛇行走的方向
enum DIRECTION
{
	UP = 1,
	DOWN,
	LEFT,
	RIGHT
};
1
2
3
4
5
6
7
8

游戏状态，可以一一列举，使用枚举

//游戏的状态运行
enum GAME_STSTUS
{
	OK = 1,//正常运行
	ESC,//按了ESC键退出，正常退出
	KILL_BY_WALL,//撞墙
	KILL_BY_SELF//撞自身
};

1
2
3
4
5
6
7
8
9

6. 游戏流程设计

GameStart–游戏开始

设置游戏窗口的大小
设置窗口的名字
隐藏屏幕光标
打印欢迎界面–WelcomeToGame
创建地图–CreateMap
初始化蛇身–InitSnake
创建食物–CreateFood

GameRun–游戏运行

右侧打印帮助信息–PrintHelpInfo
打印当前已获得分数和每个食物的分数
获取按键情况–KEY_PRESS
根据按键情况移动蛇–SnakeMove
2~4循环，直到游戏是结束状态

SnakeMove

根据蛇头的坐标和方向，计算下一节点的坐标
判断下一节点是否是食物–NextIsFood
不是食物，吃掉植物，尾巴删除一节–NoFood
判断是否撞墙–KillByWall
判断是否撞上自己–KillBySelf

GameEnd–游戏结束

告知游戏结束的原因
释放蛇身节点

7. 核心逻辑实现分析

游戏主逻辑

#define _CRT_SECURE_NO_WARNINGS 1
#include "snack.h"


void test()
{
	
	int ch = 0;

	do
	{
		//创建贪吃蛇
		Snake snake = { 0 };
		GameStart(&snake);//游戏开始前的初始化

		GameRun(&snake);//玩游戏的过程
		GameEnd(&snake);//善后的工作

		SetPos(20,15);
		printf("再来一局吗？（Y/N）:");
		ch = getchar();
		getchar();//清理\n
	} while (ch=='Y'||ch=='y');
}

int main()
{
	//修改适配本地中文环境
	setlocale(LC_ALL,"");
	test();//贪吃蛇游戏的测试
	SetPos(0,27);
	return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

游戏开始

void GameStart(pSnake ps)
{
	//设置控制台的信息，窗口大小，窗口名称
	system("mode con cols=100 lines=30");
	system("title 贪吃蛇");

	//隐藏光标
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO CursorInfo;
	GetConsoleCursorInfo(handle, &CursorInfo);
	CursorInfo.bVisible = false;
	SetConsoleCursorInfo(handle, &CursorInfo);
	
	
	//打印欢迎信息
	WelcomeToGame();
	
	//绘制地图
	CreateMap();

	//初始化蛇
	InitSnake(ps);

	//创建食物
	CreateFood(ps);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

打印欢迎界面

void WelcomeToGame()
{
	//欢迎信息
	SetPos(40,10);
	printf("欢迎来到贪吃蛇小游戏\n");
	SetPos(40, 20);
	system("pause");
	system("cls");

	//功能介绍信息
	SetPos(15, 10);
	printf("用↑．↓．← ．→　来控制蛇的移动，A是加速，D是减速");
	SetPos(15, 11);
	printf("加速能够得到更高的分数");
	SetPos(40, 20);
	system("pause");
	system("cls");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

创建地图

创建地图就是将墙体打印出来，因为是宽字符打印，所有使用wprintf函数，打印格式串前使用L打印地图的关键是要算好坐标，才能在想要的位置打印墙体。

墙体打印的宽字符：

#define WALL L’□’

创建地图函数CreateMap

void CreateMap()
{
	//上
	SetPos(0, 0);
	int i = 0;
	for (i = 0; i <= 56; i += 2)
	{
		wprintf(L"%lc", WALL);
	}
	//下
	SetPos(0, 26);
	for (i = 0; i <= 56; i += 2)
	{
		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);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

蛇初始化蛇身

蛇最开始长度为5节，每节对应链表的一个节点，蛇身的每一个节点都有自己的坐标。

创建5个节点，然后将每个节点存放在链表中进行管理。创建完蛇身后，将蛇的每一节打印在屏幕上。

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

蛇身打印的宽字符：

#define BODY L’●’

初始化蛇身函数：InitSnake

void InitSnake(pSnake ps)
{
	pSnakeNode cur = NULL;
	for(int i=0;i<5;i++)
	{
		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
		if (cur == NULL)
		{
			printf("InitSnake():malloc() fail\n");
			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->FoodWeight = 10;
	ps->pFood = NULL;
	ps->Score = 0;
	ps->SleepTime = 200;
	ps->status = OK;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

创建第一个食物

先随机生成食物的坐标
- x的坐标必须是2的倍数
- 食物的坐标不能和蛇身每个节点的坐标重复
创建食物节点，打印食物

食物打印的宽字符：

#define FOOD L’★’

创建食物的函数：CreateFood

//创建食物
void CreateFood(pSnake ps)
{
	int x = 0;
	int y = 0;

again:
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 24 + 1;
	} while (x % 2 != 0);

	//坐标和蛇的身体的每个节点的坐标比较
	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;
	ps->pFood = pFood;
	SetPos(x, y);
	wprintf(L"%lc", FOOD);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

游戏运行

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

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

如果游戏继续，就是检测按键情况，确定蛇下一步的方向，或者是否加速减速，是否暂停或者退出游戏。

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

//游戏运行的整个逻辑
void GameRun(pSnake ps)
{
	//打印帮助信息
	PrintHelpInfo();
	
	do
	{
		//当前的分数情况
		SetPos(62, 10);
		printf("总分：%5d\n", ps->Score);
		SetPos(62, 11);
		printf("食物的分值：%02d\n", ps->FoodWeight);


		//监测按键
		//上、下、左、右、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(0x41))
		{
			//加速，休眠时间变短
			if (ps->SleepTime >= 80)
			{
				ps->SleepTime -= 30;
				ps->FoodWeight += 2;
			}
		}
		else if (KEY_PRESS(0x44))
		{
			if (ps->FoodWeight > 2)
			{
				ps->SleepTime += 30;
				ps->FoodWeight -= 2;
			}
		}
		

		//走一步
		SnakeMove(ps);

		//睡眠一下
		Sleep(ps->SleepTime);

	} while (ps->status == OK);
	
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

KEY_PRESS

检测按键状态，我们分装了一个宏

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

PrintHelpInfo

//打印帮助信息
void PrintHelpInfo()
{
	SetPos(62, 15);
	printf("1.不能穿墙，不能咬到自己");
	SetPos(62, 16);
	printf("2.用↑．↓．← ．→　来控制蛇的移动");
	SetPos(62, 17);
	printf("3.A是加速，D是减速");
	SetPos(62, 18);
	printf("4.ESC退出游戏，space暂停游戏");

	SetPos(62, 19);
	printf("加油噻！");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

蛇身移动

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

确定了下一个位置后，看下一个位置是否是食物，是食物就吃掉食物（EatFood）,如果不是食物则做前进一步的处理（NoEatFood）

蛇身移动后，判断此次移动是否会造成撞墙（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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

NextIsFood

//判断蛇头的下一步要走的位置处是否是食物
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
5
6
7
8
9
10
11

EatFood

//下一步要走的位置处是食物
void EatFood(pSnake ps, pSnakeNode pNext)
{
	pNext->next = ps->pSnake;
	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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

NoEatFood

将下⼀个节点头插⼊蛇的⾝体，并将之前蛇⾝最后⼀个节点打印为空格，放弃掉蛇⾝的最后⼀个节点


//下一步要走的位置不是食物
void NotEatFood(pSnake ps, pSnakeNode pNext)
{
	//头插法
	pNext->next = ps->pSnake;
	ps->pSnake = pNext;

	//释放尾结点
	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;


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

KillByWall

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

//监测是否被撞墙
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;
	}
}
1
2
3
4
5
6
7
8

KillBySelf

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

//监测是否撞自己
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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

游戏结束

游戏状态不再是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;
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

完整

test.c–贪吃蛇的测试

#define _CRT_SECURE_NO_WARNINGS 1
#include "snack.h"


void test()
{
	
	int ch = 0;

	do
	{
		//创建贪吃蛇
		Snake snake = { 0 };
		GameStart(&snake);//游戏开始前的初始化

		GameRun(&snake);//玩游戏的过程
		GameEnd(&snake);//善后的工作

		SetPos(20,15);
		printf("再来一局吗？（Y/N）:");
		ch = getchar();
		getchar();//清理\n
	} while (ch=='Y'||ch=='y');
}

int main()
{
	//修改适配本地中文环境
	setlocale(LC_ALL,"");
	test();//贪吃蛇游戏的测试
	SetPos(0,27);
	return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

snack.h–贪吃蛇游戏中类型的声明，函数的声明

#define _CRT_SECURE_NO_WARNINGS 1
#include 
#include 
#include 
#include 
#include 
#include 

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


//贪吃蛇，蛇身节点的定义
typedef struct SnakeNode
{
	int x;
	int y;
	struct SnakeNode* next;
}SnakeNode, * pSnakeNode;

//游戏的状态运行
enum GAME_STSTUS
{
	OK = 1,//正常运行
	ESC,//按了ESC键退出，正常退出
	KILL_BY_WALL,//撞墙
	KILL_BY_SELF//撞自身
};

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


//贪吃蛇
typedef struct Snake
{
	pSnakeNode pSnake;//维护整条蛇的指针
	pSnakeNode pFood;//指向食物的指针
	int Score;//当前累积的分数
	int FoodWeight;//一个食物的分数
	int SleepTime;//蛇休眠的时间，时间越短，速度越快
	enum GAME_STATUS status;//游戏的当前状态
	enum DIRECTION dir;//蛇当前走的方向
}Snake,*pSnake;



//定位控制台的光标位置
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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

snake.c–函数的实现

#define _CRT_SECURE_NO_WARNINGS 1
#include "snack.h"

void SetPos(int x, int y)
{
	//获得设备句柄
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	//根据句柄设置光标的位子
	COORD pos = { x,y };
	SetConsoleCursorPosition(handle, pos);
}


void WelcomeToGame()
{
	//欢迎信息
	SetPos(40,10);
	printf("欢迎来到贪吃蛇小游戏\n");
	SetPos(40, 20);
	system("pause");
	system("cls");

	//功能介绍信息
	SetPos(15, 10);
	printf("用↑．↓．← ．→　来控制蛇的移动，A是加速，D是减速");
	SetPos(15, 11);
	printf("加速能够得到更高的分数");
	SetPos(40, 20);
	system("pause");
	system("cls");
}



void CreateMap()
{
	//上
	SetPos(0, 0);
	int i = 0;
	for (i = 0; i <= 56; i += 2)
	{
		wprintf(L"%lc", WALL);
	}
	//下
	SetPos(0, 26);
	for (i = 0; i <= 56; i += 2)
	{
		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)
{
	pSnakeNode cur = NULL;
	for(int i=0;i<5;i++)
	{
		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
		if (cur == NULL)
		{
			printf("InitSnake():malloc() fail\n");
			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->FoodWeight = 10;
	ps->pFood = NULL;
	ps->Score = 0;
	ps->SleepTime = 200;
	ps->status = OK;
}


//创建食物
void CreateFood(pSnake ps)
{
	int x = 0;
	int y = 0;

again:
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 24 + 1;
	} while (x % 2 != 0);

	//坐标和蛇的身体的每个节点的坐标比较
	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;
	ps->pFood = pFood;
	SetPos(x, y);
	wprintf(L"%lc", FOOD);
}


void GameStart(pSnake ps)
{
	//设置控制台的信息，窗口大小，窗口名称
	system("mode con cols=100 lines=30");
	system("title 贪吃蛇");

	//隐藏光标
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO CursorInfo;
	GetConsoleCursorInfo(handle, &CursorInfo);
	CursorInfo.bVisible = false;
	SetConsoleCursorInfo(handle, &CursorInfo);
	
	
	//打印欢迎信息
	WelcomeToGame();
	
	//绘制地图
	CreateMap();

	//初始化蛇
	InitSnake(ps);

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





//打印帮助信息
void PrintHelpInfo()
{
	SetPos(62, 15);
	printf("1.不能穿墙，不能咬到自己");
	SetPos(62, 16);
	printf("2.用↑．↓．← ．→　来控制蛇的移动");
	SetPos(62, 17);
	printf("3.A是加速，D是减速");
	SetPos(62, 18);
	printf("4.ESC退出游戏，space暂停游戏");

	SetPos(62, 19);
	printf("加油噻！");
}


void pause()
{
	while (1)
	{
		Sleep(100);
		if (KEY_PRESS(VK_SPACE))
		{
			break;
		}
	}
}


//判断蛇头的下一步要走的位置处是否是食物
int NextIsFood(pSnake ps, pSnakeNode pNext)
{
	if (ps->pFood->x == pNext->x && ps->pFood->y == pNext->y)
	{
		return 1;//下一处坐标是食物
	}
	else {
		return 0;
	}
}

//下一步要走的位置处是食物
void EatFood(pSnake ps, pSnakeNode pNext)
{
	pNext->next = ps->pSnake;
	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);
}

//下一步要走的位置不是食物
void NotEatFood(pSnake ps, pSnakeNode pNext)
{
	//头插法
	pNext->next = ps->pSnake;
	ps->pSnake = pNext;

	//释放尾结点
	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;
			return;
		}
		cur = cur->next;
	}
}





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





//游戏运行的整个逻辑
void GameRun(pSnake ps)
{
	//打印帮助信息
	PrintHelpInfo();
	
	do
	{
		//当前的分数情况
		SetPos(62, 10);
		printf("总分：%5d\n", ps->Score);
		SetPos(62, 11);
		printf("食物的分值：%02d\n", ps->FoodWeight);


		//监测按键
		//上、下、左、右、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(0x41))
		{
			//加速，休眠时间变短
			if (ps->SleepTime >= 80)
			{
				ps->SleepTime -= 30;
				ps->FoodWeight += 2;
			}
		}
		else if (KEY_PRESS(0x44))
		{
			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;
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462

相关阅读:
解析Redis缓存穿透、击穿和雪崩问题及解决方案
 JavaScript逆向循环和嵌套循环
 【Python数据结构与判断7/7】数据结构小结
 【ROS】初识ROS
React - 路由 NavLink 使用与 NavLink 组件封装使用（路由高亮）
heic图片转换
 【电商】电商供应链产品介绍
 JS-Vue-属性表单事件绑定
 C++/C关于#define的那些奇奇怪怪的用法
 Linux第一个小程序——进度条
原文地址：https://blog.csdn.net/weixin_52550678/article/details/136254344

C语言--贪吃蛇

目录

1. 实现目标

2. 需掌握的技术

3. Win32 API介绍

控制台程序

控制台屏幕上的坐标COORD

GetStdHandle

GetConsoleCursorinfo

CONSOLE_CURSOR_INFO

SetConsoleCursorInfo

SetConsoleCursorPosition

GetAsyncKeyState

4. 贪吃蛇游戏设计与分析

地图

本地化

类项

setlocale函数

宽字符打印

地图坐标

蛇身和食物

5. 数据结构设计

6. 游戏流程设计

7. 核心逻辑实现分析

游戏主逻辑

游戏开始

打印欢迎界面

创建地图

蛇初始化蛇身

创建第一个食物

游戏运行

KEY_PRESS

PrintHelpInfo

蛇身移动

NextIsFood

EatFood

NoEatFood

KillByWall

KillBySelf

游戏结束

完整

test.c–贪吃蛇的测试

snack.h–贪吃蛇游戏中类型的声明，函数的声明

snake.c–函数的实现