球球大作战

2744557306

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

5 b* z: F. i0 c3 ?/ n5 S在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
. K3 i* E8 ~0 k* r1 b
: u9 g/ ^' p; r( `: E1 q游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

; s# o  ?' ~6 d* T玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

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

3 c6 B6 u; t% N' r' B2 O体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

* o% T, _6 u; ?/ r玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

/ }4 i1 b. A. Xai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

接下来，我们将通过以下几个步骤来实现这个游戏：
4 b. @2 D7 p" ]
初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。
; N6 q( q& q2 H" _! M. I$ ~0 L, u
生成足够数量的食物小球。
/ L" y' q2 X& _( Q7 n) Q$ C' k
. y' l  ?' P. I6 o$ k生成ai小球，并控制其移动。

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

通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
& h& v+ y" M9 V: V& b
1. 小球的要素
  y- V& ?3 t+ c7 {1 v5 u, F9 H在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

struct Ball
{
        int x;
7 u( y& R& A. k( Y. b2 f        int y;
  @) j$ [6 d) L! X        float r;
' o4 @" ?. S! y        DWORD color;
};
4 D* i" \7 T% ^0 N: _2. 初始化小球的信息
+ c- n/ V% j( \/ a将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
7 |, ?, ?8 _/ O. P0 n
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

橙色可以通过RGB值（255, 128, 0）来表示。
6 d! M' w6 }- L) t5 N黄色的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()
   8 h! h) ]5 v' x; Y+ V
2. {
   0 t# I( \4 q5 F9 [3 _0 I% _
3.     //玩家小球& n- X$ @7 ]0 c  F% N  a1 `6 i
   
4.   srand((unsigned)time(NULL));
   8 Z% a& K0 A2 y1 b( ~
5.   player.x = Wide / 2;
   0 \\" V' l* R5 M2 O1 Z( }& p& R
6.   player.y = Hight / 2;7 X# N: A; f# J/ K
   
7.   player.r = 10;
   - d+ E( I+ m/ R! y
8.     //食物小球
   ) [, u3 I# ]; K) T/ v+ `* V
9.   for (int i = 0; i < Food_num; i++)
   # Y% ^9 [7 B# m, m4 Z8 q
10.   {
    9 n7 v' a) C5 K( @4 `
11.     Food[i].x = rand() % Wide_map;4 B5 w) H) f& p6 }9 v
    
12.     Food[i].y = rand() % Hight_map;1 w8 e! |# g\" H4 F# N
    
13.     Food[i].r = rand() % 5 + 1;
    \" g6 d) W0 \4 R: z/ H
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);1 N) i; ~( b% K6 B, ~3 m* ]
    
15.   }* o  m0 d/ F/ q5 g4 E2 v: s
    
16.     //ai小球: l. Y+ \' D# c) T# U# |- U  R
    
17.   for (int i = 0; i < Enemy_num; i++)& |2 [% \2 u( L7 `; {5 q2 z
    
18.   {% ^3 Q, s& ?3 a/ P) ?
    
19.     Enemy[i].x = rand() % Wide_map;
    $ U. R4 T% a5 q; Y1 F
20.     Enemy[i].y = rand() % Hight_map;
    4 c, c/ Z3 {* U+ Y\" l
21.     Enemy[i].r = 10;2 l1 \3 _7 s3 b& T/ Z8 A
    
22.     Enemy[i].color = RGB(0,255,0);  J. p: V8 m\" e( e7 [
    
23.   }4 c0 \9 Y  U  e- Q* a- W0 l
    
24. 
    1 q. u: @2 A5 f% g9 ?  i  M
25. }

复制代码

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

1. void Player_move()) E& m. n3 q3 A, a# O6 r/ R
   
2. {5 |6 P4 N9 i/ p9 e
   
3.   if (GetAsyncKeyState(VK_UP))+ }& d  f$ ~! j# e  {5 f  w
   
4.   {. f5 N# I! k9 ]
   
5.     if (player.y > 0)
   , `\" S1 {1 S9 g\" F! n/ u; R) A4 T
6.     {% z; g4 u3 l' E- l0 b0 V6 V' Z6 A
   
7.       player.y -= player_sleep;
   0 [7 b4 D0 A* L6 N5 N+ n' |/ e. B
8.     }
   ' t, F& A! z( j. b& \! A
9.   }% L7 R. f, T4 ^7 W, B
   
10.   if (GetAsyncKeyState(VK_DOWN)): o/ J  u1 t2 N) h0 ]0 l2 g
    
