球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
! r6 M( c$ t. M0 q- N* A
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

9 S4 ]7 m, u$ c游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
$ U7 |5 ^$ ]# `7 m' \& I2 O
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
) z! |" u' q' y* }/ \& s
- f( }: H& B$ I, Y9 \( f: @$ S4 B其他小球：其他小球又分为食物小球，和ai控制的小球

8 j' |4 U7 [: M" p' X( h5 c体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

" x" f. V  i/ b; h4 p+ U& B玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

8 _, a. {0 {+ |+ x# h& mai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
8 |: K$ S* H# B4 B( ~; Z
# |) o6 _$ Q; B5 X% K接下来，我们将通过以下几个步骤来实现这个游戏：

  H$ \5 H! v- p0 P: w) r6 W7 q初始化游戏界面和小球的信息。
1 E/ l  |7 M; r0 M
+ Q  @7 {% u3 [) R, T" ?% K处理键盘输入，实现玩家小球的移动和加速。

4 L7 g; {! ]- t( {$ T3 `. t! s生成足够数量的食物小球。

+ A, a, U5 C* ]# c生成ai小球，并控制其移动。
! M8 \+ I0 l5 l' V7 P* r
. H. X/ n( H9 ^" ^1 l  @5 p检测小球之间的吞噬关系，增加相应的体积。

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

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

4 E- r- G5 o/ J/ N+ S/ k1 ustruct Ball
{
5 Q0 P0 J9 t7 a- V! [6 _" u        int x;
        int y;
        float r;
! a& I& g* `# |) ^3 N5 ~        DWORD color;
+ R1 S7 _) d' N' D: G, [+ I9 o};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

, [5 ]& m. y; I. R) d6 k, uRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
1 f5 S/ r8 I/ C: \
0 r" L. C2 I! z! U  v- R' |7 {( N橙色可以通过RGB值（255, 128, 0）来表示。
; J7 }8 q: ?  R+ ^黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
1 B. b6 B- {; z蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
, N) V: u. {7 ]  B黑色的RGB值为（0, 0, 0）。
, @. I- a! i4 M. U/ u白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   ! g. z; W& B) j6 e& B
2. {
   . Z# |% M) O7 E* O
3.     //玩家小球7 b0 n4 H- N( ]7 W  X( ~
   
4.   srand((unsigned)time(NULL));! L\" [: T1 ^\" s! |5 ~
   
5.   player.x = Wide / 2;) j, s* T/ N7 G+ y- c
   
6.   player.y = Hight / 2;
   ) ^5 @8 P  [% @& O8 ^8 `; U8 n
7.   player.r = 10;
   . O, M) ]2 x4 B1 n% q
8.     //食物小球( M) f* I8 u6 q* V# l
   
9.   for (int i = 0; i < Food_num; i++)- m  Z! H0 z# x/ d! p9 B/ ?
   
10.   {
    ' D- D0 S3 o+ H! K) A& Z
11.     Food[i].x = rand() % Wide_map;
    ( J8 B4 n8 _- S; {
12.     Food[i].y = rand() % Hight_map;
    0 n8 F. K3 T- W% i* h! x
13.     Food[i].r = rand() % 5 + 1;/ O7 S! n( I' O- D: V4 e, J
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);+ K) z9 ]& C( ^# A0 }) Z7 {
    
15.   }
    8 R7 [; Z- O4 {; _, l! q8 l
16.     //ai小球6 c. |- z\" Q& w\" W7 c# x
    
17.   for (int i = 0; i < Enemy_num; i++)
    , h/ S/ k, _$ b# R1 E
18.   {4 x& |7 G& b4 ~, D: `, _( w
    
19.     Enemy[i].x = rand() % Wide_map;
    . X6 s2 j2 d/ I% O
20.     Enemy[i].y = rand() % Hight_map;- x9 l9 ?* F3 M. ], O! f8 ^( A
    
21.     Enemy[i].r = 10;6 B' u3 e\" _8 x\" U) a1 E+ g- k
    
22.     Enemy[i].color = RGB(0,255,0);
    ) C6 C  J% c- T8 I! O# {4 c* b1 O2 j
23.   }
    ( A2 ^+ B6 }. ?* ?8 r
24. ! c8 L% g6 G\" C
    
25. }

