球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
" q) g5 S2 Q4 q
4 M0 [1 N7 S; O) u6 `) E' |1 K  s玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
: e. e2 K" s" ?0 s
4 Q+ I' h4 @# {8 w2 W体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
- I; e% d5 x6 H3 n& b8 A; h% u
& D* C$ ]* v. E& a& t7 i9 `1 h# _5 Y玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

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

3 R6 S: {0 M, X4 M! R: R8 b8 x1 L  G接下来，我们将通过以下几个步骤来实现这个游戏：
1 a, }! {; s; C3 B% v4 _7 u4 u
. R3 m2 z+ h; A& S$ x8 I7 f  V0 E初始化游戏界面和小球的信息。

! T3 o4 _! W+ \$ P处理键盘输入，实现玩家小球的移动和加速。

# h- a1 K2 q3 m8 J生成足够数量的食物小球。

生成ai小球，并控制其移动。
3 J1 l2 t; `1 D; @& _
  J- [+ ^$ \5 N- f1 f! r$ d2 O; d* N检测小球之间的吞噬关系，增加相应的体积。
9 h, ]5 C9 P$ K" W0 E0 w! B' ^
* w" C- B9 u, i7 l通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
7 z9 `& X8 K8 S+ u: D
1 B% E5 t) V8 x7 \: d" Z9 Y3 [1. 小球的要素
2 d' g" a1 d7 ^# U在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
  _) d1 H4 x2 g  @0 D
) H# s; f, ?3 B( {" N2 d/ n' nstruct Ball
) j; u' k/ h, \- J, Z( H{
! ]* i. r; y2 a& W        int x;
- k6 S# }$ c) ?2 D: t" w        int y;
        float r;
        DWORD color;
" |2 g6 c8 x! t' ~' R2 Y* }};
  L, K, e% W; N- o0 P. u6 o( |2. 初始化小球的信息
( J* V3 }. U$ O! D将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
5 h" j5 B. F3 {: k) t2 E
! x& D# L$ K6 C! r1 PRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

4 \% y4 O3 U. A4 J) |4 P/ ~) I橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
) c% z8 J/ K# k2 u+ k* L+ b9 ^3 {绿色的RGB值是（0, 255, 0）。
7 T: p4 g% o& ^1 F* G蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset(); R5 U% x\" d; R- ]7 L# K' v9 q
   
2. {1 U! \$ J\" r. B2 C* j
   
3.     //玩家小球
   * T% x. {  `( V8 f1 K! m, Q
4.   srand((unsigned)time(NULL));
   ( t7 @/ t$ i! j! P3 Y' @; M$ N
5.   player.x = Wide / 2;
   1 n; u$ z; \9 M& u8 k, M' |' ^\" t
6.   player.y = Hight / 2;+ R/ z9 h, C, e: \1 f. W- ?2 r
   
7.   player.r = 10;. Q4 A7 ^; o* B; Q% B' P7 P
   
8.     //食物小球# l) Y5 o% A- c; v
   
9.   for (int i = 0; i < Food_num; i++)
   : {+ u5 {- O. e4 e8 d
10.   {/ L& ?3 S1 Y! [
    
11.     Food[i].x = rand() % Wide_map;# A) o3 q* x5 }
    
12.     Food[i].y = rand() % Hight_map;
    ; ~. \6 `1 t3 {, t7 K
13.     Food[i].r = rand() % 5 + 1;\" K\" }* e2 ~9 y0 M+ a! m3 P; R
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ; a1 b! B6 c! h8 c2 p& I7 y- z8 y. }
15.   }
    3 U0 o- Q- ^  R6 Y1 G
16.     //ai小球8 o0 |) V3 e* y
    
17.   for (int i = 0; i < Enemy_num; i++)
    4 |6 u4 }8 C/ C' S2 J
18.   {
    ; P4 q; R: f' S, w  T) v6 n* {+ |$ U& W& F: v
19.     Enemy[i].x = rand() % Wide_map;  a4 v$ C0 _7 E$ e9 |) p0 @0 T
    
20.     Enemy[i].y = rand() % Hight_map;9 k$ L$ ?- S1 i) j0 ^
    
