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

C语言实现贪吃蛇游戏（全干货免费）_贪吃蛇初始化游戏界面怎么实现

作者：正经夜光杯 | 2024-08-19 08:40:39

赞

踩

贪吃蛇初始化游戏界面怎么实现

目录

1、实现环境、思路

2、win32 API 函数

2.1 控制台程序

2.2 GetStdHandle

2.3 GetConsoleCursorInfo

2.4 CONSOLE_CURSOR_INFO

2.5 SetConsoleCursorInfo

2.6 控制台屏幕上坐标COORD

2.7 SetConsoleCursorPosition

3、贪吃蛇游戏设计与分析

3.1 GameStart 初始化游戏

3.1.1  welComeToGame 打印欢迎界面

3.1.2 CreateMap 地图

3.1.3 InitSnake 初始化贪吃蛇

3.3.4 CreatFood 创建食物

3.2 GameRun 运行游戏

 3.2.1 PrintHelpInfo 打印规则和分数

3.2.2 Pause 暂停功能

3.2.3  SnakeMove 蛇的移动

3.2.4 NextIsFood 判断走的下一个节点是否是食物

3.2.5 EatFood 是食物就吃掉

3.2.6 NoFood 不是食物也吃，然后释放尾节点

3.2.7 KillByWall 撞墙

3.2.8 KillBySelf 自杀（吃到自身）

3.3 GameEnd 结束游戏

4、 完整代码实现，分3个文件，复制粘贴即可运行

4.1 Snake.h

4.2 Snake.c

4.3 test.c

1、实现环境、思路

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

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

技术要点：C语言、数据结构（链表）、枚举、结构体、动态内存管理、预处理指令、win32 API

2、win32 API 函数

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

2.1 控制台程序

在Windows中win+R输入cmd即可唤起控制台程序，使用cmd命令可以设置控制台窗口长宽。

mode con cols=120 lines=40

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

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

HANDLE GetStdHandle(DWORD nStdHandle);

就单对这个贪吃蛇的项目来说，我们需要在windows的控制台上执行的，也就是我们需要找到这个控制台，取得这个控制台的句柄，建立联系。

实例：

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

2.3 GetConsoleCursorInfo

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

  1. BOOL WINAPI GetConsoleCursorInfo(
  2.  HANDLE hConsoleOutput,   //句柄
  3.  PCONSOLE_CURSOR_INFO lpConsoleCursorInfo  //一个结构体接收有关控制台游标的信息
  4. );

实例

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

2.4 CONSOLE_CURSOR_INFO

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

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

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

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

例如我们要隐藏闪烁的光标：

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

2.5 SetConsoleCursorInfo

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

  1. BOOL WINAPI SetConsoleCursorInfo(
  2.  HANDLE hConsoleOutput, //句柄
  3.  const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo  //所需设置光标信息的结构体指针
  4. );

实例：

  1. HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  2.  
  3. //影藏光标操作
  4. CONSOLE_CURSOR_INFO CursorInfo;
  5. GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
  6. CursorInfo.bVisible = false; //隐藏控制台光标
  7. SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态

2.6 控制台屏幕上坐标COORD

COORD 是Windows API中定义的一种结构，表示一个字符在控制台屏幕上的坐标 
  1. typedef struct _COORD {
  2.  SHORT X;
  3.  SHORT Y;
  4. } COORD, *PCOORD;
给坐标赋值： 
COORD pos={ 10 , 15 };

2.7 SetConsoleCursorPosition

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

  1. BOOL WINAPI SetConsoleCursorPosition(
  2.  HANDLE hConsoleOutput,
  3.  COORD pos
  4. );

实例：

  1. COORD pos = { 10, 5};
  2. HANDLE hOutput = NULL;
  3. //获取标准输出的句柄(用来标识不同设备的数值)
  4. hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  5. //设置标准输出上光标的位置为pos
  6. SetConsoleCursorPosition(hOutput, pos);

SetPos：封装⼀个设置光标位置的函数

  1. //设置光标的坐标
  2. void SetPos(short x, short y)
  3. {
  4.  COORD pos = { x, y };
  5.  HANDLE hOutput = NULL;
  6.  //获取标准输出的句柄(⽤来标识不同设备的数值)
  7.  hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  8.  //设置标准输出上光标的位置为pos
  9.  SetConsoleCursorPosition(hOutput, pos);
  10. }

2.8 GetAsyncKeyState

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

  1. SHORT GetAsyncKeyState(
  2.  int vKey
  3. );

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

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

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

