devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言实现贪吃蛇小游戏详细讲解_游戏程序设计

作者：空白诗007 | 2024-08-19 08:42:10

赞

踩

游戏程序设计

今天我们用C语言来编写一个简易版的1贪吃蛇小游戏，在代码层面是由Snake.h  Snake.c  game.c 三个文件构成的项目，使用的集成开发环境是VS2022，下面我将较为详细的介绍相关的背景知识与整体实现的代码。

完全运行后效果演示如下：

 

 

 

Win32 API 介绍

这次的贪吃蛇游戏需要用到部分Win32 API的知识来完成许多游戏界面的布设。

1：Win32 API

我们平常所说的windows，既是一个可以协调应用程序的执行、分配内存、管理资源的多作业系统，也是一个服务中心，调用这个服务中心的各种服务（实际上就是函数），可以帮助应用程序达到开启视窗、描绘图形、使用周边设备的目的。这样的函数被称为API函数。

Win32 API指的就是Microsoft Windows 32位平台的应用程序编程接口。

2：控制台程序（console）

平常我们运行程序时显示出来的黑框就是控制台，为了实现贪吃蛇游戏，我们需要对控制台窗口进行设置。

首先我们右击控制台窗口上方，选择属性，确保你的默认终端应用程序是Windows控制台主机。

在属性——颜色界面，可以根据个人喜好选择背景与字体颜色，如图为灰色背景和蓝色字体。

很可能你的VS默认是“让Windows决定”，这时我们在相同位置右击—— 设置——启动——将默认终端应用程序修改为Windows控制台主机。

平时我们可以直接在电脑的搜索栏或者 Windows+R键 用cmd指令调用控制台进行设置。如：mode con cols=100 lines=30 是用来设置控制台窗口的长度（100列）和宽度（30行）的。

游戏过程中我们希望标题栏可以显示“贪吃蛇字样”，可以使用指令：title 贪吃蛇

那么在C语言代码中想要实现以上功能，需要使用库函数 system(); 同时需要包含头文件<stdlib.h> 列如：

  1. system("mode con cols=50 lines=20");
  2. system("title 贪吃蛇");
  3. system("pause");
  4. //标题只会在程序运行过程中显示，结束之后不再显示
  5. //可以用pause指令暂停以查看

3：控制台屏幕上的坐标 COORD

想要在屏幕上的不同位置打印字样，必然用到坐标，控制台屏幕上的坐标是以左上角为（0,0）点，水平向右为X轴正方向，竖直向下是Y轴正方向。位置坐标的数据类型是COORD。

  1. //COORD类型的声明
  2. typedef struct _COORD{
  3. SHORT X;
  4. SHORT Y;
  5. }COORD,*PCOORD;

现在我可以定义一个坐标（需要头文件<windows.h>）。

COORD pos ={40,10};

4：GetStdHandle

这是一个Windows API函数，用于从一个特定的标准设备（包括标准输入、标准输出、标准错误）中取得一个句柄（用来标识不同设备的数值），使用这个句柄可以操作设备。我们往往通过传不同的控制台对应的句柄给函数来操作。

5：GetConsoleCursorInfo

这个函数用于检索有关指定控制台屏幕缓冲区的光标大小和可见性的信息。应用实例：

  1. HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);//获取句柄
  2. CONSOLE_CURSOR_INFO CursorInfo;//初始化光标信息
  3. GetConsoleCursorInfo(handle, &CursorInfo);//获取光标信息

以下是光标信息的内部结构体：

  1. typedef struct _CONSOLE_CURSOR_INFO{
  2. DWORD dwSize;
  3. BOOL bVisible;
  4. }_CONSOLE_CURSOR_INFO,*P_CONSOLE_CURSOR_INFO;

其中dwSize是由光标填充的字符单元格的百分比，介于1到100；bVisible是游标可见性，可见为TRUE。

6：SetConsoleCursorInfo

这个函数用于设置指定控制台屏幕缓冲区的光标大小和可见性。我们可以接续上述代码：

  1. HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);//获取句柄
  2. CONSOLE_CURSOR_INFO CursorInfo;//初始化光标信息
  3. GetConsoleCursorInfo(handle, &CursorInfo);//获取光标信息
  4. CursorInfo.dwSize=100;
  5. CursorInfo.bVisible=false;//隐藏光标
  6. SetConsoleCursorInfo(handle,&CursorInfo);//设置光标信息

7：SetConsoleCursorPosition

这个函数用于设置指定控制台屏幕缓冲区中的光标位置。下面是使用格式：

  1. HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  2. COORD pos={20,5};
  3. SetConsoleCursorPosition(handle,pos);
  4. printf("111");
  5. //这样打印的位置就会在窗口的（20,5）

为了使用的方便，我们可以将这一整个设置位置的操作封装为函数：

  1. void SetPos(int x,int y){
  2. HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  3. COORD pos ={x,y};
  4. SetConsoleCursorInfo(handle,pos);
  5. }

