devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

贪吃蛇游戏（C语言实现）_c语言贪吃蛇游戏代码

作者：菜鸟追梦旅行 | 2024-04-04 13:19:38

赞

踩

c语言贪吃蛇游戏代码

 前言

本篇基于Esayx图形库的基础上，在Visual Studio编译器上运行，主要通过构建各个不同功能的函数（面向过程）来实现这款经典的小游戏———贪吃蛇。

 一 主要函数

//该函数用于绘制出一个网格出来
void paintGrid();

//该函数用于绘制出一个蛇
void paintSnake(node* snake, int n);

//该函数将依次移动蛇节头并根据前进方向设置蛇头
//以此来控制蛇的移动
node snakeMove(node* snake, int length, int direction);

//该函数通过键盘输入的方式来调整蛇移动的方向
void changDirection(enum direction* p);

//该函数用于在画布中创建出一个食物类型
node creatFood(node* snake, int length);

//该函数用于在画布中生成一个食物
void paintFood(node* food);

//该函数用于判断游戏是否结束
bool isGameover(node* snake, int length);

//该函数用于将游戏数据初始化
void reset(node* snake, int* plength, enum direction* pd);

 二 对各个函数进行实现

1.定义结构体以及一些枚举变量、常量

  1. //我们创建的画布大小是600*800大小的，将其分成宽为40的小矩形
  2. #define NOOD_WIDTH 40 
  3.  
  4. //该枚举类型分别对应四个方向，用键盘上的wsad来表示上下左右
  5. enum direction
  6. {
  7. 	eUp,
  8. 	eDown,
  9. 	eLeft,
  10. 	eRight
  11. };
  12.  
  13. //该结构node用于记录蛇的每一个节点
  14. typedef struct
  15. {
  16. 	int x;
  17. 	int y;
  18. }node;

 2.//该函数用于绘制出一个网格出来
void paintGrid();

  1. void paintGrid()
  2. {
  3. 	setlinecolor(WHITE);
  4. 	for (int x = 0; x < 800; x += NOOD_WIDTH)//以这个宽度为间距进行画竖线
  5. 	{
  6. 		line(x, 0, x, 600);//画竖线
  7. 	}
  8. 	for (int y = 0; y < 600; y += NOOD_WIDTH)//以这个宽度为间距进行画横线
  9.  
  10. 	{
  11. 		line(0, y, 800, y);//画横线
  12. 	}
  13. }

3.//该函数用于绘制出一个蛇
void paintSnake(node* snake, int n);

  1. void paintSnake(node* snake, int n)
  2. {
  3. 	int left, top, right, bottom;
  4. 	for (int i = 0; i < n; i++)
  5. 	{
  6. 		left = snake[i].x * NOOD_WIDTH;//*(snake + i).x
  7. 		top = snake[i].y * NOOD_WIDTH;
  8. 		right = (snake[i].x + 1) * NOOD_WIDTH;
  9. 		bottom = (snake[i].y + 1) * NOOD_WIDTH;
  10. 		setlinecolor(BLACK);
  11. 		fillrectangle(left, top, right, bottom);
  12. 	}
  13. }

 4.//该函数将依次移动蛇节头并根据前进方向设置蛇头
//以此来控制蛇的移动
node snakeMove(node* snake, int length, int direction);

  1. node snakeMove(node* snake, int length, int direction)
  2. {
  3. 	node tail = snake[length - 1];
  4. 	//用一个循环将数组中的元素从后往前依次进行覆盖
  5. 	for (int i = length - 1; i > 0; i--)
  6. 	{
  7. 		snake[i] = snake[i - 1];//将前一个节点覆盖后一个节点
  8. 	}
  9. 	node newhead = snake[0];
  10. 	if (direction == eUp)
  11. 	{
  12. 		newhead.y--;//在原蛇头的基础上进行修改
  13. 	}
  14. 	if (direction == eDown)
  15. 	{
  16. 		newhead.y++;
  17. 	}
  18. 	if (direction == eLeft)
  19. 	{
  20. 		newhead.x--;
  21. 	}
  22. 	if (direction == eRight)
  23. 	{
  24. 		newhead.x++;
  25. 	}
  26. 	snake[0] = newhead;//最后在把修改后的蛇头数据赋值给原数组的首元素
  27. 	return tail;
  28. }