3、贪吃蛇游戏设计与分析

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

  1. typedef struct SnakeNode
  2. {
  3.     int x;
  4.     int y;
  5.     struct SnakeNode* next; //链接每一个节点组成的一条蛇
  6. }SnakeNode, * pSnakeNode;

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

  1. typedef struct Snake {
  2. 	pSnakeNode _psnake;//贪吃蛇的第一个节点，头结点的指针
  3. 	pSnakeNode _pFood; //指向食物节点的指针
  4. 	int _Score;//贪吃蛇累计的总分
  5. 	int _FootWeight;//一个食物的分数
  6. 	int _SleepTime;//每走一步休息的时间，时间越短，速度越快，时间越长。速度越慢
  7. 	enum DIRECTION _Dir;//描述蛇的方向
  8. 	enum GAME_STATUS _Status;//游戏的状态：正常、退出、撞墙、吃到自己
  9. }Snake, * pSnake;

 以下是枚举蛇方向和存活状态：

  1. enum DIRECTION
  2. {
  3. 	UP = 1,
  4. 	DOWN,
  5. 	LEFT,
  6. 	RIGHT
  7. };
  8.  
  9. //贪吃蛇的存活的状态
  10. enum GAME_STATUS {
  11. 	OK,//正常运行
  12. 	END_NORMAL,//按esc退出
  13. 	KILL_BY_WALL,//撞墙
  14. 	KILL_BY_SELF//自杀
  15. };

我们设计这个贪吃蛇分三个步骤，初始化贪吃蛇（包括地图的创建以及贪吃蛇本身的结构）、运行游戏的过程、结束游戏（释放资源），接下来就以这些步骤开始：

3.1 GameStart 初始化游戏

游戏的初始化

  1. //游戏初始化
  2. void GameStart(pSnake ps) {
  3. 	setlocale(LC_ALL, "");
  4. 	system("mode con cols=120 lines=40"); //设置了x=120，y=40控制台窗口
  5. 	system("title 贪吃蛇");
  6.  
  7. 	//1_隐藏光标
  8. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); //先获得控制台的句柄
  9. 	//一个控制台光标的信息的结构体 CONSOLE_CURSOR_INFO
  10. 	CONSOLE_CURSOR_INFO CursorInfo;
  11. 	//通过句柄获取控制台的光标信息，并储存在 CursorInfo 内
  12. 	GetConsoleCursorInfo(handle, &CursorInfo);
  13. 	//通过修改 CursorInfo 内的光标信息 bVisible 隐藏掉，不显示
  14. 	CursorInfo.bVisible = false;  //需要头文件 <stdbool.h>
  15. 	//修改成功后需要执行修改
  16. 	SetConsoleCursorInfo(handle, &CursorInfo);
  17.  
  18. 	//2_打印欢迎界面
  19. 	welComeToGame();
  20.  
  21. 	//3_创建地图
  22. 	CreateMap();
  23.  
  24. 	//4_初始化贪吃蛇
  25. 	InitSnake(ps);
  26.  
  27. 	//5_创建食物
  28. 	CreatFood(ps);
  29. }
3.1.1  welComeToGame 打印欢迎界面
  1. void welComeToGame() {
  2. 	SetPos(51, 18);  //定位控制台光标的位置
  3. 	printf("欢迎来到贪吃蛇游戏");
  4.  
  5. 	SetPos(53, 36);
  6. 	//Windows 中暂停的指令，按任意键结束暂停
  7. 	system("pause");
  8.  
  9. 	//清除之前屏幕上打印的信息
  10. 	system("cls");
  11.  
  12. 	SetPos(51, 18);
  13. 	printf("游戏玩法规则如下：");
  14.  
  15. 	SetPos(35, 20);
  16. 	printf("←↑→↓来操控贪吃蛇移动，Esc退出游戏，Space暂停游戏");
  17.  
  18. 	SetPos(53, 22);
  19. 	printf("F3加速，F4减速");
  20.  
  21. 	SetPos(53, 36);
  22. 	system("pause");
  23.  
  24. 	system("cls");
  25. }

3.1.2 CreateMap 地图
  1. void CreateMap() {
  2. 	//上
  3. 	SetPos(0, 0);
  4. 	for (int i = 0; i <= 78; i += 2) {
  5. 		wprintf(L"%lc", WALL);
  6. 	}
  7. 	//左
  8. 	for (int i = 1; i <= 34; i++) {
  9. 		SetPos(0, i);
  10. 		wprintf(L"%lc", WALL);
  11. 	}
  12. 	//右
  13. 	for (int i = 1; i <= 34; i++) {
  14. 		SetPos(78, i);
  15. 		wprintf(L"%lc", WALL);
  16. 	}
  17. 	//下
  18. 	SetPos(0, 34);
  19. 	for (int i = 0; i <= 78; i += 2) {
  20. 		wprintf(L"%lc", WALL);
  21. 	}
  22. }