8：GetAsynckeyState

这个函数可以获取按键情况，将键盘上每个键的虚拟键值传递给函数，函数返回值（short类型）可以用来分辨按键的状态。要判断一个键是否被按过，可检测GetAsynckeyState返回值最低值是否为1，使用时我们将它封装为一个宏：

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

在vk的位置输入指定的虚拟键值（详情可自查），如此按键被按过则为1，否则为0，恰好对应条件为真或假。

游戏设计

在了解了这些函数之后，我们实际上已经可以将诸多程序的实现做得更加完善了，下面系统介绍

一下贪吃蛇游戏的编写。

1：地图设计

①：宽字符

我们平常所打印的英文字母等实际只会占一个字节（一格光标）的位置，打印地图时使用到的是宽字符 ■ ★ ● ，一次占两个字节（两格光标），包括汉字也是如此。

②：<locale.h>本地化

控制C标准库中对于不同地区会产生不一样行为的部分，这里有数字量、货币量的格式，字符集，日期和时间的表示形式。

③：setlocale函数

C语言支持针对不同类项的修改，如LC_COLLATE、LC_ALL等。setlocale函数可以修改当前地区，参数一是类项，参数二只有 "c"（正常）和 ""（本地）。列如：

  1. setlocale(LC_ALL,"c");
  2. setlocale(LC_ALL,"");

函数返回一个字符串指针，若调用失败，返回空指针NULL。如果将参数二设为NULL，可用来查询当前地区。

④：宽字符的打印

宽字符数据类型为 wchar_t,宽字符字面量前须加前缀L，打印时使用wprintf。

L在 ' ' 前表示宽字符，对应的占位符为%lc，在 " " 前表示宽字符串，对应的占位符为%ls。举例：

  1. setlocale(LC_ALL,"");
  2. wchar_t ch1=L'中',ch2=L'国';
  3. wprintf(L"%lc",ch1);
  4. wprintf(L"%lc",ch2);

2：数据结构设计

我们同过单链表的形式来维护蛇，在头文件中，定义蛇的结构体：

  1. //蛇的每个节点
  2. typedef struct SnakeNode {
  3. 	int x;//坐标
  4. 	int y;
  5. 	struct SnakeNode* next;
  6. }SnakeNode,*pSnakeNode;
  7. //重命名，并定义指向每个节点的指针

然后是对整条蛇的结构体：

  1. typedef struct Snake
  2. {
  3. 	pSnakeNode pSnake;//维护整条蛇的指针，指向蛇头
  4. 	pSnakeNode pFood;//指向食物的指针
  5. 	int score;//分数
  6. 	int FoodWeight;//食物的分数
  7. 	int SleepTime;//休眠时间
  8. 	enum GAME_STATUS status;//游戏状态
  9. 	enum DIRECTION dir;//蛇当前走的方向
  10.  }Snake,*pSnake;

游戏状态可以分为正常运行、退出，因为撞墙或装到自己而死亡，可以用枚举来表示：

  1. enum GAME_STATUS
  2. {
  3. 	OK = 1,//正常运行
  4. 	ESC,//正常退出
  5. 	KILL_BY_WALL,
  6. 	KILL_BY_SELF
  7. };

蛇的运行与速度和方向有关，速度即是每走一步的休眠时间，方向再用一个枚举来表示：

  1. enum DIRECTION
  2. {
  3. 	UP=1,
  4. 	DOWN,
  5. 	LEFT,
  6. 	RIGHT
  7. };

3：游戏开始

在主函数中将依次运行各个部分的函数，首先是GameStart函数：

  1. void GameStart(pSnake ps)
  2. {
  3. 	//设置控制台窗口
  4. 	system("mode concols=100 lines=30");
  5. 	system("title 贪吃蛇");
  6. 	//隐藏光标
  7. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  8. 	CONSOLE_CURSOR_INFO CursorInfo;
  9. 	GetConsoleCursorInfo(handle, &CursorInfo);
  10. 	CursorInfo.bVisible = false;
  11. 	SetConsoleCursorInfo(handle, &CursorInfo);
  12.  
  13. 	WelcomeToGame();
  14. 	CreateMap();
  15. 	InitSnake(ps);
  16. 	CreateFood(ps);
  17. }

接下来是打印开头的信息，将光标定位到屏幕的中间位置，每次结束，暂停程序，清理屏幕

  1. void WelcomeToGame()
  2. {
  3. 	SetPos(35, 10);
  4. 	printf("欢迎来到贪吃蛇小游戏");
  5. 	SetPos(39, 11);
  6. 	printf("作者：zhuoer");
  7. 	SetPos(38, 20);
  8. 	system("pause");
  9. 	system("cls");
  10. 	SetPos(22, 10);
  11. 	printf("用↑.↓.←.→来控制方向，左shift是加速，右shift是减速");
  12. 	SetPos(36, 11);
  13. 	printf("加速能获得更高的分数");
  14. 	SetPos(38, 20);
  15. 	system("pause"); 
  16. 	system("cls");
  17. }

