• 贪吃蛇（C语言实现）

      贪食蛇（也叫贪吃蛇）是一款经典的小游戏。

    ——————————————————————

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

    实行的基本功能：

    •  贪吃蛇地图的绘制

    •  蛇吃食物的功能（上、下、左、右方向键来控制蛇的方向）

    •  蛇撞墙死亡

    •  蛇撞自身死亡

    •  计算得分

    •  蛇身加速、减速

    •  暂停游戏

    主要框架（主要函数）：

    1. GameStrat();//游戏开始前的初始化
    2. GameRun();//玩游戏的过程
    3. GameEnd();//善后工作（节点的释放）

    游戏流程设计：

    参考代码：

    snake.h

    1. #pragma once
    2.  
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define WALL L'□'
    11. #define BODY L'●'
    12. #define FOOD L'★'
    13.  
    14.  
    15. //蛇默认的起始坐标
    16. #define POS_X 24
    17. #define POS_Y 5
    18.  
    19. #define KEY_PRESS(VK)  ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )
    20.  
    21. //游戏的状态
    22. enum GAME_STATUS
    23. {
    24. 	OK=1,//正常运行
    25. 	ESC, //按了ESC键退出，正常退出
    26. 	KILL_BY_WALL,//撞墙
    27. 	KILL_BY_SELF //撞到自身
    28. };
    29.  
    30. //蛇行走的方向
    31. enum DIRECTION
    32. {
    33. 	UP=1,
    34. 	DOWN,
    35. 	LEFT,
    36. 	RIGHT
    37. };
    38.  
    39. //蛇身结点的定义
    40. typedef struct SnakeNode
    41. {
    42. 	int x;
    43. 	int y;
    44. 	struct SnakeNode* next;
    45. }SnakeNode, * pSnakeNode;
    46.  
    47.  
    48. //贪吃蛇
    49. typedef struct Snake
    50. {
    51. 	pSnakeNode pSnake;//维护整条蛇的指针，是指向蛇头
    52. 	pSnakeNode pFood;//指向食物的指针
    53. 	int Score;//当前累积的分数
    54. 	int FoodWeight;//一个食物的分数
    55. 	int SleepTime;//蛇休眠的时间，休眠的时间越短，蛇的速度越快，休眠的时间越长，蛇的速度越慢
    56. 	enum GAME_STATUS status;//游戏当前的状态
    57. 	enum DIRECTION dir;//蛇当前走的方向
    58. 	//...
    59. }Snake, * pSnake;
    60.  
    61.  
    62. //定位控制台光标位置
    63. void SetPos(int x, int y);
    64.  
    65. //游戏开始前的准备
    66. void GameStart(pSnake ps);
    67.  
    68. //打印欢迎界面
    69. void WelcomeToGame();
    70.  
    71. //绘制地图
    72. void CreateMap();
    73.  
    74. //初始化贪吃蛇
    75. void InitSnake(pSnake ps);
    76.  
    77. //创建食物
    78. void CreateFood(pSnake ps);
    79.  
    80. //游戏运行的整个逻辑
    81. void GameRun(pSnake ps);
    82.  
    83. //打印帮助信息
    84. void PrintHelpInfo();
    85.  
    86. //蛇移动的函数- 每次走一步
    87. void SnakeMove(pSnake ps);
    88.  
    89. //判断蛇头的下一步要走的位置处是否是食物
    90. int NextIsFood(pSnake ps, pSnakeNode pNext);
    91.  
    92. //下一步要走的位置处就是食物，就吃掉食物
    93. void EatFood(pSnake ps, pSnakeNode pNext);
    94.  
    95. //下一步要走的位置处不是食物，不吃食物
    96. void NotEatFood(pSnake ps, pSnakeNode pNext);
    97.  
    98. //检测是否撞墙
    99. void KillByWall(pSnake ps);
    100.  
    101. //检测是否撞自己
    102. void KillBySelf(pSnake ps);
    103.  
    104. //游戏结束的资源释放
    105. void GameEnd(pSnake ps);

    snake.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "snake.h"
    4.  
    5. void SetPos(int x,int y)
    6. {
    7. 	//获得设备句柄
    8. 	HANDLE hanlde = GetStdHandle(STD_OUTPUT_HANDLE);
    9. 	//根据句柄设置光标的位置
    10. 	COORD pos = { x, y };
    11. 	SetConsoleCursorPosition(hanlde, pos);
    12. }
    13.  
    14. void WelcomeToGame()
    15. {
    16. 	//欢迎信息
    17. 	SetPos(35, 10);
    18. 	printf("欢迎来到贪吃蛇小游戏\n");
    19. 	SetPos(38, 20);
    20. 	system("pause");
    21. 	system("cls");
    22.  
    23. 	//功能介绍信息
    24. 	SetPos(15, 10);
    25. 	printf("用 ↑ . ↓ . ← . → 来控制蛇的移动，F3是加速，F4是减速");
    26. 	SetPos(15, 11);
    27. 	printf("加速能得到更高的分数");
    28. 	SetPos(38, 20);
    29. 	system("pause");
    30. 	system("cls");
    31. }
    32.  
    33. void CreateMap()
    34. {
    35. 	int i = 0;
    36. 	//上
    37. 	SetPos(0, 0);
    38. 	for (i = 0; i <= 56; i += 2)
    39. 	{
    40. 		wprintf(L"%lc", WALL);
    41. 	}
    42. 	//下
    43. 	SetPos(0, 26);
    44. 	for (i = 0; i <= 56; i += 2)
    45. 	{
    46. 		wprintf(L"%lc", WALL);
    47. 	}
    48. 	//左
    49. 	for (i = 1; i <= 25; i++)
    50. 	{
    51. 		SetPos(0, i);
    52. 		wprintf(L"%lc", WALL);
    53. 	}
    54. 	//右
    55. 	for (i = 1; i <= 25; i++)
    56. 	{
    57. 		SetPos(56, i);
    58. 		wprintf(L"%lc", WALL);
    59. 	}
    60. }
    61.  
    62.  
    63. void InitSnake(pSnake ps)
    64. {
    65. 	//创建5个蛇身的结点
    66. 	pSnakeNode cur = NULL;
    67. 	int i = 0;
    68. 	for (i = 0; i < 5; i++)
    69. 	{
    70. 		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
    71. 		if (cur == NULL)
    72. 		{
    73. 			perror("InitSnake():malloc()");
    74. 			return;
    75. 		}
    76. 		cur->x = POS_X + 2 * i;
    77. 		cur->y = POS_Y;
    78. 		cur->next = NULL;
    79.  
    80. 		//头插法
    81. 		if (ps->pSnake == NULL)
    82. 		{
    83. 			ps->pSnake = cur;
    84. 		}
    85. 		else
    86. 		{
    87. 			cur->next = ps->pSnake;
    88. 			ps->pSnake = cur;
    89. 		}
    90. 	}
    91.  
    92. 	//打印蛇身
    93. 	cur = ps->pSnake;
    94. 	while (cur)
    95. 	{
    96. 		SetPos(cur->x, cur->y);
    97. 		wprintf(L"%lc", BODY);
    98. 		cur = cur->next;
    99. 	}
    100.  
    101. 	//贪吃蛇的其他信息初始化
    102. 	ps->dir = RIGHT;
    103. 	ps->FoodWeight = 10;
    104. 	ps->pFood = NULL;
    105. 	ps->Score = 0;
    106. 	ps->SleepTime = 200;
    107. 	ps->status = OK;
    108. }
    109.  
    110. void CreateFood(pSnake ps)
    111. {
    112. 	int x = 0;
    113. 	int y = 0;
    114.  
    115. again:
    116. 	do
    117. 	{
    118. 		x = rand() % 53 + 2;
    119. 		y = rand() % 24 + 1;
    120. 	} while (x % 2 != 0);
    121.  
    122. 	//坐标和蛇的身体的每个节点的做坐标比较
    123. 	pSnakeNode cur = ps->pSnake;
    124. 	while (cur)
    125. 	{
    126. 		if (x == cur->x && y == cur->y)
    127. 		{
    128. 			goto again;
    129. 		}
    130. 		cur = cur->next;
    131. 	}
    132.  
    133. 	//创建食物
    134. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
    135. 	if (pFood == NULL)
    136. 	{
    137. 		perror("CreateFood()::malloc()");
    138. 		return;
    139. 	}
    140. 	
    141. 	pFood->x = x;
    142. 	pFood->y = y;
    143.  
    144. 	ps->pFood = pFood;
    145. 	SetPos(x, y);
    146. 	wprintf(L"%lc", FOOD);
    147.  
    148. }
    149.  
    150.  
    151.  
    152. void GameStart(pSnake ps)
    153. {
    154. 	//设置控制台的信息，窗口大小，窗口名
    155. 	system("mode con cols=100 lines=30");
    156. 	system("title 贪吃蛇");
    157.  
    158. 	//隐藏光标
    159. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    160. 	CONSOLE_CURSOR_INFO CursorInfo;
    161. 	GetConsoleCursorInfo(handle, &CursorInfo);//获取控制台光标信息
    162. 	CursorInfo.bVisible = false;
    163. 	SetConsoleCursorInfo(handle, &CursorInfo);
    164.  
    165. 	//打印欢迎信息
    166. 	WelcomeToGame();
    167.  
    168. 	//绘制地图
    169. 	CreateMap();
    170.  
    171. 	//初始化蛇
    172. 	InitSnake(ps);
    173.  
    174. 	//创建食物
    175. 	CreateFood(ps);
    176. }
    177.  
    178. void PrintHelpInfo()
    179. {
    180. 	SetPos(62, 15);
    181. 	printf("1.不能穿墙，不能咬到自己");
    182. 	SetPos(62, 16);
    183. 	printf("2.用 ↑.↓.←.→ 来控制蛇的移动"); 
    184. 	SetPos(62, 17);
    185. 	printf("3.F3是加速，F4是减速");
    186.  
    187. 	SetPos(62, 19);
    188. 	printf("版权@比特就业课");
    189. }
    190.  
    191.  
    192. void pause()
    193. {
    194. 	while (1)
    195. 	{
    196. 		Sleep(100);
    197. 		if (KEY_PRESS(VK_SPACE))
    198. 		{
    199. 			break;
    200. 		}
    201. 	}
    202. }
    203.  
    204. int NextIsFood(pSnake ps, pSnakeNode pNext)
    205. {
    206. 	if (ps->pFood->x == pNext->x && ps->pFood->y == pNext->y)
    207. 		return 1;//下一个坐标处是食物
    208. 	else
    209. 		return 0;
    210. }
    211.  
    212. void EatFood(pSnake ps, pSnakeNode pNext)
    213. {
    214. 	pNext->next = ps->pSnake;
    215. 	ps->pSnake = pNext;
    216.  
    217. 	//打印蛇
    218. 	pSnakeNode cur = ps->pSnake;
    219. 	while (cur)
    220. 	{
    221. 		SetPos(cur->x, cur->y);
    222. 		wprintf(L"%lc", BODY);
    223. 		cur = cur->next;
    224. 	}
    225.  
    226. 	ps->Score += ps->FoodWeight;
    227.  
    228. 	//释放旧的食物
    229. 	free(ps->pFood);
    230. 	//新建食物
    231. 	CreateFood(ps);
    232. }
    233.  
    234. void NotEatFood(pSnake ps, pSnakeNode pNext)
    235. {
    236. 	//头插法
    237. 	pNext->next = ps->pSnake;
    238. 	ps->pSnake = pNext;
    239.  
    240. 	//释放尾结点
    241. 	pSnakeNode cur = ps->pSnake;
    242. 	while (cur->next->next)
    243. 	{
    244. 		SetPos(cur->x, cur->y);
    245. 		wprintf(L"%lc", BODY);
    246. 		cur = cur->next;
    247. 	}
    248. 	//将尾节点的位置打印成空白字符
    249. 	SetPos(cur->next->x, cur->next->y);
    250. 	printf("  ");
    251.  
    252. 	free(cur->next);
    253. 	cur->next = NULL;//易错
    254. }
    255.  
    256.  
    257. //检测是否撞墙
    258. void KillByWall(pSnake ps)
    259. {
    260. 	if (ps->pSnake->x == 0 ||
    261. 		ps->pSnake->x == 56 ||
    262. 		ps->pSnake->y == 0 ||
    263. 		ps->pSnake->y == 26)
    264. 	{
    265. 		ps->status = KILL_BY_WALL;
    266. 	}
    267. }
    268.  
    269. //检测是否撞自己
    270. void KillBySelf(pSnake ps)
    271. {
    272. 	pSnakeNode cur = ps->pSnake->next;//从第二个节点开始
    273. 	while (cur)
    274. 	{
    275. 		if (cur->x == ps->pSnake->x && cur->y == ps->pSnake->y)
    276. 		{
    277. 			ps->status = KILL_BY_SELF;
    278. 			return;
    279. 		}
    280. 		cur = cur->next;
    281. 	}
    282. }
    283.  
    284. void SnakeMove(pSnake ps)
    285. {
    286. 	pSnakeNode pNext = (pSnakeNode)malloc(sizeof(SnakeNode));
    287. 	if (pNext == NULL)
    288. 	{
    289. 		perror("SnakeMove()::malloc()");
    290. 		return;
    291. 	}
    292. 	pNext->next = NULL;
    293.  
    294. 	switch (ps->dir)
    295. 	{
    296. 	case UP:
    297. 		pNext->x = ps->pSnake->x;
    298. 		pNext->y = ps->pSnake->y - 1;
    299. 		break;
    300. 	case DOWN:
    301. 		pNext->x = ps->pSnake->x;
    302. 		pNext->y = ps->pSnake->y + 1;
    303. 		break;
    304. 	case LEFT:
    305. 		pNext->x = ps->pSnake->x-2;
    306. 		pNext->y = ps->pSnake->y;
    307. 		break;
    308. 	case RIGHT:
    309. 		pNext->x = ps->pSnake->x+2;
    310. 		pNext->y = ps->pSnake->y;
    311. 		break;
    312. 	}
    313.  
    314. 	//下一个坐标处是否是食物
    315. 	if (NextIsFood(ps, pNext))
    316. 	{
    317. 		//是食物就吃掉
    318. 		EatFood(ps, pNext);
    319. 	}
    320. 	else
    321. 	{
    322. 		//不是食物就正常一步
    323. 		NotEatFood(ps, pNext);
    324. 	}
    325. 	
    326. 	//检测撞墙
    327. 	KillByWall(ps);
    328.  
    329. 	//检测撞到自己
    330. 	KillBySelf(ps);
    331. }
    332.  
    333.  
    334. void GameRun(pSnake ps)
    335. {
    336. 	//打印帮助信息
    337. 	PrintHelpInfo();
    338.  
    339. 	do
    340. 	{
    341. 		//当前的分数情况
    342. 		SetPos(62, 10);
    343. 		printf("总分:%5d\n", ps->Score);
    344. 		SetPos(62, 11);
    345. 		printf("食物的分值:%02d\n", ps->FoodWeight);
    346. 	    //检测按键
    347. 		//上、下、左、右、ESC、空格、F3、F4
    348. 		if (KEY_PRESS(VK_UP) && ps->dir != DOWN)
    349. 		{
    350. 			ps->dir = UP;
    351. 		}
    352. 		else if (KEY_PRESS(VK_DOWN) && ps->dir != UP)
    353. 		{
    354. 			ps->dir = DOWN;
    355. 		}
    356. 		else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT)
    357. 		{
    358. 			ps->dir = LEFT;
    359. 		}
    360. 		else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT)
    361. 		{
    362. 			ps->dir = RIGHT;
    363. 		}
    364. 		else if (KEY_PRESS(VK_ESCAPE))
    365. 		{
    366. 			ps->status = ESC;
    367. 			break;
    368. 		}
    369. 		else if (KEY_PRESS(VK_SPACE))
    370. 		{
    371. 			//游戏要暂定
    372. 			pause();//暂定和回复暂定
    373. 		}
    374. 		else if(KEY_PRESS(VK_F3))
    375. 		{
    376. 			if (ps->SleepTime >= 80)
    377. 			{
    378. 				ps->SleepTime -= 30;
    379. 				ps->FoodWeight += 2;
    380. 			}
    381. 		}
    382. 		else if (KEY_PRESS(VK_F4))
    383. 		{
    384. 			if (ps->FoodWeight > 2)
    385. 			{
    386. 				ps->SleepTime += 30;
    387. 				ps->FoodWeight -= 2;
    388. 			}
    389. 		}
    390. 		//走一步
    391. 		SnakeMove(ps);
    392.  
    393. 		//睡眠一下
    394. 		Sleep(ps->SleepTime);
    395.  
    396. 	} while (ps->status == OK);
    397. }
    398.  
    399.  
    400. void GameEnd(pSnake ps)
    401. {
    402. 	SetPos(15, 12);
    403. 	switch (ps->status)
    404. 	{
    405. 	case ESC:
    406. 		printf("主动退出游戏，正常退出\n");
    407. 		break;
    408. 	case KILL_BY_WALL:
    409. 		printf("很遗憾，撞墙了，游戏结束\n");
    410. 		break;
    411. 	case KILL_BY_SELF:
    412. 		printf("很遗憾，咬到自己了，游戏结束\n");
    413. 		break;
    414. 	}
    415. 	//释放贪吃蛇的链表资源
    416. 	pSnakeNode cur = ps->pSnake;
    417. 	pSnakeNode del = NULL;
    418.  
    419. 	while (cur)
    420. 	{
    421. 		del = cur;
    422. 		cur = cur->next;
    423. 		free(del);
    424. 	}
    425. 	free(ps->pFood);
    426. 	ps = NULL;
    427. }

    test.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "snake.h"
    4.  
    5. void test()
    6. {
    7. 	//创建贪食蛇
    8. 	int ch = 0;
    9. 	do
    10. 	{
    11. 		Snake snake = { 0 };
    12. 		GameStart(&snake);//游戏开始前的初始化
    13. 		GameRun(&snake);//玩游戏的过程
    14. 		GameEnd(&snake);//善后的工作
    15. 		SetPos(20, 15);
    16. 		printf("再来一局吗？(Y/N):");
    17. 		ch = getchar();
    18. 		getchar();// 清理\n
    19. 	} while (ch == 'Y' || ch =='y');
    20. }
    21.  
    22.  
    23. int main()
    24. {
    25. 	//修改适配本地中文环境
    26. 	setlocale(LC_ALL, "");
    27.  
    28. 	test();//贪吃蛇游戏的测试
    29. 	SetPos(0, 27);
    30. 	return 0;
    31. }

    这个博客如果对你有帮助，给博主一个免费的点赞就是最大的帮助❤

    欢迎各位点赞，收藏和关注哦❤

    如果有疑问或有不同见解，欢迎在评论区留言哦❤

    后续我会一直分享双一流211西北大学软件（C，数据结构，C++，Linux，MySQL）的学习干货以及重要代码的分享

  • 相关阅读:
    关于Docker挂载的问题！
    Java -- 每日一问：Exception 和 Error 有什么区别？
    27. 移除元素
    虚拟与实际内存之间的关系
    浅谈智能安全配电装置在老年人建筑中的应用
    Linux环境下Arm端源码编译OpenCV+ncnn目标检测模型实例运行调试完整实践记录
    java计算机毕业设计消防应急管理系统源码+系统+数据库+lw文档+mybatis+运行部署
    scrollTop、clientHeight、 scrollHeight...学完真的理解了
    手机厂商“互卷”之年：“机海战术”失灵，“慢节奏”打法崛起
    《QT从基础到进阶·十六》QT实现客户端和服务端的简单交互
  • 原文地址：https://blog.csdn.net/m0_73751295/article/details/136589628