• C语言结课实战项目_贪吃蛇小游戏

    ✨✨所属专栏：C语言✨✨

    ✨✨作者主页：嶔某✨✨

    游戏源代码链接：function/贪吃蛇 · 钦某/c-language-learning - 码云 - 开源中国 (gitee.com)

    最终实现效果：

    实现基本的功能：

    1. void set_pos(short x, short y);//定位光标位置
    2.  
    3. void Game_Start(pSnake ps);//初始化
    4.  
    5. void WelcomeToGame(void);//打印欢迎界面
    6.  
    7. void CreateMap(void);//创建地图
    8.  
    9. void InitSnake(pSnake ps);//初始化蛇身
    10.  
    11. void CreateFood(pSnake ps);//创建食物
    12.  
    13. void Game_Run(pSnake ps);//游戏运行逻辑
    14.  
    15. void SnakeMove(pSnake ps);//蛇的移动
    16.  
    17. bool NextIsFood(pSnakeNode pn,pSnake ps);//判断下一位置是否为食物
    18.  
    19. void EatFood(pSnakeNode pn, pSnake ps);//吃掉食物
    20.  
    21. void NoFood(pSnakeNode pn, pSnake ps);//下一个位置不是食物
    22.  
    23. void KillByWall(pSnake ps);//检测撞墙
    24.  
    25. void KillBySelf(pSnake ps);//检测撞自己
    26.  
    27. void Game_End(pSnake ps);//游戏善后

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

    运用到的知识：C语⾔函数、枚举、结构体、动态内存管理、预处理指令、链表、Win32API等

    根据游戏进程解释代码：

    这里分为下面几个函数对游戏进行实现：

    1. system("cls");
    2. //创建贪吃蛇
    3. pSnakeNode pSnake = NULL;
    4.  
    5. Snake snake = { 0 };
    6.  
    7. //初始化游戏
    8. Game_Start(&snake);
    9.  
    10. //运行游戏
    11. Game_Run(&snake);
    12.  
    13. 结束游戏
    14. Game_End(&snake);

    游戏初始化：

    1. void Game_Start(pSnake ps)//初始化
    2. {
    3. 	//0.设置窗口大小/名字
    4. 	system("mode con cols=100 lines=30");
    5. 	system("title 贪吃蛇");
    6.  
    7. 	//1.隐藏光标
    8. 	HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    9. 	CONSOLE_CURSOR_INFO CursorInfo;
    10. 	GetConsoleCursorInfo(houtput,&CursorInfo);
    11. 	CursorInfo.bVisible = false;
    12. 	SetConsoleCursorInfo(houtput,&CursorInfo);
    13. 	
    14. 	//2.打印欢迎界面,介绍功能
    15. 	WelcomeToGame();
    16.  
    17. 	//3.绘制地图
    18. 	CreateMap();
    19.  
    20. 	//4.创建蛇
    21. 	InitSnake(ps);
    22.  
    23. 	//5.创建食物
    24. 	CreateFood(ps);
    25. }

    首先进入游戏，我们应该将窗口名称改为 “贪吃蛇” 并将光标隐藏掉。再在中间打印游戏信息。

    这里用到的函数有：

    （1）system("mode con cols=100 lines=30");

    将窗口设置为100列，30行

    （2）system("title 贪吃蛇");

    将title设置为贪吃蛇

    （3）system("pause");

    暂停程序，按下任意键继续

    （4）system("cls");

    清理屏幕

    1. /*******************************************/
    2. //0.设置窗口大小/名字
    3. system("mode con cols=100 lines=30");
    4. system("title 贪吃蛇");
    5. /*******************************************/
    6. void set_pos(short x, short y)
    7. {
    8. 	//获得标准输出设备的句柄
    9. 	HANDLE houtput = NULL; 
    10. 	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    11.  
    12. 	//定位光标的位置
    13. 	COORD pos = { x,y };
    14. 	SetConsoleCursorPosition(houtput,pos);
    15. }
    16. /*******************************************/
    17. void WelcomeToGame()
    18. {
    19. 	set_pos(40, 12);
    20. 	wprintf(L"欢迎来到贪吃蛇小游戏");
    21. 	set_pos(42,18);
    22. 	system("pause");
    23. 	system("cls");
    24. 	set_pos(30, 12);
    25. 	wprintf(L"用上下左右控制蛇的移动，按 {[ 加速, ]} 减速\n");
    26. 	set_pos(38, 13);
    27. 	wprintf(L"加速可以得到更高的分数\n");
    28. 	set_pos(42, 18);
    29. 	system("pause");
    30. 	system("cls");
    31. }
    32. /********************************************/

     之后我们要把地图打印出来：

    分别打印上下左右的墙，将墙宏定义为WALL，字符为’□‘

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

    然后我们将贪吃蛇创建出来，将蛇有关的信息用结构体和枚举类型封装起来，将蛇身用链表维护。

    蛇头指针：指向链表头节点的指针，方便对蛇身进行维护

    食物指针：从开发角度来说，其实食物也是蛇的一个节点，当蛇头的下一个位置为食物时，将食物的节点头插到蛇身上面。

    方向：对蛇的方向进行枚举

    游戏状态：方便判断蛇的状态：（1）正常（2）撞墙（3）撞到自己（4）正常退出每一次while循环后判断游戏状态

    食物权重：每次加速食物权重+2，减速-2。

    总成绩：每吃掉一个食物，蛇身长度+1，分数+=食物权重。

    每走一步的缓冲时间：缓冲时间越短，蛇走得越快；反之越慢。

    1. #define POS_X 24
    2. #define POS_Y 5
    3.  
    4. #define WALL L'□'
    5. #define BODY L'●'
    6. #define FOOD L'★'
    7. typedef struct SnakeNode
    8. {
    9. 	//坐标
    10. 	int x;
    11. 	int y;
    12. 	//下一个节点
    13. 	struct SnakeNode* next;
    14. }SnakeNode,*pSnakeNode;
    15.  
    16. enum DRECCTION//方向
    17. {
    18. 	UP = 1,
    19. 	DOWN,
    20. 	LEFT,
    21. 	RIGHT
    22. };
    23.  
    24. //蛇的状态
    25. enum GAME_STATUS
    26. {
    27. 	OK,//正常
    28. 	KILL_BY_WALL,//撞墙
    29. 	KILL_BY_SELF,//撞自己
    30. 	END_NORMAL//正常退出
    31. };
    32.  
    33. typedef struct Snake
    34. {
    35. 	pSnakeNode _pSnake;//指向蛇头的指针
    36. 	pSnakeNode _pFood;//指向食物节点的指针
    37. 	enum DRECCTION _dir;//蛇的方向
    38. 	enum GAME_STAYUS _status;//游戏状态
    39. 	int _food_weight;//一个食物都分数
    40. 	int _score;//总成绩
    41. 	int _sleep_time;//休息时间
    42.  
    43. }Snake,*pSnake;
    44. /************************************/
    45. void InitSnake(pSnake ps)//初始化蛇
    46. {
    47. 	int i = 0;
    48. 	pSnakeNode cur = NULL;
    49. 	for (int i = 0; i < 5; i++)
    50. 	{
    51. 		cur = (pSnakeNode)malloc(sizeof(SnakeNode));
    52. 		if (cur == NULL)
    53. 		{
    54. 			perror("InitSnake()::malloc()");
    55. 			return;
    56. 		}
    57. 		cur->next = NULL;
    58. 		cur->x = POS_X + 2 * i;
    59. 		cur->y = POS_Y;
    60. 		//头插插入
    61. 		if (ps->_pSnake == NULL)
    62. 			ps->_pSnake = cur;
    63. 		else
    64. 		{
    65. 			cur->next = ps->_pSnake;
    66. 			ps->_pSnake = cur;
    67. 		}
    68. 	}
    69. 	cur = ps->_pSnake;
    70. 	while (cur)
    71. 	{
    72. 		set_pos(cur->x,cur->y);
    73. 		wprintf(L"%lc", BODY);
    74. 		cur = cur->next;
    75. 	}
    76. 	//设置蛇的属性
    77. 	ps->_dir = RIGHT;//默认
    78. 	ps->_score = 0;
    79. 	ps->_food_weight = 10;
    80. 	ps->_sleep_time = 200;//单位为ms
    81. 	ps->_status = OK;
    82. }

    创建食物

    生成随机数，赋给x，y。

    这里x和y都有范围，不能超出地图边界，并且不能与蛇身重合。

    1. void CreateFood(pSnake ps)//创建食物
    2. {
    3. 	int x = 0;
    4. 	int y = 0;
    5. again:
    6. 	do
    7. 	{
    8. 		x = rand() % 52 + 2;//2~54
    9. 		y = rand() % 24 + 1;//1~25
    10. 	} while (x % 2 != 0);//x为2的倍数
    11. 	//不能和蛇身的坐标相同
    12. 	pSnakeNode cur = ps->_pSnake;
    13. 	while (cur)
    14. 	{
    15. 		if (x == cur->x && y == cur->y)
    16. 			goto again;
    17. 		cur = cur->next;
    18. 	}
    19. 	//创建食物节点
    20. 	pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
    21. 	if (pFood == NULL)
    22. 	{
    23. 		perror("CreateFood()::malloc");
    24. 		return;
    25. 	}
    26. 	pFood->x = x;
    27. 	pFood->y = y;
    28. 	pFood->next = NULL;
    29. 	set_pos(x, y);
    30. 	wprintf(L"%lc", FOOD);
    31. 	ps->_pFood = pFood;
    32. }

     游戏开始：

    1.  
    2. void Game_Run(pSnake ps)//游戏运行逻辑
    3. {
    4. 	//打印帮助信息
    5. 	PrintHelpInfo();
    6. 	do
    7. 	{
    8. 		//打印分数，食物权重
    9. 		set_pos(64, 8);
    10. 		printf("总分数:%d\n",ps->_score);
    11. 		set_pos(64, 9);
    12. 		printf("当前食物权重:%2d\n", ps->_food_weight);
    13. 		//按键检测
    14. 		if (KEY_PRESS(VK_UP) && ps->_dir != DOWN)
    15. 		{
    16. 			ps->_dir = UP;
    17. 		}
    18. 		else if (KEY_PRESS(VK_DOWN) && ps->_dir != UP)
    19. 		{
    20. 			ps->_dir = DOWN;
    21. 		}
    22. 		else if (KEY_PRESS(VK_LEFT) && ps->_dir != RIGHT)
    23. 		{
    24. 			ps->_dir = LEFT;
    25. 		}
    26. 		else if (KEY_PRESS(VK_RIGHT) && ps->_dir != LEFT)
    27. 		{
    28. 			ps->_dir = RIGHT;
    29. 		}
    30. 		else if (KEY_PRESS(VK_SPACE))
    31. 		{
    32. 			//暂停
    33. 			Pause();
    34. 		}
    35. 		else if (KEY_PRESS(VK_ESCAPE))
    36. 		{
    37. 			//正常退出
    38. 			ps->_status = END_NORMAL;
    39. 		}
    40. 		else if (KEY_PRESS(VK_OEM_6))
    41. 		{
    42. 			//加速
    43. 			if (ps->_sleep_time > 80)
    44. 			{
    45. 				ps->_sleep_time -= 30;
    46. 				ps->_food_weight += 2;
    47. 			}
    48. 		}
    49. 		else if (KEY_PRESS(VK_OEM_4))
    50. 		{
    51. 			//减速
    52. 			if (ps->_food_weight > 2)
    53. 			{
    54. 				ps->_sleep_time += 30;
    55. 				ps->_food_weight -= 2;
    56. 			}
    57. 		}
    58.  
    59. 		SnakeMove(ps);//蛇走一步的过程
    60. 		Sleep(ps->_sleep_time);
    61.  
    62. 	} while (ps->_status == OK);
    63. }

    用dowhile循环对主体进行不断刷新

    每次循环后让系统暂停一段时间（初始为200ms）

    打印相关信息

    蛇每走一步，分数都有可能变化，每次循环都打印一次。

    按键检测

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

    （1）用虚拟键值检测是否按下上下左右键，按下相应键并且蛇的当前方向不能与之相反。

    （2）检测是否按下空格，按下就进函数：

    1. void Pause()
    2. {
    3. 	while (1)
    4. 	{	
    5. 		Sleep(200);
    6. 		if (KEY_PRESS(VK_SPACE))
    7. 			break;
    8. 	}
    9. }

     再次按下空格退出函数。

    （3）检测加速减速，按下加速键就将缓冲时间变短，食物权重增加；反之变长，食物权重减少。（这里也是有范围的，食物权重不能为负数，也不能过大）

    蛇的移动

    进入函数，创建蛇头的下一个位置所在的节点，并根据方向算出所在位置。

    判断下一位置是否为食物：
    1. bool NextIsFood(pSnakeNode pn, pSnake ps)//判断下一位置是否为食物
    2. {
    3. 	return (ps->_pFood->x == pn->x && ps->_pFood->y == pn->y);
    4. }
     下一位置是食物：

    先将新节点头插进蛇身，打印蛇身在屏幕上，总分数加上食物权重。

    再次创建食物。

    1. void EatFood(pSnakeNode pn, pSnake ps)
    2. {
    3. 	//头插
    4. 	ps->_pFood->next = ps->_pSnake;
    5. 	ps->_pSnake = ps->_pFood;
    6.  
    7. 	//释放下一个位置的节点
    8. 	free(pn);
    9. 	pn = NULL;
    10.  
    11. 	//打印
    12. 	pSnakeNode cur = ps->_pSnake;
    13. 	while (cur)
    14. 	{
    15. 		set_pos(cur->x, cur->y);
    16. 		wprintf(L"%lc",BODY);
    17. 		cur = cur->next;
    18. 	}
    19. 	ps->_score += ps->_food_weight;
    20. 	//重新创建食物
    21. 	CreateFood(ps);
    22. }
    下一位置不是食物：

    创建下一位置的节点，也是头插，但是在打印蛇身之后，将蛇尾位置打印两个空格(不打印空格蛇身就不会清除一直留在屏幕上：拖尾)，将蛇尾的节点释放掉。（cur->next一定要置空，不能让它为野指针）

    1. void NoFood(pSnakeNode pn, pSnake ps)//下一个位置不是食物
    2. {
    3. 	//头插
    4. 	pn->next = ps->_pSnake;
    5. 	ps->_pSnake = pn;
    6.  
    7. 	pSnakeNode cur = ps->_pSnake;
    8. 	while (cur->next->next)
    9. 	{
    10. 		set_pos(cur->x,cur->y);
    11. 		wprintf(L"%lc",BODY);
    12.  
    13. 		cur = cur->next;
    14. 	}
    15. 	//把最后一个节点打印空格
    16. 	set_pos(cur->next->x,cur->next->y);
    17. 	printf("  ");
    18. 	//将最后一个节点释放
    19. 	free(cur->next);
    20. 	//将倒数第二个节点置为空
    21. 	cur->next = NULL;
    22. }
     检测是否撞墙：

    判断蛇头坐标位置是否超出范围，若超出范围，将蛇的状态改为KILL_BY_WALL

    1. void KillByWall(pSnake ps)//检测撞墙
    2. {
    3. 	if (ps->_pSnake->x == 0 || ps->_pSnake->x == 56 ||
    4. 		ps->_pSnake->y == 0 || ps->_pSnake->y == 26)
    5. 	{
    6. 		ps->_status = KILL_BY_WALL;
    7. 	}
    8. }
    检测是否撞到自己：

    遍历蛇身链表，若坐标重合，将蛇的状态改为KILL_BY_SELF，并且跳出循环。

    1. void KillBySelf(pSnake ps)//检测撞自己
    2. {
    3. 	pSnakeNode cur = ps->_pSnake->next;
    4. 	while (cur)
    5. 	{
    6. 		if (cur->x == ps->_pSnake->x && cur->y == ps->_pSnake->y)
    7. 		{
    8. 			ps->_status = KILL_BY_SELF;
    9. 			break;
    10. 		}
    11. 		cur = cur->next;
    12. 	}
    13. }
     蛇移动一步的总函数：
    1. void SnakeMove(pSnake ps)//蛇的移动
    2. {
    3. 	//创建蛇头的下一个节点
    4. 	pSnakeNode pNextNode = (pSnakeNode)malloc(sizeof(SnakeNode));
    5. 	if (pNextNode == NULL)
    6. 	{
    7. 		perror("SnakeMove()::malloc()");
    8. 		return;
    9. 	}
    10. 	switch (ps->_dir)
    11. 	{
    12. 	case UP:
    13. 		pNextNode->x = ps->_pSnake->x;
    14. 		pNextNode->y = ps->_pSnake->y-1;
    15. 		break;
    16. 	case DOWN:
    17. 		pNextNode->x = ps->_pSnake->x;
    18. 		pNextNode->y = ps->_pSnake->y + 1;
    19. 		break;
    20. 	case LEFT:
    21. 		pNextNode->x = ps->_pSnake->x - 2;
    22. 		pNextNode->y = ps->_pSnake->y;
    23. 		break;
    24. 	case RIGHT:
    25. 		pNextNode->x = ps->_pSnake->x + 2;
    26. 		pNextNode->y = ps->_pSnake->y;
    27. 		break;
    28. 	}
    29. 	if (NextIsFood(pNextNode,ps))//检测下一个位置是否为食物
    30. 	{
    31. 		EatFood(pNextNode, ps);
    32. 	}
    33. 	else
    34. 	{
    35. 		NoFood(pNextNode, ps);
    36. 	}
    37. 	//检测是否撞墙
    38. 	KillByWall(ps);
    39. 	//检测是否撞自己
    40. 	KillBySelf(ps);
    41. }

     游戏结束：

    判断游戏结束的原因，并打印。

    释放蛇身链表

    1. void Game_End(pSnake ps)//游戏善后
    2. {
    3. 	set_pos(24,12);
    4. 	switch (ps->_status)
    5. 	{
    6. 	case END_NORMAL:
    7. 		printf("您主动结束游戏\n");
    8. 		break;
    9. 	case KILL_BY_WALL:
    10. 		printf("您被墙单杀了\n");
    11. 		break;
    12. 	case KILL_BY_SELF:
    13. 		printf("您被自己单杀了\n");
    14. 		break;
    15. 	}
    16.  
    17. 	//释放蛇身链表
    18. 	pSnakeNode cur = ps->_pSnake;
    19. 	while (cur)
    20. 	{
    21. 		pSnakeNode del = cur;
    22. 		cur = cur->next;
    23. 		free(del);
    24. 	}
    25. }

    后续改进：

    1.穿墙

    2.食物分类

    3.多个食物

    4.双人游戏

    ……

     本期博客到这里就结束了，如果有什么错误，欢迎指出，如果对你有帮助，请点个赞，谢谢！

  • 相关阅读:
    【乐吾乐3D可视化组态编辑器】相机与视角
    sqlmap注入枚举参数详解
    RabbitMQ系列-Exchange介绍
    XXL-job-oracle 版本
    新车「智能化+安全」进入纵深区，艾拉比OTA成高频词
    深度学习Day-19：DenseNet算法实战与解析
    3. 项目立项三板斧
    Golang中make和new的区别
    Kotlin基础从入门到进阶系列讲解（入门篇）Activity的使用
    Vue2：Vue2 @vue/cli脚手架
  • 原文地址：https://blog.csdn.net/2301_80194476/article/details/137958506