然后是打印墙体，为了方便，将墙体的宽字符封装为一个宏：

#define WALL L'■'

  1. void CreateMap()
  2. {
  3. 	int i = 0;
  4.  
  5. 	SetPos(0, 0);
  6. 	for (i = 0; i <= 56; i += 2)
  7. 	{
  8. 		wprintf(L"%lc", WALL);
  9. 	}
  10. 	SetPos(0,26);
  11. 	for (i = 0; i <= 56; i += 2)
  12. 	{
  13. 		wprintf(L"%lc", WALL);
  14. 	}
  15. 	for (i = 1; i <= 25; i++)
  16. 	{
  17. 		SetPos(0, i);
  18. 		wprintf(L"%lc", WALL);
  19. 	}
  20. 	for (i = 1; i <= 25; i++)
  21. 	{
  22. 		SetPos(56, i);
  23. 		wprintf(L"%lc", WALL);
  24. 	}
  25. }

初始化蛇体，我们假设蛇的基础长度是5，首先建立蛇头，蛇头的基础位置再可以封装为宏，接下来依次建立一个个蛇体的节点，并头插到链表中。

  1. #define BODY L'●'
  2. #define POS_X 24
  3. #define POS_Y 5
  1. void InitSnake(pSnake ps)
  2. {
  3. 	pSnakeNode cur = NULL;
  4. 	int i = 0;
  5. 	for (i = 0; i < 5; i++)
  6. 	{
  7. 		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  8. 		if (cur == NULL)
  9. 		{
  10. 			perror("InitSnake():malloc()");
  11. 			return;
  12. 		}
  13. 		cur->x = POS_X + 2 * i;
  14. 		cur->y = POS_Y;
  15. 		cur->next = NULL;
  16. 		//头插
  17. 		if (ps->pSnake == NULL)
  18. 		{
  19. 			ps->pSnake = cur;
  20. 		}
  21. 		else
  22. 		{
  23. 			cur->next = ps->pSnake;
  24. 			ps->pSnake = cur;
  25. 		}
  26. 		//打印蛇身
  27. 		cur = ps->pSnake;
  28. 		while (cur)
  29. 		{
  30. 			SetPos(cur->x, cur->y);
  31. 			wprintf(L"%lc", BODY);
  32. 			cur = cur->next;
  33. 		}
  34. 	}
  35. 	//其他信息初始化
  36. 	ps->dir = RIGHT;
  37. 	ps->FoodWeight = 10;
  38. 	ps->pFood = NULL;
  39. 	ps->score = 0;
  40. 	ps->SleepTime = 200;//单位毫秒
  41. 	ps->status = OK;
  42. }

在地图上随机地生成食物，并确保他们的位置不会重复，也不会生成在蛇的身体里。

#define FOOD L'★'

  1. void CreateFood(pSnake ps)
  2. {
  3. 	srand((unsigned int)time(NULL));
  4. 	int x = 0, y = 0;
  5. again:
  6. 	do {
  7. 		x = rand() % 53 + 2;
  8. 		y = rand() % 25 + 1;
  9. 	} while (x % 2 != 0);
  10. 	//确保食物不会生成在蛇的身体里
  11. 	pSnakeNode cur = ps->pSnake;
  12. 	while (cur)
  13. 	{
  14. 		if (x == cur->x && y == cur->y)
  15. 		{
  16. 			goto again;
  17. 		}
  18. 		cur = cur->next;
  19. 	}
  20. 	//创建食物
  21. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  22. 	if (pFood == NULL)
  23. 	{
  24. 		perror("CreateFood()::malloc()");
  25. 		return;
  26. 	}
  27. 	pFood->x = x;
  28. 	pFood->y = y;
  29. 	ps->pFood = pFood;
  30. 	SetPos(x, y);
  31. 	wprintf(L"%lc", FOOD);
  32. 	
  33. }

4：游戏运行

接下来是游戏运行的部分，完成GameRun函数，我们先在地图界面的旁边打印分数和帮助信息，分数应该按照循环多次打印，并希望食物的分数随速度变化而变化。

  1. void PrintHelpInfo()
  2. {
  3. 	SetPos(62, 14);
  4. 	printf("注意：");
  5. 	SetPos(62, 15);
  6. 	printf("不能穿墙，不能咬到自己");
  7. 	SetPos(62, 16);
  8. 	printf("用↑.↓.←.→来控制蛇前进的方向");
  9. 	SetPos(62, 17);
  10. 	printf("左shift是加速，右shift是减速");
  11. 	SetPos(62, 18);
  12. 	printf("按ESC键退出，按空格键暂停");
  13. }
  1. SetPos(62, 10);
  2. printf("总分：%5d", ps->score);
  3. SetPos(62, 11);
  4. printf("每个食物的分数：%02d", ps->FoodWeight);