复制代码

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

1. void Player_move()( l8 _4 Q9 q1 l- u! A
   
2. {
   * G6 P9 S6 h+ x
3.   if (GetAsyncKeyState(VK_UP))( h/ g- y; z) a! p
   
4.   {/ G& N! f6 _; k+ Y8 ?\" F- b
   
5.     if (player.y > 0)) H! q' J7 @& m% a& ^1 n
   
6.     {
   5 s8 M' D3 w. l\" \* J
7.       player.y -= player_sleep;! Y. }. ?' U3 ]7 b0 x; n
   
8.     }
   7 c3 e1 Z$ K& v! y5 ^7 @
9.   }
   8 D$ `; w; X' s) B8 n5 b
10.   if (GetAsyncKeyState(VK_DOWN))
    # m2 ]+ r2 O8 N' @( `$ Q6 V
11.   {$ k+ y5 b* {  \0 O\" c: L0 S+ p\" t' N1 V
    
12.     if (player.y < Hight_map)8 o( K2 z2 L. J/ K8 @9 N* w
    
13.     player.y += player_sleep;8 Z* P7 g3 C6 F
    
14.   }5 x8 w* x; w/ p' f
    
15.   if (GetAsyncKeyState(VK_LEFT))
    , W5 P3 K) g( w; y) ?& }5 w- c
16.   {
    $ e: R/ z9 T\" m9 z2 G; E2 a* i
17.     if (player.x > 0)
    + v* j+ v1 j3 d5 j+ Q+ E6 W
18.     player.x -= player_sleep;0 q, M+ w. |1 s/ Y% Q
    
19.   }# g+ L( C& N2 J7 X
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    1 m# Y/ O7 N* F5 u  r
21.   {
    : p6 i. j& o! I$ S
22.     if (player.x < Wide_map)5 H: H2 q1 J, h0 U% }# S5 b- k! L
    
23.     player.x += player_sleep;
    8 n\" c3 h- G7 L9 ^; u; W
24.   }8 T- L- p- [: q/ E+ E7 K% H' ~$ X
    
25.   if (GetAsyncKeyState(0x20))
    4 Q& y: S6 N6 Y, x* y, j( r
26.   {
    $ l2 i/ D2 C9 l
27.     player_sleep = l + 5;6 ~5 ]% e9 C; G1 ]4 d$ z/ y
    
28.   }
    . B, D$ S3 ?& q6 T
29.   else
    : s% c3 ~# A% P; i% g# d8 L7 l# N
30.   {' K6 C& L! x8 u* D- b8 {
    
31.     player_sleep = l;
    ; E, T. E9 W. F, \2 U* F, l$ K
32.   }' \0 a; Z# ?% P3 L+ V' ], x
    
33. }

复制代码

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

1. void Show()5 |6 Y+ H; B( y% ^) |
   
2. {
   4 @% b. Z, r7 b! d: x4 F2 Y
3.   0 x8 m& }1 H; q- n\" W& f) a2 t
   
4.   //设置地图
   ) X, C3 p: p1 o0 Q. u; [
5.   SetWorkingImage(&map);
   0 }' z& h4 C: k
6.   //清屏6 y5 E8 J* ]* t& G
   
7.   cleardevice();
     C\" P3 z\" K' u2 ^. D/ ~# a, A2 t
8.   //背景颜色
   \" G# n! ^- U+ q
9.   setbkcolor(WHITE);5 s. ^# L$ l# v& H+ J
   
10.   //划线颜色3 j. g. d: r+ `3 ~0 s  m
    
11.   setlinecolor(RGB(230,231,239));
    $ U' N- _9 n  H  @! _
12.   //划线3 I6 U\" F9 ]* @1 r7 m- g
    
13.   for (int i = 0; i < Wide_map; i += 10)
    7 N3 u  Q6 V$ z