21.     Enemy[i].r = 10;+ g! ?5 ]/ E/ e4 {
    
22.     Enemy[i].color = RGB(0,255,0);; n8 [% A% d7 {0 w
    
23.   }
    4 G- H* b) B9 u$ G* [
24. ( k; L% B4 ?/ h
    
25. }

复制代码

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

1. void Player_move()
   # K) o  `\" `: d% r
2. {. {3 g4 X3 V) D4 M
   
3.   if (GetAsyncKeyState(VK_UP))8 O$ c, Q& \+ g3 r
   
4.   {' ?5 ^) a( N% M& X9 D+ q( G
   
5.     if (player.y > 0)$ O8 }# {$ }, z4 J' w- p' V: W
   
6.     {
   + w- O4 U$ A/ U* r/ c. Y
7.       player.y -= player_sleep;* X: n! L8 h# K7 Y% G/ P
   
8.     }
   + m# o\" b- g& P6 N6 f1 N/ c2 {
9.   }
   ' m$ Q, n0 e  w# r- R9 z0 }
10.   if (GetAsyncKeyState(VK_DOWN)). s& ]! q! i/ W9 \
    
11.   {( ]0 ^3 _: H3 {0 n4 D! O9 P$ w' w
    
12.     if (player.y < Hight_map)
    2 x. }3 Q& D! |' z5 W8 L
13.     player.y += player_sleep;  i, P& c1 |* ~, e3 B
    
14.   }\" [% _; J( P0 w) D# i9 U5 E
    
15.   if (GetAsyncKeyState(VK_LEFT))
    7 G6 ^' [6 j7 Q* k- v+ Q. M
16.   {
    6 i7 t& q& p4 j. k3 K
17.     if (player.x > 0)
    # u( g. {: C: ]5 w$ y8 G
18.     player.x -= player_sleep;  g, f& \\" l/ l5 u\" g, g
    
19.   }1 ^# L: g8 \4 s( U+ b
    
20.   if (GetAsyncKeyState(VK_RIGHT))' Y% ~) Y4 E+ l! G' v5 S
    
21.   {
    . p8 Y9 L9 r. O
22.     if (player.x < Wide_map)
    ) e, w+ @- q) I7 q6 w
23.     player.x += player_sleep;7 D: R- Q$ M. h' v
    
24.   }$ U; D  C7 ~- z4 Q9 B2 R
    
25.   if (GetAsyncKeyState(0x20))4 l. A$ F! Q  w3 U
    
26.   {) E7 S+ _2 ?. Z2 n& W7 w* D$ m& U* R, a
    
27.     player_sleep = l + 5;
    3 |: e& f. I, v0 U
