（C语言）球球大作战

  前言：

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球

体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。

生成足够数量的食物小球。

生成ai小球，并控制其移动。

检测小球之间的吞噬关系，增加相应的体积。

通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1. 小球的要素

在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

1. struct Ball
2. {
3. int x;
4. int y;
5. float r;
6. DWORD color;
7. };

2. 初始化小球的信息

将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

• 橙色可以通过RGB值（255, 128, 0）来表示。
• 黄色的RGB值为（255, 255, 0）。
• 绿色的RGB值是（0, 255, 0）。
• 蓝色的RGB值为（0, 0, 255）。
• 紫色可以通过RGB值（170, 0, 255）来表示。
• 黑色的RGB值为（0, 0, 0）。
• 白色的RGB值为（255, 255, 255）。
• 灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
2. {
3. //玩家小球
4. srand((unsigned)time(NULL));
5. player.x = Wide / 2;
6. player.y = Hight / 2;
7. player.r = 10;
8. //食物小球
9. for (int i = 0; i < Food_num; i++)
10. {
11. Food[i].x = rand() % Wide_map;
12. Food[i].y = rand() % Hight_map;
13. Food[i].r = rand() % 5 + 1;
14. Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
15. }
16. //ai小球
17. for (int i = 0; i < Enemy_num; i++)
18. {
19. Enemy[i].x = rand() % Wide_map;
20. Enemy[i].y = rand() % Hight_map;
21. Enemy[i].r = 10;
22. Enemy[i].color = RGB(0,255,0);
23. }
25. }

3. 玩家操作小球

在这里需要用到GetAsyncKeyState(vk virtual key)函数获取异步按键状态,其中vk virtual key是虚拟键值，如果接受到这个虚拟键值，它会返回真。VK_UP、VK_DOWN、VK_LEFT、VK_RIGHT、0x20分别是上箭头键、下箭头键、左箭头键、右箭头键、空格键的虚拟键值。

1. void Player_move()
2. {
3. if (GetAsyncKeyState(VK_UP))
4. {
5. if (player.y > 0)
6. {
7. player.y -= player_sleep;
8. }
9. }
10. if (GetAsyncKeyState(VK_DOWN))
11. {
12. if (player.y < Hight_map)
13. player.y += player_sleep;
14. }
15. if (GetAsyncKeyState(VK_LEFT))
16. {
17. if (player.x > 0)
18. player.x -= player_sleep;
19. }
20. if (GetAsyncKeyState(VK_RIGHT))
21. {
22. if (player.x < Wide_map)
23. player.x += player_sleep;
24. }
25. if (GetAsyncKeyState(0x20))
26. {
27. player_sleep = l + 5;
28. }
29. else
30. {
31. player_sleep = l;
32. }
33. }

4. 显示出小球

在此游戏中，小球是一个实心圆，在easyx图形库中提供了一个画实心圆的函数—solidcircle函数，通过它我们就可以在窗口中显示小球了，但显示出的小球默认颜色为白色，为了区分不同的小球，我们还需使用setfillcolor函数来改变小球的颜色。因为显示的函数、玩家操作小球的函数等函数都是放在同一个while循环重复执行的，这样就会重复显示小球，所以我们还需要用到一个清屏函数cleardevice。为了使窗口更好看可以使用setbkcolor函数修改窗口的背景颜色，以及使用line函数在窗口中画一些线，函数setlinecolor可以改变线的颜色。

