球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
, p' _9 h3 Y/ l6 N  y: E
0 H6 M. ?! S) j: D. U在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
+ C0 e7 y) B. }
  B0 U, D  O! y游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

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

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

1 |0 r3 p$ S! b6 d. o4 D% s体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

9 ~4 T* E4 S- i6 y玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
2 \: R" h+ f+ J* }, K8 }, g
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
  K/ j1 k* N; Z$ @
接下来，我们将通过以下几个步骤来实现这个游戏：
' ?/ @9 F5 n6 p/ E
初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。
: h, }. M+ P* K& D* F( T" B5 Z
4 w) g6 C9 [& k' R2 [生成足够数量的食物小球。

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

检测小球之间的吞噬关系，增加相应的体积。
* G, @2 k( W  \
  A8 ~% h! o7 Y3 a通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1 w' ^: X8 t1 z, }0 {9 a2 z1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
6 T9 d& V, t, l! K
& H# c2 B' K; y  B0 j1 t8 Fstruct Ball
{
        int x;
* S$ G, W' U2 v6 Q        int y;
; T9 R1 U( g2 Z. R" n  b3 O        float r;
        DWORD color;
* _) {# H2 Y: `9 h. m$ H};
' F7 @- `1 Y+ }. Z, Z+ P7 y5 M2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
# w! r  v4 n9 u( q
/ Q4 s  o  d, C9 ]/ C: fRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
7 a/ V' [  a7 Y- T& G, }
9 F5 d: q* A4 e- f2 h橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
& a" K7 H* ]& v* B蓝色的RGB值为（0, 0, 255）。
5 T) N  `6 h" F. u/ n紫色可以通过RGB值（170, 0, 255）来表示。
8 N7 i: y, C! i5 l6 P4 m* I黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
/ C& L/ c0 J) E- n( ~灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   / I. Y! Z3 Z\" ^7 V9 M
2. {\" T* G2 s$ d/ i* D( Q; @
   
3.     //玩家小球, T- i7 P$ }$ [' s* K- H# @7 Q
   
4.   srand((unsigned)time(NULL));# l4 ^2 u- ^/ Q\" y. A; B3 M
   
5.   player.x = Wide / 2;$ t  @, f3 v9 C) t# J
   
6.   player.y = Hight / 2;
   - C7 {! m8 s0 u8 E
7.   player.r = 10;
   ! A5 G  o( w- d( [. [
8.     //食物小球
   % ?* f2 V, w* K
9.   for (int i = 0; i < Food_num; i++)* b  ^6 c+ L% ^0 u\" q
   
10.   {\" ]3 e& Q6 k/ P& G, ^' P  T6 Y
    
11.     Food[i].x = rand() % Wide_map;
    3 z3 Q) O5 l0 C/ i( Y. a% R! X
12.     Food[i].y = rand() % Hight_map;: `2 |# m+ K. J& z$ \4 h' S
    
13.     Food[i].r = rand() % 5 + 1;
    - U8 T! p3 V& }# m
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);8 o- U9 ]  j' W5 b
    
15.   }
    6 @8 O- T9 g! K
16.     //ai小球
    9 W) e4 B0 f\" k/ f- Q! W
17.   for (int i = 0; i < Enemy_num; i++), h/ y2 p- u0 n, o  H' @; P5 w. V
    
18.   {
    & U1 M  c( g9 o) z2 ?& x& g0 f
19.     Enemy[i].x = rand() % Wide_map;
    # ~4 n7 k6 F/ i5 F+ z& U/ Z  i8 }
20.     Enemy[i].y = rand() % Hight_map;
    5 ?  e, P. K& U, b2 ~
21.     Enemy[i].r = 10;0 J4 b; |0 q4 N3 U* \/ A9 D# x
    
22.     Enemy[i].color = RGB(0,255,0);' d$ a0 g$ [1 M
    
23.   }
    % ?3 E1 H+ H2 E\" S
24. 
    ( t  _' A\" S6 @% Y
25. }

复制代码

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

