球球大作战

2744557306

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

7 n4 k6 [5 p! L) e, P. A在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
, ~6 e( r- R, m+ ]7 w9 d
9 i% L$ h4 P! E9 g游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

. ?9 \! t3 y: X( r4 F' s. ]3 n; W1 ?玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
! c8 v  R9 E* f
+ Q" H& q- N0 Y& Y其他小球：其他小球又分为食物小球，和ai控制的小球

; W3 t+ `' S7 |# ?( W  J+ C5 W体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
7 s* Z  Y5 \1 r& [
. ^7 g- f  _9 D" x& U玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

+ D+ B  r5 e' K- Xai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

% U  e6 [7 T  T' H& j9 o6 R# l接下来，我们将通过以下几个步骤来实现这个游戏：
" N  [6 j5 {! h
  i. N; s4 [. |; k5 P) M初始化游戏界面和小球的信息。

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

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

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

' \0 ]5 i) G9 {% j8 W; e检测小球之间的吞噬关系，增加相应的体积。

1 }) |8 y& L% y% @" G通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

  ^  Q4 o; R+ G0 c1. 小球的要素
0 K" E. f4 D0 ?4 u7 O* u0 b+ p6 h在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

5 X: Y8 X7 b+ H3 J" {( V6 sstruct Ball
{
: `1 H' }" q; ?0 t* o5 X1 J- H        int x;
        int y;
        float r;
( e, S2 B; t# `7 g' z        DWORD color;
: H' j. S1 i0 D+ u4 v0 b' T# f};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
, d' z7 ]0 D, F; @
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
# N" T7 B7 C  p5 g0 _- x蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
2 T. L8 n1 P  {: ?1 d灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   $ k) U\" l5 W* A- V; h0 p\" U
2. {) T& m5 Q3 X0 R1 z. e( A- P
   
3.     //玩家小球7 _4 k/ k2 [8 e8 a
   
4.   srand((unsigned)time(NULL));2 U) b- ~4 N1 Y
   
5.   player.x = Wide / 2;. q5 F7 _) M1 D8 I1 q
   
6.   player.y = Hight / 2;
   8 X, s7 [! e. m! g4 c
7.   player.r = 10;
   ! O8 d0 r8 J& V# q/ x8 ?* [4 U
8.     //食物小球9 L1 Q; o# A7 l8 Y6 j# O
   
9.   for (int i = 0; i < Food_num; i++)
   & c. U0 E# a) R, y- k
10.   {! n2 q5 X8 _0 e! _4 C4 {- z
    
11.     Food[i].x = rand() % Wide_map;0 p; t3 V: c: z4 {. E/ D4 Y
    
12.     Food[i].y = rand() % Hight_map;: n# A  A$ l9 n1 \! o
    
13.     Food[i].r = rand() % 5 + 1;9 ^1 h$ p1 q6 H) _+ K
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    * s  @9 K0 y& J1 A. Q/ m
15.   }
    1 Y! N) b\" w5 v/ ?6 X4 T! a
16.     //ai小球, Q4 G( l/ [# J( t% |: \
    
17.   for (int i = 0; i < Enemy_num; i++)
    5 V! Q6 |- Q0 R+ R  |: A& J% o
18.   {
    - E5 g$ K2 W* ~8 O1 S
19.     Enemy[i].x = rand() % Wide_map;& k0 @8 `, U' T
    
20.     Enemy[i].y = rand() % Hight_map;, H3 \+ d( T, O8 [+ A
    
21.     Enemy[i].r = 10;$ e0 s# w2 n9 R
    
22.     Enemy[i].color = RGB(0,255,0);- s8 q\" _( p; J1 J( a# M
    
23.   }
    ( w0 ^( d9 U% B9 R( _8 B: w
24.   q0 j* d; f- J; T9 K! [! B
    
25. }

复制代码

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

1. void Player_move()) L$ d2 n, x1 J$ O
   
2. {
   \" m) k4 j( f& K& w  f' [% y
3.   if (GetAsyncKeyState(VK_UP))
   ! T) {\" ^0 z) R6 l) ~6 ?/ C
4.   {
   # y/ x8 c9 i, F
5.     if (player.y > 0)+ l& N/ p2 _( j. t, R0 d2 u
   
6.     {
     f& v4 R0 b+ c1 R' I
7.       player.y -= player_sleep;4 t8 ?9 z- b' \
   
8.     }
   3 ]0 L8 z- W' |8 \$ U
9.   }* C6 s# i! h/ @- k% ~0 @
   
10.   if (GetAsyncKeyState(VK_DOWN))
    0 s. T* x; P' J2 Y
11.   {
    ! v+ \2 V, r6 @, }; e) K1 J
12.     if (player.y < Hight_map)\" M+ l/ x/ C4 F2 M
    
13.     player.y += player_sleep;) y2 H& y2 v2 G: q. G$ e
    
14.   }\" ~; G; U  X, h4 ]- B
    
15.   if (GetAsyncKeyState(VK_LEFT))+ P* ^+ @* M1 c* x6 Y
    
16.   {
    5 Y\" C3 |3 K5 C% G8 ~) j! U- |8 P
17.     if (player.x > 0)- R. ~6 P6 g! c' ]& g. M
    
18.     player.x -= player_sleep;. a4 v2 O8 T$ t: [- v; e: _8 E
    
19.   }
    1 L% v5 R# ]9 c\" \0 c* G
20.   if (GetAsyncKeyState(VK_RIGHT))0 Z\" e, h% @# l+ f; q
    
21.   {7 b1 }* ]( W/ H7 Q0 ?  A
    
22.     if (player.x < Wide_map)- O' p$ R  p( T0 }- o4 x; |. c( v
    
23.     player.x += player_sleep;
      a; @8 i7 {& u- E0 ^1 B# D
24.   }- {\" d( N2 D9 C! c
    
25.   if (GetAsyncKeyState(0x20))0 t' F' M: D# D' B
    
26.   {
    - X5 ]  W! w! f/ u7 Z
27.     player_sleep = l + 5;1 v. @$ B6 l5 x4 u& W8 d
    
28.   }
    ; b2 n& x! Q, |/ a
29.   else
    : z( K) B% t\" [
30.   {; p\" O( s% `- \6 p\" e! F
    
31.     player_sleep = l;9 f5 h' J% A' @6 E$ n5 w/ Q
    
32.   }
    + r8 A1 A  L: v: K4 O$ c
33. }

复制代码

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

1. void Show(); r0 h2 V2 H8 k  e: P1 g. v* H
   
2. {9 o\" D6 D, F: t$ D9 }$ V, y
   
3.   % M7 R9 `$ x; y* E8 U
   
4.   //设置地图' X  C0 z\" c; e* r$ n
   
5.   SetWorkingImage(&map);# A  Z$ d- S2 \
   
6.   //清屏
   / G' k% X4 y; s5 h( n8 P
7.   cleardevice();
   4 Q/ U/ y: o; h: j
8.   //背景颜色) i/ g) Q3 Q: a
   
9.   setbkcolor(WHITE);4 x# n, p: m- M9 K. n) `
   
10.   //划线颜色/ x4 |2 Q- H. x5 s2 r$ w: N: ]
    
11.   setlinecolor(RGB(230,231,239));
    ; u\" x- _# Z) Q1 Z$ s
12.   //划线
    - c' |% ?4 Z/ T# m& A! G) L8 j4 ~; j
13.   for (int i = 0; i < Wide_map; i += 10)
    6 s/ }, x9 d) W