1. void Show()
2. {
4. //设置地图
5. SetWorkingImage(&map);
6. //清屏
7. cleardevice();
8. //背景颜色
9. setbkcolor(WHITE);
10. //划线颜色
11. setlinecolor(RGB(230,231,239));
12. //划线
13. for (int i = 0; i < Wide_map; i += 10)
14. {
15. line(i, 0, i, Hight_map);
16. }
17. for (int i = 0; i < Hight_map; i += 10)
18. {
19. line(0, i, Wide_map, i);
20. }
21. //食物
22. for (int i = 0; i < Food_num; i++)
23. {
24. setfillcolor(Food[i].color);
25. solidcircle(Food[i].x, Food[i].y, Food[i].r);
26. }
27. //敌人
28. for (int i = 0; i < Enemy_num; i++)
29. {
30. setfillcolor(Enemy[i].color);
31. solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
32. }
33. //玩家
34. setfillcolor(RED);
35. solidcircle(player.x, player.y, player.r);
36. SetWorkingImage();
38. int x = player.x - (Wide / 2);
39. int y = player.y - (Hight / 2);
40. //防止窗口越界
41. if (x < 0)
42. {
43. x = 0;
44. }
45. if (y < 0)
46. {
47. y = 0;
48. }
49. if (x > Wide_map - Wide)
50. {
51. x = Wide_map - Wide;
52. }
53. if (y > Hight_map - Hight)
54. {
55. y = Hight_map - Hight;
56. }
57. //把map输出到窗口上
58. putimage(0, 0, Wide, Hight, &map, x, y);
59. }

5. 生成地图

可以使用IMAGE map(Wide_map, Hight_map) 创建一个图像映射，其中 Wide_map 代表图像的宽度，而 Hight_map 代表图像的高度。然后使用SetWorkingImage(&map)，将map的地址作为参数传递给SetWorkingImage函数。这个函数的作用是将map作为当前操作的对象，以便在后续的图像处理过程中使用。最后使用putimage(0, 0, Wide, Hight, &map, x, y) 将地址绘制到窗口上，其中要让玩家小球始终出现在窗口的中央位置，那么其中的x=player.x - (Wide / 2);y=player.y - (Hight / 2);但是单单这样写就会出现窗口越界的情况，所以我们还需要限制x和y的范围：

1. //防止窗口越界
2. if (x < 0)
3. {
4. x = 0;
5. }
6. if (y < 0)
7. {
8. y = 0;
9. }
10. if (x > Wide_map - Wide)
11. {
12. x = Wide_map - Wide;
13. }
14. if (y > Hight_map - Hight)
15. {
16. y = Hight_map - Hight;
17. }

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：

