球球大作战

2744557306

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

% @1 O) ]( P; g/ |- k在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

5 Z. \# `# @& J3 ]6 t2 c游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

; N9 M6 J$ q, {: o! p. Y# L) x& X2 x玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
' ^( K# C1 H, @7 p! g- D! l/ O5 W) A
其他小球：其他小球又分为食物小球，和ai控制的小球

3 g$ B) a8 ^6 ~7 ^$ f体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

- j6 v) q& n) L0 g0 h+ _2 ?玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
- W' E8 l* S( n& c& v7 L6 V. `6 X
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

* I& E( v: f/ h2 A接下来，我们将通过以下几个步骤来实现这个游戏：
: |3 \4 C( L3 L9 _$ B6 {4 A. f
初始化游戏界面和小球的信息。

- O. a2 M8 _. P$ ?. j6 q处理键盘输入，实现玩家小球的移动和加速。
6 {+ [# D8 p! w3 E$ w
生成足够数量的食物小球。
: \' X& p9 ?2 f; \6 k4 d% J
生成ai小球，并控制其移动。

检测小球之间的吞噬关系，增加相应的体积。
" }, Q* K2 T3 J1 V
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
0 u7 d  E3 _! k$ J$ n
8 G: x" S3 K8 V3 U1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
3 X: y  Q/ f; ^! v. w
5 J3 p" m4 J9 x8 r' I9 Tstruct Ball
{
        int x;
1 z8 ~' g4 |  S5 f        int y;
        float r;
9 o5 ~! T; {+ L; N; K: l+ D        DWORD color;
- I$ }! ]7 {% n* x( _};
* A& ]8 {+ y6 A$ m2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

) B- O+ _- o/ H橙色可以通过RGB值（255, 128, 0）来表示。
6 S6 ^* ]0 A$ r黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
- s: Z9 d* ]6 ~. D6 C* Y蓝色的RGB值为（0, 0, 255）。
, {3 g7 q) x5 I3 f2 y9 X紫色可以通过RGB值（170, 0, 255）来表示。
/ s& n& v( `4 C9 W8 G黑色的RGB值为（0, 0, 0）。
8 {. H# L: m8 c9 b$ V2 @白色的RGB值为（255, 255, 255）。
' d; v+ s* ~8 ~+ k2 V7 [灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   - B: r  R/ o1 ?. C  F  H
2. {3 i\" _  G3 u# f. i3 W# Z% L
   
3.     //玩家小球+ E# F1 U, T\" N' B
   
4.   srand((unsigned)time(NULL));
   / T\" z9 l& ?& O4 F\" V: f* P
5.   player.x = Wide / 2;
   / L; c- c5 q) g\" {: R) x\" M0 z
6.   player.y = Hight / 2;
   3 n3 ~& l& R; A% _, k1 `
7.   player.r = 10;
   ) p* T) |( M\" u1 r0 ~
8.     //食物小球1 Q- P* R, D/ w6 p  a- }\" r2 u
   
9.   for (int i = 0; i < Food_num; i++)
   - z2 N# t0 I' Z+ A' G9 l
10.   {
    5 s  H9 b/ G- ?' I1 r6 u7 J0 d# d- m. k
11.     Food[i].x = rand() % Wide_map;
    ( s9 c4 I8 q\" G$ L+ \) }& G3 [
12.     Food[i].y = rand() % Hight_map;
    % }) f' B4 F1 _8 c5 b  e% m. Z
13.     Food[i].r = rand() % 5 + 1;
    . r$ v/ V- z4 E2 _2 I2 p$ d, n
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    3 e# F$ V4 T9 B) G' R
15.   }- ^( e5 D' i; K0 j
    
16.     //ai小球
    ; N* u/ N6 B3 g2 W4 m, \9 _
17.   for (int i = 0; i < Enemy_num; i++)1 i, g5 v5 |4 x9 S, P  {& }& ^
    
18.   {) p. J. Z9 O- ?# R& E
    
19.     Enemy[i].x = rand() % Wide_map;$ J  w5 N: k  v* _2 @: d6 C9 x2 C
    
20.     Enemy[i].y = rand() % Hight_map;
    ( w+ A6 n. @- T
21.     Enemy[i].r = 10;: O2 V' I# N) {/ h
    
22.     Enemy[i].color = RGB(0,255,0);* ]& a: V7 Q6 a# ?0 V
    
23.   }
    4 `: L! w- r6 |$ B0 @7 H
24. ' U& c1 E* \# \' u+ A9 S# h) N
    
25. }

复制代码

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

1. void Player_move()2 [( ]) s! q& d* ]\" y3 M2 o4 y
   
2. {
   . ^# u& [) R! o\" E( D! \
3.   if (GetAsyncKeyState(VK_UP))
   3 Z) Z% ]1 R. z0 I: W( e
4.   {
   0 V( t) {: I$ _; v8 X: O
5.     if (player.y > 0)
   + ^$ L7 m' w, u3 A/ h/ M& I
6.     {* Z% n$ Z4 h, N
   
7.       player.y -= player_sleep;
   ! a. N6 T3 T' z! w
8.     }\" n# O  V) J, R! k
   
9.   }4 ~' T3 L( u$ A5 W: `3 I7 E2 q
   
10.   if (GetAsyncKeyState(VK_DOWN))
    - G9 [2 F+ @3 [0 o3 ~& f
11.   {- P+ P9 c# q$ n- O
    
12.     if (player.y < Hight_map)
    ' v6 o2 @\" `3 V0 k2 I& m
13.     player.y += player_sleep;+ R8 @2 ~' s0 q$ M4 B
    
14.   }+ K' p3 |# F- ~  G& i4 R
    
15.   if (GetAsyncKeyState(VK_LEFT))
      e. @6 @9 d+ V0 a1 W
16.   {! N+ L- E9 E8 W' b8 Y
    
17.     if (player.x > 0)2 F3 \6 j% K. w  L0 l
    
18.     player.x -= player_sleep;
    ( D+ H$ S9 e$ R: x% W4 C  p1 S4 ]
19.   }
    5 P! A; h) o9 f: f. u. Q5 f
20.   if (GetAsyncKeyState(VK_RIGHT))
    ; s% g% N) H5 T5 h. c* B0 L; }0 e
21.   {
    ; K$ f7 N( y5 ^6 ]( r\" f& @0 O
22.     if (player.x < Wide_map)% z+ n7 D\" [2 K1 _) H$ e
    
23.     player.x += player_sleep;
    . \6 v) T5 [9 o5 @
24.   }
    2 o% `/ k: a4 N
25.   if (GetAsyncKeyState(0x20))8 h; p- s* Z' l! Y( [! _+ g
    
26.   {, b7 o$ y- V; H, M+ G$ b* J. L
    
27.     player_sleep = l + 5;% P9 k) Q- ]5 Z1 O* u
    
28.   }
    + u& I' J& s: {9 D
29.   else6 g3 O0 }, c/ g6 r& N6 Z
    
30.   {# p$ o; g2 _8 N! J: b\" }
    
31.     player_sleep = l;
    % i+ a6 x$ \, F
32.   }
    , B) c\" f. G' B6 J' J
33. }

复制代码

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

1. void Show()
   2 C3 x) m2 f+ [. Q
2. {
   ) l, `' r6 v# U1 k# M* _) m, i
3.   
   6 b( l% I/ }2 P3 d0 D* Q
4.   //设置地图
   ' `/ G5 w  w6 l' [2 w& g
5.   SetWorkingImage(&map);
   % m  M% ?5 Z' _\" A3 W' c# W\" o/ {
6.   //清屏, a, o& ?; e\" @) x3 D# Y( j/ M
   
7.   cleardevice();
   - C& r4 ]& y0 W
8.   //背景颜色
   % G\" b2 X; q0 y
9.   setbkcolor(WHITE);; F\" }% G- C1 u% N: R
   
10.   //划线颜色
    + f- c3 H3 `9 Q. r
11.   setlinecolor(RGB(230,231,239));
    \" c9 W0 l3 E+ o: E$ I
12.   //划线
    * T& C# T: V2 g/ L7 M
13.   for (int i = 0; i < Wide_map; i += 10): x0 U/ a; O. z  r2 T8 ?
    
14.   {6 I; W\" Y, J$ [7 ?6 Y$ Q
    
15.     line(i, 0, i, Hight_map);8 y. l; Q9 R& B\" u4 t+ ]7 \\" e
    
16.   }# O/ m7 ~% l6 Y$ w. {
    
17.   for (int i = 0; i < Hight_map; i += 10)1 Q! |. ?1 n  r; W; [
    
18.   {
    + w9 B. w3 p% \( {$ @7 `
19.     line(0, i, Wide_map, i);  T+ b! s$ U, p\" x5 |# k- C- y
    
20.   }; @* `9 S+ C# G: P. C3 ?* ~
    
21.   //食物
    7 y6 e5 Y& W3 K# n
22.   for (int i = 0; i < Food_num; i++)# `$ x; {1 f! x% Y* g
    
23.   {2 ^: r) [  J5 [/ }' x9 ?
    
24.     setfillcolor(Food[i].color);
    # S' ?1 A: [/ Z
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);5 x) P! F& a! R% A; R- B/ k. Q+ P. n
    
26.   }\" y0 s. k3 B) ^% ?% I4 @
    