14.   {2 @& j2 T  p/ m\" \. n% x
    
15.     line(i, 0, i, Hight_map);
    / P5 g1 X5 \5 v, }
16.   }  K. b! g1 l: i* z5 M
    
17.   for (int i = 0; i < Hight_map; i += 10)
    4 s$ e$ |/ g, Q4 T! L8 r3 P7 s
18.   {& W* H- N5 r! i. s3 X
    
19.     line(0, i, Wide_map, i);% G  J3 {% W, b
    
20.   }9 h  A8 }2 W) B1 x: [/ r
    
21.   //食物0 I6 Y  a: W2 R+ L
    
22.   for (int i = 0; i < Food_num; i++)# J% X; e( h& T* J6 S) d
    
23.   {
    2 c$ l& t! T5 k3 M\" q) O$ C; l
24.     setfillcolor(Food[i].color);\" u! h, w: G' M# |, U4 o$ ^, K( T
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);  ~/ [\" z7 M  j# ]
    
26.   }* J; l& G$ I\" x% v8 C0 V
    
27.   //敌人1 L4 p) p2 }$ ]\" j; m* A1 s
    
28.   for (int i = 0; i < Enemy_num; i++)7 k! e2 g, t: z+ |' X7 a+ s. T
    
29.   {
    ) ]0 v! h6 w  Q2 p6 M: N& a5 T