1. (0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

2. Wide：这个参数指定了要绘制的图像的宽度。

3. Hight：这个参数指定了要绘制的图像的高度。

4. &map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

5. x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

6. y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。

6. ai小球的移动

随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是。

1. //距离
2. int Distance(int x, int y, int x1, int y1)
3. {
4. return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
5. }

然后判断两小球的距离是否小于50个像素点，即判断是否小于玩家小球的半径 + ai小球的半径 + 50。判断完后比较两小球的半径大小，如果ai小球的半径大于玩家小球的半径，那么ai小球就要追击玩家小球，即ai小球的坐标需要靠近玩家小球的坐标，就是如果ai小球的x大于玩家小球的x那么ai小球的x就减小，同理可得剩下的操作。

1. void Enemy_move()
2. {
3. srand((unsigned)time(NULL));
4. for (int i = 0; i < Enemy_num; i++)
5. {
6. int direction = rand() % 4;
8. if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
9. {
10. if (direction == 0)
11. {
12. if (Enemy[i].y > 0)//防止小球越界的判断语句
13. {
14. Enemy[i].y -= enemy_sleep;
15. }
16. }
17. if (direction == 1)
18. {
19. if (Enemy[i].y < Hight_map)
20. Enemy[i].y += enemy_sleep;
21. }
22. if (direction == 2)
23. {
24. if (Enemy[i].x > 0)
25. Enemy[i].x -= enemy_sleep;
26. }
27. if (direction == 3)
28. {
29. if (Enemy[i].x < Wide_map)
30. Enemy[i].x += enemy_sleep;
31. }
32. }
33. //敌人追击玩家
34. if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
35. {
36. if (Enemy[i].r > player.r)
37. {
38. if (Enemy[i].x < player.x)
39. {
40. if (Enemy[i].x < Wide_map)
41. {
42. Enemy[i].x += enemy_sleep;
43. }
44. }
45. if (Enemy[i].x > player.x)
46. {
47. if (Enemy[i].x > 0)
48. {
49. Enemy[i].x -= enemy_sleep;
50. }
51. }
52. if (Enemy[i].y < player.y)
53. {
54. if (Enemy[i].y < Hight_map)
55. {
56. Enemy[i].y += enemy_sleep;
57. }
58. }
59. if (Enemy[i].y > player.y)
60. {
61. if (Enemy[i].y > 0)
62. {
63. Enemy[i].y -= enemy_sleep;
64. }
65. }
66. }
67. //敌人逃跑
68. else
69. {
70. if (Enemy[i].x < player.x)
71. {
72. if (Enemy[i].x > 0)
73. {
74. Enemy[i].x -= enemy_sleep;
75. }
76. }
77. if (Enemy[i].x > player.x)
78. {
79. if (Enemy[i].x < Wide_map)
80. {
81. Enemy[i].x += enemy_sleep;
82. }
83. }
84. if (Enemy[i].y < player.y)
85. {
86. if (Enemy[i].y > 0)
87. {
88. Enemy[i].y -= enemy_sleep;
89. }
90. }
91. if (Enemy[i].y > player.y)
92. {
93. if (Enemy[i].y < Hight_map)
94. {
95. Enemy[i].y += enemy_sleep;
96. }
97. }
98. }
99. }
100. }
101. }

7. 小球之间的吞噬关系

玩家小球与ai小球、ai小球与ai小球：

当两小球的圆心小于最大的那个圆的半径时，小的那个球就会被吃掉。吃点就是那个小球重新找个位置生成。吃完后，吃的那个小球半径增加被吃小球半径的十分之一。

ai小球与食物小球、玩家小球与食物小球：同上。

1. void EatFood()
2. {
3. for (int i = 0; i < Food_num; i++)
4. {
5. //玩家吃食物
6. if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
7. {
8. player.r += Food[i].r / 100;
9. Food[i].x = rand() % Wide_map;
10. Food[i].y = rand() % Hight_map;
11. Food[i].r = rand() % 5 + 1;
12. Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
13. }
15. }
16. for (int j = 0; j < Enemy_num; j++)
17. {
18. //敌人吃食物
19. for (int i = 0; i < Food_num; i++)
20. {
21. if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
22. {
23. Enemy[j].r += Food[i].r / 50;
24. Food[i].x = rand() % Wide_map;
25. Food[i].y = rand() % Hight_map;
26. Food[i].r = rand() % 5 + 1;
27. Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
28. }
29. }
30. //敌人吃敌人
31. for (int i = 0; i < Enemy_num; i++)
32. {
33. if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
34. {
35. Enemy[j].r += Enemy[i].r / 10;
36. Enemy[i].x = rand() % Wide_map;
37. Enemy[i].y = rand() % Hight_map;
38. Enemy[i].r = 10;
39. Enemy[i].color = RGB(0, 255, 0);
40. }
41. if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
42. {
43. Enemy[i].r += Enemy[j].r / 10;
44. Enemy[j].x = rand() % Wide_map;
45. Enemy[j].y = rand() % Hight_map;
46. Enemy[j].r = 10;
47. Enemy[j].color = RGB(0, 255, 0);
48. }
49. }
50. if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
51. {
52. //玩家吃敌人
53. if (player.r > Enemy[j].r)
54. {
55. player.r += Enemy[j].r / 10;
56. Enemy[j].x = rand() % Wide_map;
57. Enemy[j].y = rand() % Hight_map;
58. Enemy[j].r = 10;
59. Enemy[j].color = RGB(0, 255, 0);
60. }
61. //敌人吃玩家
62. else
63. {
64. if (invincibility == 0)
65. {
66. Enemy[j].r += player.r / 10;
67. player.x = Wide / 2;
68. player.y = Hight / 2;
69. player.r = 10;
70. invincibility = 10;
71. }
72. }
73. }
74. }
75. }

最终效果：

球球大作战

源码：

1. #include
2. #include
3. #include
4. #include
5. #define Wide 1024
6. #define Hight 640
7. #define Wide_map (Wide*5)
8. #define Hight_map (Hight*5)
9. #define Food_num 1888
10. #define Enemy_num 888
11. //整个游戏地图
12. IMAGE map(Wide_map, Hight_map);
13. //复活时的无敌时间
14. int invincibility = 10;
15. //玩家速度
16. int player_sleep = 5;
17. int l = 5;
18. int enemy_sleep = 5;
19. struct Ball
20. {
21. int x;
22. int y;
23. float r;
24. DWORD color;
25. };
26. struct Ball player;
27. struct Ball Food[Food_num];
28. struct Ball Enemy[Enemy_num];
29. //初始化球的数据
30. void Inset()
31. {
32. srand((unsigned)time(NULL));
33. player.x = Wide / 2;
34. player.y = Hight / 2;
35. player.r = 10;
36. for (int i = 0; i < Food_num; i++)
37. {
38. Food[i].x = rand() % Wide_map;
39. Food[i].y = rand() % Hight_map;
40. Food[i].r = rand() % 5 + 1;
41. Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
42. }
43. for (int i = 0; i < Enemy_num; i++)
44. {
45. Enemy[i].x = rand() % Wide_map;
46. Enemy[i].y = rand() % Hight_map;
47. Enemy[i].r = 10;
48. Enemy[i].color = RGB(0,255,0);
49. }
51. }
52. //玩家操作
53. void Player_move()
54. {
55. if (GetAsyncKeyState(VK_UP))
56. {
57. if (player.y > 0)
58. {
59. player.y -= player_sleep;
60. }
61. }
62. if (GetAsyncKeyState(VK_DOWN))
63. {
64. if (player.y < Hight_map)
65. player.y += player_sleep;
66. }
67. if (GetAsyncKeyState(VK_LEFT))
68. {
69. if (player.x > 0)
70. player.x -= player_sleep;
71. }
72. if (GetAsyncKeyState(VK_RIGHT))
73. {
74. if (player.x < Wide_map)
75. player.x += player_sleep;
76. }
77. if (GetAsyncKeyState(0x20))
78. {
79. player_sleep = l + 5;
80. }
81. else
82. {
83. player_sleep = l;
84. }
85. }
86. //距离
87. int Distance(int x, int y, int x1, int y1)
88. {
89. return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
90. }
91. //敌人移动
92. void Enemy_move()
93. {
94. srand((unsigned)time(NULL));
95. for (int i = 0; i < Enemy_num; i++)
96. {
97. int direction = rand() % 400;
99. if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
100. {
101. if (direction < 100)
102. {
103. if (Enemy[i].y > 0)
104. {
105. Enemy[i].y -= enemy_sleep;
106. }
107. }
108. if (direction < 200 && direction >= 100)
109. {
110. if (Enemy[i].y < Hight_map)
111. Enemy[i].y += enemy_sleep;
112. }
113. if (direction < 300 && direction >= 200)
114. {
115. if (Enemy[i].x > 0)
116. Enemy[i].x -= enemy_sleep;
117. }
118. if (direction <400 && direction >= 300)
119. {
120. if (Enemy[i].x < Wide_map)
121. Enemy[i].x += enemy_sleep;
122. }
123. }
124. //敌人追击玩家
125. if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
126. {
127. if (Enemy[i].r > player.r)
128. {
129. if (Enemy[i].x < player.x)
130. {
131. if (Enemy[i].x < Wide_map)
132. {
133. Enemy[i].x += enemy_sleep;
134. }
135. }
136. if (Enemy[i].x > player.x)
137. {
138. if (Enemy[i].x > 0)
139. {
140. Enemy[i].x -= enemy_sleep;
141. }
142. }
143. if (Enemy[i].y < player.y)
144. {
145. if (Enemy[i].y < Hight_map)
146. {
147. Enemy[i].y += enemy_sleep;
148. }
149. }
150. if (Enemy[i].y > player.y)
151. {
152. if (Enemy[i].y > 0)
153. {
154. Enemy[i].y -= enemy_sleep;
155. }
156. }
157. }
158. //敌人逃跑
159. else
160. {
161. if (Enemy[i].x < player.x)
162. {
163. if (Enemy[i].x > 0)
164. {
165. Enemy[i].x -= enemy_sleep;
166. }
167. }
168. if (Enemy[i].x > player.x)
169. {
170. if (Enemy[i].x < Wide_map)
171. {
172. Enemy[i].x += enemy_sleep;
173. }
174. }
175. if (Enemy[i].y < player.y)
176. {
177. if (Enemy[i].y > 0)
178. {
179. Enemy[i].y -= enemy_sleep;
180. }
181. }
182. if (Enemy[i].y > player.y)
183. {
184. if (Enemy[i].y < Hight_map)
185. {
186. Enemy[i].y += enemy_sleep;
187. }
188. }
189. }
190. }
191. //for (int j = 0; j < Enemy_num; j++)
192. //{
193. // if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r + Enemy[i].r + 30)
194. // {
195. // //敌人追敌人
196. // if (Enemy[i].r > Enemy[j].r)
197. // {
198. // int sleep = rand() % 6;
199. // int enemy_sleep1;
200. // if (sleep > 2)
201. // {
202. // enemy_sleep1 = enemy_sleep;
203. // }
204. // else
205. // {
206. // enemy_sleep1 = enemy_sleep + 5;
207. // }
208. // if (Enemy[i].x < Enemy[j].x)
209. // {
210. // if (Enemy[i].x < Wide_map)
211. // {
212. // Enemy[i].x += enemy_sleep1;
213. // }
214. // }
215. // if (Enemy[i].x > Enemy[j].x)
216. // {
217. // if (Enemy[i].x > 0)
218. // {
219. // Enemy[i].x -= enemy_sleep1;
220. // }
221. // }
222. // if (Enemy[i].y < Enemy[j].y)
223. // {
224. // if (Enemy[i].y < Hight_map)
225. // {
226. // Enemy[i].y += enemy_sleep1;
227. // }
228. // }
229. // if (Enemy[i].y > Enemy[j].y)
230. // {
231. // if (Enemy[i].y > 0)
232. // {
233. // Enemy[i].y -= enemy_sleep1;
234. // }
235. // }
236. // }
237. // //逃跑
238. // else
239. // {
240. // int sleep = rand() % 6;
241. // int enemy_sleep1;
242. // if (sleep > 2)
243. // {
244. // enemy_sleep1 = enemy_sleep;
245. // }
246. // else
247. // {
248. // enemy_sleep1 = enemy_sleep + 5;
249. // }
250. // if (Enemy[i].x < Enemy[j].x)
251. // {
252. // if (Enemy[i].x > 0)
253. // {
254. // Enemy[i].x -= enemy_sleep1;
255. // }
256. // }
257. // if (Enemy[i].x > Enemy[j].x)
258. // {
259. // if (Enemy[i].x < Wide_map)
260. // {
261. // Enemy[i].x += enemy_sleep1;
262. // }
263. // }
264. // if (Enemy[i].y < Enemy[j].y)
265. // {
266. // if (Enemy[i].y > 0)
267. // {
268. // Enemy[i].y -= enemy_sleep1;
269. // }
270. // }
271. // if (Enemy[i].y > Enemy[j].y)
272. // {
273. // if (Enemy[i].y < Hight_map)
274. // {
275. // Enemy[i].y += enemy_sleep1;
276. // }
277. // }
278. // }
279. // }
280. //}
281. }
282. }
284. //吃食物
285. void EatFood()
286. {
287. for (int i = 0; i < Food_num; i++)
288. {
289. //玩家吃食物
290. if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
291. {
292. player.r += Food[i].r / 100;
293. Food[i].x = rand() % Wide_map;
294. Food[i].y = rand() % Hight_map;
295. Food[i].r = rand() % 5 + 1;
296. Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
297. }
299. }
300. for (int j = 0; j < Enemy_num; j++)
301. {
302. //敌人吃食物
303. for (int i = 0; i < Food_num; i++)
304. {
305. if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
306. {
307. Enemy[j].r += Food[i].r / 50;
308. Food[i].x = rand() % Wide_map;
309. Food[i].y = rand() % Hight_map;
310. Food[i].r = rand() % 5 + 1;
311. Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
312. }
313. }
314. //敌人吃敌人
315. for (int i = 0; i < Enemy_num; i++)
316. {
317. if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
318. {
319. Enemy[j].r += Enemy[i].r / 10;
320. Enemy[i].x = rand() % Wide_map;
321. Enemy[i].y = rand() % Hight_map;
322. Enemy[i].r = 10;
323. Enemy[i].color = RGB(0, 255, 0);
324. }
325. if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
326. {
327. Enemy[i].r += Enemy[j].r / 10;
328. Enemy[j].x = rand() % Wide_map;
329. Enemy[j].y = rand() % Hight_map;
330. Enemy[j].r = 10;
331. Enemy[j].color = RGB(0, 255, 0);
332. }
333. }
334. if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
335. {
336. //玩家吃敌人
337. if (player.r > Enemy[j].r)
338. {
339. player.r += Enemy[j].r / 10;
340. Enemy[j].x = rand() % Wide_map;
341. Enemy[j].y = rand() % Hight_map;
342. Enemy[j].r = 10;
343. Enemy[j].color = RGB(0, 255, 0);
344. }
345. //敌人吃玩家
346. else
347. {
348. if (invincibility == 0)
349. {
350. Enemy[j].r += player.r / 10;
351. player.x = Wide / 2;
352. player.y = Hight / 2;
353. player.r = 10;
354. invincibility = 10;
355. }
356. }
357. }
358. }
359. }
360. //显示
361. void Show()
362. {
364. //设置地图
365. SetWorkingImage(&map);
366. //清屏
367. cleardevice();
368. //背景颜色
369. setbkcolor(WHITE);
370. //划线颜色
371. setlinecolor(RGB(230,231,239));
372. //划线
373. for (int i = 0; i < Wide_map; i += 10)
374. {
375. line(i, 0, i, Hight_map);
376. }
377. for (int i = 0; i < Hight_map; i += 10)
378. {
379. line(0, i, Wide_map, i);
380. }
381. //食物
382. for (int i = 0; i < Food_num; i++)
383. {
384. setfillcolor(Food[i].color);
385. solidcircle(Food[i].x, Food[i].y, Food[i].r);
386. }
387. //敌人
388. for (int i = 0; i < Enemy_num; i++)
389. {
390. setfillcolor(Enemy[i].color);
391. solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
392. }
393. //玩家
394. setfillcolor(RED);
395. solidcircle(player.x, player.y, player.r);
396. SetWorkingImage();
398. int x = player.x - (Wide / 2);
399. int y = player.y - (Hight / 2);
400. //防止窗口越界
401. if (x < 0)
402. {
403. x = 0;
404. }
405. if (y < 0)
406. {
407. y = 0;
408. }
409. if (x > Wide_map - Wide)
410. {
411. x = Wide_map - Wide;
412. }
413. if (y > Hight_map - Hight)
414. {
415. y = Hight_map - Hight;
416. }
417. //把map输出到窗口上
418. putimage(0, 0, Wide, Hight, &map, x, y);
419. }
420. int main()
421. {
423. initgraph(Wide, Hight);
424. Inset();
425. //缓冲
426. BeginBatchDraw();
427. while (1)
428. {
429. if (invincibility > 0)
430. invincibility--;
431. Show();
432. //玩家操作
433. Player_move();
434. Enemy_move();
435. EatFood();
436. //刷新
437. FlushBatchDraw();
438. }
439. closegraph();
440. return 0;
441. }