11.   {
    2 H# T. B% b& q( {
12.     if (player.y < Hight_map)
    % ]  \' z7 I7 y% B4 D
13.     player.y += player_sleep;
    3 v& M: @/ I, v) S6 U$ [) }
14.   }5 |# p* I) [& ~: s6 Q( Y7 Y
    
15.   if (GetAsyncKeyState(VK_LEFT))/ \; R: z  Z2 M/ [
    
16.   {/ l+ A  c7 r7 ?5 u' Q; m
    
17.     if (player.x > 0)
    / U; d\" |4 l: X5 R( e
18.     player.x -= player_sleep;2 _) M' d! ?  F' ^8 a
    
19.   }
    ) w\" m8 H4 e7 g; ^) P( W  O7 a  n6 a
20.   if (GetAsyncKeyState(VK_RIGHT))4 x1 C. t\" g3 H9 \: x- T
    
21.   {5 z8 |8 x/ u/ J7 p
    
22.     if (player.x < Wide_map)5 |& |8 ]9 D2 Z8 R/ R
    
23.     player.x += player_sleep;. v' e) u' U0 G/ Y5 S- a\" u- T
    
24.   }+ F- o* Q\" a* O4 [5 ^% h' z
    
25.   if (GetAsyncKeyState(0x20))/ Y; C! N# i& D
    
26.   {
    2 W, K& f3 E4 W\" ?# g% Z5 J
27.     player_sleep = l + 5;5 E! Z  N) N- w6 q0 p( R6 g- P
    
28.   }
    ; A) J$ i4 A/ Z8 c* u
29.   else
    4 E9 S; z  y0 H4 K3 t: E/ j& i% w
30.   {7 s, ]# `6 z% P: [% l
    
31.     player_sleep = l;
    % O* ?0 v% h8 F% b
32.   }
    4 z1 l* V, _* t8 T. `
33. }

复制代码

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

1. void Show()
   6 J8 y! e) _5 w- \& _\" R
2. {\" Z* z$ p' o\" \3 y0 W9 b8 Z9 A6 a
   
3.   - k\" n) s9 L; _9 a
   
4.   //设置地图
     n- |9 w- s: r. [# A7 H! W
5.   SetWorkingImage(&map);
   ( ~  E\" I; Y* R3 i\" P& J5 H
6.   //清屏
   ! j; }- Z3 N) q1 [+ _& A
7.   cleardevice();  B# a' H  q$ f8 s3 u# n
   
8.   //背景颜色6 N& S# F% W: O3 F7 i
   
9.   setbkcolor(WHITE);8 c) V, Y) u3 i0 G# g* Y/ A
   
10.   //划线颜色( J* r\" f  Q& C4 g. F) U2 k
    
11.   setlinecolor(RGB(230,231,239));
    3 Z! l' a7 o2 ~$ F6 B
12.   //划线0 B8 k\" ^4 G% G3 X5 u
    
13.   for (int i = 0; i < Wide_map; i += 10)
    1 V2 L# t- D- C
14.   {3 h) ]& i+ B. j# j3 I
    
15.     line(i, 0, i, Hight_map);
    $ A\" W# L, R$ O' B% `
16.   }5 e; {* O' I/ O. c( M0 S
    
17.   for (int i = 0; i < Hight_map; i += 10)
    6 O+ u. G8 H4 u
18.   {9 H: e0 m, E4 _: d# U
    
19.     line(0, i, Wide_map, i);
    ' D7 f7 p8 }* h4 }$ c6 D
20.   }
    , }2 ]# N\" b1 s/ @