1. void Player_move()$ _) r% {\" L\" F8 a% P
   
2. {1 K. D4 d7 a1 j! [1 W
   
3.   if (GetAsyncKeyState(VK_UP))
   9 V! z1 l7 p2 D# K# I6 o
4.   {. E4 P& b2 w7 z
   
5.     if (player.y > 0)
   2 K0 H0 V\" O, F# q2 _% |- C4 \
6.     {
   # v/ m* E! E$ u+ W\" q4 n3 {% D  G
7.       player.y -= player_sleep;
   3 ^7 r' ~9 D\" }. X3 t/ L
8.     }/ y; S! `- i: c
   
9.   }
   % N; T- ]3 G& G  d% {
10.   if (GetAsyncKeyState(VK_DOWN))
    ' @7 S; Y7 {8 l; S  x
11.   {
    \" z+ j1 ~; n& w  N2 a
12.     if (player.y < Hight_map)
    8 |\" X% z5 y4 g1 `
13.     player.y += player_sleep;
    5 Q) M. O' ^\" @\" O) j1 o  e9 ?
14.   }& z! u( V- C  K$ `* I- g
    
15.   if (GetAsyncKeyState(VK_LEFT))' q: Q3 K8 d7 x/ B6 a' c# F
    
16.   {% S4 S# ~6 Z8 a\" J! g6 v  I% d* J3 _
    
17.     if (player.x > 0)
    7 w0 f$ g; I% |  s
18.     player.x -= player_sleep;  S) G0 D4 f# y5 t5 o
    
19.   }
    9 a+ c5 w6 U  S* E9 P6 i$ s0 d- _
20.   if (GetAsyncKeyState(VK_RIGHT))
    ' P7 s, I1 H0 L5 }0 I' T
21.   {
    , j+ [+ y7 Z* X7 k/ h7 ^8 K
22.     if (player.x < Wide_map)
    % e' Y( F0 d! r# m6 u
23.     player.x += player_sleep;! l1 _- {, J0 {- b  G: t- L; j4 v
    
24.   }
    7 ^$ G. g3 ?; ~. ?\" [* ]
25.   if (GetAsyncKeyState(0x20))
    8 l; {0 r0 E6 Y- d5 R9 Q
26.   {
    8 a  q; ?/ a  \  h( i
27.     player_sleep = l + 5;# d\" o, _# i( p9 U
    
28.   }
    ( l6 }! P8 c* ~  y7 [1 u7 F\" N
29.   else
    & ?$ P) I+ o# I  m  O/ X1 x
30.   {: K, w' o\" i/ u( m
    
31.     player_sleep = l;/ j3 K7 g! l& w: N& M
    
32.   }9 A\" v0 h. V4 C9 V& y+ y# d+ M1 |
    
33. }

复制代码

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

1. void Show()
   ; B8 U$ l+ L; O' R, M
2. {
   * }+ Z& {* e  q# n- G( J' ~
3.   
   2 ^* s  m, {, {: Z, e5 J
4.   //设置地图
   ( a6 _+ a; I) a9 B0 B4 q
5.   SetWorkingImage(&map);
   2 H: f8 ]1 \7 a6 G\" Z$ O
6.   //清屏
   # o  B2 w8 T; [5 f1 `
7.   cleardevice();
   0 C, n( x: Q& [5 w
8.   //背景颜色
   # W/ y, |( A& e. \\" O; ~
9.   setbkcolor(WHITE);. F, R* \5 c: I; y4 z+ u( i
   
10.   //划线颜色
    % v8 X7 v1 q0 C( S1 O# l2 E
11.   setlinecolor(RGB(230,231,239));
    . ^0 o  q- Q1 q5 J, Y+ N- V
12.   //划线
    5 I7 X, C( [* L) u
13.   for (int i = 0; i < Wide_map; i += 10)0 L- G0 ?5 E\" E& ~. G8 P* t
    
14.   {& f0 H9 l; ^: x! S\" V' F
    
15.     line(i, 0, i, Hight_map);
    1 H\" e4 S6 Y, u
16.   }# X6 R+ N6 ]6 V) _. H
    
17.   for (int i = 0; i < Hight_map; i += 10)# k0 E; O1 o4 w3 U
    
18.   {
    7 H) S/ g% @, G* I
19.     line(0, i, Wide_map, i);
    + p1 I4 p\" B' q' d2 g9 R
20.   }
    / e5 a: p/ P* X
21.   //食物6 ~6 E; o4 Y+ u2 T+ ?2 Y5 y. |( {
    
22.   for (int i = 0; i < Food_num; i++); X# d2 I8 D/ }# V) p
    
23.   {
    * [' {% N! V7 N- I( i( }
24.     setfillcolor(Food[i].color);
    * I( J\" _3 ]% k& L
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    & ~! j# ^' _6 n. q
26.   }8 V7 P2 p+ m3 e4 J
    
27.   //敌人
    5 u* B- s; ^0 \. k8 f% j! W0 f
28.   for (int i = 0; i < Enemy_num; i++)! V* B3 c\" B; `% p  U8 w. q, B
    
29.   {
    7 m- F3 n: I9 K\" G; D; m( b
30.     setfillcolor(Enemy[i].color);
    % y, x: [5 w/ d  U+ y; B
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    9 Q/ P7 h9 y6 E& ^0 l8 {
32.   }
    5 O& W\" f. U0 \3 [
33.   //玩家
    1 `9 ?: o) ]- N/ b\" k\" A/ r
34.   setfillcolor(RED);
    ' W8 V\" S8 m6 R% T: d3 [1 B
35.   solidcircle(player.x, player.y, player.r);3 `; }7 N: ]+ G. P! X. R
    
36.   SetWorkingImage();. [5 o3 n+ i/ e# S2 K) q' J7 c
    
37. 
    9 Y) o8 ^\" k( p% R' f- A
38.   int x = player.x - (Wide / 2);
    ' K4 G* g. L! \, L
39.   int y = player.y - (Hight / 2);' W. y+ H2 x% i# {\" g& {+ s
    
40.   //防止窗口越界
    ; A: b; R- z8 k  e
41.   if (x < 0)
    1 }8 m1 \\" [6 h- Y
42.   {1 H& F9 j+ y) @! n
    
43.     x = 0;
    $ K: i' d' J. {
44.   }
      X4 V$ Y/ K, \\" s* v; `
45.   if (y < 0)
    \" \# y; r& K% t- k3 C- n6 E
46.   {- w. Z, r& D8 l
    
47.     y = 0;
      e( F7 T: w  }0 d
48.   }: o: w: C3 Y, N4 P8 Q
    
49.   if (x > Wide_map - Wide)
    ; P/ `( y. V1 r3 W
50.   {
    0 M# p$ n* h: E7 [9 E1 G# q7 m- n\" w
51.     x = Wide_map - Wide;\" o5 m3 O8 r; {/ k2 r
    
52.   }\" j. f/ W! P2 O
    
53.   if (y > Hight_map - Hight)
    6 y/ c7 }\" Z4 ?  M% _' X' A) C6 g1 ?
54.   {
    0 t' M; J* z8 k+ ?7 O1 l
55.     y = Hight_map - Hight;7 U4 K6 M& |6 y6 m/ ~5 J7 O
    
56.   }
    * w& ~& E; o5 D: v, l  G' o
57.   //把map输出到窗口上
    ' s) i) M1 a# B/ I0 i! `; t( Y
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    9 _+ G6 c- u0 G% @
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. //防止窗口越界8 o( f0 _% t4 S( ]( k& y
   
2. if (x < 0)
   $ H9 N& l. v# O% P7 u1 s
3. {8 o+ I. m2 m2 @
   
4.   x = 0;
   . v: Y4 n8 P  h+ D3 W
5. }
   & T) D& ^* X1 }\" p' o
6. if (y < 0)
   ' Q8 e+ W' M# ^9 J3 }- W
7. {
   2 J: ^5 m; E  g: a' i( r4 U9 \
8.   y = 0;7 I2 _7 ?# R; E' O9 M* B
   
9. }
   ' J) V2 `( L3 X9 ]1 F1 z
10. if (x > Wide_map - Wide)
    . V' l( r% e8 |, Z1 n
11. {
    # \9 @8 w' L, M+ b7 R
12.   x = Wide_map - Wide;- d( @: z' p5 O% \
    
13. }
    5 `: n* _7 W3 F) G& H( O
14. if (y > Hight_map - Hight)8 O3 M7 Y6 f6 N6 k* q2 x
    
15. {' a9 O4 \1 T7 V1 R
    
16.   y = Hight_map - Hight;* D  x# @3 n$ k% N0 K- U. Q+ P
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
6 Y1 @- o* n- u  L+ z2 Z
& T* z0 I4 [2 i! O+ V( J(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

Wide：这个参数指定了要绘制的图像的宽度。
4 D# y9 |# R& e- ~0 E3 Z
6 o) U' c8 Z2 BHight：这个参数指定了要绘制的图像的高度。
* A5 {% v* p& w9 n( \
, i( U* h7 n0 {3 L6 N&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
' U- V+ W: M% Y- Y; ]8 T3 X4 G
2 R% T, N+ G& `3 Y' F9 e. D1 C$ c) @x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
+ e( W# f! ]; R0 u
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
5 p  j/ V  }1 G. n" y& Z6. ai小球的移动
- F+ z: H3 b/ q8 T0 [随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   , U2 R) i\" _% c) C2 B9 q
2. int Distance(int x, int y, int x1, int y1)
   ; \+ I\" i) D. x8 b! v\" H  G
3. {
   1 ^, S7 f. ?* H, l9 f9 [5 |
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   6 c* r0 X% d: J& _, a/ t# u
5. }

复制代码

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

1. void Enemy_move()$ K; U6 T) u6 M, b
   
2. {6 p8 k- i' Y1 X; v: s/ A1 z
   
3.   srand((unsigned)time(NULL));5 A\" W+ a. }( {: H
   
4.   for (int i = 0; i < Enemy_num; i++)- M5 Z5 i5 q! v% S' n  f0 R
   
5.   {( t. f9 O! C+ l9 B' B! U
   
6.     int direction = rand() % 4;- c0 W+ B6 r4 c$ Z- V% o6 `
   
7. ; t0 j1 r, ^8 e# s3 V# B7 h
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   \" @9 x( W( F0 ?
9.     {
   9 r2 z2 Y$ M5 X% t7 u\" G. @
10.       if (direction == 0)
    . t3 w\" e7 O8 R; W# c
11.       {) h) T1 P- @: x\" U4 ^
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    5 ~. z/ q2 h8 F% V
13.         {, |# H& l# |/ H2 D
    
14.           Enemy[i].y -= enemy_sleep;
    7 P* W, p/ ?+ `
15.         }
    , D+ Y2 P# B6 W: J
16.       }: O9 t0 X1 m6 j2 ]1 n
    
17.       if (direction == 1)4 \; H) K* b2 S\" ^# y, `) O
    
18.       {) x% `8 o3 p# ]2 T2 R  u+ \
    
19.         if (Enemy[i].y < Hight_map); a. g. l) I/ }, N( Y$ m: x- Y
    
20.           Enemy[i].y += enemy_sleep;1 \) S! n( E8 c& v* d& j! @
    
21.       }/ f7 _+ K- g% j8 D- }) t
    
22.       if (direction == 2)
    , r% D+ r0 k  I2 o
23.       {$ n% Q. i, G% i( Z/ P5 Q
    
24.         if (Enemy[i].x > 0)  K\" R' G# o1 o( e3 x  i
    
25.           Enemy[i].x -= enemy_sleep;) E  P, E$ Q7 v( U0 F& |: _
    
26.       }
    6 V* f- D1 i0 a$ {9 [! |7 a7 E. L
27.       if (direction == 3)2 t# V( A. O! j: M
    
28.       {3 j% o5 c  n# Y\" h6 j
    
29.         if (Enemy[i].x < Wide_map)
    1 F, L6 t7 U9 c# G: B6 l
30.           Enemy[i].x += enemy_sleep;
    % {6 |% \5 t4 N. C
31.       }\" V0 _; ^5 w8 U
    
32.     }
    ) L' g% O6 `( @
33.     //敌人追击玩家9 G5 j9 j( F4 p  l7 G; @\" h
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    0 \3 F5 k2 h; D' W, c! @
35.     {
    ! }5 i) D0 |* c0 P' f0 d
36.       if (Enemy[i].r > player.r)$ ~& V% J1 z; f\" e5 N, ]) q
    
37.       {
    & _3 _2 w5 L' v# D6 b
38.         if (Enemy[i].x < player.x)
    % D& S4 h- v0 `! g+ a* p! w8 \
39.         {
    3 w6 {+ _  `0 h\" g- k
40.           if (Enemy[i].x < Wide_map)
    2 [4 z' x1 _6 P5 y
41.           {
    . E$ M& g\" A9 h/ \( `- S0 k6 B  L
42.             Enemy[i].x += enemy_sleep;
    1 F1 D5 H9 l2 V/ y* G$ Q+ A, E% Q
43.           }
    # d) m, S/ L6 n9 y1 g1 Y& M; P
44.         }
    9 Z7 C/ V% j- K6 q
45.         if (Enemy[i].x > player.x)
    # f  `, D2 K! b7 }+ ~' \
46.         {
    2 k- b, l; N8 ]
47.           if (Enemy[i].x > 0)
    1 E: k  f# q0 _) }, r: y0 O
48.           {: K- d; F4 M; ]( w1 C' t& ]$ b
    
49.             Enemy[i].x -= enemy_sleep;5 q! I' \5 r7 |1 A8 C
    
50.           }
    + t7 n5 W$ D, t/ m* W. @6 H
51.         }
    / i! b: b3 ~- }8 ?
52.         if (Enemy[i].y < player.y)8 a0 ^5 m\" t! I
    
53.         {) T6 ^# t9 l  }+ a' p& T
    
54.           if (Enemy[i].y < Hight_map)6 P: C6 s- x\" C
    
55.           {8 b$ s$ g\" x5 m1 s
    
56.             Enemy[i].y += enemy_sleep;
    9 o7 }- Q0 [7 p, y& ?
57.           }
    - H) }8 W$ N7 S& r' j
58.         }' a0 s% r8 d+ q1 u
    
59.         if (Enemy[i].y > player.y)  B4 B7 h& |2 O! U9 p5 p6 D- w
    
60.         {
    . r9 A\" [+ F# M8 H' O1 y
61.           if (Enemy[i].y > 0)
    - h/ |3 T! ?+ m( N$ Q7 U2 e0 I
62.           {7 T1 O# E% x/ O/ l
    
63.             Enemy[i].y -= enemy_sleep;
    ) t) C% g! T; y/ |
64.           }
    5 P! w) j/ j/ M+ h' G! I
65.         }
    2 ]\" c  n; T4 ]: _( u6 M6 k