3.1.3 InitSnake 初始化贪吃蛇
  1. void InitSnake(pSnake ps) {
  2. 	pSnakeNode cur = NULL;
  3. 	for (int i = 0; i < 5; i++) {
  4. 		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  5. 		if (cur == NULL) {
  6. 			perror("InitSnake() error!");
  7. 			return;
  8. 		}
  9. 		cur->x = POS_X + i * 2;
  10. 		cur->y = POS_Y;
  11. 		cur->next = NULL;
  12.  
  13. 		//头插法
  14. 		if (ps->_psnake == NULL) {
  15. 			ps->_psnake = cur;
  16. 		}
  17. 		else {
  18. 			cur->next = ps->_psnake;
  19. 			ps->_psnake = cur;
  20. 		}
  21. 	}
  22. 	// 遍历这个链表
  23. 	while (cur) {
  24. 		SetPos(cur->x, cur->y);
  25. 		wprintf(L"%lc", BODY);
  26. 		cur = cur->next;
  27. 	}
  28. 	
  29. 	ps->_Status = OK;
  30. 	ps->_Score = 50;
  31. 	ps->_pFood = NULL;
  32. 	ps->_SleepTime = 200;
  33. 	ps->_FootWeight = 10;
  34. 	ps->_Dir = RIGHT;
  35. }
3.3.4 CreatFood 创建食物
  1. void CreatFood(pSnake ps) {
  2. 	//1、坐标应该是随机生成的，但是这个随机是由约束的
  3. 	//2、食物坐标必须在方框内
  4. 	//3、食物的x坐标必须是2的倍数
  5. 	int x = 0;
  6. 	int y = 0;
  7. again:
  8. 	do {
  9. 		x = rand() % 76 + 2;
  10. 		y = rand() % 33 + 1;
  11. 	} while (x % 2 != 0);
  12.  
  13. 	//4、食物的坐标不能跟蛇身重叠，冲突 ，一一进行比较
  14. 	pSnakeNode cur = ps->_psnake;
  15. 	while (cur) {
  16. 		//比较
  17. 		if (cur->x == x && cur->y == y) {
  18. 			//出现重叠的就 goto 前面重新来过
  19. 			goto again;
  20. 		}
  21. 		cur = cur->next;
  22. 	}
  23. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  24. 	if (pFood == NULL) {
  25. 		perror("CreateFood(); malloc error!");
  26. 		return;
  27. 	}
  28. 	pFood->x = x;
  29. 	pFood->y = y;
  30. 	ps->_pFood = pFood;
  31.  
  32. 	SetPos(x, y);
  33. 	wprintf(L"%lc", FOOD);
  34. }

3.2 GameRun 运行游戏

游戏运行期间，右侧打印帮助信息，提示玩家根据游戏状态检查游戏是否继续，如果是状态是OK，游戏继续，否则游戏结束。如果游戏继续，就是检测按键情况，确定蛇下一步的方向，或者是否加速减速，是否暂停或者退出游戏。确定了蛇的方向和速度，蛇就可以移动了。

  1. void GameRun(pSnake ps) {
  2. 	PrintHelpInfo(); //打印游戏规则介绍和分数
  3. 	do {
  4. 		SetPos(85, 10);
  5. 		printf("得分：%05d", ps->_Score);
  6. 		SetPos(85, 11);
  7. 		printf("食物分数：%2d", ps->_FootWeight);
  8.  
  9. 		//检测按键情况 
  10. 		//本来方向就是向上就不能往相反方向了
  11. 		if (KEY_PRESS(VK_UP) && ps->_Dir != DOWN) {
  12. 			ps->_Dir = UP;
  13. 		}
  14. 		else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP) {
  15. 			ps->_Dir = DOWN;
  16. 		}
  17. 		else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT) {
  18. 			ps->_Dir = LEFT;
  19. 		}
  20. 		else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT) {
  21. 			ps->_Dir = RIGHT;
  22. 		}
  23. 		else if (KEY_PRESS(VK_ESCAPE)) {
  24. 			ps->_Status = END_NORMAL;
  25. 			break;
  26. 		}
  27. 		else if (KEY_PRESS(VK_SPACE)) {
  28. 			//封装一个暂停函数
  29. 			Pause();
  30. 		}
  31. 		//加速
  32. 		else if (KEY_PRESS(VK_F3)) {
  33. 			if (ps->_SleepTime >= 100) {
  34. 				ps->_SleepTime -= 30;
  35. 				ps->_FootWeight += 2;
  36. 			}
  37. 		}
  38. 		//减速
  39. 		else if (KEY_PRESS(VK_F4)) {
  40. 			if (ps->_SleepTime <= 320) {
  41. 				ps->_SleepTime += 30;
  42. 				ps->_FootWeight -= 2;
  43. 			}
  44. 		}
  45. 		//设置完后要应用休眠的时间
  46. 		Sleep(ps->_SleepTime);
  47. 		//让蛇移动起来
  48. 		SnakeMove(ps);
  49.  
  50. 	} while (ps->_Status == OK);
  51. }
 3.2.1 PrintHelpInfo 打印规则和分数
  1. void PrintHelpInfo() {
  2.  
  3. 	SetPos(85, 12);
  4. 	printf("1、不能撞墙,不能吃到自己");
  5.  
  6. 	SetPos(85, 14);
  7. 	printf("2、←↑→↓来操控贪吃蛇移动");
  8.  
  9. 	SetPos(85, 16);
  10. 	printf("3、F3加速，F4减速");
  11.  
  12. 	SetPos(85, 18);
  13. 	printf("4、Esc退出游戏，Space暂停游戏");
  14.  
  15. }