21.   //食物
    6 n/ W8 R' ]9 H
22.   for (int i = 0; i < Food_num; i++)( @) r\" I1 a! ^; |7 O
    
23.   {3 j8 B0 H\" P& V0 P$ |  ?
    
24.     setfillcolor(Food[i].color);
    ) }, @/ A4 u( U/ _
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    + @1 u1 c4 H7 K. Y
26.   }- [: X+ e% {+ u. _8 ]. M
    
27.   //敌人: R! q' o# B, ]! V, d, Z1 O5 r9 G
    
28.   for (int i = 0; i < Enemy_num; i++)
    4 d6 [, S7 E/ T; m& j1 p$ N) B
29.   {
    - U# M3 v6 p$ {\" F
30.     setfillcolor(Enemy[i].color);
    ) f0 b6 O: n; _% N, I
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);\" e9 i8 P' G# M+ H. }
    
32.   }
    / K: J. `5 [7 P4 S
33.   //玩家- `+ ~0 U0 H- d0 u0 s5 Q: l, I, _4 c
    
34.   setfillcolor(RED);/ s\" j9 S5 b  ^9 p6 y# ~% f
    
35.   solidcircle(player.x, player.y, player.r);! q\" b\" {2 C* S$ g6 Y+ V0 g( {7 K/ W; `
    
36.   SetWorkingImage();
    # \: H2 p2 h: |# Y9 v
37. 
    5 T9 K\" F- a. [& C* H& I
38.   int x = player.x - (Wide / 2);7 q9 B% R/ ]. U3 d% P9 i
    
39.   int y = player.y - (Hight / 2);
      {5 h0 W9 q; u: U: b& h
40.   //防止窗口越界
    - V6 F; N! F% v3 @# o6 O
41.   if (x < 0)2 x. c5 O) Q( b, K% z5 n
    
42.   {7 ~9 ~6 w/ ?' B+ O
    
43.     x = 0;0 i1 t$ a# z( c\" F/ [
    
44.   }
    ) z* e. N3 t( o+ \
45.   if (y < 0)
    5 O3 N9 K\" |9 v3 ]2 J
46.   {
    & U7 h8 ~* A4 Z. b. V, q
47.     y = 0;; ]2 m) U3 a* r% y
    
48.   }2 l( \# H0 H, R; {( ^! D7 y
    
49.   if (x > Wide_map - Wide)6 B- j  f+ S1 p
    
50.   {
    ) _9 p9 L3 S, g8 t
51.     x = Wide_map - Wide;
    0 V4 `7 M6 C) T4 F. J
52.   }
    1 Y& O+ f* m; O
53.   if (y > Hight_map - Hight)  S! F) i* j+ B$ Q) W9 G2 B, ]
    
54.   {0 u1 z3 q' n. A1 F& v- M6 C
    
55.     y = Hight_map - Hight;9 Q: P7 w( G& M4 Q9 [\" _
    
56.   }- o* M0 y$ u* s  G0 ?
    
57.   //把map输出到窗口上  B1 V/ |  F/ P) K4 f) O
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);1 m% |\" j9 \\" H9 Z
    
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. //防止窗口越界
   . n9 |- L( j1 @% C: _1 L0 ]
2. if (x < 0)# ^- {1 X$ R) V( P/ T
   
3. {& s4 h\" u! L& D6 g5 @
   
4.   x = 0;' t& c2 Z/ v5 m; `% C
   
5. }
   9 [. p4 x# y9 I# Q7 g- z5 b
6. if (y < 0)6 |3 H2 ~5 _. Y1 u
   
7. {; |3 b& T2 E' g& v7 Q\" |
   
8.   y = 0;7 S8 n& Q6 O9 x
   
9. }
   : \% Z$ |) W! G$ y  a: e+ o* ]
10. if (x > Wide_map - Wide)
    4 n9 B; }# p  Z7 f
11. {3 c& h; O* Y) K
    
12.   x = Wide_map - Wide;
    ; T! s' M& f: T; N2 F7 S+ S