30.     setfillcolor(Enemy[i].color);( [! E; F' T1 U: _* b  r
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);5 S  g; H. j  q. H; k
    
32.   }
    ' K, [% q. Q7 [) y3 f
33.   //玩家3 z8 e\" {8 w/ ~5 I
    
34.   setfillcolor(RED);
    : ~\" @6 M6 r6 c( q  h
35.   solidcircle(player.x, player.y, player.r);
    ) G+ w+ }. F  X& l; ]* c0 ?
36.   SetWorkingImage();
    1 n6 ^: t' G7 M% x  R! J5 I' F: s) K/ _
37. 
    0 ]4 i  ^: c4 X$ H3 x; P% ~2 x
38.   int x = player.x - (Wide / 2);+ n; U\" ]! O2 O! V$ B, j8 m
    
39.   int y = player.y - (Hight / 2);' W% v. L1 a- i; R$ l1 k7 \1 q( {
    
40.   //防止窗口越界
    ! {' s% [' h' t, o! L
41.   if (x < 0)
    1 u$ x7 A* [% W9 U5 n7 x/ F
42.   {
    $ R9 o\" m+ ~$ M) y* b! y
43.     x = 0;1 n7 \1 c\" A! V$ q6 n( E
    
44.   }
    ( k; n0 c; x0 s5 Y9 x8 M0 T
45.   if (y < 0)( r' t1 ], g2 u  k! D# [\" c
    
46.   {% S8 \  y# I4 I\" N! D; C! E: t0 L
    
47.     y = 0;
    ' s5 @% h) o1 F/ a+ p
48.   }4 Z8 T% I5 F) N  V# `\" T
    
49.   if (x > Wide_map - Wide)
    * x2 ^# y0 T, Y* B+ w+ Z# x# T) g
50.   {
    ' @2 J, B* c# |; N+ w\" |1 g, v. ^
51.     x = Wide_map - Wide;4 @$ K1 z2 c1 Y* Z/ ]0 _3 R
    
52.   }
    ' Y$ V- {# ^) V& q: y4 Y9 o
53.   if (y > Hight_map - Hight)
    ! Q( E2 L1 @9 F9 \1 C; o& |- k3 O. g
54.   {3 I$ e' ^' t* G6 K6 r' d3 x
    
55.     y = Hight_map - Hight;
    ! f7 E6 |7 C1 [) b9 g+ ~
56.   }$ s8 [3 ^* u; H: `* \2 E
    
57.   //把map输出到窗口上0 p4 N7 Y: R5 c+ ?% p
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    : C8 r$ W2 O/ G7 f: l9 G
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. //防止窗口越界
   $ W\" n. I: {8 U! Z
2. if (x < 0); o& t, e* [, O9 Z
   
3. {
   ) d! U, X. ~: |$ N9 h3 Z; }) X2 K
4.   x = 0;
   # Q3 a' R) _$ Z- v1 M9 r3 [
5. }
   8 A' O8 U/ r6 {2 R
6. if (y < 0)& \- I4 H5 B) k% g$ P8 S
   
7. {* v0 j4 Z5 D& c* b; n
   
8.   y = 0;  Q! b6 g0 Y& V9 x1 g! b
   
9. }\" S6 C7 w8 [2 K0 d\" L* J; L
   
10. if (x > Wide_map - Wide)
    % `& n! D+ n8 Q
11. {3 i4 ~2 X1 f* k4 t' ~  s9 N
    
12.   x = Wide_map - Wide;
    - ]- h2 H8 e* {1 Y& Q
13. }; o! d' L' u) y% c! P  j1 B
    
14. if (y > Hight_map - Hight)
      [* W8 |- c, f& o
15. {
    ; @\" B, r; P2 C; k$ ?6 o3 s
16.   y = Hight_map - Hight;0 C% H' o/ h( C: G6 G# X7 d! P
    
17. }

复制代码

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

(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

' Q/ z3 a: [, X: v, Y: hWide：这个参数指定了要绘制的图像的宽度。
! I# F/ a, `3 y7 T/ _
Hight：这个参数指定了要绘制的图像的高度。

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
" [" R( ^2 I6 N
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
, A3 A9 N1 C4 s
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
1 M. s  s/ i" `7 a( R随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离\" C; L0 p- [7 k: }& u  v8 T- i
   
2. int Distance(int x, int y, int x1, int y1). D, Y7 {0 L& \* L
   
3. {; g2 V1 i9 r6 z+ |
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));. p- w& o5 t* l3 `
   
5. }

复制代码

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

1. void Enemy_move()
   2 v. e* k  R- M/ N2 u) [5 R( _  j
2. {: C# J4 |3 Q  w# t5 E
   
3.   srand((unsigned)time(NULL));  Y: F. v% i& V- {
   
4.   for (int i = 0; i < Enemy_num; i++)
   7 H# v4 Q) T5 c) x% X0 F
5.   {. c8 W& i5 c7 _9 J
   
6.     int direction = rand() % 4;
   + W9 h0 z  `8 N' f! U8 W
7. 
   3 G# {# l/ O( O' |$ W
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   9 S% X0 e* A$ A) T: `1 P$ d
9.     {
   / k2 P3 u! A  K9 H
10.       if (direction == 0)
    3 |- n( Z\" U1 p( {* C
11.       {+ _% _2 x# v5 `3 e$ ?2 @5 k  |
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    & K, w8 e% A# h\" ]8 Q1 {& e/ `3 a, b
13.         {. i1 U$ h4 y( j8 v8 u/ h$ U
    
14.           Enemy[i].y -= enemy_sleep;
    / N5 ^0 Y0 N, g
15.         }3 n0 y5 P$ W* ]3 Y$ s/ w6 Z8 @+ s
    
16.       }
    , A3 q+ @1 z. L$ q% b/ _
17.       if (direction == 1). b( P+ r2 [! }6 z
    
18.       {
    3 r& h: D/ }* {. Z* d
19.         if (Enemy[i].y < Hight_map)  }( f  {) o( V3 [  v4 j
    
20.           Enemy[i].y += enemy_sleep;. }2 q, k) n7 I, |
    
21.       }0 |) w\" p7 Y3 L- |
    
22.       if (direction == 2)( h) L* }7 D. F% H  |  U6 r# A  \
    
23.       {) M  \$ b: B& G
    
24.         if (Enemy[i].x > 0)
    . X1 g9 b+ s: Q, k$ X
25.           Enemy[i].x -= enemy_sleep;9 X* N  m# P- T1 H0 u1 N/ g
    
26.       }2 A2 D2 G  H4 `) L( u
    
27.       if (direction == 3): }: l- l- z% O6 f  y0 h
    
28.       {
    * G$ M: |0 `% d4 t$ L
29.         if (Enemy[i].x < Wide_map)( R) m5 Y# F\" w& w8 O$ g2 m
    
30.           Enemy[i].x += enemy_sleep;
    2 s% d* M' ~: Z, p8 G. \5 Q
31.       }; E7 ?' m) Q2 u& @! f9 L1 ?- P
    
32.     }
    7 y8 K) ?5 d& e& X  b- {
33.     //敌人追击玩家
    3 b9 I+ s$ \* Q' j4 L4 \* K  T. i
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50), B* p1 f1 M  B4 z: C. o
    