3.2.2 Pause 暂停功能
  1. void Pause() {
  2.     //让系统一直休眠，直到再次按下空格键
  3. 	while (1) {
  4. 		Sleep(200);
  5. 		if (KEY_PRESS(VK_SPACE)) {
  6. 			break;
  7. 		}
  8. 	}
  9. }
3.2.3  SnakeMove 蛇的移动

先创建下一个节点，根据移动方向和蛇头的坐标，蛇移动到下一个位置的坐标。确定了下一个位置后，看下一个位置是否是食物（NextIsFood），是食物就做吃食物处理（EatFood），如果不是食物则做前进一步的处理（NoFood）。蛇身移动后，判断此次移动是否会造成撞墙（KillByWall）或者撞上自己蛇身（KillBySelf），从而影响游戏的状态。

  1. void SnakeMove(pSnake ps) {
  2. 	//为下一个移动的点创建一个节点
  3. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
  4. 	if (pNext == NULL) {
  5. 		perror("SnakeMove() malloc() error!");
  6. 		return;
  7. 	}
  8.  
  9. 	switch (ps->_Dir) {
  10. 	case UP:
  11. 	{
  12. 		pNext->x = ps->_psnake->x;
  13. 		pNext->y = ps->_psnake->y - 1;
  14. 	}
  15. 	break;
  16. 	case DOWN: {
  17. 		pNext->x = ps->_psnake->x;
  18. 		pNext->y = ps->_psnake->y + 1;
  19. 	}
  20. 			 break;
  21. 	case LEFT: {
  22. 		pNext->x = ps->_psnake->x - 2;
  23. 		pNext->y = ps->_psnake->y;
  24. 	}
  25. 			 break;
  26. 	case RIGHT: {
  27. 		pNext->x = ps->_psnake->x + 2;
  28. 		pNext->y = ps->_psnake->y;
  29. 	}
  30. 			  break;
  31. 	}
  32.  
  33. 	//判断是否是食物
  34. 	if (NextIsFood(ps, pNext)) {
  35. 		//吃掉食物
  36. 		EatFood(ps, pNext);
  37. 	}
  38. 	else {
  39. 		//不吃
  40. 		NoFood(ps, pNext);
  41. 	}
  42.  
  43. 	判断是否撞墙
  44. 	KillByWall(ps);
  45. 	判断是否自杀
  46. 	KillBySelf(ps);
  47. }
3.2.4 NextIsFood 判断走的下一个节点是否是食物
  1. int NextIsFood(pSnake ps, pSnakeNode pNext) {
  2. 	if (ps->_pFood->x == pNext->x && ps->_pFood->y == pNext->y) {
  3. 		return 1;
  4. 	}
  5. 	return 0;
  6. }
3.2.5 EatFood 是食物就吃掉
  1. void EatFood(pSnake ps, pSnakeNode pNext) {
  2. 	pNext->next = ps->_psnake;
  3. 	ps->_psnake = pNext;
  4.  
  5.  
  6. 	pSnakeNode cur = ps->_psnake;
  7. 	while (cur) {
  8. 		SetPos(cur->x, cur->y);
  9. 		wprintf(L"%lc", BODY);
  10. 		cur = cur->next;
  11. 	}
  12.  
  13. 	//给总分加上分数
  14. 	ps->_Score += ps->_FootWeight;
  15.  
  16. 	free(ps->_pFood);
  17. 	//还得重新创建新的食物
  18. 	CreatFood(ps);
  19. }
3.2.6 NoFood 不是食物也吃，然后释放尾节点
  1. void NoFood(pSnake ps, pSnakeNode pNext) {
  2. 	//头插入节点
  3. 	pNext->next = ps->_psnake;
  4. 	ps->_psnake = pNext;
  5.  
  6. 	//释放尾节点
  7. 	pSnakeNode cur = ps->_psnake;
  8. 	while (cur->next->next != NULL) {
  9. 		SetPos(cur->x, cur->y);
  10. 		wprintf(L"%lc", BODY);
  11. 		cur = cur->next;
  12. 	}
  13. 	SetPos(cur->next->x, cur->next->y);
  14. 	printf("  ");
  15. 	free(cur->next);
  16. 	cur->next = NULL;
  17. }
3.2.7 KillByWall 撞墙
  1. void KillByWall(pSnake ps) {
  2. 	if (ps->_psnake->x == 0 || ps->_psnake->y == 35 || ps->_psnake->x == 80 || ps->_psnake->y == 0) {
  3. 		ps->_Status = KILL_BY_WALL;
  4. 	}
  5. }
3.2.8 KillBySelf 自杀（吃到自身）
  1. void KillBySelf(pSnake ps) {
  2. 	pSnakeNode cur = ps->_psnake->next;
  3. 	while (cur) {
  4. 		if (ps->_psnake->x == cur->x && ps->_psnake->y == cur->y) {
  5. 			ps->_Status = KILL_BY_SELF;
  6. 			
  7. 		}
  8. 		cur = cur->next;
  9. 	}
  10. }