13. }
    8 M+ ]6 b, W0 p% L/ N5 R
14. if (y > Hight_map - Hight)
    3 ?. Q' g  ^! n
15. {( ^/ E\" @* `0 s$ @
    
16.   y = Hight_map - Hight;/ j8 ]3 f- Q! p# y
    
17. }

复制代码

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

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

5 n0 ^( B/ t% h. |2 Q2 g: bWide：这个参数指定了要绘制的图像的宽度。

Hight：这个参数指定了要绘制的图像的高度。
' h' m. s7 O6 T% G) n2 Y. d
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
6 x( X  ~' F/ m6 o- X
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
  P* N% U' e* o( U4 k
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
/ ~" u0 k* R$ }% L$ `+ r" j6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离: r2 e) U' ^8 c  v! D
   
2. int Distance(int x, int y, int x1, int y1)
   4 Y6 G- F9 W) k1 K; Z- _% R
3. {  ~; s0 Y+ R# f( b) O
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   ! C$ D2 ]. t) _4 j6 J( _
5. }

复制代码

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

1. void Enemy_move()  l; ]2 `/ u: R5 u& n) \
   
2. {9 y/ n' z0 l3 J0 \9 A
   
3.   srand((unsigned)time(NULL));1 x7 n& B. u% {! H0 j8 T  o
   
4.   for (int i = 0; i < Enemy_num; i++)
   * U* u. J\" E9 {, |
5.   {
   . l\" n9 w! S7 W4 D
6.     int direction = rand() % 4;\" }\" `, W, G' G. q5 S* i
   
7. # w% R8 h& ^7 l2 [
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   : L' P. l* g( t. K7 W/ e6 J
9.     {
   6 n! U' T& v( ?, E) R- m
10.       if (direction == 0)
    - k' c$ C2 s6 V* I2 W5 I( B3 J
11.       {$ o4 I1 n7 H  N4 }6 Q  U
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句4 q# k- c; O8 [( H, Q, ^4 t. U6 I! r
    
13.         {
    % \8 p& l; X8 A% ?% }  b7 S/ i
14.           Enemy[i].y -= enemy_sleep;
    0 o6 K$ l7 R0 i' P% F
15.         }9 i0 L6 x9 Y5 n' y
    