28.   }- S( _( q6 z7 U( T- |( c- [
    
29.   else\" U( g& f6 _' m. z! z- s
    
30.   {
    3 x2 `$ Y3 m# K
31.     player_sleep = l;+ T, ]9 u' T' V3 G\" \\" P) A2 x
    
32.   }
    5 \) G* v+ h; F4 M, ], Q
33. }

复制代码

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

1. void Show(); K( G5 [2 C6 H! g7 U
   
2. {7 C- E9 A3 ?! S  A+ V& D
   
3.   
   9 d/ v. j7 s: m
4.   //设置地图
   3 s& ]3 S3 n* p\" Q; I  i) |
5.   SetWorkingImage(&map);
   7 b% O\" w5 a$ M9 G& \8 f5 c5 _7 E
6.   //清屏
   : I/ S# p; k. X, _. h0 [# x
7.   cleardevice();\" j' {4 @0 ]8 V
   
8.   //背景颜色
     `$ I. L( }2 Q+ A- p- b
9.   setbkcolor(WHITE);
   ! @  A/ A% o- H' p( U/ ~
10.   //划线颜色* x' `1 H6 z; `: X3 ]! Z9 K
    
11.   setlinecolor(RGB(230,231,239));
      e  ], ?# Y& n
12.   //划线
    \" h3 j4 D. m: c\" f9 C5 Y
13.   for (int i = 0; i < Wide_map; i += 10)1 x/ e, u* k  x6 s' f
    
14.   {
    # v; r. \3 n& S& X% A/ J4 {; u' n
15.     line(i, 0, i, Hight_map);$ M' C. y- b2 T+ i\" m
    
16.   }
    ' k+ g5 v+ c; z- Y
17.   for (int i = 0; i < Hight_map; i += 10)
    ! M+ z- W# i! ]0 M* h9 j5 B7 V
18.   {( O* n: B9 y. @6 Z) a
    
19.     line(0, i, Wide_map, i);8 @6 I5 P5 D* I: }. R$ g
    
20.   }- K4 z\" O$ w( |# d* n
    
21.   //食物( g% {\" }9 x# c3 s8 b
    
22.   for (int i = 0; i < Food_num; i++)
    2 z+ `! O. K  P+ l
23.   {
    \" O3 `( M/ H7 y1 g* A* O0 ?3 {
24.     setfillcolor(Food[i].color);
    # d, J* S1 i\" I
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);  e7 N: C\" Y4 B
    
26.   }
    + [) ]0 S& |, N4 V) _
27.   //敌人7 V3 c5 H$ w, e0 r\" d7 u4 o  q
    
28.   for (int i = 0; i < Enemy_num; i++)
    4 C. v0 G: ]# }9 ?  F
29.   {; n* V( G0 w. [' I' _4 Y) p6 |2 Y
    
30.     setfillcolor(Enemy[i].color);5 E1 ?& Y4 d2 c' U! v; t0 z' k( x
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);( {; j! B3 d) v
    
32.   }
    - S1 a* \; m0 r
33.   //玩家% U- w( U5 g/ K6 C3 X
    
34.   setfillcolor(RED);1 ?  d+ z4 [0 F% b
    
35.   solidcircle(player.x, player.y, player.r);
    ) O9 Y9 q% T) p4 X# d
36.   SetWorkingImage();
    9 A: N  n: t$ M' S1 j9 Z( y
37. % s7 ~% T4 s+ Y\" c
    
38.   int x = player.x - (Wide / 2);
    . L( U. {: C2 R
39.   int y = player.y - (Hight / 2);$ b* z# l! B! ^
    
40.   //防止窗口越界
    \" d1 k3 j. a1 S& R# F! L9 |- f, i
41.   if (x < 0)6 W\" P: z: g3 K2 A0 p; y
    
42.   {
    3 s& Y6 r/ Y+ x. ^/ O
43.     x = 0;
    ' b\" V5 W* o, d+ y5 A. b  Y1 C( [
44.   }
    1 P9 ~: ]. \8 l* k5 N0 N
45.   if (y < 0)# I% y. F, n0 E# L\" z8 g
    
46.   {
    ' G8 k\" c7 a4 i) c  v; z9 a; E
47.     y = 0;$ |8 b$ O; U% Y$ S, J7 A
    
48.   }
    \" T7 ]1 F+ K) s* m\" T+ {
49.   if (x > Wide_map - Wide)
    : H. {. x3 p- ]$ [
50.   {( g. ~; D1 H) H5 h# `
    
51.     x = Wide_map - Wide;
    2 h) H: t; k4 L. s( S
52.   }
    % g* \1 P; t2 F  b\" i
53.   if (y > Hight_map - Hight)  S# O( A$ p1 s/ M# q) S6 C
    
54.   {
    # ]; Q: a( o' Y+ Q( p
55.     y = Hight_map - Hight;
    $ l. b6 s, O* I& C# T: [8 G4 q
56.   }2 ~/ f# ^- z8 G0 W
    
57.   //把map输出到窗口上
    ; y) r2 C) h4 a3 e) n) A# \