3.3 GameEnd 结束游戏

  1. void GameEnd(pSnake ps) {
  2. 	SetPos(39, 16);
  3. 	switch (ps->_Status) {
  4. 	case END_NORMAL:
  5. 		printf("退出游戏成功！(っ °Д °;)っ下次还要再来一把");
  6. 		break;
  7. 	case KILL_BY_WALL:
  8. 		printf("撞墙啦！(╯°□°）╯︵ ┻━┻");
  9. 		break;
  10. 	case KILL_BY_SELF:
  11. 		printf("自杀啦！你怎么咬到自己了啊！( ´･･)ﾉ(._.`)");
  12. 		break;
  13. 	}
  14.  
  15. 	SetPos(39, 18);
  16.  
  17. 	pSnakeNode cur = ps->_psnake;
  18. 	while (cur) {
  19. 		pSnakeNode del = cur;
  20. 		cur = cur->next;
  21. 		free(del);
  22. 	}
  23. }

4、 完整代码实现，分3个文件，复制粘贴即可运行

4.1 Snake.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #pragma once
  3.  
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<locale.h>
  7. #include<stdbool.h>
  8. #include<windows.h>
  9. #include<time.h>
  10.  
  11. //检测按键定义的宏
  12. #define KEY_PRESS(VK) (GetAsyncKeyState(VK)& 0x1 ? 1:0)
  13. #define WALL L'□'
  14. #define BODY L'●'
  15. #define FOOD L'★'
  16.  
  17.  
  18. #define POS_X 24
  19. #define POS_Y 5
  20.  
  21. //方向
  22. enum DIRECTION
  23. {
  24. 	UP = 1,
  25. 	DOWN,
  26. 	LEFT,
  27. 	RIGHT
  28. };
  29.  
  30. //贪吃蛇的存活的状态
  31. enum GAME_STATUS {
  32. 	OK,//正常运行
  33. 	END_NORMAL,//按esc退出
  34. 	KILL_BY_WALL,//撞墙
  35. 	KILL_BY_SELF//自杀
  36. };
  37.  
  38.  
  39. //贪吃蛇本身的节点
  40. typedef struct SnakeNode {
  41. 	int x;
  42. 	int y;
  43. 	struct SnakeNode* next;
  44. }SnakeNode, * pSnakeNode; //相当于 typedef struct SnakeNode* pSnakeNode;
  45.  
  46. //描述这条贪吃蛇结构
  47. typedef struct Snake {
  48. 	pSnakeNode _psnake;//贪吃蛇的第一个节点，头结点的指针
  49. 	pSnakeNode _pFood; //指向食物节点的指针
  50. 	int _Score;//贪吃蛇累计的总分
  51. 	int _FootWeight;//一个食物的分数
  52. 	int _SleepTime;//每走一步休息的时间，时间越短，速度越快，时间越长。速度越慢
  53. 	enum DIRECTION _Dir;//描述蛇的方向
  54. 	enum GAME_STATUS _Status;//游戏的状态：正常、退出、撞墙、吃到自己
  55. }Snake, * pSnake;
  56.  
  57. //定位控制台光标
  58. void SetPos(int x, int y);
  59.  
  60.  
  61. //游戏初始化
  62. void GameStart(pSnake ps);
  63.  
  64. //2_打印欢迎界面
  65. void welComeToGame();
  66.  
  67. //3_创建地图
  68. void CreateMap();
  69.  
  70. //4_初始化贪吃蛇
  71. void InitSnake(pSnake ps);
  72.  
  73.  
  74. //————————————————————————————————————————————————————————
  75. //运行过程
  76. void GameRun(pSnake ps);
  77.  
  78. //打印基本信息
  79. void PrintHelpInfo();
  80.  
  81. //暂停
  82. void Pause();
  83.  
  84. //蛇移动
  85. void SnakeMove(pSnake ps);
  86.  
  87. //判断是否是食物
  88. int NextIsFood(pSnake ps, pSnakeNode pNext);
  89.  
  90. //吃掉食物
  91. void EatFood(pSnake ps, pSnakeNode pNext);
  92.  
  93. //不吃食物
  94. void NoFood(pSnake ps, pSnakeNode pNext);
  95.  
  96. //判断是否撞墙
  97. void KillByWall(pSnake ps);
  98.  
  99. //判断是否自杀
  100. void KillBySelf(pSnake ps);
  101.  
  102.  
  103. //————————————————————————————————————————————————————————————
  104. //游戏结束
  105. void GameEnd(pSnake ps);

