球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
7 y+ H8 }  _6 C1 i8 _
( q+ ~( d7 M1 \2 r在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
$ R4 o9 s0 P& W# L+ j- u1 U
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
) ~6 J8 `" t: t% F
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
  k7 K5 i+ n+ I2 i
+ ?5 e$ E5 ^7 u% u- O其他小球：其他小球又分为食物小球，和ai控制的小球
$ o; c) T3 @: O* I! H5 w
8 M& g/ N* ?- c* ?+ t" q* v体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

0 }4 L9 R7 F+ L$ \5 e玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
3 N0 z' T' z" ]! _) B
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
6 o7 f1 q, Q$ E& }. T
接下来，我们将通过以下几个步骤来实现这个游戏：

: ~% V/ w/ e& o初始化游戏界面和小球的信息。
0 p2 z& @+ F" S. l
处理键盘输入，实现玩家小球的移动和加速。
4 l' a' M/ L6 q
生成足够数量的食物小球。
6 X+ k+ k6 z" x. k+ C' m
' @1 d- O+ k4 `1 s  L生成ai小球，并控制其移动。
+ j; H, _1 D) m; M* ^; Q5 b
检测小球之间的吞噬关系，增加相应的体积。

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

+ W/ P+ M" n& x. D6 S1. 小球的要素
* E8 B1 ?6 T2 b# z6 b" z% O0 G0 t/ q; q在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