58.   putimage(0, 0, Wide, Hight, &map, x, y);3 y. D( [; x+ M# A1 y; O
    
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. //防止窗口越界
   / M1 e* E& i# L1 G
2. if (x < 0)
   1 s\" a0 X; ?# q: l
3. {
   3 q' ~9 p+ T! M) u! s* v0 Y
4.   x = 0;
   / _1 k& h' e& Q
5. }( ]+ Z8 M- W& Y- J
   
6. if (y < 0). U3 |5 E& T( S
   
7. {
   + X4 d6 `. |0 \3 u% A% D\" B* ~
8.   y = 0;
   . n, X/ k\" Y5 l1 y3 h
9. }
   6 f$ c1 y* G+ v8 {! R6 @+ H( l
10. if (x > Wide_map - Wide)
    % N) H' J8 L  o' g9 ]4 b9 a\" {
11. {
    , C0 \9 ]4 V8 Q2 @. y- W
12.   x = Wide_map - Wide;
    4 e6 n\" F4 w! R% Y+ M& I( O
13. }
    * m1 F5 u/ A- @# x
14. if (y > Hight_map - Hight), A# z( R; Y  d( B
    
15. {8 ^* _6 m6 _4 D+ @0 f( n
    
16.   y = Hight_map - Hight;, P, {' s- |# w\" \* ?
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
- G$ g, w! X% w
: W, S" `3 O! O; h(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
% q) h5 P$ _, W2 ^) _- C
# c: q2 b2 g, o! w5 m' |9 tWide：这个参数指定了要绘制的图像的宽度。

Hight：这个参数指定了要绘制的图像的高度。

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

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

1. //距离( j( c+ _- r$ n& Q0 u
   
2. int Distance(int x, int y, int x1, int y1)
   $ o0 k( C. ], r4 ~2 K3 Q# `: g. N
3. {
   : A1 f8 b- F9 c
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));0 b; \2 L+ C& q) [9 L, I
   
5. }

复制代码

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

1. void Enemy_move()7 ]  r) x# Y9 G: d1 t* }) ~
   
2. {0 f/ n) ?* d4 }. e. C6 C$ S
   
3.   srand((unsigned)time(NULL));2 T+ m8 f; P5 Q  s) {1 H
   
4.   for (int i = 0; i < Enemy_num; i++)2 s7 r6 G! H2 |/ B8 p1 m$ ]
   
5.   {6 ~5 |\" L/ t5 l2 l9 X8 ]3 V. ^' \
   
6.     int direction = rand() % 4;
   6 ?* {8 e% Z% r% h* V
7. 
   1 Q6 m1 ~( ^' y6 t. r
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   & y6 a8 ^# C+ I: d, w2 \0 H
9.     {3 R, \4 ~5 u6 T( T
   
10.       if (direction == 0)4 A: u8 z. D\" U
    
11.       {
    ! F$ G' l  W9 Y% K9 t4 Z  @. a
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    8 t3 S) E* ]( ?3 \% O
13.         {
    : J, a3 f7 ]. B4 W+ O3 p
14.           Enemy[i].y -= enemy_sleep;# n! n% Z7 L7 ^7 n5 {3 n/ Y
    
15.         }  \! ~- m+ L4 P4 }8 F
    
16.       }' J* x, s# h: Z9 f
    
17.       if (direction == 1)
      ]2 `# G  a2 s. N9 e
18.       {, P5 k/ f! t, l3 W9 n+ X8 m, s
    
19.         if (Enemy[i].y < Hight_map)
    ( G3 u2 P% ]& y
20.           Enemy[i].y += enemy_sleep;; o/ V/ h1 D0 \- W8 G
    
21.       }9 l% Q0 B% x; u2 O1 y2 z
    
22.       if (direction == 2)  K: e/ H+ G5 k& W
    
23.       {) u/ N0 w3 D. H\" Y) N' R  ~
    
24.         if (Enemy[i].x > 0)
    $ w\" N: a& j7 C6 D1 E% E+ v
25.           Enemy[i].x -= enemy_sleep;9 Z5 d* M4 E: P6 ~
    
26.       }
      n5 d: I; W% ?+ ^- }
27.       if (direction == 3)
    6 B. w( V* W, t6 y/ j- i( {9 _1 ?
28.       {
    # j  K3 v  S, v- g! u; [7 K( L
29.         if (Enemy[i].x < Wide_map)& G- x) u% \/ [
    
30.           Enemy[i].x += enemy_sleep;% v: U* U- \0 y# g  K3 r
    
31.       }
    . P: h/ T. T9 g9 z7 h2 ^
32.     }2 k+ t$ g' H2 @7 C  F
    
33.     //敌人追击玩家4 z* S' M6 G0 f
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    2 p! X7 k\" r' t9 |. g! h
35.     {
    0 S+ G# U- q/ |4 r
36.       if (Enemy[i].r > player.r)
    3 N0 G. i* A, L: c
37.       {
    9 E$ Y/ u( d4 h! \: L0 b
38.         if (Enemy[i].x < player.x)
    / F5 m# S3 w# M\" v( O+ q2 M
39.         {9 M( C% E8 X. b% @
    
40.           if (Enemy[i].x < Wide_map)6 G  e8 v' M0 ^\" Y\" I& z
    
41.           {0 ~/ H! B) `$ p+ g- W5 V
    
42.             Enemy[i].x += enemy_sleep;) W- f9 o9 k8 b/ t
    