4.2 Snake.c

  1. #include"Snake.h"
  2.  
  3. void SetPos(int x, int y) {
  4. 	//获取控制台句柄
  5. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  6. 	//COORD是控制台存储一个坐标的结构体，
  7. 	COORD pos = { x,y };
  8. 	//设置光标的所在位置 SetConsoleCursorPosition
  9. 	SetConsoleCursorPosition(handle, pos);
  10. }
  11.  
  12.  
  13. //打印欢迎界面
  14. void welComeToGame() {
  15. 	SetPos(51, 18);
  16. 	printf("欢迎来到贪吃蛇游戏");
  17.  
  18. 	SetPos(53, 36);
  19. 	//Windows 中暂停的指令，按任意键结束暂停
  20. 	system("pause");
  21.  
  22. 	//清除之前屏幕上打印的信息
  23. 	system("cls");
  24.  
  25. 	SetPos(51, 18);
  26. 	printf("游戏玩法规则如下：");
  27.  
  28. 	SetPos(35, 20);
  29. 	printf("←↑→↓来操控贪吃蛇移动，Esc退出游戏，Space暂停游戏");
  30.  
  31. 	SetPos(53, 22);
  32. 	printf("F3加速，F4减速");
  33.  
  34. 	SetPos(53, 36);
  35. 	system("pause");
  36.  
  37. 	system("cls");
  38. }
  39.  
  40. //游戏地图
  41. void CreateMap() {
  42. 	//上
  43. 	SetPos(0, 0);
  44. 	for (int i = 0; i <= 78; i += 2) {
  45. 		wprintf(L"%lc", WALL);
  46. 	}
  47. 	//左
  48. 	for (int i = 1; i <= 34; i++) {
  49. 		SetPos(0, i);
  50. 		wprintf(L"%lc", WALL);
  51. 	}
  52. 	//右
  53. 	for (int i = 1; i <= 34; i++) {
  54. 		SetPos(78, i);
  55. 		wprintf(L"%lc", WALL);
  56. 	}
  57. 	//下
  58. 	SetPos(0, 34);
  59. 	for (int i = 0; i <= 78; i += 2) {
  60. 		wprintf(L"%lc", WALL);
  61. 	}
  62. }
  63.  
  64. //初始化贪吃蛇
  65. void InitSnake(pSnake ps) {
  66. 	pSnakeNode cur = NULL;
  67. 	for (int i = 0; i < 5; i++) {
  68. 		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  69. 		if (cur == NULL) {
  70. 			perror("InitSnake() error!");
  71. 			return;
  72. 		}
  73. 		cur->x = POS_X + i * 2;
  74. 		cur->y = POS_Y;
  75. 		cur->next = NULL;
  76.  
  77. 		//头插法
  78. 		if (ps->_psnake == NULL) {
  79. 			ps->_psnake = cur;
  80. 		}
  81. 		else {
  82. 			cur->next = ps->_psnake;
  83. 			ps->_psnake = cur;
  84. 		}
  85. 	}
  86. 	// 遍历这个链表
  87. 	while (cur) {
  88. 		SetPos(cur->x, cur->y);
  89. 		wprintf(L"%lc", BODY);
  90. 		cur = cur->next;
  91. 	}
  92. 	
  93. 	ps->_Status = OK;
  94. 	ps->_Score = 50;
  95. 	ps->_pFood = NULL;
  96. 	ps->_SleepTime = 200;
  97. 	ps->_FootWeight = 10;
  98. 	ps->_Dir = RIGHT;
  99. }
  100.  
  101. //创建食物
  102. void CreatFood(pSnake ps) {
  103. 	//1、坐标应该是随机生成的，但是这个随机是由约束的
  104. 	//2、食物坐标必须在方框内
  105. 	//3、食物的x坐标必须是2的倍数
  106. 	int x = 0;
  107. 	int y = 0;
  108. again:
  109. 	do {
  110. 		x = rand() % 76 + 2;
  111. 		y = rand() % 33 + 1;
  112. 	} while (x % 2 != 0);
  113.  
  114. 	//4、食物的坐标不能跟蛇身重叠，冲突 ，一一进行比较
  115. 	pSnakeNode cur = ps->_psnake;
  116. 	while (cur) {
  117. 		//比较
  118. 		if (cur->x == x && cur->y == y) {
  119. 			//出现重叠的就 goto 前面重新来过
  120. 			goto again;
  121. 		}
  122. 		cur = cur->next;
  123. 	}
  124. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  125. 	if (pFood == NULL) {
  126. 		perror("CreateFood(); malloc error!");
  127. 		return;
  128. 	}
  129. 	pFood->x = x;
  130. 	pFood->y = y;
  131. 	ps->_pFood = pFood;
  132.  
  133. 	SetPos(x, y);
  134. 	wprintf(L"%lc", FOOD);
  135.  
  136. }
  137.  
  138. //游戏初始化
  139. void GameStart(pSnake ps) {
  140. 	setlocale(LC_ALL, "");
  141. 	system("mode con cols=120 lines=40");
  142. 	system("title 贪吃蛇");
  143. 	//1_隐藏光标
  144.  
  145. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); //先获得控制台的句柄
  146. 	//一个控制台光标的信息的结构体 CONSOLE_CURSOR_INFO
  147. 	CONSOLE_CURSOR_INFO CursorInfo;
  148. 	//通过句柄获取控制台的光标信息，并储存在 CursorInfo 内
  149. 	GetConsoleCursorInfo(handle, &CursorInfo);
  150. 	//通过修改 CursorInfo 内的光标信息 bVisible 隐藏掉，不显示
  151. 	CursorInfo.bVisible = false;  //需要头文件 <stdbool.h>
  152. 	//修改成功后需要执行修改
  153. 	SetConsoleCursorInfo(handle, &CursorInfo);
  154.  
  155. 	//2_打印欢迎界面
  156. 	welComeToGame();
  157.  
  158. 	//3_创建地图
  159. 	CreateMap();
  160.  
  161. 	//4_初始化贪吃蛇
  162. 	InitSnake(ps);
  163.  
  164. 	//5_创建食物
  165. 	CreatFood(ps);
  166. }
  167.  
  168. //—————————以下是运行过程——————————————————————————————————————————————————
  169. //打印基本信息
  170. void PrintHelpInfo() {
  171.  
  172. 	SetPos(85, 12);
  173. 	printf("1、不能撞墙,不能吃到自己");
  174.  
  175. 	SetPos(85, 14);
  176. 	printf("2、←↑→↓来操控贪吃蛇移动");
  177.  
  178. 	SetPos(85, 16);
  179. 	printf("3、F3加速，F4减速");
  180.  
  181. 	SetPos(85, 18);
  182. 	printf("4、Esc退出游戏，Space暂停游戏");
  183.  
  184. }
  185.  
  186. //暂停
  187. void Pause() {
  188. 	while (1) {
  189. 		Sleep(200);
  190. 		if (KEY_PRESS(VK_SPACE)) {
  191. 			break;
  192. 		}
  193. 	}
  194. }
  195.  
  196. //判断是否是食物
  197. int NextIsFood(pSnake ps, pSnakeNode pNext) {
  198. 	if (ps->_pFood->x == pNext->x && ps->_pFood->y == pNext->y) {
  199. 		return 1;
  200. 	}
  201. 	return 0;
  202. }
  203.  
  204. //吃掉食物
  205. void EatFood(pSnake ps, pSnakeNode pNext) {
  206. 	pNext->next = ps->_psnake;
  207. 	ps->_psnake = pNext;
  208.  
  209.  
  210. 	pSnakeNode cur = ps->_psnake;
  211. 	while (cur) {
  212. 		SetPos(cur->x, cur->y);
  213. 		wprintf(L"%lc", BODY);
  214. 		cur = cur->next;
  215. 	}
  216.  
  217. 	//给总分加上分数
  218. 	ps->_Score += ps->_FootWeight;
  219.  
  220. 	free(ps->_pFood);
  221. 	//还得重新创建新的食物
  222. 	CreatFood(ps);
  223. }
  224.  
  225. //不吃食物
  226. void NoFood(pSnake ps, pSnakeNode pNext) {
  227. 	//头插入节点
  228. 	pNext->next = ps->_psnake;
  229. 	ps->_psnake = pNext;
  230.  
  231. 	//释放尾节点
  232. 	pSnakeNode cur = ps->_psnake;
  233. 	while (cur->next->next != NULL) {
  234. 		SetPos(cur->x, cur->y);
  235. 		wprintf(L"%lc", BODY);
  236. 		cur = cur->next;
  237. 	}
  238. 	SetPos(cur->next->x, cur->next->y);
  239. 	printf("  ");
  240. 	free(cur->next);
  241. 	cur->next = NULL;
  242. }
  243.  
  244. //判断是否撞墙
  245. void KillByWall(pSnake ps) {
  246. 	if (ps->_psnake->x == 0 || ps->_psnake->y == 35 || ps->_psnake->x == 80 || ps->_psnake->y == 0) {
  247. 		ps->_Status = KILL_BY_WALL;
  248. 	}
  249. }
  250.  
  251. //判断是否自杀
  252. void KillBySelf(pSnake ps) {
  253. 	pSnakeNode cur = ps->_psnake->next;
  254. 	while (cur) {
  255. 		if (ps->_psnake->x == cur->x && ps->_psnake->y == cur->y) {
  256. 			ps->_Status = KILL_BY_SELF;
  257. 			
  258. 		}
  259. 		cur = cur->next;
  260. 	}
  261. }
  262.  
  263. //蛇移动
  264. void SnakeMove(pSnake ps) {
  265. 	//为下一个移动的点创建一个节点
  266. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
  267. 	if (pNext == NULL) {
  268. 		perror("SnakeMove() malloc() error!");
  269. 		return;
  270. 	}
  271.  
  272. 	switch (ps->_Dir) {
  273. 	case UP:
  274. 	{
  275. 		pNext->x = ps->_psnake->x;
  276. 		pNext->y = ps->_psnake->y - 1;
  277. 	}
  278. 	break;
  279. 	case DOWN: {
  280. 		pNext->x = ps->_psnake->x;
  281. 		pNext->y = ps->_psnake->y + 1;
  282. 	}
  283. 			 break;
  284. 	case LEFT: {
  285. 		pNext->x = ps->_psnake->x - 2;
  286. 		pNext->y = ps->_psnake->y;
  287. 	}
  288. 			 break;
  289. 	case RIGHT: {
  290. 		pNext->x = ps->_psnake->x + 2;
  291. 		pNext->y = ps->_psnake->y;
  292. 	}
  293. 			  break;
  294. 	}
  295.  
  296. 	//判断是否是食物
  297. 	if (NextIsFood(ps, pNext)) {
  298. 		//吃掉食物
  299. 		EatFood(ps, pNext);
  300. 	}
  301. 	else {
  302. 		//不吃
  303. 		NoFood(ps, pNext);
  304. 	}
  305.  
  306. 	判断是否撞墙
  307. 	KillByWall(ps);
  308. 	判断是否自杀
  309. 	KillBySelf(ps);
  310. }
  311.  
  312. void GameRun(pSnake ps) {
  313. 	PrintHelpInfo();
  314. 	do {
  315. 		SetPos(85, 10);
  316. 		printf("得分：%05d", ps->_Score);
  317. 		SetPos(85, 11);
  318. 		printf("食物分数：%2d", ps->_FootWeight);
  319.  
  320. 		//检测按键情况 
  321. 		//本来方向就是向上就不能往相反方向了
  322. 		if (KEY_PRESS(VK_UP) && ps->_Dir != DOWN) {
  323. 			ps->_Dir = UP;
  324. 		}
  325. 		else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP) {
  326. 			ps->_Dir = DOWN;
  327. 		}
  328. 		else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT) {
  329. 			ps->_Dir = LEFT;
  330. 		}
  331. 		else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT) {
  332. 			ps->_Dir = RIGHT;
  333. 		}
  334. 		else if (KEY_PRESS(VK_ESCAPE)) {
  335. 			ps->_Status = END_NORMAL;
  336. 			break;
  337. 		}
  338. 		else if (KEY_PRESS(VK_SPACE)) {
  339. 			//封装一个暂停函数
  340. 			Pause();
  341. 		}
  342. 		//加速
  343. 		else if (KEY_PRESS(VK_F3)) {
  344. 			if (ps->_SleepTime >= 100) {
  345. 				ps->_SleepTime -= 30;
  346. 				ps->_FootWeight += 2;
  347. 			}
  348. 		}
  349. 		//减速
  350. 		else if (KEY_PRESS(VK_F4)) {
  351. 			if (ps->_SleepTime <= 320) {
  352. 				ps->_SleepTime += 30;
  353. 				ps->_FootWeight -= 2;
  354. 			}
  355. 		}
  356. 		//设置完后要应用休眠的时间
  357. 		Sleep(ps->_SleepTime);
  358. 		//让蛇移动起来
  359. 		SnakeMove(ps);
  360.  
  361. 	} while (ps->_Status == OK);
  362. }
  363. //————————游戏善后———————————————————————————————————————————————————
  364.  
  365.  
  366. //游戏结束
  367. void GameEnd(pSnake ps) {
  368. 	SetPos(39, 16);
  369. 	switch (ps->_Status) {
  370. 	case END_NORMAL:
  371. 		printf("退出游戏成功！(っ °Д °;)っ下次还要再来一把");
  372. 		break;
  373. 	case KILL_BY_WALL:
  374. 		printf("撞墙啦！(╯°□°）╯︵ ┻━┻");
  375. 		break;
  376. 	case KILL_BY_SELF:
  377. 		printf("自杀啦！你怎么咬到自己了啊！( ´･･)ﾉ(._.`)");
  378. 		break;
  379. 	}
  380.  
  381. 	SetPos(39, 18);
  382.  
  383. 	pSnakeNode cur = ps->_psnake;
  384. 	while (cur) {
  385. 		pSnakeNode del = cur;
  386. 		cur = cur->next;
  387. 		free(del);
  388. 	}
  389. }

4.3 test.c

  1. #include"Snake.h"
  2.  
  3. void test() {
  4. 	int ch = 0;
  5. 	do {
  6. 		Snake snake = { 0 };//创建贪吃蛇
  7. 		//初始化状态界面
  8. 		//1、游戏开始 - 初始化游戏
  9. 		GameStart(&snake);
  10. 		//2、游戏运行 - 游戏的正常运行过程
  11. 		GameRun(&snake);
  12. 		//3、游戏结束 - 游戏善后（释放资源）
  13. 		GameEnd(&snake);
  14. 		printf("是否再来一把（Y/N）");
  15. 		ch = getchar();
  16. 		getchar();//清理
  17. 	} while (ch == 'Y' || ch == 'y');
  18.  
  19. }
  20.  
  21. int main()
  22. {
  23. 	setlocale(LC_ALL, ""); //使用本地的ASCII环境
  24. 	srand((unsigned int)time(NULL)); //随机数的设置
  25. 	test();
  26.  
  27. 	return 0;
  28. }
  29.

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/1001550
推荐阅读
相关标签

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

  

闽ICP备14008679号