35.     {
    ' g& v9 I3 a  n! E6 \
36.       if (Enemy[i].r > player.r)
    . W# A# p& n2 l
37.       {
    3 I% k7 `$ `0 f. K4 c  g# g
38.         if (Enemy[i].x < player.x)
    3 ]* v& O4 y$ |( X( P4 {
39.         {
    ) U# W9 w; x\" R5 l2 _# f
40.           if (Enemy[i].x < Wide_map)7 M& t2 z# d9 {. a. W: e; m: w1 V
    
41.           {
    ; ^5 F4 I- |/ Y  n' B
42.             Enemy[i].x += enemy_sleep;8 ?0 r5 h! y2 @/ F5 L# p8 |, a# `
    
43.           }# s5 K* g; X! Q0 m5 h
    
44.         }
    , u' f; k6 V9 e5 m
45.         if (Enemy[i].x > player.x)
    4 u& U. C, V# z  ?5 C
46.         {, M5 b9 n7 {4 O* ^# @, }
    
47.           if (Enemy[i].x > 0)
    # S1 u5 F' {5 b5 W
48.           {
    % j- q\" W8 _- q% N
49.             Enemy[i].x -= enemy_sleep;' A: k# m1 T2 p. C3 f2 t+ c/ I
    
50.           }8 ^' o! ^% _8 s1 A1 G- {
    
51.         }1 M6 p/ h& _, g. O
    
52.         if (Enemy[i].y < player.y)
    : t9 N* p  K% I/ C! S/ r, S) r) U
53.         {8 q5 ?% ^: [, T% |
    
54.           if (Enemy[i].y < Hight_map)
    4 ?$ A* K7 P1 h
55.           {
    \" f& I( B, [/ Z; `7 }$ a' a, h3 c
56.             Enemy[i].y += enemy_sleep;2 g$ K8 r4 a- E
    
57.           }
    9 F, w3 t6 w% X# x: D
58.         }/ e4 o# |- p% ~7 e
    
59.         if (Enemy[i].y > player.y)
    7 h8 K- p% @( `& S& r( g: R+ n
60.         {
    / B  A# a& Z5 n* G; H
61.           if (Enemy[i].y > 0)
    ; ~2 j/ h5 @7 k% l+ v/ ]
62.           {
    ( c2 d2 _2 Q% H/ @
63.             Enemy[i].y -= enemy_sleep;6 [: V  t9 x; i- c7 j: e0 t
    
64.           }
    / H3 V9 Q5 `' g; Z$ C
65.         }. J: T. F$ y( i6 E8 g: v* i7 D
    
66.       }
    5 |, D: C2 z  @  ]
67.       //敌人逃跑9 D+ b+ Q' V: w; @
    
68.       else
    - p' A5 G3 ?, g
69.       {
    . g  l# O+ r: ?8 S
70.         if (Enemy[i].x < player.x)
    * H  I* O: y# y& W. C) D\" l
71.         {& b9 |\" Z7 L. A7 F6 h! e' X* Q
    
72.           if (Enemy[i].x > 0); m+ R8 _# T  @9 z$ B, R5 g* k8 j
    
73.           {
    + F( w6 m9 ~% y9 {5 B
74.             Enemy[i].x -= enemy_sleep;7 t8 t+ Z. T$ d
    
75.           }0 \, L; V  v2 l; l, M
    
76.         }& }1 f\" C2 j! Y
    
77.         if (Enemy[i].x > player.x)
    6 A3 o' B: l- W3 s8 Y
78.         {0 G9 `  Y1 v( a& G7 a2 b& `
    
79.           if (Enemy[i].x < Wide_map)
    $ U6 N8 l- H$ N
80.           {1 x. [. y* n9 J
    
81.             Enemy[i].x += enemy_sleep;2 |( U: h7 l) Z; S1 l0 i; a, N) p
    
82.           }
    6 j. e) x* d* n. m* x
83.         }
      x, o% i5 G5 o
84.         if (Enemy[i].y < player.y)
    * Y. u( C3 d0 L% }* f( P' W, d
85.         {
    & w8 Z- u- M! ?9 d; H7 I
86.           if (Enemy[i].y > 0)- t1 ]& Z\" u* q+ y+ |
    
87.           {# ^# f+ ]; i9 b% {! ^2 u
    
88.             Enemy[i].y -= enemy_sleep;
    5 m- G, [4 O& P& g/ @
89.           }
    6 j0 m: ?5 p: N7 h. m- r0 u# W
90.         }
    3 o9 A0 y1 W\" U3 V
91.         if (Enemy[i].y > player.y)
    1 E: Q- n8 o9 j1 a
92.         {
    1 N8 p/ I: z% R1 v7 Q( w' O2 l
93.           if (Enemy[i].y < Hight_map)
    4 g9 t& Q& ~: a2 _$ h+ J
94.           {. f8 n# U6 B\" A' [. j
    
95.             Enemy[i].y += enemy_sleep;  L( K  x% U! j\" U$ O% R; O
    
96.           }
    6 u# p1 c/ K+ n. c' K5 N- ~1 x
97.         }
    7 C% h# z: R& X& }: d
98.       }% o3 c, }8 N5 E5 n# |. w& h6 h\" T
    
99.     }
    4 P\" L1 Q. h% @- `- [7 |% _; c7 Q
100.   }+ M/ B8 r. \8 h% f. H
     
101. }

复制代码

7. 小球之间的吞噬关系
8 q- L9 b6 B) n" t; ^. P$ M( e

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

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

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