16.       }
    ) I( {  [1 N\" T6 w$ Y: P6 J+ P8 \
17.       if (direction == 1)$ `/ U- t! q( ]2 H( }6 n; \% `
    
18.       {
    ' M; F% k  a\" j
19.         if (Enemy[i].y < Hight_map)* U. A+ f1 x7 O5 |2 D  r$ n- w8 T
    
20.           Enemy[i].y += enemy_sleep;# |1 b1 Z  F& P
    
21.       }
    & z/ `+ {- E( Q1 H
22.       if (direction == 2)
    - v% h1 s0 V; w\" w  Y8 L
23.       {
    - n& ^0 q2 t8 J( R
24.         if (Enemy[i].x > 0)4 K) ^  i* j; a  _* G
    
25.           Enemy[i].x -= enemy_sleep;
    . G% b1 H: K, K# d% t
26.       }\" _9 r( r# V0 U% h  _! m
    
27.       if (direction == 3)
    1 ^( ~& m  Q2 k- p/ g
28.       {
    , m2 n5 o8 w) ?2 o1 ]
29.         if (Enemy[i].x < Wide_map)
    - f- a: J3 G$ p/ s2 c* ~
30.           Enemy[i].x += enemy_sleep;
    * \3 u1 j\" o( d# @1 G2 n- d
31.       }7 X4 K) q+ c. k5 _\" g, b+ |
    
32.     }  m: x6 C) o3 P( Q8 @
    
33.     //敌人追击玩家0 ?& \9 e( d1 a9 g% C+ U$ d
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    # D# a, O2 t( n\" n/ a
35.     {
    6 a! G' k+ ?. @2 H2 X' {# k+ Q( F
36.       if (Enemy[i].r > player.r)
    , V# b9 z# X& O0 _. X7 z) o. b
37.       {
    * s0 u6 O. k( B% B
38.         if (Enemy[i].x < player.x). a  M  F' V  }8 p6 O. b1 P
    
39.         {- C0 F$ f& e* u, d3 }& F1 U
    
40.           if (Enemy[i].x < Wide_map)
    1 J, A2 V/ X+ W! m* H. c
41.           {, }  \  s5 Q+ c
    
42.             Enemy[i].x += enemy_sleep;2 |2 S$ w6 ~  w( G\" l
    
43.           }: D; H/ F, g( b
    
44.         }8 a- G: g: _) U. k8 a7 ~, Q3 D/ q
    
45.         if (Enemy[i].x > player.x). S! G- {6 `$ w, a, F
    
46.         {
    + U. a/ v: [% Y% B8 t& u
47.           if (Enemy[i].x > 0). c\" R- ?9 [3 E8 B0 _. r# o
    
48.           {\" j' w4 G( n& q* C7 z
    
49.             Enemy[i].x -= enemy_sleep;2 \* M- r( I' s$ L
    
50.           }2 p6 g' L* L% \* K: ]\" L/ p
    
51.         }
    % b: K7 Q: R, l- m3 Q( z9 g
52.         if (Enemy[i].y < player.y)8 p7 P# F0 \* I1 S, o7 }
    
53.         {
    \" a* Z% `9 U7 v1 d7 W/ S7 l
54.           if (Enemy[i].y < Hight_map)
    3 p7 D$ [' J$ s2 y! _
55.           {: e\" I$ k: ?6 @
    
56.             Enemy[i].y += enemy_sleep;\" `\" X3 T( ~0 k+ a: T
    
57.           }7 w\" ~; Q; a1 L: U
    
58.         }' j\" s( h7 }1 {7 }
    
59.         if (Enemy[i].y > player.y)* {7 s2 p( X% R# _
    
60.         {
    ) U2 W( M: I3 e\" s$ c0 n: C! O) t# u
61.           if (Enemy[i].y > 0)+ G# F* E! ~5 I, b
    
62.           {
    0 D7 X) y3 I6 ^) }0 J% E, u
63.             Enemy[i].y -= enemy_sleep;6 k+ S: Q& I5 E3 u9 g7 Z
    
64.           }
    0 A8 E7 O7 ?/ p/ b3 [
65.         }( |3 ~9 U3 d8 I0 }\" C
    
66.       }
    9 Q* M% ~. }/ t. V9 T* o
67.       //敌人逃跑
    + F! f' Z8 Z0 ?5 U
68.       else
    \" ^7 l8 M+ K, w5 c2 n8 [/ w
69.       {
    ' i$ `7 X. j7 H( X$ I1 X
70.         if (Enemy[i].x < player.x)4 f\" S* F+ V* x$ ^
    
71.         {
    5 P8 f  ~9 C7 w; Y% Q. h
72.           if (Enemy[i].x > 0)& V) o2 I. Z+ m2 F2 E
    
73.           {% N; @) c; w+ i3 R3 Q: i0 ~
    
74.             Enemy[i].x -= enemy_sleep;2 a\" E* L- R* t+ E& C% |/ ?
    
75.           }+ u& r: E$ I& ?5 }3 c\" b
    
76.         }: |/ m  W; a1 M9 m' j5 [/ l4 F
    
77.         if (Enemy[i].x > player.x)% L( t6 E' e1 X8 r# _
    
78.         {- B% e0 I# \! m, q( e
    
79.           if (Enemy[i].x < Wide_map)1 _$ t2 u) c; p6 @
    
80.           {: C4 L* Q! R- @# M- t+ p: \) N
    
81.             Enemy[i].x += enemy_sleep;\" P5 m, G3 y- z4 k5 ^- m
    
82.           }
    2 y+ j2 B7 ?$ C/ ?
83.         }0 {. @- T  m$ q2 `  Q5 ~9 i
    
84.         if (Enemy[i].y < player.y)- N! g4 V- p+ [. P; b  c
    
85.         {
    * a# a; r6 b0 ^3 h0 I8 }4 \* W9 O
86.           if (Enemy[i].y > 0)\" d- @& M! o# J
    
87.           {
    ! Y. D1 P2 |* b: `2 m' a3 j0 R
88.             Enemy[i].y -= enemy_sleep;( e, ^( i% d  h9 K; A7 _
    
89.           }
    4 n\" Q/ }9 [/ q3 C! x1 E
90.         }
    5 ]5 v' i* e1 M4 `. w
91.         if (Enemy[i].y > player.y)
    6 f  I/ s; t! Q
92.         {' O, F2 o# I- N2 P\" U! Y\" }, i! p
    
93.           if (Enemy[i].y < Hight_map)) |) H  \% _  u8 `: J
    
94.           {
    \" h\" C# u: \$ t8 U* S  R
95.             Enemy[i].y += enemy_sleep;
      T  y8 _, v  V. `7 c
96.           }
    ! V. i# C4 I& T/ ?. D: E
97.         }; W+ M1 Y9 ^- @
    
