C语言——贪吃蛇游戏的实现

2024-04-27 1247阅读

C语言——贪吃蛇游戏的实现

目录

 一. 贪吃蛇的介绍

二. Win32 API

1. 控制台程序

2. COORD 控制台屏幕上的坐标

3. GetStdHandle

4. GetConsoleCursorInfo

CONSOLE_CURSOR_INFO

5. SetConsoleCursorInfo

6. SetConsoleCursorPosition

封装的SetPos函数

7. GetAsyncKeyState

宏定义KEY_PRESS

三. 贪吃蛇游戏实现

1. 贪吃蛇地图

和类项

setlocale函数

打印地图

封装的墙函数

2. 设计蛇和食物

3. 游戏实现流程

1. 游戏开始-GameStart

1.打印欢迎界面

2.打印创建地图

3.创建蛇-初始化

4.创建食物

2. 游戏运行-GameRun

暂停—Pause函数

1.蛇的移动

2.下一个位置是否是食物

无食物-NoFood

判断是否是食物-NextIsFood

3.吃掉食物——EatFood

4.撞到墙——KillByWall

5.撞到自己——KillBySelf

3. 游戏结束——GameEnd

四. 展示所有全部代码

 一. 贪吃蛇的介绍

                                 C语言——贪吃蛇游戏的实现

 我们都有玩过一个小游戏——贪吃蛇，贪吃蛇也是一个经典游戏。如上图所示，游戏玩法就是操控一个蛇，让它吃掉食物，每吃掉一个食物就会增加自己身体一格长度，并且保证自己不能撞到墙和自己本身，我们就可以通过这些功能，去用代码实现这些功能从而实现贪吃蛇游戏。（贪吃蛇游戏如上图所示）

我们总结一下贪吃蛇所需要的基本功能：

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

    我们完成的游戏，是在控制台窗口完成。

    这里设计的知识要点有：C语言函数，枚举类型，结构体，动态内存管理，预处理指令，链表（链表用于维护贪吃蛇的蛇身），Win32 API等。

    二. Win32 API

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

    1. 控制台程序

    控制台（console）程序可能听起来名字比较陌生，其实是如图所示：

    C语言——贪吃蛇游戏的实现

    打开方式可以按Windows+R，在输入cmd。

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

    mode con cols=100 lines=30

    C语言——贪吃蛇游戏的实现

    我们可以看一下对比，上图所示

    设置控制台窗口的名字的指令：

    title 贪吃蛇

    C语言——贪吃蛇游戏的实现

    这些操作可以调用C语言函数system执行：

    注意：使用时记得包含stdlib.h头文件

    #include 
#include 
//system函数可以用来执行系统命令//
int main()
{
	//设置控制台的相关属性
	system("mode con cols=100 lines=30");  //设置大小
	system("title 贪吃蛇");                //设置名字
	system("pause");                      //也可以getchar();效果一样。防止程序结束，导致结果有问题
	return 0;
}

    效果展示：

    C语言——贪吃蛇游戏的实现

    2. COORD 控制台屏幕上的坐标

    C语言——贪吃蛇游戏的实现

    控制台的坐标分布是上图所示

    COORD类型的声明：

    typedef struct _ COORD {         SHORT X;         SHORT Y; } COORD, *PCOORD; 所以给坐标赋值为： 
    COORD pos = { 10, 15 };  //给坐标赋值为(10,15)

    注意：需要包含头文件windows.h

    3. GetStdHandle

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

    函数参数：

    C语言——贪吃蛇游戏的实现

    函数使用：

    int main()
{
	//获得标准输出设备的句柄
	HANDLE houtput = NULL;    //HANDLE 是一个指针变量  typedef void *HANDLE
	houtput = GetStdHandle(STD_OUTPUT_HANDLE); //获得屏幕标准输出设备
    return 0;
}

    4. GetConsoleCursorInfo

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

    C语言——贪吃蛇游戏的实现注：第二个参数是个指针，指向（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。

      5. SetConsoleCursorInfo

      //语法声明
BOOL WINAPI SetConsoleCursorInfo(
  _In_       HANDLE              hConsoleOutput,
  _In_ const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
);

      第一个参数就是句柄，第二个参数就是光标信息的地址。

      结合起来运用：

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

      效果如下：

      改占比

      C语言——贪吃蛇游戏的实现

      修改可见性

      C语言——贪吃蛇游戏的实现

      6. SetConsoleCursorPosition

      设置指定控制台屏幕缓冲区中的光标位置，我们将想要设置的坐标信息放在COORD类型的pos中，调用SetConsoleCursorPosition函数将光标位置设置到指定的位置。 
      //语法声明
