球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
6 z5 N8 e/ p8 l; F- f
' m8 O- _& Y4 v, l& s3 z+ w在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
/ n8 }6 F! w3 ]/ ^8 f
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
0 k. b# e( I2 E+ c) l8 k! ?% w. x+ ]6 c
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
+ W4 ?4 ]. S  L. Q
! p2 s8 `% b# Z体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
+ R: k8 K. X. a0 E/ P7 y
. l. f' y% [; ]. t  i& ?2 K玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

: p( _: l3 t3 l接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。
+ x9 ?; X  v9 X) Q8 S; e8 w+ G7 f
; \/ z3 ^- K( i5 O1 q* h. B7 d' l9 I2 C处理键盘输入，实现玩家小球的移动和加速。

生成足够数量的食物小球。

7 _) o- X% h& y生成ai小球，并控制其移动。
# q3 ^( z/ ?" F6 `6 S! b2 O
9 y  B7 E8 U+ b0 M检测小球之间的吞噬关系，增加相应的体积。

9 G! h+ T: k  x  b通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
* g- D! b4 ]7 W
1. 小球的要素
( F  a- ^- [8 i: k$ P4 S# n* n在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

struct Ball
% u2 Z. s! V1 a{
        int x;
$ l2 {, T# G2 v        int y;
* {0 G: V- _' U: u- {- K1 a7 }        float r;
        DWORD color;
};
2. 初始化小球的信息
- I- O8 V* P# S) t: m3 K* b将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

橙色可以通过RGB值（255, 128, 0）来表示。
" d( E' f' w+ ^  e8 J7 M黄色的RGB值为（255, 255, 0）。
( U9 `- z' a- F8 F; H+ p( h8 H绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
' ^( [6 j! g- O$ n6 N+ E# D紫色可以通过RGB值（170, 0, 255）来表示。
: W- Q8 [1 R% d6 i: H9 p( i黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
. ~; P$ e% |! p7 W灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   ! {# V3 a( F/ |, i8 A
2. {8 a' h0 `) L( T& Z# b! Z! P
   
3.     //玩家小球
   5 l8 [: a. w- u. H; ^2 Z, S9 ?
4.   srand((unsigned)time(NULL));0 ]4 F! r& d8 O* |9 P8 J1 P
   
5.   player.x = Wide / 2;1 K9 H: m\" z+ @) H) n
   
6.   player.y = Hight / 2;\" D0 T$ v/ i\" E/ a: m; Q( h
   
7.   player.r = 10;* q' ]3 H! ]3 j7 L4 w: h6 p
   
8.     //食物小球, f2 o% M- N( z; s  R
   
9.   for (int i = 0; i < Food_num; i++)* l7 A; s0 q6 G2 B7 p# N9 g\" l
   
10.   {2 B7 [# a7 I. o8 c2 Y\" S  w
    
11.     Food[i].x = rand() % Wide_map;
    3 L4 M  o7 z7 [, Q# F' b2 O
12.     Food[i].y = rand() % Hight_map;
    4 ~7 ^4 D  V) P! w
13.     Food[i].r = rand() % 5 + 1;7 s% i. X( Y7 s- h& m  R
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    - a6 n/ Y$ a, [! v
15.   }
    5 g) A5 \. O  B, |
16.     //ai小球8 _$ `# t. C, j$ `# w' ]
    
17.   for (int i = 0; i < Enemy_num; i++)
    * V3 I\" @7 c. O, d- Z7 P; D* M
18.   {
    7 \+ A, Y( u3 O/ o) n4 Z5 |
19.     Enemy[i].x = rand() % Wide_map;
    $ V. Y+ V+ L9 s
20.     Enemy[i].y = rand() % Hight_map;( H+ y3 e; E2 z
    
21.     Enemy[i].r = 10;
    % I! N9 v+ w2 z# w, u: R
22.     Enemy[i].color = RGB(0,255,0);* c0 t) s  _\" h' V
    
23.   }. V- o4 p% l% g
    
24. 
    ; R1 b8 i# \- n: ~; ^9 ]! I0 p
25. }

复制代码

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

1. void Player_move()
   ! m0 A! y8 [\" f* l$ L\" g. G
2. {* \) u0 D4 K! R8 C6 K0 i) U- b  ~+ ^
   
3.   if (GetAsyncKeyState(VK_UP))\" Q# X/ `* M/ C/ U8 U
   
4.   {
   - p0 w: R( U  p. D8 ^. A
5.     if (player.y > 0)4 a8 O' c$ r* ?+ K; H6 d
   
6.     {3 u) q  a9 B! v$ z& U# L, [
   
7.       player.y -= player_sleep;1 y! F8 g6 P: D( p+ C
   
8.     }
   7 t8 r' C+ _+ m: g  |( S
9.   }
   . _+ {& s! z! d8 V  ^
10.   if (GetAsyncKeyState(VK_DOWN))8 v7 ]  X( P+ @# Q7 j: y
    
11.   {
    ) N9 D+ ~8 r$ g9 ?5 x3 D2 l1 S
12.     if (player.y < Hight_map)
    ( g, `4 N& }5 b8 O- c! V: k
13.     player.y += player_sleep;6 W. h! N# v6 D
    
14.   }
    1 |, D; R# V! s
15.   if (GetAsyncKeyState(VK_LEFT))3 n' V: z8 f+ A6 w9 ^
    
16.   {
    7 s1 h( [+ Y! j8 m5 N$ l
17.     if (player.x > 0)
    4 M/ m  q$ j2 u4 X+ ]+ N8 j
18.     player.x -= player_sleep;
    , S  s0 E  o& s9 W1 q, G
19.   }
    ) a/ @+ i. f. k' |
20.   if (GetAsyncKeyState(VK_RIGHT))
    , w/ ~$ x% {+ j\" a
21.   {* R) }$ b2 g/ {% j* {2 |
    
22.     if (player.x < Wide_map)
    0 K% }7 A* J/ [, r8 `5 X8 h+ F
23.     player.x += player_sleep;+ F$ w/ }2 b. U, X
    
24.   }
    ; N2 R& W9 s& X* F
25.   if (GetAsyncKeyState(0x20)): O; O9 m7 E( h- r* g
    
26.   {; N  p2 @3 _0 v\" f; }
    
27.     player_sleep = l + 5;/ g: K5 r- u\" Z) k/ @) c5 d
    
28.   }
    % Z* c9 X  I! ^, u: w! `\" O, K
29.   else. ]# m\" m+ P: ^( U# h1 Y. R
    
30.   {. A9 A* s# Z! ?% j
    
31.     player_sleep = l;
    9 |  z0 e3 i  @! S2 H
32.   }$ c5 @# e5 V: Q
    
33. }

复制代码

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

1. void Show()
     }9 m! ~/ U% U8 W/ J
2. {2 Q7 j+ P( y+ l5 v4 p) j
   
3.   
   + _& X7 X: _\" n\" C5 g$ `
4.   //设置地图
   . I( L' T\" c6 H  |2 ~: Q. S
5.   SetWorkingImage(&map);3 y8 K) K8 v+ |& {
   
6.   //清屏
   2 l$ L8 z! D3 [
7.   cleardevice();  _% f$ [9 `6 q. N3 J1 z
   
8.   //背景颜色
   % \+ N) f1 B( J
9.   setbkcolor(WHITE);
   ( t3 @0 p2 G: i* Y8 I3 e
10.   //划线颜色% B) I6 K5 \+ L9 b, C% t3 E
    
11.   setlinecolor(RGB(230,231,239));
    2 C' o( f: H, c, u* l3 N
12.   //划线
      b+ f' C- ~\" I( U' d4 l- r
13.   for (int i = 0; i < Wide_map; i += 10)
    + P- d0 _5 X8 m! ~! o3 _
14.   {. n5 C2 x6 P' g1 l: G, p) }! `\" r/ C
    
15.     line(i, 0, i, Hight_map);/ r6 u/ u+ k9 b9 i
    
16.   }
    ) Y& \/ W/ J; [( P/ X8 X0 m
17.   for (int i = 0; i < Hight_map; i += 10)
    & O2 C, a' r6 R0 {& t1 C
18.   {0 Z4 u4 e3 K! }, ?
    
19.     line(0, i, Wide_map, i);
    ) C6 o0 [/ J. ~( m5 \
20.   }
    0 p1 V- y& D+ w, _6 W! a0 D
21.   //食物
    7 q: L\" H) g! R/ M6 t7 {/ B. B\" ^# z
22.   for (int i = 0; i < Food_num; i++)* F$ u( k2 u' v( a- e; q) ?/ A
    
23.   {
    ( F+ s4 x, N% c! K+ t7 a6 D/ L
24.     setfillcolor(Food[i].color);0 V7 K$ n( n: K0 I2 S4 r
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);% F+ m8 O! q+ }% V# X
    
26.   }4 X7 l0 L( u/ c: r* r
    
27.   //敌人. G* x$ f& I1 ^$ K
    
28.   for (int i = 0; i < Enemy_num; i++)6 K9 a( y1 b9 o! n. i$ [
    
29.   {
    0 h- g4 u  U  n9 A2 W
30.     setfillcolor(Enemy[i].color);1 q9 q9 u/ f5 m
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);4 v1 E5 T! x' v. f* O/ B
    
32.   }
    6 f. k# t( K' g6 i# `3 R
33.   //玩家1 B, |' m8 c4 {0 v9 ~# J! A
    
34.   setfillcolor(RED);
    , a! z5 ?8 F7 `) m$ E
35.   solidcircle(player.x, player.y, player.r);, J2 u\" E( c% d+ S3 e7 S% I% L2 V
    
36.   SetWorkingImage();, n% d5 w' Z( B6 D
    
37. 
    0 v& f4 C, m7 Y\" l$ x2 i
38.   int x = player.x - (Wide / 2);2 I3 Q; O% r5 T+ r2 T8 \. K
    
39.   int y = player.y - (Hight / 2);
    \" P) y/ P8 _9 s1 j; [. l
40.   //防止窗口越界
    7 D, q# N# s! o( w
41.   if (x < 0)
    & G\" ]# g9 D1 N
42.   {- L2 h) i, z+ ]; f% H\" G
    
43.     x = 0;\" k7 ?: c7 g% u. `; X
    
44.   }
    6 _  K9 }+ M( M9 F
45.   if (y < 0)
    9 S$ X& d; f2 o8 c6 ^; c
46.   {0 i7 _  I; z* {1 N- d* k/ c
    
47.     y = 0;, w. w  U* f  ~2 f+ Y, B
    
48.   }
      G( a+ ?9 f) Q
49.   if (x > Wide_map - Wide)/ v  j/ y  Y\" D( B+ M# x! X- ^
    
50.   {
    : y/ `\" r- B1 s0 U% V8 B
51.     x = Wide_map - Wide;
    * T6 J  ]2 r0 n) r
52.   }
    4 c4 W* K3 j+ x0 A
53.   if (y > Hight_map - Hight)
    6 \% R2 h4 V$ {$ k  ^( S, I
54.   {& P\" g( k% n  J6 x1 N
    
55.     y = Hight_map - Hight;# r- _9 Y( Z) I/ P- p
    
56.   }$ N0 F5 e+ W2 [1 d: p% V
    
57.   //把map输出到窗口上# F3 ?) O* F* C1 V2 U+ q& z
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);/ n/ g\" O$ R+ u) O3 w
    
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. //防止窗口越界& y& B' `) s& r- n
   
2. if (x < 0)
   1 b* H) F' e% S
3. {3 i1 t, H+ s5 x. g! O9 ?$ F, b% _* f
   
4.   x = 0;# e+ x! f# E( p
   
5. }2 w( M$ {1 C: {: T/ h
   
6. if (y < 0)
   6 {1 [- ~\" k1 J( H/ d3 ~( [
7. {
   # ]; A! ~2 p* E/ h# Q
8.   y = 0;- l; Q8 b1 o# y
   
9. }
   ; W1 F. Q* Q/ i
10. if (x > Wide_map - Wide)
    + l: i' X: h3 X# ]9 q, e, x
11. {( V& F\" X3 ~4 n! r  b
    
12.   x = Wide_map - Wide;7 L- E# W- c  |* h! F: Z
    
13. }/ P! Q4 k& L\" P. L+ K
    
14. if (y > Hight_map - Hight)! D1 ^6 h5 Z+ V) o
    
15. {
    \" v, Y\" ?, Q! j8 Y8 j$ v2 d; m( @
16.   y = Hight_map - Hight;
    5 `1 |2 m& F; Y+ r\" ]; m( \6 o4 {
17. }

复制代码

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

- Z) y% O/ X) s. m, H( s' @( Q(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

7 @7 }/ j/ i2 L+ pWide：这个参数指定了要绘制的图像的宽度。
, Q' `8 J+ k: M6 p' e  q3 D
Hight：这个参数指定了要绘制的图像的高度。
" E* j* r- l! j% J% w- f/ h
# P  j& Z. z" m- L2 q&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

7 A9 V9 @" N9 ^- Y  w  v: Vx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离. h. W) Z% n% R) D4 c
   
2. int Distance(int x, int y, int x1, int y1)
   : s\" t( u8 k- p' n5 C8 j
3. {+ [2 p, `2 i$ X! y# Z& P; n
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));0 j1 c6 C* J* U
   
5. }

复制代码

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

1. void Enemy_move()
   3 s7 F* H: p* G( o: g; ~
2. {' j/ I4 m' H9 k3 q
   
3.   srand((unsigned)time(NULL));1 j% W  ]5 c& }$ s  D
   
4.   for (int i = 0; i < Enemy_num; i++)  `9 y/ z; u8 i4 ]8 H7 g
   
5.   {
   4 j! z# N/ y% Q% s$ h
6.     int direction = rand() % 4;% d6 u: ^) c. e  ~# x+ r5 G! Y
   
7. , g, L3 E6 O- g9 H) Y
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   0 E3 Y9 r8 F  v* J0 |
9.     {# O9 e4 a* \* i0 j. w( b
   
10.       if (direction == 0)) q# o4 R5 K2 `  R$ ^9 p/ n# J+ z
    
11.       {; w' k+ a& F2 r4 m6 C  S* `6 L
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句- ?, ~; }. ^) y4 f- W
    
13.         {
    ; T- w/ ?* e: t) v! o\" U
14.           Enemy[i].y -= enemy_sleep;& J6 C2 ~3 p. m' Y
    
15.         }$ n6 q5 K5 X' ?3 Z) ^
    
16.       }
    $ q9 \% N. t- ]\" ?; v* e
17.       if (direction == 1)
    ( L5 z& c+ G) h\" a/ p: d
18.       {: A, \+ D+ S9 O) u1 {\" G  }$ ?4 o
    
19.         if (Enemy[i].y < Hight_map)
    $ }4 j+ ?* C. T% R# U
20.           Enemy[i].y += enemy_sleep;
    & \\" `3 @7 H+ o6 c, ]/ T
21.       }+ n3 u! {2 y# x\" Y
    
22.       if (direction == 2)- `4 G2 T: u1 {3 p
    
23.       {
    5 ^7 x3 G1 n0 Q# l
24.         if (Enemy[i].x > 0)
    + L\" g4 [0 {+ A. H) }3 u& o
25.           Enemy[i].x -= enemy_sleep;& `( a8 @2 E8 T' G2 c! L
    
26.       }( b! {! `4 \: G% ]1 B6 n: Z; F
    
27.       if (direction == 3)) \, p3 T; l$ t- ?' Y1 i7 v8 K1 _' h8 r
    
28.       {) @: F4 ?7 w9 k. H+ S7 ?
    
29.         if (Enemy[i].x < Wide_map): w( |1 b8 ~! U/ J) \5 \# s( j
    
30.           Enemy[i].x += enemy_sleep;
    ! P+ w) V\" e7 b# y5 W. i
31.       }
    0 `  h5 ~) O7 a! F$ W9 G; \
32.     }
    - Q: ^& s9 z: n: b8 V) ^1 I
33.     //敌人追击玩家, b; m3 U2 Z5 [\" i2 U
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)6 c' k+ x' T3 R4 P% `5 R% @
    
35.     {' p0 d/ F# e5 r) r7 F) b
    
36.       if (Enemy[i].r > player.r)! ?! i% H- B& X6 w
    
37.       {' g3 k' }* Z; n0 y4 a
    
38.         if (Enemy[i].x < player.x)2 k' O7 E0 d# y
    
39.         {
    \" `! p! ~1 Q1 p
40.           if (Enemy[i].x < Wide_map)
      N/ t+ O4 d' {* ]% `5 |0 e
41.           {
    - X\" Z6 O, S8 S$ ?3 S8 b/ h
42.             Enemy[i].x += enemy_sleep;
    5 m% L8 s' \  e
43.           }
    3 `( t! r5 y' k% p/ d! y
44.         }
    / V, Q, O) p) Q8 e6 n! A
45.         if (Enemy[i].x > player.x)' M& k  z6 _3 Z# v- E
    
46.         {
    , s8 K$ Q1 e0 D7 d2 w$ B7 ~
47.           if (Enemy[i].x > 0)( c3 x: ]# H% }- o3 F) A% \# \  b/ `
    
48.           {7 V# Z! M: }  s! c  O4 A0 U+ ~
    
49.             Enemy[i].x -= enemy_sleep;
    * i$ k: Q\" Q$ N0 m) @\" x  q
50.           }
    ; S9 [+ A. l& l# j5 a$ S* }  ~6 H
51.         }# ~) h\" `/ u* u/ ?6 U; a5 g! f
    
52.         if (Enemy[i].y < player.y)
      y( T8 V7 h8 C
53.         {+ P# U6 X! v4 X. ~/ Z$ X
    
54.           if (Enemy[i].y < Hight_map)
    + d# @( i0 e# z
55.           {
    5 }/ J6 b) ?5 P\" J/ |6 m
56.             Enemy[i].y += enemy_sleep;4 E1 l. B, Z* D2 c0 j2 n
    
57.           }
    ( U/ m' y8 _* G- I6 ]2 w
58.         }) |; Q6 K: \$ Z( v/ r2 S1 _- |
    
59.         if (Enemy[i].y > player.y): t6 H8 f' k2 w0 Q; O3 ?
    
60.         {( \; |3 f9 p) ?9 D
    
61.           if (Enemy[i].y > 0); U) E) M; N, d\" e& u% t
    
62.           {/ ~1 s% n; ^; B! f- R
    
63.             Enemy[i].y -= enemy_sleep;! r; s  Y* @\" ~8 x
    
64.           }
    . R7 b, z1 e9 J! ^7 @/ X! J
65.         }
    ! N& G' Q* }( M' |
66.       }
    2 c% a7 b* ]; P2 _
67.       //敌人逃跑
    - V, Z1 ~\" P% U2 g4 [' _) n0 r
68.       else0 r- J( w- }& p/ {
    
69.       {\" h8 p, p: R7 }  M5 c0 ]1 o. K
    
70.         if (Enemy[i].x < player.x)
    . q8 ^3 j& ^! G+ i5 d
71.         {5 J; e9 a7 h. k\" C7 {# G+ C
    
72.           if (Enemy[i].x > 0)
    . k4 Q; L) V8 b0 R: P8 W
73.           {
    , R$ ^* P% d6 l; \; `
74.             Enemy[i].x -= enemy_sleep;7 d7 Z* h3 X2 i
    
75.           }
    - i8 a# t\" X$ Y% J! j+ ?
76.         }
    7 w3 [# [# d% v' e0 D- O5 C% s0 v- u
77.         if (Enemy[i].x > player.x)1 Q& r7 L7 K3 v. I# a; `
    
78.         {\" m4 T4 c1 G9 W/ E
    
79.           if (Enemy[i].x < Wide_map)+ E& D8 k2 \5 [& m+ u
    
80.           {8 T' M0 V  T\" v0 y6 `# `! Z
    
81.             Enemy[i].x += enemy_sleep;% O8 d\" u. b\" X9 U, I  ]
    
82.           }
    5 v0 s7 H6 _! e. j4 Y6 g
83.         }
    ! _7 l# A7 I' {( D
84.         if (Enemy[i].y < player.y)4 E8 i0 i% t2 M, _
    
85.         {0 |/ X* k4 a: p2 W0 p  R
    
86.           if (Enemy[i].y > 0)
    8 J4 ]/ j! e4 `' j7 _
87.           {
    * k  m9 g4 L& D8 x; t( A7 Z
88.             Enemy[i].y -= enemy_sleep;3 g3 @! ^# n- q# s3 K, g6 o7 N
    
89.           }
    ) b3 I1 J- W2 ]# L. C8 S
90.         }4 c6 z, W2 P! g5 b, X
    
91.         if (Enemy[i].y > player.y)
    2 F7 J5 H# c: `2 d1 g: ~5 O0 e
92.         {
    - |$ {3 L: _3 {0 o: a
93.           if (Enemy[i].y < Hight_map)
    . i% _8 X9 S+ A) m
94.           {7 l  Z. l' P! t  m' `7 a; p% {$ d
    
95.             Enemy[i].y += enemy_sleep;8 k8 W. i' S0 W* |. F4 L3 C
    
96.           }, J8 n% A. ^( v; y2 V7 B* Z9 M
    
97.         }: D# Z% W# ~8 m' B6 o+ C: ~
    
98.       }1 ?$ Z8 B( ]8 a2 C5 V, c
    
99.     }
    3 H) a7 U/ b9 a2 ^+ @7 U
100.   }
     8 c( Y$ `  X8 r/ ?\" A0 k
101. }

复制代码

7. 小球之间的吞噬关系
" n$ V6 Q$ W6 E, r( u* y

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

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

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

1. void EatFood(). w; Q1 M: p. q( U3 W2 D
   
2. {
   * e0 G  e8 U1 }5 i\" B5 ~! _: ?
3.   for (int i = 0; i < Food_num; i++)
   \" J% ]3 Z4 {: t* H8 B! N
4.   {! _+ K9 l0 O: d# a/ f: E0 Z# S( ~
   
5.     //玩家吃食物% c( `\" l2 h& v  a5 Z& Z7 [& p3 M
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)& x9 s2 @/ y; j* y1 |) {# l2 A
   
7.     {
   - z6 A; t7 U; `\" B2 |5 g
8.       player.r += Food[i].r / 100;
   . F: y* {8 f* z
9.       Food[i].x = rand() % Wide_map;4 D\" Y# }' I4 k) }1 z9 d4 }+ C
   
10.       Food[i].y = rand() % Hight_map;- I' Q* D0 f7 V+ l  p* w
    
11.       Food[i].r = rand() % 5 + 1;
    & E, \( @) M9 _7 r7 n/ O
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    2 k# f1 x' s+ m$ G3 U; w' Q
13.     }
    \" n' j' }% d/ l
14.    
    , C+ _: F/ D* M: B
15.   }% k) x( n! }% o; p( }2 g- Y: c
    
16.   for (int j = 0; j < Enemy_num; j++)
    : n4 A\" t7 o3 y* N- Z& E+ a) b4 l
17.   {
    \" X( `: a3 L3 S9 [% K5 T: L0 W6 w- P
18.     //敌人吃食物
    5 ]! X* z+ U) g
19.     for (int i = 0; i < Food_num; i++)6 f/ Z, K% f1 |
    
20.     {
    ; ]: y5 Q1 j/ N
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)! _. j8 O4 Y% `2 x
    
22.       {
    ; i. O! j7 h9 r2 r: }9 [
23.         Enemy[j].r += Food[i].r / 50;
    1 C2 N( v+ N6 G6 N7 x
24.         Food[i].x = rand() % Wide_map;  B6 m/ h/ Q! d! C( u, E) v
    
25.         Food[i].y = rand() % Hight_map;' Y+ P+ O: B/ w9 G
    
26.         Food[i].r = rand() % 5 + 1;$ `\" X' Y1 P- H0 }/ |4 t
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);1 m  R) y! @7 f0 p
    
28.       }6 ?. Z# v0 y1 G5 z# G
    
29.     }5 z/ n* i+ X* n1 C3 Z
    
30.     //敌人吃敌人
    5 O$ n1 I& W- |5 [0 D- R2 [
31.     for (int i = 0; i < Enemy_num; i++)1 m' U+ j; w. X0 b) p
    
32.     {
    7 J2 R0 u' ]6 a  \* ~: F% I
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    1 X4 s! M- T& ]3 C
34.       {
    * K3 {6 N- U8 K# q
35.         Enemy[j].r += Enemy[i].r / 10;: h\" @3 ]+ f9 o
    
36.         Enemy[i].x = rand() % Wide_map;& k' i* A\" Y+ z0 a
    
37.         Enemy[i].y = rand() % Hight_map;4 f4 N, ?5 J9 N7 ^
    
38.         Enemy[i].r = 10;
    - S* Q4 g4 v$ H/ t
39.           Enemy[i].color = RGB(0, 255, 0);
    - c( L8 h- t% q2 y
40.       }
    ( K1 n! S9 [, A4 T% Z
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)7 M0 ~- R) J4 o' Z& l
    
42.       {, X4 D& o, f0 N% `- A$ o0 M
    
43.         Enemy[i].r += Enemy[j].r / 10;5 U- N$ O& M, U$ H: R; a
    
44.         Enemy[j].x = rand() % Wide_map;8 Q$ D2 [, M) D2 d. U: |  U
    
45.         Enemy[j].y = rand() % Hight_map;& |2 w, L7 e+ }, `7 P
    
46.         Enemy[j].r = 10;, `/ m. N3 j' v  b5 n8 c( Y
    
47.         Enemy[j].color = RGB(0, 255, 0);\" k5 q5 j\" \* O0 z
    
48.       }
    - X1 v6 x9 Y: N- _; n3 ~' L, Y: l: ?
49.     }: j1 |; u6 C; C- k7 B1 Z
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)7 k\" R4 k. h) E9 t  L) ?
    
51.     {
    # `8 R: A9 |7 Q5 m2 s  g
52.       //玩家吃敌人1 l$ h+ [) x! I, F% T) S
    
53.       if (player.r > Enemy[j].r)3 J- @& ?1 @7 x& h
    
54.       {, W$ M0 z) E: e: i\" |6 T4 t/ a
    
55.         player.r += Enemy[j].r / 10;
    - ^8 y% c* o1 @! E
56.         Enemy[j].x = rand() % Wide_map;
    + ^+ d1 v$ W8 }; ?
57.         Enemy[j].y = rand() % Hight_map;\" p( R' R6 N- \+ E- g0 d) h( m
    
58.         Enemy[j].r = 10;
    \" m/ X  B4 L( |7 x. b
59.         Enemy[j].color = RGB(0, 255, 0);
    2 y5 K( p7 a4 A2 x7 Z
60.       }
      k, H9 a' L7 J
61.       //敌人吃玩家; b9 U$ k$ `$ S. N
    
62.       else
    % S  {8 E2 r/ h$ G3 W2 C
63.       {# y( Y8 Y& d4 @) I% Q& Q
    
64.         if (invincibility == 0)
    1 p* B) i. M4 c0 B+ S4 i) b% t
65.         {\" j8 t\" n% i4 Y
    
66.           Enemy[j].r += player.r / 10;
    * R1 x' u& a; d3 u1 H
67.           player.x = Wide / 2;
    & H  [/ {! W5 }4 q; j
68.           player.y = Hight / 2;
    ( K% v6 e6 \* w: L9 v0 E
69.           player.r = 10;0 V2 i3 x8 z4 ^4 _
    
70.           invincibility = 10;* F; ~  ^3 o\" C% U0 w
    
71.         }! c1 n0 P- F! ~6 f) D. j( H
    
72.       }
    $ E& |2 m; \8 ?5 Q; i% Q
73.     }
    # Z: j+ s  O' K  X( D* A7 _  v& p' t
74.   }2 ?8 z\" w1 G6 n$ K: i
    
75. }

复制代码

完整代码见附件：

3 c+ C9 P- E, K$ x. z* g
" q, i$ X% W, b( k+ P! F- K