5. //该函数通过键盘输入的方式来调整蛇移动的方向
void changDirection(enum direction* p);

 

  1. void changDirection(enum direction* p)
  2. {
  3. 	if (_kbhit() != 0)
  4. 	{
  5. 		char c = _getch();
  6. 		switch (c)
  7. 		{
  8. 		case 'a':
  9. 			if(*p != eRight)
  10. 			    *p = eLeft;
  11. 			break;
  12. 		case 'd':
  13. 			if (*p != eLeft)
  14. 			    *p = eRight;
  15. 			break;
  16. 		case 'w':
  17. 			if (*p != eDown)
  18. 			    *p = eUp;
  19. 			break;
  20. 		case's':
  21. 			if (*p != eUp)
  22. 			    *p = eDown;
  23. 			break;
  24. 		}
  25. 	}
  26. }

 6.//该函数用于在画布中创建出一个食物类型
node creatFood(node* snake, int length);

  1. node creatFood(node* snake, int length)
  2. {
  3. 	//先在画布圈定的范围之内随机生成一个食物点
  4. 	node food;
  5. 	//然后用一个死循环来对食物点进行检验（不能与蛇的身体进行重合）
  6. 	while (1)
  7. 	{
  8. 		food.x = rand() % (800 / NOOD_WIDTH);
  9. 		food.y = rand() % (600 / NOOD_WIDTH);
  10. 		int i = 0;
  11. 		for (i = 0; i < length; i++)
  12. 		{
  13. 			if (food.x == snake[i].x && food.y == snake[i].y)
  14. 				break;
  15. 		}
  16. 		if (i < length)
  17. 			continue;
  18. 		else
  19. 			break;
  20. 	}
  21. 	return food;
  22. }

7.//该函数用于在画布中生成一个食物
void paintFood(node* food);

  1. void paintFood(node* food)
  2. {
  3. 	int left, top, right, bottom;
  4. 		left = food->x * NOOD_WIDTH;//*(snake + i).x
  5. 		top = food->y* NOOD_WIDTH;
  6. 		right = (food->x + 1) * NOOD_WIDTH;
  7. 		bottom = (food->y + 1) * NOOD_WIDTH;
  8. 		setfillcolor(YELLOW);
  9. 		solidrectangle(left, top, right, bottom);
  10. 		setfillcolor(WHITE);
  11. }

 8.//该函数用于判断游戏是否结束
bool isGameover(node* snake, int length);

 

  1. bool isGameover(node* snake, int length)
  2. {
  3. 	if (snake[0].x < 0 || snake[0].x>800 / NOOD_WIDTH)
  4. 	{
  5. 		return true;
  6. 	}
  7. 	if (snake[0].y < 0 || snake[0].y>600 / NOOD_WIDTH)
  8. 	{
  9. 		return true;
  10. 	}
  11. 	for (int i = 1; i < length; i++)
  12. 	{
  13. 		if (snake[0].x == snake[i].x && snake[0].y == snake[i].y)
  14. 			return true;
  15. 	}
  16. 	return false;
  17. }

9. //该函数用于将游戏数据初始化
void reset(node* snake, int* plength, enum direction* pd);

  1. void reset(node* snake, int* plength, enum direction* pd)
  2. {
  3. 	for (int i = 0; i < 5; i++)
  4. 	{
  5. 		for (int j = 5; j > 0; j--)
  6. 		{
  7. 			snake[i].x = j;
  8. 		}
  9. 		snake[i].y = 7;
  10. 	}
  11. 	*plength = 5;
  12. 	*pd = eRight;
  13. }