BOOL WINAPI SetConsoleCursorPosition(
  _In_ HANDLE hConsoleOutput,
  _In_ COORD  dwCursorPosition
);

      第一个参数是句柄

      第二个参数就是位置

      #include 
#include 
int main()
{
	//获得标准输出设备的句柄
	HANDLE houtput = NULL;
	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	//定位光标的位置
	COORD pos = { 10, 20 };
	SetConsoleCursorPosition(houtput, pos);
	printf("hehe\n");
	return 0;
}

      效果如下：

      C语言——贪吃蛇游戏的实现

      我们把这个封装一个设置光标位置的函数

      封装的SetPos函数

      void SetPos(short x, short y)
{
	//获得标准输出设备的句柄
	HANDLE houtput = NULL;
	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	//定位光标的位置
	COORD pos = { x, y };
	SetConsoleCursorPosition(houtput, pos);
}
int main()
{
	
	SetPos(10, 20);
	printf("1\n");
	SetPos(10, 10);
	printf("2\n");
	getchar();
	//system("pause");
	return 0;
}

      效果展示如图：

      C语言——贪吃蛇游戏的实现

      7. GetAsyncKeyState

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

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

      虚拟键码链接：虚拟键码

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

      因此我们可以定义一个宏

      宏定义KEY_PRESS
      //结果是1表示按过
//结果是0表示未按过
#define KEY_PRESS(vk)  ((GetAsyncKeyState(vk)&1)?1:0)

      这个就以便于我们后面实现贪吃蛇用按键控制方向所使用。

      三. 贪吃蛇游戏实现

      1. 贪吃蛇地图

      C语言——贪吃蛇游戏的实现

      我们可以用自己所想要的符号来完成地图（墙）的创建，这里使用了宽字符，墙体的为□，蛇的为⚪，食物为★。

      注意：普通字符占一个字节，宽字符占2个字节。

      和类项

      提供的函数用于控制C标准库中对于不同的地区会产生不⼀样行为的部分。 在标准中，依赖地区的部分有以下几项：
      • 数字量的格式
      • 货币量的格式
      • 字符集
      • 日期和时间的表示形式

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

        注：LC_ALL-针对所有类项修改，将所有类别设置为给定的语言环境。

        setlocale函数

        //函数原型
char* setlocale (int category, const char* locale);
        setlocale 函数用于修改当前地区，可以针对一个类项修改，也可以针对所有类项。 setlocale 的第一个参数可以是前面说明的类项中的一个，那么每次只会影响一个类项，如果第一个参数是LC_ALL，就会影响所有的类项。 注意：C标准给第二个参数仅定义了2种可能取值："C"（正常模式）和" "（本地模式）。并且在任意程序执行开始，都会隐藏式执行调用： 
        setlocale(LC_ALL, "C");
当地区设置为"C"时，库函数按正常⽅式执⾏，小数点是一个点。

        若要改变地区，调用setlocale函数。用""作为第二个参数

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

        打印地图

        在此之前，需要知道宽字符打印的格式和函数

        宽字符的字面量必须加上前缀“L”，否则 C 语言会把字面量当作窄字符类型处理。前缀“L”在单引号前面，表示宽字符，对应 wprintf() 的占位符为 %lc ；在双引号前面，表示宽字符串，对应 wprintf() 的占位符为 %ls 。 
        //使用格式如下
#include 
#include 
int main()
{
	//设置本地化
	setlocale(LC_ALL, "");
	char a = 'a';
	char b = 'b';
	printf("%c%c\n", a, b);
	wchar_t wc1 = L'测';
	wchar_t wc2 = L'试';
	wprintf(L"%lc\n", wc1);
	wprintf(L"%lc\n", wc2);
	wprintf(L"%lc\n", L'●');
	wprintf(L"%lc\n", L'★');
	return 0;
}

        我们看一下结果：

        C语言——贪吃蛇游戏的实现

        ab是普通字符，以下都是宽字符，对比看出，ab两个字符所占字节才等于一个宽字符所占字节。

        我们要设计一个27*27的范围，就是要设计一个27行，58列的棋盘，我们封装的函数SetPos设置光标坐标函数就用上了

        封装的墙函数
        #define WALL L'□'