struct Ball
{
        int x;
        int y;
2 H9 T* q. |/ A! e8 z( m        float r;
        DWORD color;
};
" d" x. M# f# o5 t: Y% _1 ~2. 初始化小球的信息
/ ^) A' j, q9 T8 c, Y将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
+ Y: r8 f6 P; t紫色可以通过RGB值（170, 0, 255）来表示。
. h4 H( j5 Y" P; H: F9 l! \黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset(). H1 Y7 o$ D6 P7 l
   
2. {: F. Y. U4 h8 s! q' t/ N$ S: L
   
3.     //玩家小球( v+ M/ l- k. }( d9 R
   
4.   srand((unsigned)time(NULL));
     T9 [0 O2 p# x5 C$ O
5.   player.x = Wide / 2;6 b/ S  I4 D$ i% A$ \3 E/ p& _
   
6.   player.y = Hight / 2;# B* {) @) n+ K& v8 A1 y0 v7 Y
   
7.   player.r = 10;
   2 J; x. T1 T* Y4 Y\" T, h\" z. `/ k/ T
8.     //食物小球' O. \- F: s* r) m\" ~  O
   
9.   for (int i = 0; i < Food_num; i++)2 |9 D+ X3 k% h\" K. @# W- x+ S
   
10.   {! J. O) L, M1 u& x3 Q+ g
    
11.     Food[i].x = rand() % Wide_map;( V, t- m5 {  T7 Z& e
    
12.     Food[i].y = rand() % Hight_map;- W3 R1 ^* q+ ~
    
13.     Food[i].r = rand() % 5 + 1;
    4 ^9 i4 w6 z& @- Z- L# Z
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    2 w+ Q# J) I8 g8 P
15.   }  T6 F; e1 }, H
    
16.     //ai小球
    9 d- n0 A. {3 G4 O
17.   for (int i = 0; i < Enemy_num; i++)# T# P1 i, Z1 w6 L8 v7 ~
    
18.   {
    ) ]) q# Y2 u) A' D. V
19.     Enemy[i].x = rand() % Wide_map;
    , `5 y6 {% g$ B8 s6 R: C& R
20.     Enemy[i].y = rand() % Hight_map;  G( e3 z4 f2 i2 K& U
    
21.     Enemy[i].r = 10;( N* x2 n$ W% d( o
    
22.     Enemy[i].color = RGB(0,255,0);
    8 V) j6 f3 F\" H
23.   }9 e6 I5 Z8 r2 R5 e
    
24. ; e* n+ ~* v% J# B% y
    
25. }

复制代码

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

1. void Player_move()
   % Q, i! Q& g. d; c5 L; T8 t* d! F
2. {
   7 s2 [8 q& ~! \& v! j; @3 {
3.   if (GetAsyncKeyState(VK_UP))
   4 d6 R0 D# P5 N1 D  ?. O
4.   {4 g! d) V: R' ~/ o\" _$ I6 L: V: V
   
5.     if (player.y > 0)  o3 x0 M% Q& _( u  d. J9 F- d
   
6.     {
   9 N8 P/ n8 k8 F. G# b$ k
7.       player.y -= player_sleep;& w% ~0 A/ H0 @5 R4 _* y  B
   
8.     }
   * A. S8 n6 h9 A+ @\" x7 [
9.   }
   8 `* ?, p  ?! v. s2 b
10.   if (GetAsyncKeyState(VK_DOWN))
    - n! E5 S% X, y0 q
11.   {0 {, A: A. \% [1 c# p3 W
    
12.     if (player.y < Hight_map)' R# B1 ?  n% F. K0 [) X% L
    
13.     player.y += player_sleep;
    0 P\" r& v: ^\" g' h3 }) _2 ]
14.   }
    0 Z6 Q' U% K3 X! K\" h
15.   if (GetAsyncKeyState(VK_LEFT))0 d9 C/ P8 m3 P\" g5 y
    
16.   {% D; {4 X- I, B3 |! G, d
    
17.     if (player.x > 0)# o3 P9 e- c, S1 c5 F
    
18.     player.x -= player_sleep;8 v+ @\" p2 o( }, o- M  s
    
19.   }
    8 Y) \: G3 y  }8 `! Q# _5 _
20.   if (GetAsyncKeyState(VK_RIGHT))
    7 S/ L( d# u& t\" y
21.   {# B! K% z7 i& l
    
22.     if (player.x < Wide_map)% \/ V% k+ g' u- d6 J1 x4 O6 i
    
23.     player.x += player_sleep;/ L- `: X5 J# F
    
24.   }% E. Z& Y* o\" S( u# h# G
    
25.   if (GetAsyncKeyState(0x20))
    / D/ ~\" t7 x5 J  j
26.   {
    * v- I( _+ k/ ^/ J0 r: u
27.     player_sleep = l + 5;. {$ E: m6 r+ O* x' i
    
28.   }
    . R, H' I8 o/ D
29.   else% I! t' G6 V  Z/ J2 C
    
30.   {: z* W  d. z) a. m
    
31.     player_sleep = l;
    ( ~9 E& p$ d5 E% L, V0 \3 r# {
32.   }
    % Q. Q$ D$ [5 l- A2 H9 J# _
33. }

复制代码

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

1. void Show()
     w- g% `( n) p3 q9 r
2. {7 B: Q0 j* t' O7 T
   
3.   6 Y3 f  _. s1 W
   
4.   //设置地图3 h5 K( T7 r) S3 n/ S
   
5.   SetWorkingImage(&map);
   9 b# H5 H' L, f% N( o; y8 |
6.   //清屏
   9 D- A1 s1 a: M  z: C; P0 o: F& B
7.   cleardevice();
   3 o( A& n( P/ ]/ t! C7 R' v0 L1 e
8.   //背景颜色' u9 W5 p: P% T\" m
   
9.   setbkcolor(WHITE);
   : W1 Z' {) T\" y! e9 O
10.   //划线颜色
    ' p' t* b; q! {\" m' N- o; i8 N+ T/ [
11.   setlinecolor(RGB(230,231,239));
    7 \' G/ X0 M\" y$ Q* G  q: h) u9 g
12.   //划线8 E2 `/ `1 l. A) n
    
13.   for (int i = 0; i < Wide_map; i += 10)4 C) _8 B; c3 x; p; x) R
    
14.   {
    # B0 K- |/ H3 n
15.     line(i, 0, i, Hight_map);4 R0 p' c6 w& r5 d; w. g
    
16.   }
    $ p4 S% h) z# K: c( G\" }' l% Q
17.   for (int i = 0; i < Hight_map; i += 10)- Y4 L' j8 P! Q6 \! P/ w\" A
    
18.   {8 @1 d: z: [+ O: o/ a, a
    
19.     line(0, i, Wide_map, i);
    ! o5 O' V( v% t) W
20.   }
    + f* B6 s/ c, w5 U$ c
21.   //食物
    ) x, m/ _! O6 g, D, \
22.   for (int i = 0; i < Food_num; i++)% X2 U9 C0 p+ i7 w\" [- q: `- O
    
23.   {
    : \' Z\" T) a5 R: L
24.     setfillcolor(Food[i].color);/ h5 K8 [, `5 }! ^) H
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);, d' p$ r1 |, M+ V$ B. g* o2 q
    
26.   }
    : q+ u5 X6 W' ~4 R
27.   //敌人
    2 v\" I. x0 J! j7 n3 P. L6 R9 U
28.   for (int i = 0; i < Enemy_num; i++)2 U' B/ \2 q; Y8 P  v/ E  d7 [
    
29.   {
    + i* e; g' M\" s' G
30.     setfillcolor(Enemy[i].color);
    ) [+ P7 O) _3 h8 A: `6 r+ A+ |
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);% X+ _* y) P/ ^; r% q
    
32.   }  _  ~3 t  t5 t0 d3 L( b3 K- Y
    
33.   //玩家/ s3 @* K: u! g\" U* n2 A3 V3 N\" X; c6 w
    
34.   setfillcolor(RED);/ F1 {% h0 {7 [  m
    
35.   solidcircle(player.x, player.y, player.r);
    0 @0 {5 Y2 J0 C
36.   SetWorkingImage();
    2 G' i( [9 K3 \/ N) |% f
37. ) @1 H: b) J1 G$ l. v
    
38.   int x = player.x - (Wide / 2);  `$ M: Y7 i9 S* u
    
39.   int y = player.y - (Hight / 2);! C6 T9 s! k3 J
    
40.   //防止窗口越界
    & G\" P6 {) H3 r$ q6 r7 }& N+ T# r
41.   if (x < 0)% b7 q( e- ~$ R% v1 a/ M+ @; y
    
42.   {5 Y6 `+ k3 w; U\" s
    
43.     x = 0;4 _& R; K; r# |3 X9 b# H
    
44.   }
    & Q- v* |7 b( k( M' i9 a1 ~
45.   if (y < 0)! Q! H2 `$ T( D
    
46.   {
      v$ y6 K! s# Z5 `
47.     y = 0;5 |8 E5 i2 W3 L( r: ?+ y
    
48.   }
    0 v' t4 t, J8 \9 b! h1 r
49.   if (x > Wide_map - Wide)7 f$ G0 W6 t3 {* E2 d! z7 ~
    
50.   {  E( K/ Y  R& v, z
    
51.     x = Wide_map - Wide;
    8 Y, F' v3 G& T8 N  ~\" L
52.   }! u8 f$ t3 y, K4 u7 X. D
    
53.   if (y > Hight_map - Hight)
    ) _8 K' S* a7 d* G+ u4 i! g
54.   {
    . ]4 j; s. F0 a8 k% ?0 P* r% I
55.     y = Hight_map - Hight;
    0 n) \1 Z- [. Y
56.   }' `( P8 r7 ]) T! d5 _6 a! \
    
57.   //把map输出到窗口上
    5 V2 G- ?; E. p6 O
58.   putimage(0, 0, Wide, Hight, &map, x, y);9 d9 n0 S; X% y% ~* n
    
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. //防止窗口越界
   ) E' c% q. h+ d, L& f3 U
2. if (x < 0)
   1 P9 y4 H: s5 N2 ?) l  k$ e
3. {
   4 P4 W/ C$ d6 I0 s; U5 U; H
4.   x = 0;
   , n: L8 f& u' ]8 O& L) P
5. }
   8 G% m0 ~7 {* j& j
6. if (y < 0)# N; D; r0 S. @+ k2 ?$ O
   
7. {
     b8 E  r4 w4 A8 ?
8.   y = 0;+ c% {7 F( ]  X% G\" {3 ?9 D8 ^+ o9 {
   
9. }  r5 P+ e4 H; E
   
10. if (x > Wide_map - Wide)+ e0 Q  u- v. j3 z3 G( r6 W
    
11. {7 o3 s6 h! v1 q8 c: ]& h& }) x
    
12.   x = Wide_map - Wide;
    8 T7 m3 [( G$ v& s3 l3 c+ T\" A
13. }
    0 J: N/ i, Y3 J0 t, _1 y8 K
14. if (y > Hight_map - Hight)  w2 _  d6 K) h& O! ~\" j. E% ]
    
15. {
    5 {4 n0 q) m/ Y( P6 J# O
16.   y = Hight_map - Hight;
    . u/ _# Y' m* W\" _! @. o, V6 @' L\" t
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
- j* B. o& s+ m0 M7 w; D
4 y4 X, g. z8 V% |  n2 ~! u( f(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
+ E( h/ i" N! @0 }
Wide：这个参数指定了要绘制的图像的宽度。
3 \2 l5 F4 `8 Q$ a+ M" ^9 ~
* N1 z5 K" y3 aHight：这个参数指定了要绘制的图像的高度。
' t+ Y0 r; @- M$ I* M
( r9 D$ ^3 _, y1 B&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
* g$ n* \4 x& d  {/ d, y5 J% f: p
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离. H. C& ~\" H0 f8 E* {5 K
   
2. int Distance(int x, int y, int x1, int y1)
   ) B+ h  ]7 i% b/ @+ n4 s9 r( `
3. {, v' q! _: M+ P, M1 N/ J  d
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   \" T/ R7 U2 Q, g1 J- U! U
5. }

复制代码

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

1. void Enemy_move()
   2 f5 {9 g/ U9 O; m) `$ M
2. {' D( ^. n; I- k# @) \0 G' s
   
3.   srand((unsigned)time(NULL));
   - k1 O' l; O4 Q4 c3 M# k$ I' B0 I
4.   for (int i = 0; i < Enemy_num; i++)
   3 H, `+ ^0 A; i
5.   {# x8 l! @4 u% p6 A\" j
   
6.     int direction = rand() % 4;\" H  r, P5 p7 ?
   
7. 3 o  T# K3 |3 S; e. H: N% m
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   0 D9 b7 f+ N) w8 v* u3 n
9.     {  P. Q7 [6 R5 n% G- P% {
   
10.       if (direction == 0)1 o, q1 X7 v5 T
    
11.       {
    : r# i0 b$ Y: {2 _- H5 Q( s# o1 j
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句\" q) t! R8 R4 H# [
    
13.         {' V) ?, F# w, D& f4 s
    
14.           Enemy[i].y -= enemy_sleep;
    , t% R, M\" \0 L( o$ t5 h: P2 r
15.         }
    : f$ d0 p2 _\" D9 p, J4 L. I6 j
16.       }! a$ [- m( T! B1 Y' M$ z- ~
    
17.       if (direction == 1)% ]0 q+ h, S8 g# @# {1 e  `- x9 [
    
18.       {5 i! Z9 m\" J3 g2 L
    
19.         if (Enemy[i].y < Hight_map)
    / M6 u\" W& ?: P: W0 m
20.           Enemy[i].y += enemy_sleep;
    ' ?, b, s$ G; O) u% A( B$ U# e% A
21.       }
    3 w# m+ F- |  \  A
22.       if (direction == 2)& B8 y0 Z3 h! K\" t* S, O7 |- Z
    
23.       {
    % b3 ~0 t3 Y/ I/ P2 p. l' Y
24.         if (Enemy[i].x > 0)
    , {0 [( S/ t' X& \
25.           Enemy[i].x -= enemy_sleep;
    9 D# v& K; n  }! M% d
26.       }) i/ h6 V! u7 G) V+ r6 ^
    
27.       if (direction == 3)
    * s! n; T3 }8 T% C. `
28.       {
    0 `, L6 ^  {( n4 D$ U\" a
29.         if (Enemy[i].x < Wide_map)
    2 X2 C+ V9 w& H
30.           Enemy[i].x += enemy_sleep;2 Z# b. \) k3 }5 E3 t5 t
    
31.       }
    + C) N! I$ C; H; Y+ [% j' H2 y, N  U
32.     }
    3 z  A& E* D7 A0 |% U
33.     //敌人追击玩家
    * ~) v: P: @; R, b% l, y6 j
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    \" v$ K! ~. u; X7 q5 ]0 h/ \. N- P
35.     {, `: S8 z* l- O+ D4 Z
    
36.       if (Enemy[i].r > player.r)
    ( b% m/ u& K* J; i+ p2 ~
37.       {4 N, v+ |$ H6 _% |8 z
    
38.         if (Enemy[i].x < player.x)
    ' t6 G1 U( v+ u* O
39.         {
    / u! N( W2 V9 O; H4 p8 t
40.           if (Enemy[i].x < Wide_map)9 S% }. K4 O* ~
    
41.           {9 L* b% w2 Y1 r* P  T; E4 Y3 w% \
    
42.             Enemy[i].x += enemy_sleep;
    # u1 \  o/ v% N  ?$ r, S& d+ _
43.           }\" X# ~* v3 N  g$ V% l
    
44.         }
    5 ^. a5 w: w% `
45.         if (Enemy[i].x > player.x)
    # \9 ]7 @4 T0 {3 z0 {
46.         {, }- t% `( V2 W; Z, ^3 j5 G7 p, R
    
47.           if (Enemy[i].x > 0)0 |, L5 ^3 I7 T, a- T1 q$ b
    
48.           {
    ; }\" x. c9 B: u/ c
49.             Enemy[i].x -= enemy_sleep;' T) I  T$ w; j+ y. }& \) k
    
50.           }* Z' ^: S2 i$ o% H# e) Y
    
51.         }( i: e+ j* t5 P
    
52.         if (Enemy[i].y < player.y)
      W/ Q$ p; v+ a; G\" o/ A1 }
53.         {$ \6 h) y( N# a7 g6 b0 \
    
54.           if (Enemy[i].y < Hight_map)+ i  o% i3 c; Y. @/ z/ }0 G( K
    
55.           {3 d9 D. k0 r4 @& }2 X
    
56.             Enemy[i].y += enemy_sleep;9 D- S2 C# Q3 p5 x
    
57.           }/ @, J, b\" v7 Q, k: ~6 F
    
58.         }) U( [* C0 D% @$ B
    
59.         if (Enemy[i].y > player.y)
    ; k: f  `9 v$ d3 q/ _; |) C
60.         {5 `% @- h2 Z9 O% b  \; g) B
    
61.           if (Enemy[i].y > 0)
    . h% A$ S& J  x* E
62.           {
    2 o, {. ~% M+ q7 U6 P4 v
63.             Enemy[i].y -= enemy_sleep;
    9 W\" B) G( O% ]# s* F5 b$ O& G: {
64.           }; c# h' q* a7 j( M4 K
    
65.         }
    6 v! y( ~( y. h2 Q
66.       }# F6 ?- b# p. a$ e  _
    
67.       //敌人逃跑5 l+ G2 Z8 g+ X: o
    
68.       else
      K$ w* J1 @2 t6 v
69.       {1 w9 F2 z% q  L- e9 M4 w+ f8 W
    
70.         if (Enemy[i].x < player.x)& ~6 J. P7 J$ Q2 a& O* g, [/ \5 M
    
71.         {
    ' X: w9 h: m/ R1 h3 B' Y1 A
72.           if (Enemy[i].x > 0)
    , \2 Z4 Y6 O1 k\" I\" I
73.           {
    # j4 ]! }) X9 d\" L9 I3 o) |5 P- Y
74.             Enemy[i].x -= enemy_sleep;* c2 h4 s- j7 F- y; L* p% s6 o( g' y
    
75.           }
      q0 m9 _7 j9 ~3 U- Q
76.         }; W; ]5 w, H- B' z
    
77.         if (Enemy[i].x > player.x)
    \" z' `0 V+ T' U& ^9 A
78.         {
    3 \4 w6 Z0 U2 _; ~) P2 k# [4 i
79.           if (Enemy[i].x < Wide_map)6 j: C( v3 Z0 S
    
80.           {4 @4 A. O+ e) L: R
    
81.             Enemy[i].x += enemy_sleep;1 S( h5 q/ |% g1 Y% M  g( S
    
82.           }
    3 K6 \+ s* h& _# |' g& S
83.         }( V+ y; {# m# J/ h
    
84.         if (Enemy[i].y < player.y)
    ; ?! j9 h# w* x: w' o5 X$ g4 t& b; `* Y
85.         {
      o7 \( t, q( [
86.           if (Enemy[i].y > 0)
    9 Z9 }; z+ ~\" P  i# M$ r7 Z
87.           {, `0 o  \% I7 d\" M
    
88.             Enemy[i].y -= enemy_sleep;
    7 f) D& H  u9 T. \7 l( u4 U- c
89.           }
    + J3 g7 |) c, F) l\" B
90.         }' E5 J5 l% C* W' Y% K
    
91.         if (Enemy[i].y > player.y)7 j+ I# w8 C9 ?* R
    
92.         {
    \" D, T+ N+ D4 G- R2 n7 e1 I/ p$ L
93.           if (Enemy[i].y < Hight_map)/ V7 D  k4 |6 F8 ?: [/ `+ Z
    
94.           {
    1 N' q3 r* b$ ^; h/ H1 F8 T) F
95.             Enemy[i].y += enemy_sleep;- |; y1 _- }  ]* N4 m
    
96.           }
    ( {\" Z9 K( H4 S3 y
97.         }
    0 `) }) m+ r- E( t* ]
98.       }* `6 h/ n  l) T! r& x' B
    
99.     }
    0 J  V7 i! g# h! k' M0 Y; q+ X- F, z
100.   }6 F- X+ C1 j. r1 u
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()9 x+ f9 G% y& A\" Q  P
   
2. {
   \" g; |( x7 y4 G9 D! N, N2 c5 ^; ~
3.   for (int i = 0; i < Food_num; i++)
   ) g7 U# N- n\" g' i
4.   {
   2 N% H6 m- q* F- z1 X. D
5.     //玩家吃食物
   . a% m0 J8 u0 ]- o
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   8 R% V9 Z- ?/ l* S( [: s5 J
7.     {3 q; R& j$ q6 E5 p# t& g
   
8.       player.r += Food[i].r / 100;2 K9 s\" Y6 T+ J' N
   
9.       Food[i].x = rand() % Wide_map;/ Z8 o$ n: k  i
   
10.       Food[i].y = rand() % Hight_map;
    ' a8 V) Y9 v2 A
11.       Food[i].r = rand() % 5 + 1;
    0 n# V' g6 t7 A: Q% \( a& v
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    0 t/ ^9 y2 s: T# @
13.     }
    & p6 @! l( ~\" H% l7 S
14.    
    5 t4 D/ n+ T( z! B* n. H
15.   }
    5 O! t2 k- f, \' y' ^# k\" Z! w
16.   for (int j = 0; j < Enemy_num; j++)
    ( J' Y% P  q8 m9 k8 t
17.   {2 @: a, Y8 I+ s\" y! k: m8 P+ q
    
18.     //敌人吃食物
    - a9 L3 l2 }$ d3 J! v- [
19.     for (int i = 0; i < Food_num; i++)
    7 Y2 `1 Y4 o# o5 j
20.     {, a9 u/ s- C# l/ N1 N
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    & n, b& ]8 |: |+ o) Z0 V$ J2 ?
22.       {
    7 s- D- A3 b. |, K4 ~: d8 }
23.         Enemy[j].r += Food[i].r / 50;
    5 V/ Q. T+ Q5 s; R% Q0 l
24.         Food[i].x = rand() % Wide_map;
    4 {8 l6 y) q6 d5 n2 x* R) S+ i3 P
25.         Food[i].y = rand() % Hight_map;
    4 J) S5 ~& Y/ z
26.         Food[i].r = rand() % 5 + 1;
    \" ?* k* n! |) L& ~! d8 T
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);7 ^\" ]9 W1 M1 |9 _1 D% ?
    
28.       }
    / x' K) s8 C* i/ l* y
29.     }' l2 k' C8 [$ h* j: J3 m
    
30.     //敌人吃敌人5 l$ Y+ h8 d( B+ x1 |: b! ?
    
31.     for (int i = 0; i < Enemy_num; i++)
    9 F2 D. H! A  Z# ]
32.     {) q' h( s2 w! |1 f1 l/ C* T4 [
    
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 N4 K+ _( \4 A. }; n
    
34.       {
    6 X7 M6 D  K* t2 ?* \0 i( D: M' d, u
35.         Enemy[j].r += Enemy[i].r / 10;) V, X  ^+ n8 h\" S9 {
    
36.         Enemy[i].x = rand() % Wide_map;1 F  U3 o\" b3 N& ?$ L& g\" J1 c
    
37.         Enemy[i].y = rand() % Hight_map;1 E( u) Y7 c2 @7 M5 |, S1 a1 B: v4 w
    
38.         Enemy[i].r = 10;( H$ `: G7 v2 Y6 G, a( m% o
    
39.           Enemy[i].color = RGB(0, 255, 0);
    # h/ c1 k\" B, p8 o0 @6 C5 o3 e
40.       }
    , l' l' Q0 k7 G, M1 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)
    + H+ y- G2 o& V. R9 i* `6 x
42.       {
    % c; u0 F9 v) x. f
43.         Enemy[i].r += Enemy[j].r / 10;4 E7 l+ x$ j6 |+ e# H- q9 E& D
    
44.         Enemy[j].x = rand() % Wide_map;  w% E: A; m. `
    
45.         Enemy[j].y = rand() % Hight_map;; u. s5 E4 a8 `! Z$ h4 J' {; i8 D1 c
    
46.         Enemy[j].r = 10;
    # }. ?1 Z: c6 }2 ~\" y
47.         Enemy[j].color = RGB(0, 255, 0);
    ( U% Z+ n* T7 S5 ^6 k3 a
48.       }
    ! P& c9 n+ O, q/ O0 D) V
49.     }/ \; |- N# J  i! p8 X7 V8 t
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)5 D' t  B, z& G
    
51.     {
    6 K3 e5 r: h2 I* O
52.       //玩家吃敌人
    * K8 t2 I, k( T( Z* T# U
53.       if (player.r > Enemy[j].r)
      W2 z: }+ t% G- y5 r
54.       {2 ^9 u# C) n# j% g5 E$ a
    
55.         player.r += Enemy[j].r / 10;
    # a% N+ Y! i) j: h$ f
56.         Enemy[j].x = rand() % Wide_map;\" }; x3 k\" K4 Q
    
57.         Enemy[j].y = rand() % Hight_map;, D0 `' [# G$ X7 \6 v
    
58.         Enemy[j].r = 10;
    8 y9 [- m5 {7 g: s
59.         Enemy[j].color = RGB(0, 255, 0);& p9 A9 _. d$ O. n- e3 [& B/ A+ d
    
60.       }7 v$ |! U% z1 Q7 p
    
61.       //敌人吃玩家
    # m, l9 D$ L; g  v3 s
62.       else5 B- X6 z9 n; x+ g2 Y6 [) v
    
63.       {
    ! s7 d( h. i# ~, h( ~
64.         if (invincibility == 0)3 o1 V( g9 I\" o2 b
    
65.         {
    * v: r$ {$ _, Y2 l
66.           Enemy[j].r += player.r / 10;) b; L9 ?* r' L' T* @6 @
    
67.           player.x = Wide / 2;& c: }8 w# b, ?0 w* A& V& x
    
68.           player.y = Hight / 2;
    ' P, t\" T; g8 l
69.           player.r = 10;
    & F6 s+ ^) z\" L: k0 a, E
70.           invincibility = 10;
    ( J3 j' D$ v/ d+ b4 a! i8 n4 I
71.         }
    1 |\" Q9 F. ?0 R; E
72.       }# k4 C\" x. T$ l% h* ~. T5 B
    
73.     }
    % S9 L8 f# C8 F6 y; E+ K( c
74.   }
    / P3 v* E4 `\" m+ ]: L
75. }

复制代码

完整代码见附件：
8 Q& M! {0 X) C+ z) K* S! B( D

& \6 [( i- a9 d
& K1 j+ S8 g. N; v) E