27.   //敌人
    5 |\" W8 l0 }/ x0 i' e$ l\" L- F
28.   for (int i = 0; i < Enemy_num; i++), X+ }& _1 g\" x7 ]$ v, x# q
    
29.   {
    ) B0 {9 T0 H( T3 U4 P& m
30.     setfillcolor(Enemy[i].color);& u/ j- @/ w# q' Q* n+ B2 g6 p8 z
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);7 X5 |% j# N: Y5 v
    
32.   }
    ( w5 @\" F  D/ r8 x/ E9 p; K
33.   //玩家
    - j. F. \% Z# }8 B* K. C
34.   setfillcolor(RED);( e( `  p4 O  I9 |0 t
    
35.   solidcircle(player.x, player.y, player.r);' o6 _6 W) O# K% Q
    
36.   SetWorkingImage();3 _! l; y3 T: N( k% ]
    
37. 0 g$ ^  X$ d$ T. \# A% g
    
38.   int x = player.x - (Wide / 2);% E2 U+ K# Y6 r& P- q1 z, z
    
39.   int y = player.y - (Hight / 2);
    : }- D: t0 G% c2 [1 h- B- e1 _0 ^
40.   //防止窗口越界. j2 ]) c8 _. u1 P8 v+ U4 }' ]  T& m
    
41.   if (x < 0)# n4 I+ l) U; R$ C
    
42.   {  O6 G\" X- H% L7 N! M
    
43.     x = 0;# J& W3 @. w. L' G1 J  e5 k* R
    
44.   }
    3 i\" {- _3 j7 U2 i7 B2 L9 Y; B
45.   if (y < 0)
    ; i; \3 G4 U2 F- R' E5 m: K4 J+ R
46.   {
    6 z1 }0 I/ }  u* I8 x2 d7 l
47.     y = 0;5 Q\" A  M+ e+ `, O
    
48.   }5 v! j; l/ g7 U  Z
    
49.   if (x > Wide_map - Wide)
    / h3 `$ n6 E/ W$ S% u' \4 t
50.   {
    4 R  X5 Q\" Z4 c  w! V# a9 _: d* u
51.     x = Wide_map - Wide;
    & P+ `5 ~; K7 O, R) T1 s3 v
52.   }
    ; G7 M0 t; r1 E5 }2 b. C7 Z