//创建地图
void CreateMap()
{
	//上
	int i = 0;
	for (i = 0; i y = POS_Y;          //初始化y坐标
		//头插法插入链表
		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;  //默认总分0
	ps->_food_weight = 10; //食物分数10
	ps->_sleep_time = 200; //单位毫秒
	ps->_status = OK;      //正常运行
}
        4.创建食物
        • 随机生成食物的坐标：x坐标必须2的倍数、食物坐标不能和蛇身重复
        • 创建食物节点，打印 
          //创建食物
void CreateFood(pSnake ps)
{
	int x = 0;
	int y = 0;
	//生成x是2的倍数
	//x:2---52
	//y:1---25
again:
	//要使x坐标为2的倍数，否则对不齐蛇头坐标
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 25 + 1;
	} while (x % 2 != 0);
	//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;
	}
	else
	{
		pFood->x = x;
		pFood->y = y;
		pFood->next = NULL;
		SetPos(x, y);  //定位位置
		wprintf(L"%lc", FOOD);
		ps->_pFood = pFood;  //把随机的食物节点赋值到用于维护贪吃蛇的结构体成员中用于维护食物
	}
}

          查看一下成果：

          C语言——贪吃蛇游戏的实现

          C语言——贪吃蛇游戏的实现C语言——贪吃蛇游戏的实现可以看到开始游戏已经实现，蛇要运动还需要完成GameRun

          2. 游戏运行-GameRun

          • 根据游戏状态检查游戏是否继续，如果是OK，则继续，否则结束。
          • 如果游戏继续，检查按键情况，确定蛇下一步方向、是否加速减速、是否暂停或者退出游戏。
          • 我们要在（64，15）这个坐标开始，在运行期间，打印帮助信息，提示玩家。

            先完成PrintHelpInfo打印帮助信息函数

            //打印帮助信息
void PrintHelp()
{
	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退出游戏，按空格暂停游戏");
}

            所需虚拟键盘的罗列：

            • 上：VK_UP
            • 下：VK_DOWN
            • 左： VK_LEFT
            • 右： VK_RIGHT
            • 空格： VK_SPACE
            • ESC：VK_ESCAPE
            • F3：VK_F3
            • F4：VK_F4 蛇的方向和速度确定，就可以让蛇移动了 
              //游戏运行
void GameRun(pSnake ps)
{
	//打印帮助信息
	PrintHelp();
	do
	{
		//打印总分数和食物的分值
		SetPos(64, 10);
		printf("总分数：%d\n", ps->_score);
		SetPos(64, 11);
		printf("当前食物的分数:%2d\n", ps->_food_weight);  //%2d防止打印一位数时出bug
		//判断按键情况，并做出相应操作
		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->_sleep_time -= 30;
				ps->_food_weight += 2;
			}
		}
		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);
}
              暂停—Pause函数
              //暂停
void Pause()
{
	while (1)
	{
		Sleep(200);
		if (KEY_PRESS(VK_SPACE))
		{
			break;
		}
	}
}
              1.蛇的移动

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

              注：

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

                注意：x+2是要确保x坐标为2的倍数。

                2.下一个位置是否是食物
                无食物-NoFood

                将下一个节点头插入蛇的身体，并将之前的蛇身最后一个节点打印为空格，释放掉蛇身最后一个节点。

                注意：释放最后一个节点后，还要把指向最后一个节点的指针改为NULL，保证蛇尾打印可以正常结束，不会越界访问。

                // 下一个位置不是食物
//pSnakeNode pn 是下一个节点的地址
//pSnake 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("  ");  //注意要两个空格，否则会出bug
	//释放最后一个结点
	free(cur->next);
	//把倒数第二个节点的地址置为NULL
	cur->next = NULL;
}
                判断是否是食物-NextIsFood

                只需判断下一个节点的坐标是否与所存储的食物的坐标一致就可，若是就返回真

                //判断下一个坐标是否是食物
//pSnakeNode pn 是下一个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnakeNode pn, pSnake ps)
{
	return (pn->x == ps->_pFood->x) && (pn->y == ps->_pFood->y);
}
                3.吃掉食物——EatFood

                只需将这个节点头插到蛇身，释放节点，再把蛇打印，无需打印空格，并且总分增加，最后重新创建食物。

                //吃掉食物
//pSnakeNode pn 是下一个节点的地址
//pSnake ps 维护蛇的指针
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);
}
                4.撞到墙——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;
	}
}
                5.撞到自己——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;
			break;
		}
		cur = cur->next;
	}
}

                3. 游戏结束——GameEnd

                游戏状态不再是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);
	}
}

                四. 展示所有全部代码

                //test.c