在游戏运行过程中，我们希望通过按键来控制蛇的状态（用 ↑ ↓ ← →键来转向），包括移动方向、速度，游戏的暂停与退出，这些都通过按键检测函数来实现（已封装为宏）：

  1. if (KEY_PRESS(VK_UP) && ps->dir != DOWN)
  2. //方向改变，注意无法直接变成相反方向
  3. {
  4. 	ps->dir = UP;
  5. }
  6. else if (KEY_PRESS(VK_DOWN) && ps->dir != UP)
  7. {
  8. 	ps->dir = DOWN;
  9. }
  10. else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT)
  11. {
  12. 	ps->dir = LEFT;
  13. }
  14. else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT)
  15. {
  16. 	ps->dir = RIGHT;
  17. }
  18. else if (KEY_PRESS(VK_ESCAPE))//退出
  19. {
  20. 	ps->status = ESC;
  21. 	break;
  22. }
  23. else if (KEY_PRESS(VK_SPACE))//暂停
  24. {
  25. 	Pause();
  26. }
  27. //加减速，注意食物权重跟随改变，并设置上下限
  28. else if (KEY_PRESS(VK_LSHIFT))
  29. {
  30. 	if (ps->SleepTime >= 80)
  31. 	{
  32. 		ps->SleepTime -= 30;
  33. 		ps->FoodWeight += 2;
  34. 	}
  35. }
  36. else if (KEY_PRESS(VK_RSHIFT))
  37. {
  38. 	if (ps->FoodWeight >2)
  39. 	{
  40. 		ps->SleepTime += 30;
  41. 		ps->FoodWeight -= 2;
  42. 	}
  43. }

完善暂停的函数，实际上就是一直循环休眠，再次空格会继续游戏：

  1. void Pause()
  2. {
  3. 	while (1)
  4. 	{
  5. 		Sleep(100);
  6. 		if (KEY_PRESS(VK_SPACE))
  7. 		{
  8. 			SetPos(15, 12);
  9. 			break;
  10. 		}
  11. 	}
  12. }

GameRun函数的最后一个部分，在休眠一个SleepTime的时间过后，进行移动，再将整个部分用循环框起来，条件就是游戏状态处于“OK”（运行中）。下面完成蛇的移动的函数，每次移动，都需要判断蛇头的下一个位置是否是食物，先封装为一个函数：

  1. int NextIsFood(pSnake ps, pSnakeNode pNext)
  2. //pNext指向下一个位置
  3. {
  4. 	if (ps->pFood->x == pNext->x && ps->pFood->y == pNext->y)
  5. 	{
  6. 		return 1;
  7. 	}
  8. 	else 
  9. 		return 0;
  10. }

然后是SnakeMove函数，根据当前方向的不同可以得出下一个位置的坐标，同时每一步移动都要区分下一步是吃了食物，还是没有吃，并且有没有撞到自己或者墙：

  1. void SnakeMove(pSnake ps)
  2. {
  3. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
  4. 	if (pNext == NULL)
  5. 	{
  6. 		perror("SnakeMove()::malloc()");
  7. 		return;
  8. 	}
  9. 	pNext->next = NULL;
  10. 	switch (ps->dir)
  11. 	{
  12. 	case UP:pNext->x = ps->pSnake->x;
  13. 		pNext->y = ps->pSnake->y - 1;
  14. 		break;
  15. 	case DOWN:pNext->x = ps->pSnake->x;
  16. 		pNext->y = ps->pSnake->y + 1;
  17. 		break;
  18.     //注意x坐标一次移动两格
  19. 	case LEFT:pNext->x = ps->pSnake->x-2;
  20. 		pNext->y = ps->pSnake->y;
  21. 		break;
  22. 	case RIGHT:pNext->x = ps->pSnake->x+2;
  23. 		pNext->y = ps->pSnake->y;
  24. 		break;
  25. 	}
  26. 	if (NextIsFood(ps, pNext))
  27. 	{
  28. 		EatFood(ps, pNext);
  29. 	}
  30. 	else
  31. 	{
  32. 		NotEatFood(ps, pNext);
  33. 	}
  34. 	KillByWall(ps);
  35. 	KillBySelf(ps);
  36. }