1. void EatFood()$ O6 n  v. j. {. A' G5 w
   
2. {
   ! ^# u+ X9 n' L\" p: r7 P
3.   for (int i = 0; i < Food_num; i++)
   / W5 v. i9 n. g; B7 ]. Q
4.   {
     h3 ]3 c\" Z$ R$ i
5.     //玩家吃食物
   3 S. W( E4 a  A% t: ~' ^4 P, v
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)9 ^\" N. X* B$ a  X/ s( S: Y
   
7.     {
   8 ?2 c: s* Y) D! W2 E1 @4 n
8.       player.r += Food[i].r / 100;
   2 d4 R4 G# `0 ?0 c7 {' r0 O
9.       Food[i].x = rand() % Wide_map;# B) n3 A! `6 m( A4 L. W
   
10.       Food[i].y = rand() % Hight_map;2 e7 E6 Z' C( I9 P
    
11.       Food[i].r = rand() % 5 + 1;
    1 Z% S7 @# h/ ~( P* r
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    , A/ {3 j* h\" F3 w
13.     }
    - E0 l7 q! w1 Y\" |6 [1 O
14.     1 M( [, y. A$ ?; c2 Q7 i0 D3 n
    
15.   }
    ! N/ v0 H6 H1 K+ L' O0 T
16.   for (int j = 0; j < Enemy_num; j++)
    5 s8 S, X# ?; }
17.   {8 H9 t: n# l1 L: g/ e
    
18.     //敌人吃食物
    \" e/ r! R# x\" Z* j# F
19.     for (int i = 0; i < Food_num; i++)
    ; c5 k/ A- x4 H4 z6 E2 ~4 ?
20.     {
      h8 {/ G2 }* ]
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    : W$ u# `\" K. U9 h- d
22.       {6 M- Z# Q. E9 H# q) {: {
    
23.         Enemy[j].r += Food[i].r / 50;
    6 }) g& U; c$ `2 B0 U; V3 Q. ]
24.         Food[i].x = rand() % Wide_map;
    ) G; g) N- G- g) w
25.         Food[i].y = rand() % Hight_map;
    . F! w/ f5 J9 G
26.         Food[i].r = rand() % 5 + 1;) n* e4 E  p& o& J1 G- ]
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    4 a1 |( V) B+ A6 |. a$ q# C
28.       }3 O' P7 ^0 F7 O/ P
    
29.     }4 P# V, ~/ p+ B% y$ M
    
30.     //敌人吃敌人
    6 C  H- S8 C! h; d2 Q4 C9 r
31.     for (int i = 0; i < Enemy_num; i++). i6 F7 L2 u+ N7 K
    
32.     {
    - v3 c/ w, O0 b$ N- F5 k- l2 p
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)( _& r' d- Q6 B2 l
    
34.       {
    + Z* T0 R: `; ~0 E$ ~! \
35.         Enemy[j].r += Enemy[i].r / 10;# v: h( ^1 K- T7 G; j0 r* `
    
36.         Enemy[i].x = rand() % Wide_map;  U) Y$ u$ n8 }
    