43.           }
    4 ?, z8 c\" l7 Q
44.         }# s6 Q1 K* P: P; d
    
45.         if (Enemy[i].x > player.x)
    8 h2 C' g, \% e! E
46.         {# U9 F* B+ d7 f8 ?) N\" D+ z8 U( e
    
47.           if (Enemy[i].x > 0)
    0 R; j9 V+ I; X5 c3 c
48.           {: _0 E: g* ^7 y
    
49.             Enemy[i].x -= enemy_sleep;9 }0 L3 W$ e0 e' e- ~2 x
    
50.           }
    \" e! {* {: X, L! E6 n. d
51.         }3 A6 T1 \. X8 @1 y6 y+ d\" ]
    
52.         if (Enemy[i].y < player.y)
    - ^9 m+ x% w8 R- N% a& Y  \6 y- i. y
53.         {
    4 U! q5 \6 U) w- Y8 N
54.           if (Enemy[i].y < Hight_map)7 X+ P  N# }; y# ~
    
55.           {
    ; j( Z: a7 j+ R  c% \4 [9 x# @6 [
56.             Enemy[i].y += enemy_sleep;7 O$ {2 H\" L# t# R3 L- l
    
57.           }
    ' T3 V3 X& W\" K6 d* S. s
58.         }
    1 s+ I1 ]9 U0 o+ d- K! ^
59.         if (Enemy[i].y > player.y)
    ) A. ^, U7 D/ k1 }+ l
60.         {0 ?& f* i+ u8 C$ y7 u  v- S
    
61.           if (Enemy[i].y > 0)  b5 h: O' P+ C1 e- i7 F
    
62.           {
    8 X, Q$ X2 w* Q. ^& i  C6 ^  L
63.             Enemy[i].y -= enemy_sleep;
    # q1 K! z7 U6 ]7 I. }/ L+ t1 t
64.           }& e1 a8 G/ @' g, I- W
    
65.         }
    , E( I, j* [; e* G1 D
66.       }9 o5 F\" Y* j) k9 c5 e
    
67.       //敌人逃跑8 ?9 b- m( A  k( B3 _8 d
    
68.       else7 W9 x+ l8 p4 `\" b) Z* @$ U  o
    
69.       {7 n1 q+ n! G+ P: C5 e5 P  ^1 G6 [
    
70.         if (Enemy[i].x < player.x)* F) g- e& y# ~
    
71.         {3 U+ S) p/ R' _
    
72.           if (Enemy[i].x > 0)
    + T8 p9 e, G4 u5 }
73.           {8 b* e6 S1 H; I% r\" V; k8 t, R; |; J4 E
    
74.             Enemy[i].x -= enemy_sleep;
    + a& `3 ^; N1 `  N% u+ P9 U4 d
75.           }1 Q; y1 J, @6 @* i9 s( ^0 u3 b
    
76.         }- j7 P; U% P\" p
    
77.         if (Enemy[i].x > player.x)0 R+ F9 |' h# W; v. F/ m% ^/ I
    
78.         {
    / f7 Z8 r4 \- d5 H
79.           if (Enemy[i].x < Wide_map)
    % o) L: C- [  {# i
80.           {
    3 E5 e7 W# `- Y\" o5 U2 y4 o
81.             Enemy[i].x += enemy_sleep;
    5 U( R* N6 _7 |
82.           }- u0 D* D+ `* P4 ?: z* ]( W; ^
    
83.         }7 z& A% {  S, M, e9 f$ d
    
84.         if (Enemy[i].y < player.y)\" `; ~# y3 p; N4 b& {
    
85.         {
    & |6 s1 E, V' n+ _
86.           if (Enemy[i].y > 0)6 A! _3 a4 j* c3 @* F
    
87.           {2 ]- I0 J\" N/ z5 q- Y) ~
    
88.             Enemy[i].y -= enemy_sleep;
    - v0 F+ y9 L! L
89.           }
    , A# J* ~% c; g7 t+ I- d
90.         }
    $ m$ O\" t2 Y4 W, m