三 主函数部分 

 

  1. int main()
  2. {
  3. 	initgraph(800, 600);
  4. 	setbkcolor(RGB(164, 225, 202));
  5. 	cleardevice();
  6. 	node snake[100] = { {5,7},{4,7},{3,7},{2,7},{1,7} };
  7. 	int length = 5;
  8. 	enum direction d = eRight;
  9. 	srand(unsigned int(time(NULL)));//用当前时间作为随机数种子
  10. 	node food = creatFood(snake,length);
  11. 	while (1)
  12. 	{
  13. 		cleardevice();
  14. 		paintGrid();
  15. 		paintSnake(snake, length);
  16. 		paintFood(&food);
  17. 		Sleep(500);
  18.  
  19. 		changDirection(&d);
  20. 		node last_tail = snakeMove(snake, length, d);
  21. 		if (snake[0].x == food.x && snake[0].y == food.y)
  22. 		{
  23. 			if (length < 100)
  24. 			{
  25. 				snake[length] = last_tail;
  26. 				length++;
  27. 			}
  28. 			food = creatFood(snake, length);
  29. 		}
  30. 		if (isGameover(snake, length) == true)
  31. 		{
  32. 			reset(snake, &length, &d);
  33. 			food = creatFood(snake, length);
  34. 		}
  35. 	}
  36.  
  37. 	getchar();
  38. 	closegraph();
  39. 	return 0;
  40. }

 四 完整代码