无可避免的，我们要依次完成4个函数。每吃一个食物，蛇应该增长一格，如果没有吃，应该维持原长度，为了实现蛇的移动，我们同样增长一格，并删除当前的尾节点（这里不进行改变链表结构的多余操作，只是在末尾打印空白符）。

  1. void EatFood(pSnake ps, pSnakeNode pNext)
  2. {
  3. 	pNext->next = ps->pSnake;
  4. 	ps->pSnake = pNext;
  5. 	//吃食物，头插一个节点
  6. 	pSnakeNode cur = ps->pSnake;//打印蛇
  7. 	while (cur)
  8. 	{
  9. 		SetPos(cur->x, cur->y);
  10. 		wprintf(L"%lc", BODY);
  11. 		cur = cur->next;
  12. 	}
  13. 	ps->score += ps->FoodWeight;//增加分数
  14. 	free(ps->pFood);//释放当前的食物
  15. 	CreateFood(ps);//创建新的食物
  16. }
  17. void NotEatFood(pSnake ps, pSnakeNode pNext)
  18. {
  19. 	pNext->next = ps->pSnake;
  20. 	ps->pSnake = pNext;
  21. 	pSnakeNode cur = ps->pSnake;//打印蛇
  22. 	while (cur->next->next!=NULL)
  23. 	{
  24. 		SetPos(cur->x, cur->y);
  25. 		wprintf(L"%lc", BODY);
  26. 		cur = cur->next;
  27. 	}
  28. 	//将尾节点的位置打印成空白字符
  29. 	SetPos(cur->next->x,cur->next->y);
  30. 	printf("  ");
  31. 	free(cur->next);
  32. 	cur->next = NULL;
  33. }

被撞死的函数，相较而言简单，只需进行位置的判断，并对应的改变游戏状态（这体现出将游戏状态封装为枚举的好处），代码在后续的完整代码中再体现。

5：游戏结束

完成游戏结束的函数GameEnd，在这一步，我们只需要判断当前的“游戏状态”，打印对应的提示信息即可。

  1. SetPos(15, 12);
  2. switch(ps->status)
  3. {
  4. case ESC:
  5. 	printf("已退出游戏...");
  6. 	SetPos(38, 27);
  7. 	exit(0);
  8. case KILL_BY_SELF:
  9. 	printf("很遗憾，你咬到自己了");
  10. 	break;
  11. case KILL_BY_WALL:
  12. 	printf("很遗憾，你撞到墙了");
  13. 	break;
  14. }

为了游戏代码的完善性，不能忘记将蛇的链表资源和食物、指针等释放，当然这主要是使代码更像样，实际不会太多地影响我们这个简易的程序。

  1. pSnakeNode cur = ps->pSnake;
  2. pSnakeNode del = NULL;
  3. while (cur)
  4. {
  5. 	del = cur;
  6. 	cur = cur->next;
  7. 	free(del);
  8. }
  9. ps->pSnake = NULL;
  10. free(ps->pFood);
  11. ps->pSnake = NULL;

整个游戏还需要一些重新开始的循环系统，这些的实现都比较灵活，可自行选择，我们可以通过键位、输入数字等方法实现交互，使得整个游戏的体验更为流畅和完备。初次之外，代码还有头文件中的声明和主函数的编写部分（当然这些较为简单），我们直接在完整代码中呈现我的方案。

完整代码

Snake.h

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<locale.h>
  4. #include<Windows.h>
  5. #include<stdbool.h>
  6. #include<time.h>
  7.  
  8. #define WALL L'■'
  9. #define BODY L'●'
  10. #define FOOD L'★'
  11.  
  12. #define POS_X 24
  13. #define POS_Y 5
  14.  
  15. #define KEY_PRESS(vk) (GetAsyncKeyState(vk)&0x1?1:0)
  16.  
  17. enum GAME_STATUS
  18. {
  19. 	OK = 1,//正常运行
  20. 	ESC,//正常退出
  21. 	KILL_BY_WALL,
  22. 	KILL_BY_SELF
  23. };
  24.  
  25. enum DIRECTION
  26. {
  27. 	UP=1,
  28. 	DOWN,
  29. 	LEFT,
  30. 	RIGHT
  31. };
  32.  
  33. //蛇的每个节点
  34. typedef struct SnakeNode {
  35. 	int x;//坐标
  36. 	int y;
  37. 	struct SnakeNode* next;
  38. }SnakeNode,*pSnakeNode;
  39. //重命名，并定义指向每个节点的指针
  40.  
  41. typedef struct Snake
  42. {
  43. 	pSnakeNode pSnake;//维护整条蛇的指针，指向蛇头
  44. 	pSnakeNode pFood;//指向食物的指针
  45. 	int score;//分数
  46. 	int FoodWeight;//食物的分数
  47. 	int SleepTime;//休眠时间
  48. 	enum GAME_STATUS status;//游戏状态
  49. 	enum DIRECTION dir;//蛇当前走的方向
  50.  }Snake,*pSnake;
  51.  
  52. void SetPos(int x, int y);
  53.  
  54. void GameStart(pSnake ps);
  55. void WelcomeToGame();
  56. void CreateMap();
  57. void InitSnake(pSnake ps);
  58. void CreateFood(pSnake ps);
  59.  
  60. void GameRun(pSnake ps);
  61. void PrintHelpInfo();
  62. void Pause();
  63. void SnakeMove(pSnake ps);
  64. int NextIsFood(pSnake ps, pSnakeNode pNext);
  65. void EatFood(pSnake ps, pSnakeNode pNext);
  66. void NotEatFood(pSnake ps, pSnakeNode pNext);
  67. void KillByWall(pSnake ps);
  68. void KillBySelf(pSnake ps);
  69.  
  70. void GameEnd(pSnake ps);