37.         Enemy[i].y = rand() % Hight_map;
    1 `( j' ~- y: H8 k* Z0 I: P
38.         Enemy[i].r = 10;- v1 f! S( P/ @3 z1 i
    
39.           Enemy[i].color = RGB(0, 255, 0);8 t- j' u* F& }6 A! p
    
40.       }
    / V! i  y2 n& a4 I* ?
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    4 e; Q% o. }3 z8 g( \
42.       {+ u5 B0 ]5 u2 Z' H1 c
    
43.         Enemy[i].r += Enemy[j].r / 10;8 V( }2 I: I6 G% u6 ?$ \
    
44.         Enemy[j].x = rand() % Wide_map;+ d% U4 a' t2 Y7 }
    
45.         Enemy[j].y = rand() % Hight_map;; n, B5 T* e/ Z( z- N8 \1 J
    
46.         Enemy[j].r = 10;
    ; o2 `  ^4 [) {' {7 v) m: e5 k
47.         Enemy[j].color = RGB(0, 255, 0);
    7 W* Z5 {' C\" P5 b0 U5 z1 I
48.       }1 g. A' g4 Q+ I6 }
    
49.     }( H  c% B% u* X
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    % O7 N. K* y- v( B
51.     {4 \3 D% G! G, ]
    
52.       //玩家吃敌人
    , `! ]; v7 b, |+ ^  O7 j
53.       if (player.r > Enemy[j].r)
    & w1 {: s6 T/ i
54.       {
    \" K+ U6 o; C\" B5 U
55.         player.r += Enemy[j].r / 10;( ^; b& m+ J* B' M0 w
    
56.         Enemy[j].x = rand() % Wide_map;
    ' X0 F$ l/ t8 {  H\" {
57.         Enemy[j].y = rand() % Hight_map;
    ( g; F/ S% A3 W: G
58.         Enemy[j].r = 10;
    $ e: [* T\" X\" U1 F
59.         Enemy[j].color = RGB(0, 255, 0);; t1 e2 B. ^/ n
    
60.       }
    ( l) s6 [& P# P1 e% A% E8 r7 |
61.       //敌人吃玩家( N\" C4 J) Z* m- e$ I3 j
    
62.       else
    . `7 o- n; p4 x- ?/ R; A
63.       {. v) D: ^+ U* B
    
64.         if (invincibility == 0)
    , n) I7 k: L5 b6 p6 ~7 x( p3 v
65.         {  X% M# \# \& V  d7 R
    
66.           Enemy[j].r += player.r / 10;\" I8 _+ U- p. Q' D# n4 v
    
67.           player.x = Wide / 2;6 ?# T% i$ |% F) A7 }7 r
    
68.           player.y = Hight / 2;6 Y# s3 |4 m5 p) R( Y# Q7 g
    
69.           player.r = 10;\" ^9 x3 s, R+ I) c
    
70.           invincibility = 10;
    \" T4 @3 Y. N8 K5 c$ b- F- Q& v: f
71.         }
      t) c: w% T\" G0 ?& W, d% J0 c+ X
72.       }
    3 \, }) c5 }% O
73.     }
    - s) h$ M. W  w+ D( y1 S
74.   }
    : ~; M, g; Y; A5 W3 J
75. }

复制代码

完整代码见附件：

# _& @. r' d/ g( o4 ?; i
, G! l1 u0 A9 m8 [# g, G
! m9 M! }1 L: S& T" H+ T! E