91.         if (Enemy[i].y > player.y)8 f# d; z9 G. ~) P, w( W3 I
    
92.         {/ r/ G: y8 j$ B$ e0 G  l
    
93.           if (Enemy[i].y < Hight_map)+ x8 `# ~) x1 t
    
94.           {
    & B( }# U1 W0 P
95.             Enemy[i].y += enemy_sleep;: B! G+ y& q# }+ [: i3 R
    
96.           }
    8 g\" ~# c' U) {
97.         }( X% J7 ^5 ]. J8 G
    
98.       }7 q: @! ]0 Y2 H& e
    
99.     }
    6 R# F) O\" Z& k6 q+ w; ~% t
100.   }
     ( ?9 ]6 I, K  ?- }& m1 W& c
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   1 x, G, G% t: v9 k
2. {0 r% C7 ]; r/ k* N0 Z. T
   
3.   for (int i = 0; i < Food_num; i++)
   6 o2 ]) x( N5 X
4.   {
   4 ?\" w8 ?! R) [! Y. l% }6 U  G/ b
5.     //玩家吃食物( a* Q# t  T  E$ i
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)9 M% h0 D$ d5 ?) w) z' L
   
7.     {0 F( N4 X* Z- D' r, {
   
8.       player.r += Food[i].r / 100;
   5 D1 J8 t\" j/ g$ M/ L, c. g
9.       Food[i].x = rand() % Wide_map;: Z4 O2 o& T8 q. v+ p
   
10.       Food[i].y = rand() % Hight_map;
    2 A8 M8 o; Q1 K8 J: {  }' U
11.       Food[i].r = rand() % 5 + 1;4 f' d7 v5 K& h' K0 E' t1 n- Z
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);4 x' L8 e- N9 f. y\" W# z- v5 Z
    
13.     }
    ; Y! i4 d) z& [# m) \\" C
14.     . X3 `1 S; Q7 F# c/ ^' d. E
    
15.   }5 y* X\" g* R8 Z
    
16.   for (int j = 0; j < Enemy_num; j++)% F+ a: m5 {  o) U' q
    
17.   {
    ; G, ?0 y- I7 I
18.     //敌人吃食物; F' Q( U$ u& X$ S6 s
    
19.     for (int i = 0; i < Food_num; i++)! j: W; j* `- n) q4 }\" Y2 d' S
    
20.     {
    ; O3 p9 W) O\" p8 r' C7 K) D. j
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    1 X' n9 j5 b% t, l; q
22.       {: r. n: w* `3 L, h5 d6 B4 L
    
23.         Enemy[j].r += Food[i].r / 50;7 v4 U) t\" Q8 G: n( g
    
24.         Food[i].x = rand() % Wide_map;
    * o$ l' W- k! k. n
25.         Food[i].y = rand() % Hight_map;  K0 c6 P  f6 P, U. Y\" Q% M
    
26.         Food[i].r = rand() % 5 + 1;7 z$ w* Y/ [4 ~2 S9 f: E- X\" W
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    . g6 Z3 T\" S' u
28.       }
    5 B* ~1 q. @4 I* O( B
29.     }
    % V6 G7 m( a) I