66.       }
    # R  m\" ]  m% \2 T! \
67.       //敌人逃跑
    . D6 u# M2 i2 z6 Y
68.       else* S2 V8 m( H% l9 f% q- M! b
    
69.       {- [3 T7 W2 b2 c
    
70.         if (Enemy[i].x < player.x)& o  b% v, ^+ X
    
71.         {* S0 n; t6 a; f
    
72.           if (Enemy[i].x > 0)
    8 |7 J3 i. r/ w! x9 m( Z3 K9 t
73.           {
    \" [1 B! u( k4 o0 I; t3 E8 R3 z
74.             Enemy[i].x -= enemy_sleep;
    6 ]+ R/ \$ q! c
75.           }
    1 `2 _6 V& L0 v; U) F/ A, y4 v
76.         }2 |; R3 y: Z2 w3 }
    
77.         if (Enemy[i].x > player.x)
    ' K3 j. n: W\" ]# w2 t7 X) a4 n3 i
78.         {
    % ^7 N! ~2 j2 \( W
79.           if (Enemy[i].x < Wide_map)$ o- U\" Z7 L0 s9 U
    
80.           {6 }, I$ S$ Q* B% e$ q  C\" V
    
81.             Enemy[i].x += enemy_sleep;+ _% z. f\" s( e& ?
    
82.           }. E9 {\" [5 x7 X1 r, S# v) u
    
83.         }, Z. q# y7 B* ]\" \3 F& T0 z
    
84.         if (Enemy[i].y < player.y)
    - d) N7 ]- ]7 j* w) ^; ?
85.         {
    * \; N1 M: {& _9 \5 M
86.           if (Enemy[i].y > 0)
    2 ?: e( _\" A1 h0 T: J
87.           {
    # d6 Z0 }2 R0 m! s  G( ^/ ~- x
88.             Enemy[i].y -= enemy_sleep;
    7 l. |: }7 O  V) N; {! J3 ]
89.           }
    & S. k% z! ?' Q5 H3 N
90.         }$ @/ ]' s$ s. \4 Y  k2 t, D
    
91.         if (Enemy[i].y > player.y)
    3 G% t8 A* `8 t8 V! C  M# {0 }% u
92.         {
    6 N( S7 Q4 x  \( j4 V/ \  J- W
93.           if (Enemy[i].y < Hight_map)+ M% J- d7 J- k
    
94.           {
    4 y2 b; k5 W+ M3 i0 O
95.             Enemy[i].y += enemy_sleep;0 C2 \( [/ n4 P, Y3 K9 l, W/ H
    
96.           }
    \" B\" x* O& s; _
97.         }
    \" i& x0 K# P! j# ?5 X. X/ M, Y0 Y
98.       }
    3 G0 ^. W1 f: a# I6 x
99.     }
    * H+ v3 V3 l5 T0 _! K9 z
100.   }1 J6 q, x! L7 \0 L3 p; }\" Y$ M+ Q
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()1 Y% N$ b. W9 W9 Z. H
   
2. {% D# H* P5 W9 j
   
3.   for (int i = 0; i < Food_num; i++)
     G9 t- d3 M$ f4 h2 ^# h* |
4.   {* X; X; o5 W4 ]. x# G8 P* s' B8 b
   
5.     //玩家吃食物
   0 U; g, w( k, i% I4 C
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   # ~7 M- b! x1 U* j0 k- o\" p5 ~
7.     {, z0 C1 a1 o$ \8 F
   
8.       player.r += Food[i].r / 100;
   - N, F, Y7 U0 z. l5 Z/ _! K
9.       Food[i].x = rand() % Wide_map;
   ' f\" H+ y* {5 W& P+ V
10.       Food[i].y = rand() % Hight_map;; ~/ q3 q: |4 z
    
11.       Food[i].r = rand() % 5 + 1;+ C3 E; N) O\" ~3 i! G5 k7 ^
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    \" F7 g0 T8 B/ @. C6 |+ h. @
13.     }
    ( I: T. s* C0 R* }$ [: J
14.    
    ! i$ ?' x2 r7 g' R  u5 L9 g- l
15.   }
      }9 X, o( \) h7 X5 n
16.   for (int j = 0; j < Enemy_num; j++)
    ! e% B# g+ Z5 r* A' h9 y
17.   {: d, l+ n6 z& S+ b- @7 y% |9 r
    
18.     //敌人吃食物9 `; ^- R8 a* M\" g8 r
    
19.     for (int i = 0; i < Food_num; i++)5 n+ E  q+ J7 x* ^% \6 @3 }& ^
    
20.     {! V2 G: n( t. e& G: m
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    ) \( ?) a8 d/ T% h1 c1 b* E
22.       {
    * ]2 {- d7 s+ w- D# l
23.         Enemy[j].r += Food[i].r / 50;( n2 }5 ]; F9 t: C
    
24.         Food[i].x = rand() % Wide_map;( t6 `; e; H\" {+ A4 x: H8 \6 ?; R
    
25.         Food[i].y = rand() % Hight_map;1 h2 @/ n2 Y, O& C) T9 f* i
    
26.         Food[i].r = rand() % 5 + 1;
    8 r' B4 u' p; E
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    \" k& |! z% Y( j  l\" u* S
28.       }, V, p' }: B) b+ F0 f
    
29.     }
    ; n, z8 D& [/ ?' d
30.     //敌人吃敌人
    - n- Z4 D, Y- N  D
31.     for (int i = 0; i < Enemy_num; i++)* Q$ c8 E6 ~  T& u' f! d- j- y( y
    
32.     {0 x; N4 ]4 y  V: W
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)7 }' N5 B, G! o2 d  D2 a
    
34.       {
    9 J1 D% x  n& c9 Q  w' U
35.         Enemy[j].r += Enemy[i].r / 10;
    , y( Q9 `. s) @  h  c
36.         Enemy[i].x = rand() % Wide_map;' U9 [9 Y) N' F8 c! P
    
37.         Enemy[i].y = rand() % Hight_map;
      w4 f3 Z4 q; A# v9 _7 ]: Z
38.         Enemy[i].r = 10;
      ^4 ^# A6 x8 }3 t* D. i6 q' }
39.           Enemy[i].color = RGB(0, 255, 0);5 c0 o  @4 P4 L: L
    
40.       }
    8 J1 b- w- h, k; l; a5 \+ L
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)- r' z+ e5 H4 x* j) W
    
42.       {4 `7 ]\" H) U( O( h% P
    
43.         Enemy[i].r += Enemy[j].r / 10;\" Q2 i3 u\" o  I
    
44.         Enemy[j].x = rand() % Wide_map;- i$ [$ Q, D, A& g& R6 `
    
45.         Enemy[j].y = rand() % Hight_map;
    / H7 w6 M) B0 A# b6 x
46.         Enemy[j].r = 10;4 \' F; u  C2 X9 C* H
    
47.         Enemy[j].color = RGB(0, 255, 0);
    9 N$ j, Z- a# z  l9 b# G
48.       }; i+ s7 _' n8 C! W: J$ v2 W9 C
    
49.     }
    5 ?4 a\" e\" w5 B
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r), d, K\" r0 a8 |8 g/ H5 ]' {
    