98.       }
    8 _, L+ g/ i. o) n3 K6 i5 h$ E
99.     }# C0 W, f* X( f% I
    
100.   }  g( l9 J\" ]- M7 Z
     
101. }

复制代码

7. 小球之间的吞噬关系
, F3 S3 x9 c9 o$ R1 z+ v+ W

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

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

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

1. void EatFood()- G7 C, o+ P1 {, s
   
2. {
   2 z4 O- `& C  m; j: @6 i5 }( x
3.   for (int i = 0; i < Food_num; i++)
   * ^: h5 O0 N8 E( Y- [% H
4.   {# A3 {  o$ Q3 f! J9 i
   
5.     //玩家吃食物
   + @7 S. X$ e9 h. r
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   1 N, A- I1 w: [4 z- Q6 M: _/ O# X
7.     {
   , N3 w8 L5 N  b
8.       player.r += Food[i].r / 100;$ l9 r  u/ S7 [+ J5 O
   
9.       Food[i].x = rand() % Wide_map;' }- P2 X/ L1 J% i\" n+ a' z  A5 i
   
10.       Food[i].y = rand() % Hight_map;% Z6 W1 D4 [0 |4 g' r$ {+ i
    
11.       Food[i].r = rand() % 5 + 1;\" m- L$ s$ u& X7 {6 G. y
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    3 \. E) ?7 H0 N0 j# u
13.     }
    ' o9 T. g- T: r' i7 ~( l
14.    
    \" {# h\" s8 Y8 [& c
15.   }& q+ i4 T6 D+ c! I' @: I# k
    
16.   for (int j = 0; j < Enemy_num; j++)
    ' O( p/ _* H3 q+ {0 H  S! B' e
17.   {. `/ w. a& Z$ j  g' l% v
    
18.     //敌人吃食物
    ; g. g1 i' ~! v1 }$ L
19.     for (int i = 0; i < Food_num; i++)
    5 u. M( y' e9 n4 n' t& Y/ e
20.     {
    . A% @% S& g\" F+ v
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    $ Q5 T! @& ~) I' Y% `
22.       {
    $ A, t% x  U  D/ O+ b
23.         Enemy[j].r += Food[i].r / 50;
    $ _  ?' ^% p4 I\" _
24.         Food[i].x = rand() % Wide_map;
    5 E- R0 Z5 P/ L2 I) {' Y$ r2 w
25.         Food[i].y = rand() % Hight_map;
    \" a0 ]# i$ n0 d/ d  g$ N& Q3 Q6 ^8 g
26.         Food[i].r = rand() % 5 + 1;
    : L0 p( E5 e! x# J0 `
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    5 X( X\" D$ ?( M3 h
28.       }0 @\" S3 g, B8 q2 q8 n8 T
    
29.     }
    : s; o' o8 r- G2 `8 e
30.     //敌人吃敌人
    , U. F\" \' `\" V( g  P6 T
31.     for (int i = 0; i < Enemy_num; i++)
    1 u) H( p5 l, }1 M2 O& j
32.     {7 ?+ _, i+ i' D. {! C\" m0 h+ Z- f
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    ! q$ C8 n1 q; I1 ]
34.       {
    ) D4 Y' K# y1 B- n
35.         Enemy[j].r += Enemy[i].r / 10;
    1 i7 }2 M5 Q* v
36.         Enemy[i].x = rand() % Wide_map;9 ]8 y' n1 X0 Z! D
    
37.         Enemy[i].y = rand() % Hight_map;
      f8 k% u) x3 q