14.   {\" w1 G) s8 O\" P\" W& f5 a. W9 Y
    
15.     line(i, 0, i, Hight_map);- \1 V7 l3 c0 r. P  R# p' v
    
16.   }6 \5 ~2 {; {/ G( U
    
17.   for (int i = 0; i < Hight_map; i += 10)
    ( w7 b3 y3 L7 d* u; L
18.   {
    & H; Y, f4 E9 u- r* A  v8 d+ s2 a& K
19.     line(0, i, Wide_map, i);
    + w5 X\" P$ y9 z$ L7 {% j3 W/ ^# q
20.   }$ g: N+ `6 q2 r0 \# Q
    
21.   //食物
    9 W1 W\" l# `5 d+ S& ^5 H2 N% j
22.   for (int i = 0; i < Food_num; i++)\" s. n3 k. [; M+ {7 v# a/ {( W
    
23.   {5 T% d2 @( l( y* d+ `( n/ q. ]
    
24.     setfillcolor(Food[i].color);+ \) ]2 A6 |$ q; S2 Y
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);; L) F4 P6 W+ a- }. j! }
    
26.   }
    8 R- f& b  d: G; R2 \
27.   //敌人0 V4 L: I, ]4 d0 s/ X7 v8 I\" f
    
28.   for (int i = 0; i < Enemy_num; i++)2 i+ p' @, C4 `, {
    
29.   {/ f' Q! Q* H. z9 j& H- a9 i- k
    
30.     setfillcolor(Enemy[i].color);
    & k% W* P1 |. n
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);8 h& t- O) [* \1 k. ]
    
32.   }) [\" G! @# u' T4 p* w3 ?
    
33.   //玩家, D' K2 w- @\" k, G3 C9 Y
    
34.   setfillcolor(RED);) @2 ~9 U( a5 E0 S; W2 G0 `) |2 L4 j/ q! n
    
35.   solidcircle(player.x, player.y, player.r);
    4 k( O& {0 _; S  K& g5 j
36.   SetWorkingImage();
    + s3 C: {$ g; F/ c1 e0 i
37. : }6 o6 Q: f2 G3 u2 ]
    
38.   int x = player.x - (Wide / 2);
    \" S1 w6 ?7 N5 g8 S# L1 k
39.   int y = player.y - (Hight / 2);
    9 k5 f+ S7 \& g. I
40.   //防止窗口越界4 \  f% ^/ z( y
    
41.   if (x < 0)3 U: n2 k* t& h0 Y1 O( A( a0 ?
    
42.   {  _4 ^# e; P3 l1 _) K
    
43.     x = 0;
    ! y6 R& y7 k4 O9 s% L  ?
44.   }$ t9 b; m$ S/ L. a. N, @8 t  `
    
45.   if (y < 0)* x+ J* v( R1 Q6 G
    
46.   {
    4 M' i8 o5 J  s! o4 H. l. H. ^
47.     y = 0;
    8 F\" e, X# g: c4 k# b
48.   }# M- i- b& x! T7 J\" O
    
49.   if (x > Wide_map - Wide)
    1 ~! h# o. s9 Q5 u4 w7 u
50.   {% ]$ t/ x1 f- N
    
51.     x = Wide_map - Wide;
    / ?# M# y. O, d, S8 u; k9 x
52.   }* `) r- F9 l7 d+ p* ~) N, u
    
53.   if (y > Hight_map - Hight)( |9 u\" i5 O$ R# M- x
    
54.   {
    : M% I6 e' D! Y. d
55.     y = Hight_map - Hight;
    , L% T2 R5 [% t+ ^5 ?. ?  ?
56.   }
    ; z5 @0 }; s* j
57.   //把map输出到窗口上4 q! D2 I; N. @, d1 B
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);6 n5 T' k\" Z9 N# m0 H
    
59. }

复制代码

5. 生成地图
) P0 h7 t, q& \5 h可以使用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. //防止窗口越界* D: I; z; v8 v; s) k' ?\" ~
   
2. if (x < 0); c; I2 C5 i# _+ n2 |: p. z9 ?
   
3. {9 R8 j  X. a7 P+ H
   
4.   x = 0;
   0 t4 V& d& Z, O0 i
5. }
   . H2 u; L  N9 r# C% K, \\" S
6. if (y < 0)\" |. s# B, l1 v
   
7. {
   , @6 B# }$ c( F7 r' K! H/ }0 \
8.   y = 0;: R0 J+ \, K\" {3 k# H\" A
   
9. }
   % w% G: [; z4 u0 ~- O4 Q
10. if (x > Wide_map - Wide)+ M7 H2 J7 [, f
    
11. {
    : @3 c  [( |! K& |/ R, L4 P+ l
12.   x = Wide_map - Wide;* Y4 R7 C' D' ^7 F
    
13. }' ?0 E) j; U& f! s3 r
    
14. if (y > Hight_map - Hight)# P' ^& w\" F5 _
    
15. {
    : c, @  G! T- c7 N% K
16.   y = Hight_map - Hight;% @7 D\" T% g& }4 H: U% y
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
6 h5 P3 f+ d2 {4 A# f. {$ t  g
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

& M, p+ N- `# k5 o- z( _Wide：这个参数指定了要绘制的图像的宽度。

8 ^" _- D+ p9 |! _& H( Q' ~5 lHight：这个参数指定了要绘制的图像的高度。
' N; x* B: W- F5 K0 g
+ t" R: O, `# ?& E- ~&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
8 w0 g* h3 C$ d  A: x% Q
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
9 m' i6 f# V5 F' H% k
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
: R" s" |" S, v* |1 v+ X2 h6. ai小球的移动
( r1 `+ `( z$ P% d  c7 O随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   4 L: @& Y% j: P
2. int Distance(int x, int y, int x1, int y1): A; \& I7 h6 P) A& e7 B
   
3. {
   ' |\" D- W$ Y8 c3 U  k' V* _
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   9 U# n5 T' [* q$ I
5. }

复制代码

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

1. void Enemy_move()6 j, B0 a8 V# j* @
   
2. {; _$ `4 a# r- B$ G' _
   
3.   srand((unsigned)time(NULL));
   ) \9 p$ t0 _) n% e0 L
4.   for (int i = 0; i < Enemy_num; i++)
   $ k/ c4 ]# }: y0 G/ @( Z
5.   {
   $ ?1 q/ `8 L9 S! [! u* |' q7 Y/ s+ M
6.     int direction = rand() % 4;
   % `0 x% r) ]1 {! A- h\" {: t
7. 
   ( s  w\" c' p7 ?7 N0 C) m- b
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   2 |+ K+ L9 r. P$ T# {/ o
9.     {
   + n$ p) d$ u: w; w: ?\" @( ?6 E
10.       if (direction == 0)9 ]1 d\" _8 p0 g) C5 |8 s
    
11.       {3 O' ~8 T, v. v; B- H
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句; f+ S$ q) f2 C2 Q
    
13.         {
    , Z& b+ Z) c, S$ N
14.           Enemy[i].y -= enemy_sleep;2 M/ O* ^( Q3 V8 x2 @* ^# P
    
15.         }9 H+ ?6 e% r3 M! v
    
16.       }- k6 X0 W% j& _
    
17.       if (direction == 1)
    2 B  ?9 o* h8 |# R/ x5 ^! ?3 ~
18.       {
    ( z7 K5 f# ~6 v. {2 H
19.         if (Enemy[i].y < Hight_map)
    2 ~7 a* R% x3 U9 L! a7 f0 n0 X) k% z2 N1 d
20.           Enemy[i].y += enemy_sleep;- w& s% @6 \\" h, c' O4 B7 C
    
21.       }- x. p8 T; v5 \* {+ ^
    
22.       if (direction == 2). W# W( b: n* |+ S
    
23.       {
    , Q\" M3 G\" [9 @# O2 R\" J
24.         if (Enemy[i].x > 0)
    ) D\" F! E& `7 r
25.           Enemy[i].x -= enemy_sleep;8 J; l0 a' b9 C; R
    
26.       }
    $ J5 n4 |8 {5 l1 j9 g7 j
27.       if (direction == 3)
    % z, p7 W0 i; N  q$ J
28.       {
    1 e0 }, @+ K6 w( l! X8 z) j7 K
29.         if (Enemy[i].x < Wide_map)2 R$ d$ ^8 P6 x0 N1 q- f
    
30.           Enemy[i].x += enemy_sleep;; z% a4 p% E3 o\" j
    
31.       }\" E# i+ `; f7 w: l: K8 m3 u
    
32.     }+ K  t, Z, c9 o3 N# j! f( }
    
33.     //敌人追击玩家
    ( h/ ]- R- P9 U8 }6 q' ]
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
      H/ D- ]5 [( Y\" s\" t8 M+ V) ^
35.     {* G) P* E; b2 \$ c
    
36.       if (Enemy[i].r > player.r)& J# m4 I; F6 ?2 h2 O, @
    
37.       {
    6 L* F4 z$ k8 G, o& q
38.         if (Enemy[i].x < player.x)) F1 k\" a# M, N/ f
    
39.         {: x  `6 x4 ~8 l\" v
    
40.           if (Enemy[i].x < Wide_map)
    2 \, k2 M' D# z9 y
41.           {
    : o  Z* Z+ j6 w4 w
42.             Enemy[i].x += enemy_sleep;  C( {$ ?4 @2 U  I% v9 \7 a, o/ ^
    
43.           }
    4 a  J! `+ J6 g3 a, d/ w0 [
44.         }- n9 g, w7 {5 W! c6 ^
    
45.         if (Enemy[i].x > player.x)+ k; S: P: R+ h6 D
    
46.         {
    6 }. }* G! {$ s, u: j
47.           if (Enemy[i].x > 0)
    , n4 O$ L2 P3 a4 L% f) J' `# {' A
48.           {
    # n$ u. }' n. ]1 w
49.             Enemy[i].x -= enemy_sleep;: U$ o( m& ]+ ^% E, [* L8 [: k
    
50.           }
    . Q  {/ h# J, ], N
51.         }# F# I( Z$ p: N! G. K
    
52.         if (Enemy[i].y < player.y)
    9 t5 L: d9 h6 m4 A/ D9 W
53.         {) o. n4 \4 ^# L2 o7 `
    
54.           if (Enemy[i].y < Hight_map)
    6 q' k) Y6 m5 w
55.           {
    1 S/ W; e: p- b$ |4 N
56.             Enemy[i].y += enemy_sleep;\" Z$ l! B- x) ^! x& Q% [3 r% Q! Z4 o
    
57.           }
    ' N0 V9 |5 s% {( s3 @5 j
58.         }
    : B; d0 V2 q5 }5 [
59.         if (Enemy[i].y > player.y)* @+ @. N' ~& ~) G+ S- e
    
60.         {
    9 K! X. r, l' O\" w! |! g  `
61.           if (Enemy[i].y > 0)4 V# N. g# K1 Q7 n. F
    
62.           {
    7 B! j6 n, x; h, @8 ^
63.             Enemy[i].y -= enemy_sleep;9 [3 o* g$ r; p& k* m
    
64.           }- m: T6 c( L/ K+ S9 M
    
65.         }7 P; u0 i1 K/ H% a. j5 l
    
66.       }/ x/ a$ x( o1 b/ D\" \& ?9 t; M
    
67.       //敌人逃跑' B- O\" h$ j- }8 k- ~9 \
    
68.       else
      i  x! s! b# c3 R+ a
69.       {
      I6 G3 L  P9 W: S8 w+ y7 W
70.         if (Enemy[i].x < player.x)* ]: K4 H0 i# E  i0 t6 j0 w: [/ I
    
71.         {
    \" h% B* `\" g\" J  k
72.           if (Enemy[i].x > 0); P/ ?9 I/ S) {6 t- @* s5 w\" l0 I8 I
    
73.           {
    + C8 g, m- s* z5 C\" s\" z% i
74.             Enemy[i].x -= enemy_sleep;
      e0 c, k) h8 k: }, X% K0 `8 ^
75.           }
    : f* i  s9 d5 V
76.         }
    / Q: o# f. y. ^2 S6 m' k) i+ e
77.         if (Enemy[i].x > player.x)
    . ~' ~& `# o# |/ D  [
78.         {& y: L% k\" _# o2 V8 o1 v
    
79.           if (Enemy[i].x < Wide_map)
    1 f; M6 o% E( }\" V; _
80.           {
    6 R. J  Z( Y. t8 D! G
81.             Enemy[i].x += enemy_sleep;; x* s2 Z+ g\" G
    
82.           }3 C& C* O& }8 t: P\" h5 ^
    
83.         }
    ; t9 P, T; u* F9 ^! d
84.         if (Enemy[i].y < player.y)
    4 |& r+ _2 w' y
85.         {5 }& [* W\" }/ m8 M  I' F# G4 _) p0 d
    
86.           if (Enemy[i].y > 0)
    ! `  x& b  k8 e
87.           {4 s\" ~) `. L+ P+ q6 u
    
88.             Enemy[i].y -= enemy_sleep;8 |$ J: U1 h  F
    
89.           }
    ! V\" a) ?/ Y6 }* ]\" f
90.         }
    6 x+ \4 `5 C2 b! ^
91.         if (Enemy[i].y > player.y)
    * f5 P8 R% p3 `8 U! D0 g
92.         {
    % n8 p& J- S) H+ A
93.           if (Enemy[i].y < Hight_map)
    ( i/ y' N) R) g2 v* l0 Y4 W
94.           {
    ! W2 ]! k8 s  I- c) h3 G2 k; k
95.             Enemy[i].y += enemy_sleep;
    5 y* w/ H\" D* @* Q$ K\" D( ]. g& m
96.           }9 O6 N; k; e1 G2 O8 w' Z7 b8 a$ d
    
97.         }
    % q+ \- }1 C7 n6 `\" t
98.       }
    + ^1 v\" I7 H# ?7 V$ u  V6 S: s
99.     }
    ' O. r4 y. X5 d9 v. |4 G( _
100.   }9 s: ?# ~% F4 I4 c
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   : q1 A1 {0 r7 j3 O2 s# P0 ^
2. {' K1 z% _) _( d4 h( L- m
   
3.   for (int i = 0; i < Food_num; i++)* R4 z3 F, p\" d# r9 m- a' _, _; I
   
4.   {
     W! e\" l$ a3 t2 s4 X! K4 L
5.     //玩家吃食物
   * c\" C6 H, f/ V1 R) [3 x
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)4 O4 j* c6 q) p  [3 u7 G- F% C
   
7.     {
   : Y/ S. M7 i1 C- ?! X/ N\" C
8.       player.r += Food[i].r / 100;  `0 M  E  t/ @\" z. ?8 }8 |& h- r
   
9.       Food[i].x = rand() % Wide_map;
   7 r$ K2 W0 j: h0 I* N  W, X\" f
10.       Food[i].y = rand() % Hight_map;! g8 G3 m- q2 M+ @$ W8 z/ c
    
11.       Food[i].r = rand() % 5 + 1;
    * {% b& s! H& J4 y; J7 j- }
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    & n7 K6 t% k\" U2 K9 i
13.     }3 z% l- ?1 n4 D* [. E. J9 u1 n2 Y
    
14.     9 i. k- X\" d, y* `8 Z) z
    
15.   }
    7 T$ ?6 x2 o1 W
16.   for (int j = 0; j < Enemy_num; j++)
    5 U, |0 T( y# `0 x1 |
17.   {1 F) b, G1 j# z: D. x  v
    
18.     //敌人吃食物' M& D- B8 h! Z$ k4 m& v% C0 h) Y3 I
    
19.     for (int i = 0; i < Food_num; i++)$ |\" [, X0 H& P. v' a3 j
    
20.     {
    7 i* a% ~6 N4 n- ]+ |
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    0 L- @\" q- r+ w- Y
22.       {
    ( ^, |& P; ^! c# u7 {3 E) U$ ^9 r
23.         Enemy[j].r += Food[i].r / 50;- j2 F# G/ V0 i1 ^0 }& v
    
24.         Food[i].x = rand() % Wide_map;
    9 z* m+ z0 i3 U- N- ]+ i* ^! V
25.         Food[i].y = rand() % Hight_map;
    6 I0 N% S' u9 @  J
26.         Food[i].r = rand() % 5 + 1;( d, i3 K  ~( u) d5 f, k3 ?7 ?
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);; s5 j' S) d0 W! E  Z  o
    
28.       }
    2 x7 Z$ Y3 r- Y
29.     }
    1 _9 J$ `1 W; r  M0 E
30.     //敌人吃敌人6 b+ ?5 R8 b1 h
    
31.     for (int i = 0; i < Enemy_num; i++)/ p- j( M9 a$ k1 `( C# n* W' J
    
32.     {
    ' x& i. b/ l* ^; G* Z
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    0 U) x; ~, E- ~1 F- ]
34.       {
    8 C! @) s  ^  s. I# ^) ?. b
35.         Enemy[j].r += Enemy[i].r / 10;
    . U0 @; ~# T  [7 z\" N\" u
36.         Enemy[i].x = rand() % Wide_map;2 q/ y1 m' y4 L' e, `
    
37.         Enemy[i].y = rand() % Hight_map;
    # T- G* ?# a3 ~) n\" o
38.         Enemy[i].r = 10;
    5 v0 j$ t% s\" e+ ~\" f8 _
39.           Enemy[i].color = RGB(0, 255, 0);! a7 A, U, p8 {! R
    
40.       }3 p; i7 w4 o9 j9 m5 b2 T
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)* s4 R7 \! ^! J. M  P
    
42.       {
    & j. K; V7 w$ R: O
43.         Enemy[i].r += Enemy[j].r / 10;. F8 h  ^! c, V
    
44.         Enemy[j].x = rand() % Wide_map;5 i3 l# e& I% N9 E% T
    
45.         Enemy[j].y = rand() % Hight_map;
    : {. h$ M! K) c4 B9 ~
46.         Enemy[j].r = 10;
    , e* y: H- o8 G1 t+ y, A
47.         Enemy[j].color = RGB(0, 255, 0);
    % Z+ m2 t3 u& S$ Y6 j
48.       }' ~) ?. w6 K' T, `
    
49.     }
    # S) a3 {' m# [! W6 {% U
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)) s. F\" ]8 S2 D: ^' _  T+ O3 T
    
51.     {# n+ R5 L; h0 Z8 z1 i% W
    
52.       //玩家吃敌人
    9 Z7 M5 t% j) ~7 }1 }
53.       if (player.r > Enemy[j].r)# s3 v1 h) N& }
    
54.       {
    ( U2 h; @0 b, `: X( y; A
55.         player.r += Enemy[j].r / 10;+ b+ I& H+ o, Z& q+ r
    
56.         Enemy[j].x = rand() % Wide_map;4 G% l, x1 p% V( t, v- I' o% X
    
57.         Enemy[j].y = rand() % Hight_map;
    , Z1 s3 P9 ]. q5 s: i, |% E3 X6 V
58.         Enemy[j].r = 10;
    ; [( z- r, Q\" j. B
59.         Enemy[j].color = RGB(0, 255, 0);3 P, \, \) Z! B1 R
    
60.       }7 ]: G% Y+ Z7 z9 E4 W' q5 A. N) g/ z
    
61.       //敌人吃玩家
    4 \. z) T# u# Z
62.       else5 b( N: X) {, R3 D5 U
    
63.       {
    . R! q( o) F( t6 g( p\" t3 B2 U/ F: y
64.         if (invincibility == 0)' D4 Y2 J$ k+ t( R  H& ~
    
65.         {
    : G3 i, `% W+ m/ Z/ b% h  B  s* K& w
66.           Enemy[j].r += player.r / 10;\" U/ m; n* {. Y1 ^4 U\" c+ Y
    
67.           player.x = Wide / 2;, N! J$ Q0 W% h6 Y
    
68.           player.y = Hight / 2;( _4 e! G1 C+ V& Q$ a* V6 f  i
    
69.           player.r = 10;
    * c5 Z# y* b1 c
70.           invincibility = 10;) v( |. N% [! {\" M
    
71.         }3 H4 [2 L# q' o0 r/ Q
    
72.       }
    4 @$ ?& V, K9 g3 ~
73.     }% ?) K6 `) J1 Q6 ^' f  J9 M* Z
    
74.   }
    ) C4 F2 n8 W- @9 c% R
75. }

复制代码

完整代码见附件：

) o% K1 |" Q9 E: h2 _
# O, I2 ?2 n" U, Z. F