球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
3 z/ M/ H' W" i3 _' L
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

' C/ m2 C$ ]% K  A# _$ Y游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

9 n1 K. t- B4 ^* x3 s1 z7 h玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
7 O# w3 [$ i6 J1 u4 S) y
8 ~! G* Q' m! @8 n  R1 U体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

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

2 n; E# Z8 e& c/ ?! d  Hai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
) D/ X2 }! D' Y/ ~
接下来，我们将通过以下几个步骤来实现这个游戏：

0 h8 O9 |4 L, D. C! [# }初始化游戏界面和小球的信息。

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

5 ]$ c2 v) i, g+ f生成足够数量的食物小球。

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

9 ]  [, F/ M3 }7 r检测小球之间的吞噬关系，增加相应的体积。
9 J/ a( `/ v3 [6 ]
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
" F, H' X$ y' E) B0 l; O9 q
% A* c4 C. p8 I7 cstruct Ball
{
( M4 Y/ K$ Q% b3 u        int x;
        int y;
        float r;
        DWORD color;
};
. m3 ~1 s' ]  W2 |/ F2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

橙色可以通过RGB值（255, 128, 0）来表示。
- \$ A" p: r+ [0 z$ V4 w6 V黄色的RGB值为（255, 255, 0）。
8 d9 x1 l. n5 Y" \4 a6 ~% o' ^. p4 j9 D绿色的RGB值是（0, 255, 0）。
0 C4 x# }4 M) u& }( H2 b* p蓝色的RGB值为（0, 0, 255）。
( d8 Z6 l% t; Y, u紫色可以通过RGB值（170, 0, 255）来表示。
3 X+ M/ S  |0 O; i黑色的RGB值为（0, 0, 0）。
; T! A* [7 b  l白色的RGB值为（255, 255, 255）。
* Y3 z! a/ ?$ ]/ |灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   + R: i2 N4 z. }9 b% [\" _
2. {
   ) @+ m! C2 n! z6 Z$ b
3.     //玩家小球& C0 G( I& Y! _* c. Y1 E4 W
   
4.   srand((unsigned)time(NULL));
   9 l\" G! M  ?! R- T$ z2 G
5.   player.x = Wide / 2;- t8 w1 f. Q4 _; S
   
6.   player.y = Hight / 2;\" ^/ X- B) B, |9 u  E. {! M
   
7.   player.r = 10;( q1 V0 G; d. k7 ]
   
8.     //食物小球2 d\" A3 a. j3 a
   
9.   for (int i = 0; i < Food_num; i++)
   3 D& v  H' U/ ]3 I6 ?
10.   {0 `- J# P+ D% n  _/ f
    
11.     Food[i].x = rand() % Wide_map;7 J\" o' Y, e. O  a
    
12.     Food[i].y = rand() % Hight_map;
    ! q, F$ C8 N& G8 h6 a& o0 `8 q% V
13.     Food[i].r = rand() % 5 + 1;
    + }\" m' a, C1 o
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    % N4 D\" h* Q& e. M$ e# R; a
15.   }
    5 E\" w1 l' y  |
16.     //ai小球$ ^# u! N9 q) j! D7 V% |* @: P3 O
    
17.   for (int i = 0; i < Enemy_num; i++)  q1 c$ s7 k- }; @
    
18.   {& B7 i  r/ ^, O. E: P
    
19.     Enemy[i].x = rand() % Wide_map;- P5 @: D4 b5 M$ t/ z% W
    
20.     Enemy[i].y = rand() % Hight_map;
    ( Q4 P0 q% R, F
21.     Enemy[i].r = 10;% ]. v& R2 I. n! z
    
22.     Enemy[i].color = RGB(0,255,0);
    \" H4 u/ j% M9 N1 ^4 j) ^4 s
23.   }
    5 @* ?. G7 p. B
24. 7 {. L4 m- E% l
    
25. }

复制代码

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

1. void Player_move()
   2 s& {4 C) ~9 \9 h+ P% E/ p# g
2. {& X' q! R$ z6 L$ R' ^% {
   
3.   if (GetAsyncKeyState(VK_UP))  J1 m) P* B\" ^; Y3 l: ^
   
4.   {
     y, S+ f/ i. a5 H' K2 D3 b\" N
5.     if (player.y > 0)
   # w) w5 W, n7 U9 A+ i( b2 [
6.     {- p& I7 @, p, P
   
7.       player.y -= player_sleep;: V4 h\" ^- B5 W# k. R* m: G9 R
   
8.     }
   : R6 [- F7 }9 O7 l; A; a$ n
9.   }
   0 R; o( P, {* f
10.   if (GetAsyncKeyState(VK_DOWN))
    % b3 m' q+ ~( P8 `; @
11.   {9 W5 P! f* E$ Z  s3 t5 E9 y
    
12.     if (player.y < Hight_map)2 r# o\" _. @5 B
    
13.     player.y += player_sleep;! t0 f( C  L& p8 Z5 w6 l
    
14.   }
    3 G% b0 _7 S+ X  x% B8 ]
15.   if (GetAsyncKeyState(VK_LEFT))) {1 ^; M* D+ t2 b' G8 i+ ?
    
16.   {
    7 ?$ m; m: B: [
17.     if (player.x > 0)- x; b5 q# g2 {/ i
    
18.     player.x -= player_sleep;
    * I1 I; r3 Q% g. M- x' \
19.   }
    1 y9 z. h6 m* V/ ^: g
20.   if (GetAsyncKeyState(VK_RIGHT))
    6 X, C6 T  B( g% Z$ u
21.   {
    * ^. X0 S) I. H; X
22.     if (player.x < Wide_map)
    . e6 {  G9 b* f2 {5 R8 Q; [2 ]* Z\" C
23.     player.x += player_sleep;\" h$ P' R( F2 c
    
24.   }6 B1 y+ t$ S+ W/ b, N1 d
    
25.   if (GetAsyncKeyState(0x20))
    : N+ y) L, S9 V/ z
26.   {
    ; w8 F0 g- H: r, [$ k- H% Y1 W: i7 X1 V
27.     player_sleep = l + 5;( c3 o' g\" Q$ z% h
    
28.   }
    3 b$ ?# c/ l) d! K& [- Y
29.   else
      `' @. z0 {' G1 Y% K% n! ]
30.   {. w+ c' g% L* z, d1 Y- y
    
31.     player_sleep = l;
    $ I: j; K4 U  @$ S1 r  V5 v7 x
32.   }! \/ [# y  U; K7 l6 O8 Q
    
33. }

复制代码

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

1. void Show()5 |3 g1 X1 X, `$ [: `
   
2. {4 J  r5 X! Y$ Z) Z( ~
   
3.   
   , K: n0 V0 b6 F8 f
4.   //设置地图3 {$ ^4 `1 h, T% `. n
   
5.   SetWorkingImage(&map);4 T, F. C+ x2 Q9 }& b
   
6.   //清屏: z- `& b. a! _' e6 q! S$ ~
   
7.   cleardevice();
   , |  F2 J* a\" U7 Q9 e' t# U7 m# }1 f
8.   //背景颜色
   4 v$ |+ t! ?3 h$ D
9.   setbkcolor(WHITE);
   ! u1 B$ U5 J6 O& Y. o; E! ]  h
10.   //划线颜色# ]$ b8 z- x7 |7 |8 M, r# B6 e
    
11.   setlinecolor(RGB(230,231,239));
    \" U  Z\" L1 T2 G8 E' [+ P
12.   //划线
    : k; M+ c3 U: e  Q' q
13.   for (int i = 0; i < Wide_map; i += 10)! F# |: `; S6 N; r\" ]
    
14.   {
    % U( Q/ V$ S5 S& ^4 g
15.     line(i, 0, i, Hight_map);
    $ Y& [) l: ^: U+ Z4 |
16.   }
    5 Z$ t# }( Q0 @' }1 P& j- e0 f/ r
17.   for (int i = 0; i < Hight_map; i += 10)
    8 @4 |0 `1 n# k7 h5 Z
18.   {& D7 T0 b! y4 c9 I* V4 K
    
19.     line(0, i, Wide_map, i);7 V/ i( J: U1 L% I, t3 g1 N
    
20.   }
    . v8 K1 {7 M% `4 g# G+ @9 F
21.   //食物9 C/ n9 K, ]$ S8 z+ ^
    
22.   for (int i = 0; i < Food_num; i++)
    2 k2 ]1 P5 F; D0 x7 Y: T
23.   {/ \0 w* \# C1 @! [
    
24.     setfillcolor(Food[i].color);
    3 l  ^* t* y: `* K% ~
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);0 J0 L4 _3 A8 r2 _8 _6 p* _& g
    
26.   }
    9 n! p( u. z, N& a0 C
27.   //敌人, o& _* m6 t1 @; w! j
    
28.   for (int i = 0; i < Enemy_num; i++)1 W' k' f. w2 g& y
    
29.   {1 V5 v1 a$ X5 ?, U2 M% _( l8 q! s
    
30.     setfillcolor(Enemy[i].color);\" n8 o1 s6 O# \0 z% K/ k( E/ g
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
      P. L) R9 u' B5 N\" i! P% T
32.   }
    5 }7 Q( m7 a: ~4 B+ c, D) t
33.   //玩家
    $ y) [8 c2 q; g: G% j: N7 y
34.   setfillcolor(RED);
    ; u% [/ b5 D8 {
35.   solidcircle(player.x, player.y, player.r);7 [\" y3 }$ \6 c9 x! G0 F) H
    
36.   SetWorkingImage();
    % H; k# F2 E' o' E\" Q
37. 9 \% [( H$ M, \
    
38.   int x = player.x - (Wide / 2);
    - C- r8 K) x\" Z! g
39.   int y = player.y - (Hight / 2);3 q3 u8 C2 h7 r/ o$ O$ L8 f5 Q9 S
    
40.   //防止窗口越界7 P6 G8 k' o5 L1 x. A0 v
    
41.   if (x < 0)6 C/ L  n, D8 p; B: `- z\" [
    
42.   {
    ; E\" Z; z! H; k/ D$ H# ^6 C: v
43.     x = 0;, T+ x3 e0 M) r2 h
    
44.   }
      p8 y0 R6 G9 _, j4 C2 f
45.   if (y < 0)% o/ x- W& p. [0 b) R2 e
    
46.   {4 D. V8 b4 t. x
    
47.     y = 0;2 x& G/ _: n6 O% \( w2 d
    
48.   }6 z1 ?# l7 y% q# t
    
49.   if (x > Wide_map - Wide)4 V\" L. U2 [; d; ~3 h
    
50.   {
    ) E( t# o# `3 G- O# J
51.     x = Wide_map - Wide;
    / s* {# }- J: ?/ C5 R$ ?5 h# f
52.   }
    4 n: }; f\" ~3 X+ y) Q: ]2 E
53.   if (y > Hight_map - Hight)
    4 p; o4 w* L) A5 n9 b
54.   {
    6 V1 S: S3 s6 A1 A2 Y; a* n
55.     y = Hight_map - Hight;
    : Y) w! [) y& A4 \\" u$ b
56.   }
    & X) Q5 m! R3 ^# F4 n
57.   //把map输出到窗口上2 R! z, w3 D% A. q\" N# t& `3 I
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    4 ^5 E! I6 j\" G7 D  s- K
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. //防止窗口越界
     m# b+ E1 f1 ^# v: _$ a
2. if (x < 0)
   % G- R' \; i; t! w
3. {
   . Y' P2 w3 Q/ i/ I\" l, H
4.   x = 0;* d/ [1 @. [2 n7 b9 M, l3 J
   
5. }
   # ?$ ]2 l3 W) n, W- z, ^
6. if (y < 0)
   3 b7 X0 ]; k' s5 W\" S/ {5 ~
7. {( W  Q5 y6 x0 [! h/ {9 e
   
8.   y = 0;0 J! K3 E6 {5 p& i2 Z
   
9. }1 D' g$ `; j- P# q4 S/ |
   
10. if (x > Wide_map - Wide)5 B+ ~: q/ |8 z4 T$ j
    
11. {! u- d6 h1 i% V
    
12.   x = Wide_map - Wide;7 W4 x( y# o7 J; Z  ?: [
    
13. }
    ! r5 P6 U) {9 u
14. if (y > Hight_map - Hight)% O0 `5 K2 D( I( F
    
15. {: a) j2 e+ k/ x5 X( E4 u
    
16.   y = Hight_map - Hight;
    ( Y; f0 p8 Q6 T- O\" [
17. }

复制代码

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

3 ]( k7 ], F& u5 q" t(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

) K$ ]! s. H/ k  d, c& b$ H/ wWide：这个参数指定了要绘制的图像的宽度。

Hight：这个参数指定了要绘制的图像的高度。
/ ^# w7 K) n) {* m) M; I
, T0 @- ^/ ?& B+ O$ J&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
  P( Y! Y/ o# ^( z% e
' z6 T6 L5 Z" k6 bx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

& O# ]! U2 W& y% E" ay：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
' ~, D3 \! X& I随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离. _: k; f( d, }. c% k( l\" F* c1 W
   
2. int Distance(int x, int y, int x1, int y1)
   7 F' F& n% Y7 U) v6 |
3. {
   # ^2 V' M; t& k2 A7 F
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));+ G- b. D: m2 Q. J. C  t8 l4 e! L
   
5. }

复制代码

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

1. void Enemy_move(), c+ m1 o% u\" u: j, z
   
2. {
   2 `) T1 r; \! q\" D7 F; r
3.   srand((unsigned)time(NULL));4 {% j; Q, x; M, B7 v
   
4.   for (int i = 0; i < Enemy_num; i++)' s$ h) C8 |8 l9 f
   
5.   {1 `* _, V+ @, f! m. `+ V
   
6.     int direction = rand() % 4;
   ; m; g  \6 q\" n+ u
7. 
   # g  S5 C$ M- I4 ^3 I0 s0 p
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)9 Q; }( A$ \: S3 ~% M' v
   
9.     {
   4 h- j! b3 X) O+ Q  \# ^, P: {
10.       if (direction == 0)) X: _\" x0 ^& X1 a
    
11.       {+ c4 t/ N- w  L9 T
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句\" v4 _& [& _3 ?% n; M7 i
    
13.         {
    3 x0 {( R4 s/ O) n
14.           Enemy[i].y -= enemy_sleep;$ M! P$ e4 _/ {' I& s6 o
    
15.         }
    6 L& w2 Q( t: J8 A' A: {
16.       }
    \" i+ O+ |5 E% O6 y. x' w( v+ m, v6 ^
17.       if (direction == 1)
    * F( e! Q' G. L
18.       {6 E) R7 ?, F7 Y  c( k' k- w& C; |
    
19.         if (Enemy[i].y < Hight_map)
    , k! W- _' T$ R) P+ W0 \
20.           Enemy[i].y += enemy_sleep;
    ; @2 B' @\" @6 o/ L8 b
21.       }9 @9 S' V\" r/ M5 w$ `
    
22.       if (direction == 2)  J1 a5 d, x- F\" a  p3 T  K( b
    
23.       {  P4 z: `2 h8 `4 p
    
24.         if (Enemy[i].x > 0)
    6 `- q( D; q) |/ R' @
25.           Enemy[i].x -= enemy_sleep;1 v3 ~6 u2 |8 U% V1 R
    
26.       }! r* S7 f# @/ r% s' J8 _9 k
    
27.       if (direction == 3)
    5 q( M/ o- F7 ?% U& C
28.       {
    , E8 a- W& L! t1 [6 d
29.         if (Enemy[i].x < Wide_map)& Y& x/ l- {0 Z' z
    
30.           Enemy[i].x += enemy_sleep;
    8 @# h' U' |9 g0 F5 T$ m& [
31.       }
    ( N0 u\" K) R5 v# m: p
32.     }; `: X& E; [2 ?: W' [/ ^
    
33.     //敌人追击玩家
    8 S& {0 s) v\" m1 {$ x
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    0 K0 o/ b: V0 H
35.     {! |  {8 l% a% v3 Q& l' Z
    
36.       if (Enemy[i].r > player.r)& j) F, W: k4 g* v* l+ ]
    
37.       {
    4 L. @3 [/ \  q- _/ ?0 E9 i
38.         if (Enemy[i].x < player.x)
    & q! }0 h; W4 h* N3 Y. W
39.         {; J/ `% L( R2 S+ ?\" y3 ]  S& [) H
    
40.           if (Enemy[i].x < Wide_map)
    9 P4 G, g3 [. m, H
41.           {; |7 Q$ h7 H- d8 e/ n
    
42.             Enemy[i].x += enemy_sleep;/ ^) e8 u- }+ t+ T$ j) a# B8 r
    
43.           }
    2 d5 I\" N- }. Z% I
44.         }
    1 i( Q' Z- `; w
45.         if (Enemy[i].x > player.x)! I5 Q& ~: [. ]8 H* R
    
46.         {
    2 f9 K1 s' K, ~* j$ d
47.           if (Enemy[i].x > 0)
    8 i% |6 t) [- b8 d4 I9 W7 n
48.           {
    ( m* D5 t  Y' ]' C$ T
49.             Enemy[i].x -= enemy_sleep;\" G) L( I& W4 N$ q
    
50.           }; [( Z- f  \0 o. x6 d* j; n
    
51.         }
    * g0 V) B' F, H; D
52.         if (Enemy[i].y < player.y)
    , x5 J0 ?7 x' W: Y
53.         {
    & ^; w7 m- R3 A
54.           if (Enemy[i].y < Hight_map)
    - T: ^2 h+ R6 A; ~9 S9 b' U
55.           {
    , C\" A+ E1 I2 U, n1 }
56.             Enemy[i].y += enemy_sleep;0 Q% \0 g( O! }$ _& p4 w
    
57.           }' X; Z$ _* i# D
    
58.         }2 |) U- Y0 ?/ K, y6 L$ |
    
59.         if (Enemy[i].y > player.y)
    - V$ n) p3 |5 p! L7 I( H
60.         {# O9 L. S0 j3 ^
    
61.           if (Enemy[i].y > 0)
    & N! z( [9 O: t9 c5 T& x
62.           {9 C; o0 e) P; M) ?# U
    
63.             Enemy[i].y -= enemy_sleep;- e2 G9 m\" X9 T8 B1 K\" E1 R
    
64.           }
    . |1 P5 F% ]8 P9 b) {# u5 `: i
65.         }
    - d% ^- \/ T# H' s2 N
66.       }3 M. o+ [# ^2 y( G! o4 |  g) _
    
67.       //敌人逃跑
    1 O& C$ ^2 A, K3 y4 q
68.       else
    ; d# V; E, _1 M: I. t
69.       {; a+ J' {4 P& |, ~( |1 ~; I+ W
    
70.         if (Enemy[i].x < player.x)
    & C\" T/ A/ L: b9 }+ g
71.         {
    4 n8 B\" r! B2 D( Z5 x% N+ W6 k
72.           if (Enemy[i].x > 0)
    # ?4 w) ^2 ^7 V2 C. G
73.           {: L6 D; s+ o# h% P3 f. J: x
    
74.             Enemy[i].x -= enemy_sleep;
    7 Z% @0 u6 E1 d/ k; O7 E& v2 K5 h
75.           }
    2 Q- E( S9 i8 y0 K
76.         }$ v# L$ ~, [& o
    
77.         if (Enemy[i].x > player.x)
    3 t, D3 E5 h8 q- k1 }* n
78.         {
    % @  g' j5 s% L( J: }1 {
79.           if (Enemy[i].x < Wide_map)! N6 p3 A7 d\" w
    
80.           {# [0 k: m5 v3 ?! n+ v& b( V* l6 N
    
81.             Enemy[i].x += enemy_sleep;1 R' E, [* A( t4 B6 E& n
    
82.           }\" m3 E0 K1 d* O  C  L* A; w. O0 H
    
83.         }. z6 J$ q% g3 y0 s  B$ V
    
84.         if (Enemy[i].y < player.y)
    ' d  f5 f  [+ A
85.         {# |9 {& [7 Z' P\" F' Z
    
86.           if (Enemy[i].y > 0)
    : Q. n/ n9 G/ w& d; B
87.           {* A5 o7 r( e) p9 ~  Z4 N) S2 {
    
88.             Enemy[i].y -= enemy_sleep;
    ( a* u* `, H: d$ a) R% z\" H
89.           }
    ' N* G: p! d- C) a
90.         }
    : J- F1 p; x- v3 U3 }3 C2 ]
91.         if (Enemy[i].y > player.y)
    * ^- G. o4 ], ^
92.         {. ~! b$ {6 h; ]8 E
    
93.           if (Enemy[i].y < Hight_map)6 |- j# N3 Q1 V- l1 G( x' N
    
94.           {$ b( Q& }' v  T1 ~& N# }/ j
    
95.             Enemy[i].y += enemy_sleep;
    4 Z: K' p9 E& i2 R# }
96.           }8 f' O8 ?& E+ C6 F
    
97.         }
    5 d6 Q$ `- ^$ H3 u( _
98.       }4 g6 t% p3 ]1 g) \% Q
    
99.     }
    5 i# T+ Q1 o4 M5 J+ _& ]
100.   }- c) \% a! B; `& l; I6 |
     
101. }

复制代码

7. 小球之间的吞噬关系
, e: Z  {9 d. b' x; V

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

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

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

1. void EatFood()0 Q0 e7 r6 U3 e: s* W; W+ M
   
2. {
   8 |0 f* u7 d\" d  ~3 w6 i  n  I  A
3.   for (int i = 0; i < Food_num; i++)
   * r1 p3 m* x/ ~) L. D- j
4.   {
   ) z4 t) Z$ R9 U0 |* S' |
5.     //玩家吃食物8 t' d3 x/ l( C& z# N2 a
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)3 L& O, C2 V( `
   
7.     {
   + g: }$ K. X, u, G3 k1 B
8.       player.r += Food[i].r / 100;
   3 O& u; k4 M4 L
9.       Food[i].x = rand() % Wide_map;8 d8 a0 B+ |% ~  z* @% }
   
10.       Food[i].y = rand() % Hight_map;
    4 q6 x6 z! G# R
11.       Food[i].r = rand() % 5 + 1;
    8 B\" s! b$ [4 T! B! `/ g/ C
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ( P, A6 n0 Y+ g# |
13.     }
    9 S3 e  i5 s3 l\" P2 x* L
14.     2 \' k8 D9 ~: h. O7 E4 j
    
15.   }  C, {7 O\" l. r, k, v6 ^' W+ I. W
    
16.   for (int j = 0; j < Enemy_num; j++)
    + [/ W) @\" w8 k9 A8 c# C% t
17.   {
    # C- P0 Z: z7 q1 v
18.     //敌人吃食物- h9 u: m0 _7 E* `1 {
    
19.     for (int i = 0; i < Food_num; i++)5 s0 f3 O* m9 ?6 A# A
    
20.     {- G+ p2 {) ~4 a/ I& P7 O, I
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    7 h: L# T; A; e. q
22.       {
    ) @6 i# b- d& [& J) p/ K5 {
23.         Enemy[j].r += Food[i].r / 50;! N. n7 A) [- d; v) r! ~
    
24.         Food[i].x = rand() % Wide_map;& G- E5 p. g, |. C+ }
    
25.         Food[i].y = rand() % Hight_map;# J! R% ~+ H( J! [
    
26.         Food[i].r = rand() % 5 + 1;2 a7 `0 P& Z' T0 b% O. J4 m$ e
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    0 O  |3 B- w. ?) s
28.       }$ {; R5 ?8 A% u# e
    
29.     }, s, d; B; o) q  ]( t
    
30.     //敌人吃敌人
    . O' f) N+ d# m) W, Z
31.     for (int i = 0; i < Enemy_num; i++): n0 F: C3 W$ A7 k2 c
    
32.     {; T8 u, ~- A$ ]0 [
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    5 L: g, o; O% H$ w4 X
34.       {
    6 M5 b7 s0 }$ ?  r  b, k
35.         Enemy[j].r += Enemy[i].r / 10;
    ; Y+ z. W/ A& P- v
36.         Enemy[i].x = rand() % Wide_map;
    7 o* Y+ m; Q) I% m  y$ F
37.         Enemy[i].y = rand() % Hight_map;
    , D1 M6 S# f$ u% \2 t; i( k) G0 D
38.         Enemy[i].r = 10;
    ; x( f# P& s2 \3 \. t
39.           Enemy[i].color = RGB(0, 255, 0);
    9 ^2 E& N) q$ ]\" j0 X) G
40.       }
    1 e9 h! x$ O8 L9 U\" K& X
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    ! f) e! J0 I  G. ?( w2 j0 R8 M, G# S; k
42.       {8 O) k: l& V. L2 @% G  N9 R
    
43.         Enemy[i].r += Enemy[j].r / 10;
    , u: ^, M; w3 ~7 o7 k- E
44.         Enemy[j].x = rand() % Wide_map;$ r+ S+ T& I5 q; {( p1 X
    
45.         Enemy[j].y = rand() % Hight_map;
    2 Z7 S, h2 }1 Y3 ^% F/ ]
46.         Enemy[j].r = 10;
    ' d- p2 ^2 f9 M& z$ e
47.         Enemy[j].color = RGB(0, 255, 0);* |3 i+ l+ r: C. P3 b0 M& R6 g9 x
    
48.       }) k6 X& @  L2 Z/ Z# m' n, ^: j& {
    
49.     }
    , F9 v! i/ c& h+ X9 n
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)\" p5 h$ l0 L7 ^
    
51.     {
    $ Q! l1 v  R7 ]/ n$ T( t8 r  k
52.       //玩家吃敌人
    8 _8 u( v- Q: ?. o) P& b
53.       if (player.r > Enemy[j].r)
    - I# o. E) I4 U/ u7 k4 Q5 g
54.       {8 L* w6 W5 g% L
    
55.         player.r += Enemy[j].r / 10;
    & e5 i; _& ~3 G
56.         Enemy[j].x = rand() % Wide_map;# f0 }7 N0 g2 f4 _
    
57.         Enemy[j].y = rand() % Hight_map;
    + ?6 a: Q' G/ c+ W% }# k
58.         Enemy[j].r = 10;2 x$ d: B7 ]$ e$ _
    
59.         Enemy[j].color = RGB(0, 255, 0);& S! |  M8 v6 ?
    
60.       }$ I& m5 P) x- T. s1 z9 j9 [
    
61.       //敌人吃玩家
    : j& w* w( _. s1 ~3 |& i3 b
62.       else, D4 f& g) a6 K6 U  c0 `& a
    
63.       {
    ; z1 A4 [! b7 `2 ~/ ?( R7 j
64.         if (invincibility == 0)
    ; `! g6 _! @$ i! u5 s4 b
65.         {2 k* s4 Q2 X; \$ g$ w! k
    
66.           Enemy[j].r += player.r / 10;
    ) F+ H; O% n) p$ ?! M  A
67.           player.x = Wide / 2;/ q# {0 H\" t, y9 V9 D3 s6 q7 }1 M
    
68.           player.y = Hight / 2;
    . Z3 l4 D& O3 R8 O, Z% [
69.           player.r = 10;3 g\" f3 l0 I5 W, `7 E( U1 y
    
70.           invincibility = 10;) l\" h- P1 `) ~0 c\" j$ t* Q' E
    
71.         }- K* _6 K1 d2 ?% @
    
72.       }: S, F- g3 [7 H3 x% ]+ g7 N
    
73.     }. |0 ]5 f3 Z, c1 c' s
    
74.   }) z( X4 l5 T0 B1 w% G- D
    
75. }

复制代码

完整代码见附件：

: I# Y% W0 ~8 I. m