51.     {
    ( \; J' X# P* R6 T$ c% u
52.       //玩家吃敌人; X# u\" C) t2 v1 [8 k
    
53.       if (player.r > Enemy[j].r)4 P0 Q( {6 `4 \! q\" g\" P
    
54.       {% f! j$ u+ Y7 X4 [- x
    
55.         player.r += Enemy[j].r / 10;
    3 {! F  _- ~/ q. e# T; f/ {- v& g, J
56.         Enemy[j].x = rand() % Wide_map;: ~9 V) K) G0 i1 \5 C& M; x& m% J\" q
    
57.         Enemy[j].y = rand() % Hight_map;
    * B- A; Y' e' A5 A$ P1 T% M
58.         Enemy[j].r = 10;
    5 D$ a) L+ T' B\" t8 c. Z, S
59.         Enemy[j].color = RGB(0, 255, 0);
    - A& ]0 A/ O9 u/ r0 d) t% \
60.       }
    2 L% p- h' n6 X! K+ b! j. B
61.       //敌人吃玩家
    ' J1 ~2 G5 @/ z' p1 m/ c\" }7 @3 A# E; M
62.       else
    7 e( R9 \+ Y& E# Y+ ?4 N! d# c
63.       {
    \" n  _. J1 |\" ?9 ?
64.         if (invincibility == 0)
    . O& h9 \- l7 Y6 U) z( u$ X
65.         {
    5 }. S, o% j( f& \0 h% w7 M
66.           Enemy[j].r += player.r / 10;% y# R) A, I! {  G7 k
    
67.           player.x = Wide / 2;. O& M( r8 D! b& I- c  I
    
68.           player.y = Hight / 2;
    0 [* y2 ?! \* h8 C: s
69.           player.r = 10;
    0 L8 ~& m$ R. l9 [! B- `
70.           invincibility = 10;9 Y! x* A. k2 b+ y
    
71.         }
    6 L5 d) s' s0 k* i% i# A$ C
72.       }. F6 f1 E; `8 c3 X. ?
    
73.     }: Q! M+ n0 e# H' W
    
74.   }
    . J( L( p! F8 v
75. }

复制代码

完整代码见附件：
0 k0 A7 }/ @3 A# c/ j