38.         Enemy[i].r = 10;
      l5 J$ h\" Q5 j' K9 s
39.           Enemy[i].color = RGB(0, 255, 0);. V- x9 M# W+ |+ u
    
40.       }
    8 ^% s( Q, ?. ^2 H' b
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)6 m6 j\" _  o1 {6 \1 X; t+ k
    
42.       {
    - a2 |( \3 ]! N
43.         Enemy[i].r += Enemy[j].r / 10;* u: ]# f6 P- u; F' T
    
44.         Enemy[j].x = rand() % Wide_map;
    ) v3 E2 r9 t. E- n' J
45.         Enemy[j].y = rand() % Hight_map;; m$ ]& }% n4 _
    
46.         Enemy[j].r = 10;
    - F: H( `# |, Q2 t
47.         Enemy[j].color = RGB(0, 255, 0);
    7 [$ e; p* V7 t% J$ z& K4 U
48.       }; @6 d! [\" m\" _+ c+ W: P* ^/ E
    
49.     }9 Q* s  M( L$ [# i& N
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)& j0 _9 _3 B' R
    
51.     {
    6 v/ p& z4 E1 n; t
52.       //玩家吃敌人) c8 }/ ?9 N* b( j6 q. q\" I- s
    
53.       if (player.r > Enemy[j].r)
    * H4 @( `) k+ n$ F, x
54.       {8 v& S, w5 D8 A. D' i& l
    
55.         player.r += Enemy[j].r / 10;1 Y7 F: @! F- Z( k: W; ~: L. Q( z
    
56.         Enemy[j].x = rand() % Wide_map;
    # \) c2 r7 E4 ?& s
57.         Enemy[j].y = rand() % Hight_map;5 w: {\" M\" v5 w& S5 n$ b2 N/ l
    
58.         Enemy[j].r = 10;
    9 W$ u6 i- E3 l6 B6 |/ s
59.         Enemy[j].color = RGB(0, 255, 0);& X# G1 A5 d3 Q\" u: h% ?
    
60.       }
    . E6 d0 V3 O- z6 ?' i/ @
61.       //敌人吃玩家
    5 H( U( k! z, V. w\" H- o
62.       else
    3 a( o9 O3 K/ a! I) I+ b
63.       {
    + h' k\" l3 p3 X0 W5 v\" [
64.         if (invincibility == 0)
    / l+ s* a+ v+ W* i, c3 K
65.         {
    ! j* ~# u4 c3 ~6 G\" [3 B  N9 F
66.           Enemy[j].r += player.r / 10;
    ( Y\" A2 y# e2 k) V! E: ~& L. ~$ M
67.           player.x = Wide / 2;
    . j! \& R7 v4 m% f! G( ~/ O
68.           player.y = Hight / 2;+ [6 ~4 f+ a% H9 c
    
69.           player.r = 10;7 u! R, ]) A; C9 X% y! \, |
    
70.           invincibility = 10;
    8 U, Q/ Z% ]& N
71.         }% S( N( i1 B# K\" x\" _
    
72.       }+ f6 H9 R2 x, ^% X- G& L2 v
    
73.     }  b- C/ [+ |- i7 S! H6 k- M5 Z
    
74.   }
      N/ J5 r( l8 w  V
75. }

复制代码

完整代码见附件：
' p6 _0 x5 d1 `- t% D
' b7 z) v) G" v7 t+ B
3 U1 o0 i5 A' A