#define  _CRT_SECURE_NO_WARNINGS 1
#include 
#include "snake.h"
//完成的是游戏的测试逻辑
void test()
{
	int ch = 0;
	do
	{
		system("cls");
		//创建贪吃蛇
		Snake snake = { 0 };
		//初始化游戏
		//1. 打印环境界面
		//2. 功能介绍
		//3. 绘制地图
		//4. 创建蛇
		//5. 创建食物
		//6. 设置游戏的相关信息
		GameStart(&snake);
		//运行游戏
		GameRun(&snake);
		//结束游戏 - 善后工作
		GameEnd(&snake);
		SetPos(20, 15);
		printf("再来一局吗?(Y/N):");
		ch = getchar();
		while (getchar() != '\n');
		//system("cls");
	} while (ch == 'Y' || ch == 'y');
	SetPos(0, 27);
}
int main()
{
	//设置适配本地环境
	setlocale(LC_ALL, "");
	srand((unsigned int)time(NULL));
	test();
	return 0;
}
                //snake.h
#pragma once
#include
#include
#include
#include
#include 
#define POS_X 24
#define POS_Y 5
#define WALL L'□'
#define BODY L'●'
#define FOOD L'★'
//宏定义判断是否按过键
#define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )
//类型的声明
//蛇的方向
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 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 SetPos(short x, short y);
//游戏的初始化
void GameStart(pSnake ps);
//欢迎界面和功能介绍
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 GameEnd(pSnake ps);
//撞墙
void KillByWall(pSnake ps);
//撞自己
void KillBySelf(pSnake ps);
                #define  _CRT_SECURE_NO_WARNINGS 1
#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()
{
	//上
	int i = 0;
	for (i = 0; i y = POS_Y;          //初始化y坐标
		//头插法插入链表
		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->_status = OK;
}
//创建食物
void CreateFood(pSnake ps)
{
	int x = 0;
	int y = 0;
	//生成x是2的倍数
	//x:2---52
	//y:1---25
again:
	//要使x坐标为2的倍数，否则对不齐蛇头坐标
	do
	{
		x = rand() % 53 + 2;
		y = rand() % 25 + 1;
	} while (x % 2 != 0);
	//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;
	}
	else
	{
		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=30");
	system("title 贪吃蛇");
	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
	//隐藏光标操作
	CONSOLE_CURSOR_INFO CursorInfo;
	GetConsoleCursorInfo(houtput, &CursorInfo);//获取控制台光标信息
	CursorInfo.bVisible = false; //隐藏控制台光标
	SetConsoleCursorInfo(houtput, &CursorInfo); //设置控制台光标状态
	//1.打印环境界面
	//2.功能介绍
	WelcomeToGame();
	//3.绘制地图
	CreateMap();
	//4.创建蛇
	InitSnake(ps);
	//5.创建食物
	CreateFood(ps);
}
//打印帮助信息
void PrintHelp()
{
	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退出游戏，按空格暂停游戏");
	SetPos(64, 25);
	wprintf(L"%ls", L"DUST制作");
}
// 下一个位置不是食物
//pSnakeNode pn 是下一个节点的地址
//pSnake 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("  ");  //注意要两个空格，否则会出bug
	//释放最后一个结点
	free(cur->next);
	//把倒数第二个节点的地址置为NULL
	cur->next = NULL;
}
//判断下一个坐标是否是食物
//pSnakeNode pn 是下一个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnakeNode pn, pSnake ps)
{
	return (pn->x == ps->_pFood->x) && (pn->y == ps->_pFood->y);
}
//吃掉食物
//pSnakeNode pn 是下一个节点的地址
//pSnake ps 维护蛇的指针
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 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 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 Pause()
{
	while (1)
	{
		Sleep(200);
		if (KEY_PRESS(VK_SPACE))
		{
			break;
		}
	}
}
//游戏运行
void GameRun(pSnake ps)
{
	//打印帮助信息
	PrintHelp();
	do
	{
		//打印总分数和食物的分值
		SetPos(64, 10);
		printf("总分数：%d\n", ps->_score);
		SetPos(64, 11);
		printf("当前食物的分数:%2d\n", ps->_food_weight);  //%2d防止打印一位数时出bug
		//判断按键情况，并做出相应操作
		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->_sleep_time -= 30;
				ps->_food_weight += 2;
			}
		}
		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);
	}
}

                运行结果：C语言——贪吃蛇游戏的实现

                C语言——贪吃蛇游戏的实现C语言——贪吃蛇游戏的实现C语言——贪吃蛇游戏的实现C语言——贪吃蛇游戏的实现C语言——贪吃蛇游戏的实现C语言——贪吃蛇游戏的实现 制作不易，求各位大佬三连qwq，若有问题的地方，请大佬们多多指教。 C语言——贪吃蛇游戏的实现
VPS购买请点击我

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

相关阅读

目录[+]