完整代码如下： 

  1. #include <easyx.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <time.h>
  5. #define NODE_WIDTH 40
  6. // 节点
  7. typedef struct {
  8. int x;
  9. int y;
  10. }node;
  11. enum direction
  12. {
  13. 	eUp,
  14. 	eDown,
  15. 	eLeft,
  16. 	eRight
  17. };
  18. void paintGrid()
  19. {
  20. 	setlinecolor(WHITE);
  21. 	for (int x = 0; x < 800; x += NOOD_WIDTH)
  22. 	{
  23. 		line(x, 0, x, 600);//画竖直线段
  24. 	}
  25. 	for (int y = 0; y < 600; y += NOOD_WIDTH)
  26. 	{
  27. 		line(0, y, 800, y);//画竖直线段
  28. 	}
  29. }
  30.  
  31. void paintSnake(node* snake, int n)
  32. {
  33. 	int left, top, right, bottom;
  34. 	for (int i = 0; i < n; i++)
  35. 	{
  36. 		left = snake[i].x * NOOD_WIDTH;//*(snake + i).x
  37. 		top = snake[i].y * NOOD_WIDTH;
  38. 		right = (snake[i].x + 1) * NOOD_WIDTH;
  39. 		bottom = (snake[i].y + 1) * NOOD_WIDTH;
  40. 		setlinecolor(BLACK);
  41. 		fillrectangle(left, top, right, bottom);
  42. 	}
  43. }
  44.  
  45. node snakeMove(node* snake, int length, int direction)
  46. {
  47. 	node tail = snake[length - 1];
  48. 	//用一个循环将数组中的元素从后往前依次进行覆盖
  49. 	for (int i = length - 1; i > 0; i--)
  50. 	{
  51. 		snake[i] = snake[i - 1];//将前一个节点覆盖后一个节点
  52. 	}
  53. 	node newhead = snake[0];
  54. 	if (direction == eUp)
  55. 	{
  56. 		newhead.y--;//在原蛇头的基础上进行修改
  57. 	}
  58. 	if (direction == eDown)
  59. 	{
  60. 		newhead.y++;
  61. 	}
  62. 	if (direction == eLeft)
  63. 	{
  64. 		newhead.x--;
  65. 	}
  66. 	if (direction == eRight)
  67. 	{
  68. 		newhead.x++;
  69. 	}
  70. 	snake[0] = newhead;//最后在把修改后的蛇头数据赋值给原数组的首元素
  71. 	return tail;
  72. }
  73.  
  74. void changDirection(enum direction* p)
  75. {
  76. 	if (_kbhit() != 0)
  77. 	{
  78. 		char c = _getch();
  79. 		switch (c)
  80. 		{
  81. 		case 'a':
  82. 			if(*p != eRight)
  83. 			    *p = eLeft;
  84. 			break;
  85. 		case 'd':
  86. 			if (*p != eLeft)
  87. 			    *p = eRight;
  88. 			break;
  89. 		case 'w':
  90. 			if (*p != eDown)
  91. 			    *p = eUp;
  92. 			break;
  93. 		case's':
  94. 			if (*p != eUp)
  95. 			    *p = eDown;
  96. 			break;
  97. 		}
  98. 	}
  99. }
  100.  
  101. node creatFood(node* snake, int length)
  102. {
  103. 	//先在画布圈定的范围之内随机生成一个食物点
  104. 	node food;
  105. 	//然后用一个死循环来对食物点进行检验（不能与蛇的身体进行重合）
  106. 	while (1)
  107. 	{
  108. 		food.x = rand() % (800 / NOOD_WIDTH);
  109. 		food.y = rand() % (600 / NOOD_WIDTH);
  110. 		int i = 0;
  111. 		for (i = 0; i < length; i++)
  112. 		{
  113. 			if (food.x == snake[i].x && food.y == snake[i].y)
  114. 				break;
  115. 		}
  116. 		if (i < length)
  117. 			continue;
  118. 		else
  119. 			break;
  120. 	}
  121. 	return food;
  122. }
  123.  
  124. void paintFood(node* food)
  125. {
  126. 	int left, top, right, bottom;
  127. 		left = food->x * NOOD_WIDTH;//*(snake + i).x
  128. 		top = food->y* NOOD_WIDTH;
  129. 		right = (food->x + 1) * NOOD_WIDTH;
  130. 		bottom = (food->y + 1) * NOOD_WIDTH;
  131. 		setfillcolor(YELLOW);
  132. 		solidrectangle(left, top, right, bottom);
  133. 		setfillcolor(WHITE);
  134. }
  135.  
  136. bool isGameover(node* snake, int length)
  137. {
  138. 	if (snake[0].x < 0 || snake[0].x>800 / NOOD_WIDTH)
  139. 	{
  140. 		return true;
  141. 	}
  142. 	if (snake[0].y < 0 || snake[0].y>600 / NOOD_WIDTH)
  143. 	{
  144. 		return true;
  145. 	}
  146. 	for (int i = 1; i < length; i++)
  147. 	{
  148. 		if (snake[0].x == snake[i].x && snake[0].y == snake[i].y)
  149. 			return true;
  150. 	}
  151. 	return false;
  152. }
  153.  
  154. void reset(node* snake, int* plength, enum direction* pd)
  155. {
  156. 	for (int i = 0; i < 5; i++)
  157. 	{
  158. 		for (int j = 5; j > 0; j--)
  159. 		{
  160. 			snake[i].x = j;
  161. 		}
  162. 		snake[i].y = 7;
  163. 	}
  164. 	*plength = 5;
  165. 	*pd = eRight;
  166. }
  167. int main()
  168. {
  169. 	initgraph(800, 600);
  170. 	setbkcolor(RGB(164, 225, 202));
  171. 	cleardevice();
  172. 	node snake[100] = { {5,7},{4,7},{3,7},{2,7},{1,7} };
  173. 	int length = 5;
  174. 	enum direction d = eRight;
  175. 	srand(unsigned int(time(NULL)));//用当前时间作为随机数种子
  176. 	node food = creatFood(snake,length);
  177. 	while (1)
  178. 	{
  179. 		cleardevice();
  180. 		paintGrid();
  181. 		paintSnake(snake, length);
  182. 		paintFood(&food);
  183. 		Sleep(500);
  184.  
  185. 		changDirection(&d);
  186. 		node last_tail = snakeMove(snake, length, d);
  187. 		if (snake[0].x == food.x && snake[0].y == food.y)
  188. 		{
  189. 			if (length < 100)
  190. 			{
  191. 				snake[length] = last_tail;
  192. 				length++;
  193. 			}
  194. 			food = creatFood(snake, length);
  195. 		}
  196. 		if (isGameover(snake, length) == true)
  197. 		{
  198. 			reset(snake, &length, &d);
  199. 			food = creatFood(snake, length);
  200. 		}
  201. 	}
  202.  
  203. 	getchar();
  204. 	closegraph();
  205. 	return 0;
  206. }

 

 

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

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

  

闽ICP备14008679号