53.   if (y > Hight_map - Hight)
      o4 }- h! F, `( |
54.   {' x( J8 ?- D3 H
    
55.     y = Hight_map - Hight;
    \" [5 W% {9 a- j5 V# ~
56.   }
    # m5 x3 s& }( Y& q
57.   //把map输出到窗口上- C# c: C+ V0 @* Z% Z* W5 u8 h
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    . S9 p1 E, j/ G5 }8 [6 M
59. }

复制代码

5. 生成地图
, H- q6 @0 y# g3 e8 _7 n可以使用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. //防止窗口越界
   ( e# q8 F- s- U. y; x) g1 i
2. if (x < 0)6 O) L$ M% h4 k: l4 m( g3 U
   
3. {' W5 k9 J( u1 g6 o  h+ t  a6 r; X
   
4.   x = 0;4 d3 z; ]* {# k; S6 y& `5 Z
   
5. }
   ' Z& H+ W! q! b8 C* M
6. if (y < 0)6 e2 ~% N4 {8 Y
   
7. {
   * v: G/ K) ]! z3 u+ p, f9 T
8.   y = 0;
   , b( T' R. p! u( V( i\" Q6 G
9. }) N0 F' K0 d! B, I+ x$ ^* L
   
10. if (x > Wide_map - Wide)
    ! H9 n& G8 E( r0 n3 O
11. {
    - T  R\" x+ j$ V6 r/ T- T
12.   x = Wide_map - Wide;: z$ O4 e9 \- u9 V, t
    
13. }
    4 F0 S  P9 g/ c; `7 v% t* j; u: w
14. if (y > Hight_map - Hight)
    . f( }9 M# Y, j$ q
15. {
    9 y! Z9 o+ {2 b1 k* [3 i
16.   y = Hight_map - Hight;
    . y4 o# k. ^2 d% U8 B9 x
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
) @5 ~. k. g: Q
. B9 v3 i: ]+ `% r/ v' C- X6 r(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
6 T5 x! |+ b6 A+ h8 T% q6 \+ Q
Wide：这个参数指定了要绘制的图像的宽度。
0 }) \# s, O" o) v6 o# [
Hight：这个参数指定了要绘制的图像的高度。
, N6 L2 X$ ?! r% e2 Y. i; Y; _, i' i
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