Snake.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"Snake.h"
  3. void SetPos(int x, int y)
  4. {
  5. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  6. 	COORD pos = { x,y };
  7. 	SetConsoleCursorPosition(handle, pos);
  8. }
  9.  
  10. void WelcomeToGame()
  11. {
  12. 	SetPos(35, 10);
  13. 	printf("欢迎来到贪吃蛇小游戏");
  14. 	SetPos(39, 11);
  15. 	printf("作者：zhuoer");
  16. 	SetPos(38, 20);
  17. 	system("pause");
  18. 	system("cls");
  19. 	SetPos(22, 10);
  20. 	printf("用↑.↓.←.→来控制方向，左shift是加速，右shift是减速");
  21. 	SetPos(36, 11);
  22. 	printf("加速能获得更高的分数");
  23. 	SetPos(38, 20);
  24. 	system("pause"); 
  25. 	system("cls");
  26. }
  27.  
  28. void CreateMap()
  29. {
  30. 	int i = 0;
  31.  
  32. 	SetPos(0, 0);
  33. 	for (i = 0; i <= 56; i += 2)
  34. 	{
  35. 		wprintf(L"%lc", WALL);
  36. 	}
  37. 	SetPos(0,26);
  38. 	for (i = 0; i <= 56; i += 2)
  39. 	{
  40. 		wprintf(L"%lc", WALL);
  41. 	}
  42. 	for (i = 1; i <= 25; i++)
  43. 	{
  44. 		SetPos(0, i);
  45. 		wprintf(L"%lc", WALL);
  46. 	}
  47. 	for (i = 1; i <= 25; i++)
  48. 	{
  49. 		SetPos(56, i);
  50. 		wprintf(L"%lc", WALL);
  51. 	}
  52. }
  53.  
  54. void InitSnake(pSnake ps)
  55. {
  56. 	pSnakeNode cur = NULL;
  57. 	int i = 0;
  58. 	for (i = 0; i < 5; i++)
  59. 	{
  60. 		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  61. 		if (cur == NULL)
  62. 		{
  63. 			perror("InitSnake():malloc()");
  64. 			return;
  65. 		}
  66. 		cur->x = POS_X + 2 * i;
  67. 		cur->y = POS_Y;
  68. 		cur->next = NULL;
  69. 		//头插
  70. 		if (ps->pSnake == NULL)
  71. 		{
  72. 			ps->pSnake = cur;
  73. 		}
  74. 		else
  75. 		{
  76. 			cur->next = ps->pSnake;
  77. 			ps->pSnake = cur;
  78. 		}
  79. 		//打印蛇身
  80. 		cur = ps->pSnake;
  81. 		while (cur)
  82. 		{
  83. 			SetPos(cur->x, cur->y);
  84. 			wprintf(L"%lc", BODY);
  85. 			cur = cur->next;
  86. 		}
  87. 	}
  88. 	//其他信息初始化
  89. 	ps->dir = RIGHT;
  90. 	ps->FoodWeight = 10;
  91. 	ps->pFood = NULL;
  92. 	ps->score = 0;
  93. 	ps->SleepTime = 200;//单位毫秒
  94. 	ps->status = OK;
  95. }
  96.  
  97. void CreateFood(pSnake ps)
  98. {
  99. 	srand((unsigned int)time(NULL));
  100. 	int x = 0, y = 0;
  101. again:
  102. 	do {
  103. 		x = rand() % 53 + 2;
  104. 		y = rand() % 25 + 1;
  105. 	} while (x % 2 != 0);
  106. 	//确保食物不会生成在蛇的身体里
  107. 	pSnakeNode cur = ps->pSnake;
  108. 	while (cur)
  109. 	{
  110. 		if (x == cur->x && y == cur->y)
  111. 		{
  112. 			goto again;
  113. 		}
  114. 		cur = cur->next;
  115. 	}
  116. 	//创建食物
  117. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  118. 	if (pFood == NULL)
  119. 	{
  120. 		perror("CreateFood()::malloc()");
  121. 		return;
  122. 	}
  123. 	pFood->x = x;
  124. 	pFood->y = y;
  125. 	ps->pFood = pFood;
  126. 	SetPos(x, y);
  127. 	wprintf(L"%lc", FOOD);
  128. 	
  129. }
  130.  
  131. void GameStart(pSnake ps)
  132. {
  133. 	//设置控制台窗口
  134. 	system("mode concols=100 lines=30");
  135. 	system("title 贪吃蛇");
  136. 	//隐藏光标
  137. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  138. 	CONSOLE_CURSOR_INFO CursorInfo;
  139. 	GetConsoleCursorInfo(handle, &CursorInfo);
  140. 	CursorInfo.bVisible = false;
  141. 	SetConsoleCursorInfo(handle, &CursorInfo);
  142.  
  143. 	WelcomeToGame();
  144. 	CreateMap();
  145. 	InitSnake(ps);
  146. 	CreateFood(ps);
  147. }
  148.  
  149. void PrintHelpInfo()
  150. {
  151. 	SetPos(62, 14);
  152. 	printf("注意：");
  153. 	SetPos(62, 15);
  154. 	printf("不能穿墙，不能咬到自己");
  155. 	SetPos(62, 16);
  156. 	printf("用↑.↓.←.→来控制蛇前进的方向");
  157. 	SetPos(62, 17);
  158. 	printf("左shift是加速，右shift是减速");
  159. 	SetPos(62, 18);
  160. 	printf("按ESC键退出，按空格键暂停");
  161. }
  162.  
  163. void Pause()
  164. {
  165. 	while (1)
  166. 	{
  167. 		Sleep(100);
  168. 		if (KEY_PRESS(VK_SPACE))
  169. 		{
  170. 			SetPos(15, 12);
  171. 			break;
  172. 		}
  173. 	}
  174. }
  175.  
  176. int NextIsFood(pSnake ps, pSnakeNode pNext)
  177. //pNext指向下一个位置
  178. {
  179. 	if (ps->pFood->x == pNext->x && ps->pFood->y == pNext->y)
  180. 	{
  181. 		return 1;
  182. 	}
  183. 	else 
  184. 		return 0;
  185. }
  186.  
  187. void EatFood(pSnake ps, pSnakeNode pNext)
  188. {
  189. 	pNext->next = ps->pSnake;
  190. 	ps->pSnake = pNext;
  191. 	//吃食物，头插一个节点
  192. 	pSnakeNode cur = ps->pSnake;//打印蛇
  193. 	while (cur)
  194. 	{
  195. 		SetPos(cur->x, cur->y);
  196. 		wprintf(L"%lc", BODY);
  197. 		cur = cur->next;
  198. 	}
  199. 	ps->score += ps->FoodWeight;//增加分数
  200. 	free(ps->pFood);//释放当前的食物
  201. 	CreateFood(ps);//创建新的食物
  202. }
  203. void NotEatFood(pSnake ps, pSnakeNode pNext)
  204. {
  205. 	pNext->next = ps->pSnake;
  206. 	ps->pSnake = pNext;
  207. 	pSnakeNode cur = ps->pSnake;//打印蛇
  208. 	while (cur->next->next!=NULL)
  209. 	{
  210. 		SetPos(cur->x, cur->y);
  211. 		wprintf(L"%lc", BODY);
  212. 		cur = cur->next;
  213. 	}
  214. 	//将尾节点的位置打印成空白字符
  215. 	SetPos(cur->next->x,cur->next->y);
  216. 	printf("  ");
  217. 	free(cur->next);
  218. 	cur->next = NULL;
  219. }
  220.  
  221. void KillByWall(pSnake ps)
  222. {
  223. 	if (ps->pSnake->x == 0 || ps->pSnake->x == 56 ||
  224. 		ps->pSnake->y == 0 || ps->pSnake->y == 26)
  225. 	{
  226. 		ps->status = KILL_BY_WALL;
  227. 		return;
  228. 	}
  229. }
  230. void KillBySelf(pSnake ps)
  231. {
  232. 	pSnakeNode cur = ps->pSnake->next;
  233. 	//从第二个节点开始，检测蛇身是否为蛇头的下一个节点
  234. 	while (cur)
  235. 	{
  236. 		if (cur->x == ps->pSnake->x && cur->y == ps->pSnake->y)
  237. 		{
  238. 			ps->status = KILL_BY_SELF;
  239. 			return;
  240. 		}
  241. 		cur = cur->next;
  242. 	}
  243. }
  244. void SnakeMove(pSnake ps)
  245. {
  246. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
  247. 	if (pNext == NULL)
  248. 	{
  249. 		perror("SnakeMove()::malloc()");
  250. 		return;
  251. 	}
  252. 	pNext->next = NULL;
  253. 	switch (ps->dir)
  254. 	{
  255. 	case UP:pNext->x = ps->pSnake->x;
  256. 		pNext->y = ps->pSnake->y - 1;
  257. 		break;
  258. 	case DOWN:pNext->x = ps->pSnake->x;
  259. 		pNext->y = ps->pSnake->y + 1;
  260. 		break;
  261.     //注意x坐标一次移动两格
  262. 	case LEFT:pNext->x = ps->pSnake->x-2;
  263. 		pNext->y = ps->pSnake->y;
  264. 		break;
  265. 	case RIGHT:pNext->x = ps->pSnake->x+2;
  266. 		pNext->y = ps->pSnake->y;
  267. 		break;
  268. 	}
  269. 	if (NextIsFood(ps, pNext))
  270. 	{
  271. 		EatFood(ps, pNext);
  272. 	}
  273. 	else
  274. 	{
  275. 		NotEatFood(ps, pNext);
  276. 	}
  277. 	KillByWall(ps);
  278. 	KillBySelf(ps);
  279. }
  280.  
  281. void GameRun(pSnake ps)
  282. {
  283. 	PrintHelpInfo();
  284. 	
  285. 	do {
  286. 		SetPos(62, 10);
  287. 		printf("总分：%5d", ps->score);
  288. 		SetPos(62, 11);
  289. 		printf("每个食物的分数：%02d", ps->FoodWeight);
  290. 		if (KEY_PRESS(VK_UP) && ps->dir != DOWN)
  291. 		{
  292. 			ps->dir = UP;
  293. 		}
  294. 		else if (KEY_PRESS(VK_DOWN) && ps->dir != UP)
  295. 		{
  296. 			ps->dir = DOWN;
  297. 		}
  298. 		else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT)
  299. 		{
  300. 			ps->dir = LEFT;
  301. 		}
  302. 		else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT)
  303. 		{
  304. 			ps->dir = RIGHT;
  305. 		}
  306. 		else if (KEY_PRESS(VK_ESCAPE))
  307. 		{
  308. 			ps->status = ESC;
  309. 			break;
  310. 		}
  311. 		else if (KEY_PRESS(VK_SPACE))
  312. 		{
  313. 			Pause();
  314. 		}
  315. 		else if (KEY_PRESS(VK_LSHIFT))
  316. 		{
  317. 			if (ps->SleepTime >= 80)
  318. 			{
  319. 				ps->SleepTime -= 30;
  320. 				ps->FoodWeight += 2;
  321. 			}
  322. 		}
  323. 		else if (KEY_PRESS(VK_RSHIFT))
  324. 		{
  325. 			if (ps->FoodWeight >2)
  326. 			{
  327. 				ps->SleepTime += 30;
  328. 				ps->FoodWeight -= 2;
  329. 			}
  330. 		}
  331. 		Sleep(ps->SleepTime);
  332. 		SnakeMove(ps);
  333. 	} while (ps->status == OK);
  334. }
  335.  
  336. void GameEnd(pSnake ps)
  337. {
  338. 	SetPos(15, 12);
  339. 	switch(ps->status)
  340. 	{
  341. 	case ESC:
  342. 		printf("已退出游戏...");
  343. 		SetPos(38, 27);
  344. 		exit(0);
  345. 	case KILL_BY_SELF:
  346. 		printf("很遗憾，你咬到自己了");
  347. 		break;
  348. 	case KILL_BY_WALL:
  349. 		printf("很遗憾，你撞到墙了");
  350. 		break;
  351. 	}
  352. 	//释放链表资源
  353. 	pSnakeNode cur = ps->pSnake;
  354. 	pSnakeNode del = NULL;
  355. 	while (cur)
  356. 	{
  357. 		del = cur;
  358. 		cur = cur->next;
  359. 		free(del);
  360. 	}
  361. 	ps->pSnake = NULL;
  362. 	free(ps->pFood);
  363. 	ps->pSnake = NULL;
  364. }

game.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"Snake.h"
  3.  
  4. void game()
  5. {
  6. 	int x = 0;
  7. start:
  8. 	{
  9. 		Snake snake = { 0 };
  10. 		GameStart(&snake);
  11. 		GameRun(&snake);
  12. 		GameEnd(&snake);
  13. 		SetPos(15, 14);
  14. 		printf("输入1重新开始游戏");
  15. 		SetPos(15, 15);
  16. 		printf("输入0退出游戏");
  17. 		SetPos(15, 16);
  18. 		printf("输入你的选择：");
  19. 		scanf("%d", &x);
  20. 		switch (x)
  21. 		{
  22. 		case 1:
  23. 			goto start; 
  24. 			break;
  25. 		case 0:
  26. 			SetPos(15, 17);
  27. 			printf("已退出");
  28. 			SetPos(38, 27);
  29. 			return;
  30. 		default:
  31. 			SetPos(15, 17);
  32. 			printf("输入错误，自动退出");
  33. 			SetPos(38, 27);
  34. 			return;
  35. 		}
  36. 	}
  37. }
  38. int main()
  39. {
  40. 	setlocale(LC_ALL, "");
  41. 	game();
  42. 	return 0;
  43. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/1001554
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号