30.     //敌人吃敌人
    * [2 _/ b1 z7 J# o
31.     for (int i = 0; i < Enemy_num; i++)- u  D) K0 u  q
    
32.     {3 M& n3 D% s% w: }$ F0 U
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    6 t$ z( h# X6 \. |5 ^
34.       {
    & U+ A4 T3 ^, J) ^8 N5 ~3 f
35.         Enemy[j].r += Enemy[i].r / 10;
    1 n' j4 f; G! I9 a
36.         Enemy[i].x = rand() % Wide_map;+ \3 @; R2 V5 ], m2 E
    
37.         Enemy[i].y = rand() % Hight_map;- f1 c% P4 ^1 k: G: \+ K! _$ a& Q
    
38.         Enemy[i].r = 10;! F% e2 i6 O( s2 t8 m
    
39.           Enemy[i].color = RGB(0, 255, 0);
    5 Y% Q% C7 \6 A7 k; S: s
40.       }8 R6 Z4 f7 e7 ]8 P, e\" k  s6 b
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    ; M5 ]* f+ ^  y& U* c! p% P3 p
42.       {) g* L) i% \. t4 i
    
43.         Enemy[i].r += Enemy[j].r / 10;7 a\" l  d- c. h% d3 D! ?' `
    
44.         Enemy[j].x = rand() % Wide_map;- S\" q- U- X. \2 F& Y
    
45.         Enemy[j].y = rand() % Hight_map;
    : V& B, A( h+ q\" Z% h
46.         Enemy[j].r = 10;7 S0 p; u% x$ v8 u# x* r2 r
    
47.         Enemy[j].color = RGB(0, 255, 0);! I- j' u- Z' W
    
48.       }; `2 u5 B2 n5 o! q. @, Q8 D  J4 d
    
49.     }
    2 T6 d* `% Q& o2 z. R
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    2 ^/ `* q; Q# N7 h! |% K3 k
51.     {5 g/ ]# J1 I- J1 \
    
52.       //玩家吃敌人
    ' d  g# ~& o& @6 v& C+ x
53.       if (player.r > Enemy[j].r)
    4 P% \9 q, O! E+ V$ D; o- p
54.       {( t$ O0 }8 e. E* t, G- W0 E
    
55.         player.r += Enemy[j].r / 10;1 q+ v1 w# D$ w  X
    
56.         Enemy[j].x = rand() % Wide_map;
    & o/ u9 i4 J) r\" S& E8 T+ E
57.         Enemy[j].y = rand() % Hight_map;
      C- r5 r4 J; |
58.         Enemy[j].r = 10;
    5 t  j% X# O# ~
59.         Enemy[j].color = RGB(0, 255, 0);
    & H2 e7 v3 }/ N, k
60.       }% h4 Q1 o% [# N8 l) N  [! o9 n8 m
    
61.       //敌人吃玩家
    4 l( ?4 [) |2 Y& i, t
62.       else
    # W' w) j+ U7 |3 ]! s
63.       {- r' t; w1 ~* E, O5 d1 A8 ^
    
64.         if (invincibility == 0)1 J; t! A9 N+ p' T2 p
    
65.         {% l: m, Q8 H0 R/ b( [8 r6 d* V
    
66.           Enemy[j].r += player.r / 10;
    ) J\" d& z, c- q! a# h& m8 a/ c, Q
67.           player.x = Wide / 2;
    $ U( T9 ~8 r\" A
68.           player.y = Hight / 2;  Y4 o$ [/ a6 T  F* Y- P2 v# G
    
69.           player.r = 10;
    5 }; Y9 Y\" }% ^( Q
70.           invincibility = 10;# x- k- \) _) U& i5 ]) W  p
    
71.         }; J# p1 K: y6 d/ s. @# j. T
    
72.       }' h6 Q5 O% N$ y. c0 |0 M& i
    
73.     }
    3 }9 E$ w/ K& T' k( W) k
74.   }( i- k; K7 f' S2 w
    
75. }

复制代码

完整代码见附件：
/ p  e2 n- s' I# b' O+ {' V1 J8 i
; G) ?5 b+ f  [+ X9 T