' D$ A# ?* D  ], ]: |1 \( q$ ]x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
+ h+ d2 |: p/ J) X
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
- x  [0 G  m& ~1 o8 _1 H( l6. ai小球的移动
% n- w. E" g0 G6 p' E4 W, o随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离9 b) `7 {) [3 f. G; l3 z/ ?: x
   
2. int Distance(int x, int y, int x1, int y1)
   0 M. c4 }( {+ x# j1 C$ E
3. {7 ^5 V$ m/ K2 k$ f: G
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   0 w9 d$ }# y  x! |5 W
5. }

复制代码

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

1. void Enemy_move()
   4 w, Z5 `* \4 h5 S! q- A. \
2. {, R8 s8 `4 H+ n6 p. P% ~
   
3.   srand((unsigned)time(NULL));: @( H. z$ H4 u# W\" _9 d
   
4.   for (int i = 0; i < Enemy_num; i++)
   ' H* b9 v, R0 H, O2 n2 L+ W* y; I  X
5.   {5 S) |- B5 Z/ q0 `$ P3 Z
   
6.     int direction = rand() % 4;
   \" B- j$ U4 T8 \( {. G( `) p8 M
7. , |. {/ k; M/ X  V8 j0 P/ [3 b
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)6 e0 T: t( w6 C: d* r2 c
   
9.     {
   ; u; ^% c- \' t
10.       if (direction == 0)
    # q1 M- Q6 z, G\" D7 W2 [3 y# w9 H1 m
11.       {1 d3 P2 L! M6 ~6 ~  W/ C
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句. Z5 t# Z& e8 X) b% O
    
13.         {
    2 N\" W$ G( Z; X+ I$ a
14.           Enemy[i].y -= enemy_sleep;( S+ \7 t! I* {: X* b- u
    
15.         }$ n1 k. ~/ T8 y% x
    
16.       }# K6 ^' |5 U/ N1 G) C+ C$ H6 z
    
17.       if (direction == 1)+ {% O  A7 G! h7 C3 [8 G& K( `2 X
    
18.       {9 V1 h& K3 q* a* }2 \\" X
    
19.         if (Enemy[i].y < Hight_map)4 @8 S3 w% ?% {$ w
    
20.           Enemy[i].y += enemy_sleep;5 d0 K& X; k$ d
    
21.       }
    ( L, m  x  f3 V$ h: W4 e
22.       if (direction == 2)
    - \4 X+ G' N# H$ U
23.       {
    . }( D! T8 b- ~' ~& F7 w) d' e
24.         if (Enemy[i].x > 0)
    2 `; L1 s4 M. N- U# f
25.           Enemy[i].x -= enemy_sleep;
    4 j$ }% v) f9 b( W
26.       }1 t; Y* ]1 F& o1 ?% b1 z
    
27.       if (direction == 3)
    7 S( r; O( J4 A% u6 F\" n* F
28.       {) Z' s5 ^  ^9 y- s( D! p
    
29.         if (Enemy[i].x < Wide_map)
    ( P5 b& p, y, J% Z/ M; I
30.           Enemy[i].x += enemy_sleep;5 S6 x& d% b* g
    
31.       }! b/ V0 Q( h' J+ i& d1 u
    
32.     }\" ^2 V: R6 }1 ^+ i. S
    
33.     //敌人追击玩家
    1 X3 Y3 f& _' s/ v) I1 x
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)* W$ L; H! C& y2 K8 h8 n+ h
    
35.     {; [  |% _, R\" y. K$ h
    
36.       if (Enemy[i].r > player.r)8 `  ?3 G' {6 `( X. e: Z' ?7 x9 f8 T
    
37.       {
    ! p( q1 T5 B/ _3 _4 w3 _; g: Z
38.         if (Enemy[i].x < player.x)
    * ^; `\" v6 O, j6 d% l  ~5 i
39.         {5 M4 V- c. v\" p; n8 O3 K' y
    
40.           if (Enemy[i].x < Wide_map)9 K  F: Q. Z& ^  k; j# p: e; P* X
    
41.           {
    2 A) k8 K1 M! S6 Z; X
42.             Enemy[i].x += enemy_sleep;
    8 M9 V: q8 J; C5 \/ Q  @7 @3 K5 F
43.           }
    / b7 u1 W; {4 D1 v
44.         }
    0 n$ ~. t- x/ t5 A( V# l/ p
45.         if (Enemy[i].x > player.x)
    ; M1 ^1 q\" V. O! F
46.         {
    ! ?+ ]& U: ~1 I* I! ]* O
47.           if (Enemy[i].x > 0)
    ( {+ s! B1 O$ H9 r, _% l1 C, p) K( k
48.           {
    . K; u) J( e1 c( u9 C
49.             Enemy[i].x -= enemy_sleep;2 k3 b: W! n, y
    
50.           }
    $ Y* t( `  X* k! d% `4 l7 e
51.         }
    6 L\" A8 R  @  |5 y! Z; B
52.         if (Enemy[i].y < player.y)% I* T9 o  _3 Z9 ]% W1 H
    
53.         {8 s8 H- Y- N* [9 F+ c; y
    
54.           if (Enemy[i].y < Hight_map)* [\" h( v: Y\" H4 ^6 U5 u& R
    
55.           {2 w% `/ [# s& z6 ^' h; \) S
    
56.             Enemy[i].y += enemy_sleep;! V- Q7 c7 v1 ~8 Z
    
57.           }5 ]' o' I% @7 R\" z
    
58.         }
    , c\" x! j$ H% _2 ~+ S
59.         if (Enemy[i].y > player.y)/ I6 m1 P5 I3 i$ a
    
60.         {
    \" \$ _- `1 Z\" G) Z% Q
61.           if (Enemy[i].y > 0)
    7 G/ j: a' N# G' D3 Z# ]# {5 n
62.           {
    & v/ f9 J, x6 W/ V6 H) t% W
63.             Enemy[i].y -= enemy_sleep;; g( A9 @1 r3 F& ?% ~5 o
    
64.           }
    4 C7 m4 f\" b/ z\" \$ f
65.         }
    * {) O$ d8 ?6 ^\" s& Z( ~
66.       }, {% I2 d# X* o: Z, C3 b
    
67.       //敌人逃跑
    ) Z' k  l: J* Z
68.       else4 R4 j' f# Q2 {0 n3 o
    
69.       {) `* K& e  }5 M5 ^* g\" X/ U0 \
    
70.         if (Enemy[i].x < player.x)
    ) c1 o/ A/ }+ O\" p. A! x
71.         {4 d+ m1 h  |6 \0 i) U3 U2 ~3 C
    
72.           if (Enemy[i].x > 0)
    ' r+ w\" p$ t& q8 J6 L8 d
73.           {# p  T1 Z, I' \0 ~: a/ ^% Z) }
    
74.             Enemy[i].x -= enemy_sleep;/ S; z5 }+ C5 \( N
    
75.           }
    ! W6 l+ f' m( g; T
76.         }. P% Y0 D8 V& L\" y) z) N# {4 y* U
    
77.         if (Enemy[i].x > player.x)
    \" X# W+ m+ U* H& r
78.         {8 T4 c) f' g6 P( W% h
    
79.           if (Enemy[i].x < Wide_map)* b, g  e/ u% B' ~\" e
    
80.           {
    ) D* o1 C$ @( }' D
81.             Enemy[i].x += enemy_sleep;/ L; H  R6 g8 \# M
    
82.           }
    ( t) Y' b4 _4 K; J2 M
83.         }
    0 x+ {2 [- J$ s  B\" _1 u\" U
84.         if (Enemy[i].y < player.y)
    \" q3 i3 o7 W. W$ R\" G4 m5 V& C
85.         {) z) @& [* d( {- }; _+ a
    
86.           if (Enemy[i].y > 0)
    7 f4 z1 t( ~/ B; q
87.           {& j. U  a. P$ r; Y9 p/ M$ E
    
88.             Enemy[i].y -= enemy_sleep;
    $ n9 s& E. n! R, y; d
89.           }# H0 D* L; {0 }2 ^' @* T* }
    
90.         }* ?8 e* R9 _9 C7 f/ Q: T0 e
    
91.         if (Enemy[i].y > player.y)
    & Y2 Z0 i/ {5 I4 n/ s
92.         {. ]2 w6 j0 _. M. @) T; p\" I
    
93.           if (Enemy[i].y < Hight_map)
    % K0 L2 R0 R  m\" [+ J' L
94.           {
    - c$ Q. d  y) t! ^! f2 {1 Q
95.             Enemy[i].y += enemy_sleep;9 o. Y4 m, N) P7 E' ^: w! Q3 D3 B. [
    
96.           }
    * \; V4 J  P$ M& A7 y: A
97.         }% a3 s! O& q/ S# _3 \( S; F! X
    
98.       }
    6 b$ R* \! G. r! ?( C& s; y/ }
99.     }9 s+ o9 ~+ ^4 C) S% X2 t  e
    
100.   }) G6 W. E. q' d! Y& c4 S
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()8 ^, Q8 c# u# N8 U0 a( E  S
   
2. {
   * w( w& r# L4 d- z+ e
3.   for (int i = 0; i < Food_num; i++)2 ], e+ J; q/ L
   
4.   {
   8 h- f7 Y6 P7 p
5.     //玩家吃食物
   ( f9 F2 F8 \- f; U' T! P+ ~
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)0 F1 }& `( @: o) I' l
   
7.     {, D8 X& J( y1 L/ W
   
8.       player.r += Food[i].r / 100;
   / u# E; z# K9 ]! Y# Z; Y
9.       Food[i].x = rand() % Wide_map;
   ' g1 ~: A1 F0 W
10.       Food[i].y = rand() % Hight_map;
    $ k0 t1 o4 D$ e+ X9 l1 [% t8 [; e
11.       Food[i].r = rand() % 5 + 1;6 `; m2 o0 v6 i' _) \3 X6 w% v, {
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);5 R2 |2 }0 W, W& F
    
13.     }! C# g  Q1 S/ m9 ]0 H
    
14.    
    8 M( J) c$ N1 d! X: Z
15.   }
      d  I3 |\" }* H5 p; n% B& {, `& r
16.   for (int j = 0; j < Enemy_num; j++)
    4 |( N, P' y# |7 d7 l
17.   {% |) i. t7 r9 g$ s9 W! [6 @! l
    
18.     //敌人吃食物
    ; z5 i' D& [; i* A- E9 }
19.     for (int i = 0; i < Food_num; i++)\" M% Y+ Z% p/ K. m5 X6 N( C1 b
    
20.     {1 f8 v2 c+ a& Z: J. H. Y4 {
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    : b& p8 M( A: p* W
22.       {
    $ B, ^8 C7 f* R9 v/ x0 }
23.         Enemy[j].r += Food[i].r / 50;3 q. a2 }! ]) w& s9 O
    
24.         Food[i].x = rand() % Wide_map;( @, }' n$ O, x0 z+ }
    
25.         Food[i].y = rand() % Hight_map;  b& h  f! K5 [3 @7 P* i
    
26.         Food[i].r = rand() % 5 + 1;' I6 R6 [0 L, e( y6 R
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);. {+ u) h6 `- v4 _6 l\" @
    
28.       }  G) n1 ~( X, i2 `* b- f
    
29.     }
    & r0 ^: j+ g1 g
30.     //敌人吃敌人% E0 P! t1 y! W5 F( x2 O
    
31.     for (int i = 0; i < Enemy_num; i++)
    - Y* Q0 Z9 R1 d. N/ \6 A5 G3 `6 b
32.     {
    $ s/ T  P% b3 t
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    3 c: V. X2 w9 g/ n2 E. Q$ M
34.       {
    . }9 T* }/ v* I3 [
35.         Enemy[j].r += Enemy[i].r / 10;; H3 j6 w0 W2 f6 F# {
    
36.         Enemy[i].x = rand() % Wide_map;9 Z6 K' t, O. b\" D( g2 Q
    
37.         Enemy[i].y = rand() % Hight_map;6 j# V& P. Y8 F
    
38.         Enemy[i].r = 10;0 F& q* V+ N, l
    
39.           Enemy[i].color = RGB(0, 255, 0);0 h! p8 N1 a- V6 l3 q9 _: \: F
    
40.       }
    % h+ J% f. H+ f9 x$ e
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)! L* X3 |0 D2 e9 S, V; D
    
42.       {7 q) X' q2 [; [' a3 Z
    
43.         Enemy[i].r += Enemy[j].r / 10;
    # }/ N6 [9 I, E\" h3 ~
44.         Enemy[j].x = rand() % Wide_map;, ]  m  ^- X2 w7 \\" b5 I
    
45.         Enemy[j].y = rand() % Hight_map;
    7 L5 [5 b\" u+ e6 ?6 E7 S- [
46.         Enemy[j].r = 10;
    5 p+ d' R6 J0 @) l# q0 g
47.         Enemy[j].color = RGB(0, 255, 0);
    / _, \- I0 R7 u/ F
48.       }
    ; I: \  ^- L% A. B: ^& m
49.     }
    8 U9 G# @( P0 X: l1 U
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)7 r\" H) n6 G) ^: D
    
51.     {9 z: A; _) p% l/ Y/ |$ Y6 J8 m- o9 v
    
52.       //玩家吃敌人
    / m$ X# U0 H2 _0 ]5 s& d
53.       if (player.r > Enemy[j].r)( ^/ q) l( a3 v8 R
    
54.       {9 e) `1 X6 w2 L4 e
    
55.         player.r += Enemy[j].r / 10;
    $ k' z' G7 Y8 H/ J; H
56.         Enemy[j].x = rand() % Wide_map;. K/ M5 h& d) {+ @* l. y' x4 }
    
57.         Enemy[j].y = rand() % Hight_map;' [9 T2 ]8 a  ?% a. M/ l% {: r
    
58.         Enemy[j].r = 10;
    7 y\" ~4 l8 b$ g3 i
59.         Enemy[j].color = RGB(0, 255, 0);3 ~( Z1 `3 _0 S9 x. T( @5 K
    
60.       }5 {' v1 E; p. G5 H* R
    
61.       //敌人吃玩家
    2 V+ r$ u1 m; y3 I7 l' {
62.       else& _& G# ^4 H  V/ }
    
63.       {
    0 \2 A\" q# O; p+ H8 L, D4 Q. c, g
64.         if (invincibility == 0)
      b/ z2 e- W7 c0 f
65.         {
    ! b; C- p3 H\" p! s; e, e
66.           Enemy[j].r += player.r / 10;: V3 `' s7 {: Y$ X+ t# i
    
67.           player.x = Wide / 2;
    2 |0 Y& e/ |. X  n. ^
68.           player.y = Hight / 2;7 D/ E7 b9 g0 p& z5 r
    
69.           player.r = 10;
    ; y# b$ F( Z8 O8 o; j/ X
70.           invincibility = 10;  R4 v( i7 N) d& I4 ^
    
71.         }$ \2 |- U* b2 j3 s2 Z% J5 \( A0 K: S
    
72.       }
    7 l! N: B) E7 D- o2 j1 v% k
73.     }
    - `6 ~2 p3 X7 Q# ^* e7 D
74.   }
    0 d$ @1 U! j: N1 V( _
75. }

复制代码

完整代码见附件：
6 d$ }2 _' d5 D) w: j

4 s3 D/ L4 G, I
. F2 W7 G, J3 u8 J