球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
7 b# r# o0 p1 E( @( p" t" o
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
% p7 ^* W6 n! K- y7 X0 J7 Y0 M
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

. e6 L6 z2 q$ N5 o5 A. f0 s玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
* Y3 |% {6 r3 y( V$ {
* _7 S: n; v2 {5 O$ A) Y5 Q, s1 ]ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
; X4 S/ G3 H9 X$ f: I8 e( u/ X% \
接下来，我们将通过以下几个步骤来实现这个游戏：
4 }  o9 s! i, h
1 P0 V/ \- ~, s初始化游戏界面和小球的信息。
4 X- d" W4 `5 i- ^1 U; ~% w" N
6 |- p9 M& S4 g4 z2 y, V处理键盘输入，实现玩家小球的移动和加速。
5 F( F2 a2 r, \! E, J4 n0 w
( T+ s- m  _6 [; `! M4 q: j! p生成足够数量的食物小球。

5 c. L6 d. T' S4 R生成ai小球，并控制其移动。
6 {' k* H* f1 C: b$ `4 U3 Y4 C( E' e
# P# i% W- Y) U# G* ^( i& i2 a检测小球之间的吞噬关系，增加相应的体积。
" p" j$ g0 B) G3 D) ~
8 U/ w9 p* h" Q& T( K( D$ L% X通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
& V5 r6 {& a+ B' s+ B
1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

* N3 M3 o9 f8 Q8 ]: z3 J3 Dstruct Ball
{
        int x;
        int y;
        float r;
        DWORD color;
};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
, d! I& u- \( n- A8 F) q( {+ n
$ n  B0 v) u& p* XRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

5 R% {6 i; E; R/ ]橙色可以通过RGB值（255, 128, 0）来表示。
8 A4 |6 x0 x$ j  \8 c黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
! e' A2 S- r+ H( x紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
! z3 q6 r) e# e' {( [/ B/ G. k白色的RGB值为（255, 255, 255）。
6 Z7 _1 H, J! o& `) S6 h0 G1 O灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()) p# c# \4 N- `! {0 ~
   
2. {/ F0 h' Y! q; U0 Z  d
   
3.     //玩家小球& d! @: X7 u$ E
   
4.   srand((unsigned)time(NULL));
   2 O1 d( T  h0 L& }1 J
5.   player.x = Wide / 2;
   - e; D/ p0 p: i/ J* `5 f
6.   player.y = Hight / 2;6 n, `% u3 v7 n5 c7 K8 w3 N
   
7.   player.r = 10;
     v) I# E; X8 M% J\" n. i
8.     //食物小球( D0 o5 t5 C1 n\" M
   
9.   for (int i = 0; i < Food_num; i++)\" L* {% y7 L6 z6 U
   
10.   {
    $ l8 t4 o7 Q7 c( {& @/ f& x9 G
11.     Food[i].x = rand() % Wide_map;
    2 r2 |; m9 [5 G4 B# Y0 D. X! l) ^
12.     Food[i].y = rand() % Hight_map;  S6 n- p& }9 }
    
13.     Food[i].r = rand() % 5 + 1;0 O3 {3 H0 G1 K7 j  L6 F! ~
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);. ^  Y. R# ]2 e
    
15.   }3 N- }' G9 d& |  X) ]/ H
    
16.     //ai小球6 T- G5 O\" {  n* e. C  v# ?
    
17.   for (int i = 0; i < Enemy_num; i++)
    0 |. C1 C, i) m( \7 w9 U  B
18.   {. c/ T, M! D) b# c; Q
    
19.     Enemy[i].x = rand() % Wide_map;2 C. ], i9 \  K. C: l& {
    
20.     Enemy[i].y = rand() % Hight_map;$ p# l\" ^$ n* D\" ?% E$ p) o
    
21.     Enemy[i].r = 10;3 E( L  {' d) i; s3 u* I
    
22.     Enemy[i].color = RGB(0,255,0);9 {& K9 o7 e9 C8 [$ J$ q; g+ ?
    
23.   }
    / K* }: g* F. [4 P3 ]\" s  V, L
24. 
    7 U: {. {' v& y4 k# J( |
25. }

复制代码

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

1. void Player_move()/ w! x2 e; Z9 l' n
   
2. {4 X\" \2 u  o$ r2 ^
   
3.   if (GetAsyncKeyState(VK_UP))4 \' X0 B9 g6 r
   
4.   {
   7 j: N/ _( B: P- x' f
5.     if (player.y > 0)
     \. T. B* V; H$ P
6.     {
   2 b) U4 D% ^8 v  j\" j6 K+ N
7.       player.y -= player_sleep;
   , z6 S5 A+ J+ \3 G8 S4 ~
8.     }
   4 u5 f  t5 f7 H* ?$ d2 c- j/ u
9.   }\" I8 \. O! c/ e
   
10.   if (GetAsyncKeyState(VK_DOWN))
    7 c7 f7 t6 @! l\" a) `\" n
11.   {
    % S, J9 _( n2 w* a
12.     if (player.y < Hight_map)! E1 k( n$ }. d* u4 k
    
13.     player.y += player_sleep;
    * S/ M9 k$ c* K  {
14.   }
    9 t\" S) v8 x+ U
15.   if (GetAsyncKeyState(VK_LEFT))
    2 \) S( ?/ y- y\" Y1 t( `
16.   {+ U7 w\" V) E! h- s3 [2 C+ I
    
17.     if (player.x > 0)
    * J# X6 v8 b% A
18.     player.x -= player_sleep;
    9 o. Y; j2 q6 |9 M
19.   }
    + O5 }  ]$ ]9 X. s7 V
20.   if (GetAsyncKeyState(VK_RIGHT))
    8 J. u0 }# s' @7 Y: L% g- z2 s
21.   {
    , D1 w* P\" x4 [
22.     if (player.x < Wide_map)
    5 q- k& m& F4 K! b' N5 o) I  a
23.     player.x += player_sleep;3 x: h# `! e8 z5 ]$ o$ y
    
24.   }
    : h7 o6 |' X6 i. @+ c
25.   if (GetAsyncKeyState(0x20))
    - j7 V6 r# }5 w! Q1 @$ g4 {* \% h
26.   {) z2 @3 S- t1 O' p
    
27.     player_sleep = l + 5;# v% l\" [0 \# F$ O8 o; l
    
28.   }
    $ r& l9 v4 r9 z\" R9 h! `+ H+ t+ z6 {
29.   else. m' p2 `. `- s9 J+ B, H
    
30.   {% k& d/ ]& l5 w
    
31.     player_sleep = l;
    . Z) F. ?# e- i1 y3 h
32.   }$ h; z% Y( t  X* L3 J
    
33. }

复制代码

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

1. void Show()* Q. S9 }3 A+ G+ ~( N7 O- l  A
   
2. {0 J$ p  g- ?\" L* u) D
   
3.   $ Z* o9 N) r4 y9 Q4 k2 k7 x
   
4.   //设置地图% Z0 c  I: H8 C1 h
   
5.   SetWorkingImage(&map);
   ! o& _. b8 j( ~) }8 Y5 W
6.   //清屏
   7 J, K. ]* {1 F6 j$ l* W/ l
7.   cleardevice();. V- t. V- x: u# G, u. r
   
8.   //背景颜色
   ' Z\" x( N5 w# Y! O7 U6 ^3 Z) z\" i
9.   setbkcolor(WHITE);
     X5 r9 o! H( g$ X: J1 ~3 k
10.   //划线颜色
      z. S$ `+ D, W) s
11.   setlinecolor(RGB(230,231,239));7 u1 H& F% T, L
    
12.   //划线) k$ g2 p& [; k% @8 V\" l) c
    
13.   for (int i = 0; i < Wide_map; i += 10)
    % m7 z5 k) x- X\" P
14.   {
    , J8 B5 N. ~9 _2 y- {6 _: a0 a8 ^, H
15.     line(i, 0, i, Hight_map);2 L% K3 j2 ?7 P4 R5 v\" S2 L6 X1 W
    
16.   }
      P7 e) ~2 Z3 m+ Z\" Z2 F. J
17.   for (int i = 0; i < Hight_map; i += 10)! ]+ [+ x% z; C8 j' P5 t( ]  ?
    
18.   {
    / y/ M$ v1 a  s- K0 t# B
19.     line(0, i, Wide_map, i);% a6 `  d% H. ]3 `
    
20.   }0 c( F7 l8 Z4 F
    
21.   //食物7 v2 T6 o0 p1 B6 S\" V) Z+ |
    
22.   for (int i = 0; i < Food_num; i++)
    ) [4 P& @: K' y8 n8 Z# Z
23.   {% ]- O; e* }  K
    
24.     setfillcolor(Food[i].color);
    , t7 H) _! T9 B
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);/ i3 U* r5 E/ V8 f9 g
    
26.   }
    ! D) h; @# M& h8 f6 K# s
27.   //敌人- h/ L: h\" S  f
    
28.   for (int i = 0; i < Enemy_num; i++)
    5 {. \7 U9 v+ u0 z
29.   {
      H4 X+ Q8 J5 V' a2 ]6 K- \! Z
30.     setfillcolor(Enemy[i].color);
    ! ^* T+ }2 A- X5 k3 |( @3 w
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);/ y& F2 @/ o! |. H' x9 v
    
32.   }0 `) c* @* h/ a' j2 B8 w  K
    
33.   //玩家\" ], h. W  g% u; }% c\" J/ t* p
    
34.   setfillcolor(RED);! X, H* _, J- Z$ f4 v& m
    
35.   solidcircle(player.x, player.y, player.r);9 f9 [, U' H& y7 r4 Y; ~! N
    
36.   SetWorkingImage();
    ! K\" |, X0 I% v5 \
37. 2 n& z& N' l7 y4 U: P! p# M
    
38.   int x = player.x - (Wide / 2);
    0 ^4 j3 p* i% r
39.   int y = player.y - (Hight / 2);
      V/ J! g) S* F+ _, n
40.   //防止窗口越界+ K! g  m% {( I
    
41.   if (x < 0)2 v8 E5 x8 k3 V4 m! S6 F\" b
    
42.   {
    . u% b6 j4 f& q# b
43.     x = 0;
    % v) k\" Z$ D: }# u( j1 M
44.   }& ~5 p, i2 P, z! |3 k
    
45.   if (y < 0)* K+ L3 B+ d8 f) v. f
    
46.   {
    & r9 e; w6 M- l4 j+ p
47.     y = 0;8 Y9 o0 w# z% o3 P# d# f
    
48.   }8 h& O# |9 ?/ b' |\" P/ ~5 E
    
49.   if (x > Wide_map - Wide)
    $ n5 |  j\" M% E( J. p7 \
50.   {' c$ v7 `: {- w+ Q
    
51.     x = Wide_map - Wide;
    5 y4 s& o7 o, N' w2 O
52.   }
    6 F4 G! d1 H/ s1 }
53.   if (y > Hight_map - Hight)
    6 Z1 I9 U* W7 U9 e! Z) d0 |
54.   {
    / W7 e# @7 m4 z3 _3 H0 P2 Y7 T- d
55.     y = Hight_map - Hight;+ W) o1 L; x* ~$ k2 b# Q$ B
    
56.   }
    7 w# `: j7 ~! {$ F, q' r0 U3 y
57.   //把map输出到窗口上
    - a7 c, L1 v1 Z; W
58.   putimage(0, 0, Wide, Hight, &map, x, y);! B2 y0 z$ u  x
    
59. }

复制代码

5. 生成地图
9 o! W( E: [9 r" o1 q可以使用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. //防止窗口越界$ q3 k5 Z+ ]$ {# V+ J8 N. m
   
2. if (x < 0)
   % X3 m0 I2 ^! q6 f8 i3 K7 b7 f9 V
3. {
   3 V3 Y# ~% j4 G! a' k
4.   x = 0;0 d- L! T* B7 X2 ~+ ]9 k
   
5. }+ V, l% R8 l+ F5 P- ]5 A/ l
   
6. if (y < 0)
   ( v7 g7 n& V6 z; g
7. {
   $ w+ s: E7 Y* f% d
8.   y = 0;
   ) e$ }# N$ @1 V9 P& p3 B# ~- G
9. }4 \( G! C( |2 g  d, {/ P5 {* h6 y
   
10. if (x > Wide_map - Wide)& x: T1 t) ?' A( N* i* ?# G% W0 {' n9 V
    
11. {
    5 e2 p. N7 K\" Y8 Q/ h
12.   x = Wide_map - Wide;
    2 u2 H7 e\" M6 D
13. }
    # l' s, w6 V. Y1 Q$ l( F# H5 A! i6 z
14. if (y > Hight_map - Hight)0 {$ W) c/ z4 c7 f! }/ ^; y
    
15. {$ l# h  L, \0 ~: y
    
16.   y = Hight_map - Hight;
    # F  H2 N% {( H2 Y\" z: w2 z
17. }

复制代码

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

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

0 [  `) E* e1 AWide：这个参数指定了要绘制的图像的宽度。
& ?3 f, u4 ?: }/ f
Hight：这个参数指定了要绘制的图像的高度。

+ l, g) I1 A$ c6 b8 A" f* n&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

  w! j4 d% y7 A( C$ z5 [' }x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离( L! Z' Q& U+ v$ t( w* i1 }) l7 [
   
2. int Distance(int x, int y, int x1, int y1)- i# w5 x6 g\" Z2 _; J0 w( z1 [  n
   
3. {+ ~) S% n5 s# U/ `& x# |
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));0 B; j5 X# _7 C  M& ]
   
5. }

复制代码

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

1. void Enemy_move()5 {2 W* S: R* O' I8 Y
   
2. {- _5 B# b& U2 i2 m
   
3.   srand((unsigned)time(NULL));
   0 v! A6 R3 ]* \; s$ T. w* U1 W
4.   for (int i = 0; i < Enemy_num; i++); x8 S/ r* L  @, c5 ]
   
5.   {
   * ~& ^/ i. r1 y
6.     int direction = rand() % 4;
   3 W- V  K0 r# a- B  x6 L: J
7. 
   : f6 {4 L6 j5 L$ p' O3 ^# {  h8 q
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   4 f1 d9 V7 u9 W
9.     {$ C& Y) c( C8 G
   
10.       if (direction == 0)/ T2 e% s. G, C. W1 G$ M
    
11.       {
    6 W\" V8 O: [- s* ]1 w) F  o
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    # |( C2 ~1 X: m8 w
13.         {
    ; f. }+ \. s; q' ^
14.           Enemy[i].y -= enemy_sleep;6 K7 Z3 J: M* `$ ?
    
15.         }
    ( O* j9 Q\" v3 ?
16.       }4 H' q9 e, j( v) H/ H
    
17.       if (direction == 1)+ R' O( t: ?5 T) c9 ~: B
    
18.       {( j5 Z* A8 E' \  W
    
19.         if (Enemy[i].y < Hight_map)
    ) X, `% }. P3 {; U; y/ S9 p
20.           Enemy[i].y += enemy_sleep;
    ! v) u7 ^1 U  }* U
21.       }- I, Z- ]3 g6 z$ d$ H* x
    
22.       if (direction == 2)6 w( }6 \  ], m9 X
    
23.       {# ~0 |2 T1 @5 ~
    
24.         if (Enemy[i].x > 0)7 i3 S1 ?; g4 Y! D; e
    
25.           Enemy[i].x -= enemy_sleep;7 f: `; C! [7 D2 W/ K. S; Q1 z
    
26.       }
    8 f9 t# Q3 \* L3 P% z& O+ m
27.       if (direction == 3)
      T! }( }% U1 g  T; v6 X
28.       {2 F0 N/ O* x! e# p6 U4 a\" X4 k5 w5 T
    
29.         if (Enemy[i].x < Wide_map)1 ?' ]& W, z3 C( x% r1 P% R$ |2 [
    
30.           Enemy[i].x += enemy_sleep;+ y6 N. o7 z1 f  e: y
    
31.       }* G\" H5 n* n: o$ i! w
    
32.     }$ D& Z- V/ [\" W: j( k
    
33.     //敌人追击玩家
    3 i5 q' c: x: a% j5 g
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    - w# s  ]# U8 l* i2 V* I7 t
35.     {2 N+ Q0 t5 x- [( ~. p
    
36.       if (Enemy[i].r > player.r)' J4 M; W, W9 d0 R% v6 |
    
37.       {0 g8 s! ~. r1 J* X$ W) A
    
38.         if (Enemy[i].x < player.x)
    # `& D  s- G7 I: I
39.         {3 V1 m: e% _4 d0 G* E$ y: H9 O: [
    
40.           if (Enemy[i].x < Wide_map)' @$ y- T% [\" r
    
41.           {6 l- a$ D1 t7 u$ N# @* l1 M
    
42.             Enemy[i].x += enemy_sleep;% d& W. X, W4 o5 P  w( @, t/ t
    
43.           }
    0 h* O% p% {# V
44.         }
    ( L# |+ M7 Z: |; O
45.         if (Enemy[i].x > player.x)9 h, U5 [9 ?3 u# l: C! u* }
    
46.         {
    ) M  M2 k7 `# M- w1 ?, j
47.           if (Enemy[i].x > 0), H5 ~( O; s7 X* r% b) `
    
48.           {
    - s. w, O/ o# p# v% S
49.             Enemy[i].x -= enemy_sleep;
    ; E) E: L* ?  S+ m; a! ~  O
50.           }
    4 R: [; K: N* `% i8 s/ f
51.         }
    ! Z7 L$ z! D3 N8 f% [/ c
52.         if (Enemy[i].y < player.y)
    9 F7 D7 z6 }5 Q8 s- I. Q; u2 H3 D- p
53.         {+ Q+ U, X1 n: Q: y9 ?0 W  q
    
54.           if (Enemy[i].y < Hight_map)' w4 d4 H: j\" b! w* p
    
55.           {
    ) j1 h/ g3 s2 S$ ~* q/ x
56.             Enemy[i].y += enemy_sleep;
    : g; G9 ?3 |: z\" a
57.           }
    + e! }+ \5 q9 y# n' A
58.         }
    0 F2 u6 T3 v4 @( i: _* ]2 C
59.         if (Enemy[i].y > player.y)
    # Z% k2 s/ Z/ S5 h* h! }
60.         {  s4 x3 p6 f2 ?( B) F
    
61.           if (Enemy[i].y > 0)8 P; M3 l/ B& G2 E
    
62.           {/ w6 f& W4 F9 A6 P
    
63.             Enemy[i].y -= enemy_sleep;
    + T& r0 m( g# P
64.           }2 v$ S0 f4 ~# M! M  J! `/ Y
    
65.         }
    5 t0 r( l* y9 n
66.       }: q4 Z\" v\" n\" H; ]4 \  I9 ^
    
67.       //敌人逃跑
      Z, @$ [& y, N
68.       else- }$ u1 s\" W+ Z9 t, e6 {
    
69.       {# ?+ \\" m# i% s( T- {6 b, H
    
70.         if (Enemy[i].x < player.x)
    ( m0 q* O1 M! y8 A; P9 B, u
71.         {( O6 s) ]& t8 R: C4 l; K6 M
    
72.           if (Enemy[i].x > 0)7 T  E7 `4 D9 Y+ {\" K5 ?2 I: @
    
73.           {
    + g0 U8 ^9 I. v9 J/ z8 A( P3 _0 {
74.             Enemy[i].x -= enemy_sleep;( k# }( |9 C1 J( P7 ~
    
75.           }
    $ ^' y* V6 e& M& T\" D0 t
76.         }
    9 R1 t( p$ C8 D& f
77.         if (Enemy[i].x > player.x)- m8 o5 \9 @  l  }
    
78.         {( z; t8 R2 u# |, K1 k
    
79.           if (Enemy[i].x < Wide_map)
    : Z  z, _( ?7 g& i# i5 A, ^
80.           {
    4 h; j+ D% M7 q  P$ f1 Y* q
81.             Enemy[i].x += enemy_sleep;\" R4 ]2 i% D\" b( X% i
    
82.           }) }* z2 [2 C' ]6 Z+ I# n* z
    
83.         }5 V' J( D% ~* {
    
84.         if (Enemy[i].y < player.y)
    - h; t6 O1 k5 H  s- i# B+ W8 I
85.         {
    ; a; ]\" K; i6 ?
86.           if (Enemy[i].y > 0)
    : b. {  W% |9 w
87.           {) ]% W& ^: a3 @; p: W
    
88.             Enemy[i].y -= enemy_sleep;! C, D1 R5 U) _5 i: l2 j& \- ~% _
    
89.           }$ C( P0 U/ s: x; r- m9 S; E
    
90.         }9 c3 D1 {+ n. p8 u/ ]* a
    
91.         if (Enemy[i].y > player.y)7 a, s2 T. a9 }8 I: J. F/ y
    
92.         {
    6 w* Z1 S9 Q8 S/ s  P% m9 l
93.           if (Enemy[i].y < Hight_map)
    3 m. G: B4 z- O% W0 [7 C2 H
94.           {
    / h3 H+ \7 i5 \: k3 E4 O# }' g: e
95.             Enemy[i].y += enemy_sleep;( B, S9 d1 Q; {\" x9 m
    
96.           }
    & m% J  X% i1 K
97.         }
    2 j. D' e$ j# S$ X1 |5 w- G; o' H
98.       }
    ! W0 X0 y% \* B- b: X
99.     }
    6 E. S( a9 {$ K' @6 r( `. c
100.   }8 p4 e: P- \1 F. _4 l  L2 d
     
101. }

复制代码

7. 小球之间的吞噬关系
' G1 g9 o: A0 J5 p1 ]

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

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

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

1. void EatFood()
   * K% P; a2 k; e\" t
2. {
   8 n4 w  N$ P1 ^\" ], K, N4 i4 l3 S
3.   for (int i = 0; i < Food_num; i++)' x\" m. z, ~4 o4 T
   
4.   {4 p1 y4 n# y4 }$ ^
   
5.     //玩家吃食物( {7 Y* y6 w( W8 N$ Y+ `5 F, Q
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)7 e0 |: y- |' I3 \& i7 P
   
7.     {
     z* `; B; k3 h9 K3 U7 c4 S; h
8.       player.r += Food[i].r / 100;9 e5 @$ W# U7 I% v4 }1 N
   
9.       Food[i].x = rand() % Wide_map;1 w3 O4 y. I- r
   
10.       Food[i].y = rand() % Hight_map;6 x; f# Q* F7 R+ I7 S
    
11.       Food[i].r = rand() % 5 + 1;) w2 Q8 I: v  C3 C5 u
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);\" o/ L, h/ h! H4 @% z
    
13.     }) B( x% \  p9 {% B: ?4 o, W
    
14.    
    ! }4 x, d0 Q0 D( H
15.   }
    0 W- l: c! `9 P; ?0 N* b. J9 i
16.   for (int j = 0; j < Enemy_num; j++)5 u) h& _/ Y8 g
    
17.   {- @1 ^* l* }# `- E7 {6 |, z\" Z1 }
    
18.     //敌人吃食物' u\" A- w% h' W. C$ U) }) y\" a, v
    
19.     for (int i = 0; i < Food_num; i++)\" |( c. e# }9 T! @) w7 Q7 ?
    
20.     {% {7 W4 t7 c$ n\" d5 N( O
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    / C( I/ R2 J/ D% w
22.       {
    # |\" b, l  I1 c# t2 ~- `! @
23.         Enemy[j].r += Food[i].r / 50;# ?\" K0 t! L. g/ m# q( r
    
24.         Food[i].x = rand() % Wide_map;
    4 x9 R( W9 J+ |
25.         Food[i].y = rand() % Hight_map;& B; f+ i) W\" l( z+ n
    
26.         Food[i].r = rand() % 5 + 1;. B5 B9 A7 m( a* {1 ^
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);0 J; N9 t\" J' L  g4 x7 }3 ]
    
28.       }( U; l; H# y- v: _# \* u. q\" S
    
29.     }* f* X9 @. k& S- e
    
30.     //敌人吃敌人
    6 c% O5 R  }\" ?4 f. G
31.     for (int i = 0; i < Enemy_num; i++)
    1 z0 b: Z3 c  B
32.     {
    $ l, _: B! f  R
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)* e! g) m3 l% d# }3 Z
    
34.       {2 _2 l3 s2 y6 u
    
35.         Enemy[j].r += Enemy[i].r / 10;
    ) @+ ~' X3 l6 l  t8 _5 A
36.         Enemy[i].x = rand() % Wide_map;
    ( l# K# }7 P& a- Z
37.         Enemy[i].y = rand() % Hight_map;
    + O9 h7 {* i& Y/ g- x1 x
38.         Enemy[i].r = 10;
    * y7 j6 c4 `& a4 i
39.           Enemy[i].color = RGB(0, 255, 0);7 |& K; W6 H% Z0 l
    
40.       }
    0 o, F% @2 P4 E& ]- v; l6 n) T7 x
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    # v! h; i! \, i! |$ K. J
42.       {
    3 u. G0 U/ h1 F
43.         Enemy[i].r += Enemy[j].r / 10;7 m6 z$ `7 z3 f' z\" i
    
44.         Enemy[j].x = rand() % Wide_map;5 r0 D* b' e. h
    
45.         Enemy[j].y = rand() % Hight_map;
    * S& X; m& i* [+ I; v+ r
46.         Enemy[j].r = 10;( a% r  H% Y) k( R. ^5 q+ w- g
    
47.         Enemy[j].color = RGB(0, 255, 0);$ H1 v1 g) H9 D* s) \2 Q# H/ _8 X\" Z
    
48.       }( e8 l7 N( V7 f, ~6 @
    
49.     }# Q- n: d# }\" g0 K2 h
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    - i+ k% L! H( a- S! r& {
51.     {/ n; _. _: |$ E' Y: R
    
52.       //玩家吃敌人3 c' L  R. M) G& y, }
    
53.       if (player.r > Enemy[j].r)
    / t/ A& \1 c' b( N0 W( P! ~/ W+ r* T
54.       {  B3 ], _1 E8 v( M/ L& D
    
55.         player.r += Enemy[j].r / 10;
    0 N$ @' s. r3 A
56.         Enemy[j].x = rand() % Wide_map;/ P0 t5 K0 n\" |, a* m' w! l
    
57.         Enemy[j].y = rand() % Hight_map;$ O! a! |# F' [; V7 |) |! e5 E$ T
    
58.         Enemy[j].r = 10;
    3 c/ d0 ?$ b& Z' E
59.         Enemy[j].color = RGB(0, 255, 0);
    ! w  p+ i& c# |1 h0 o
60.       }
    ; w# ^' P8 g5 f' n9 D$ W$ H, |5 [
61.       //敌人吃玩家* i( q  f5 h' d7 t. v; ]
    
62.       else
    9 j0 i) i5 w3 y\" Z. f1 \! Z5 j\" v
63.       {9 m9 O2 f- v& c
    
64.         if (invincibility == 0)
    \" V- O: s# @) g4 h8 W8 r8 @! E6 P
65.         {
    5 W% X- q/ L; W1 E\" D1 y& k
66.           Enemy[j].r += player.r / 10;$ _% N3 D2 j\" T. @  k$ K( B
    
67.           player.x = Wide / 2;
    # k\" a+ Q4 t4 D1 \1 X0 ^
68.           player.y = Hight / 2;
    5 D/ T# Z6 Q6 C' j6 E% m
69.           player.r = 10;
    / ~; n5 |' n, ^/ K
70.           invincibility = 10;  ]# d8 s\" t$ V+ o5 X$ M( N; k/ l
    
71.         }
      y5 o- z7 G$ E$ T4 M\" Y/ r# h' v8 m, f
72.       }
    # j, |; p! g7 r* |
73.     }2 B2 y' F1 A( H9 o' g: R
    
74.   }
      }' _/ ~% R  E
75. }

复制代码

完整代码见附件：
# u7 p) w0 {8 ]& X

: p& O6 e( N6 z) M. U
( `3 K6 Y5 l6 n2 Z6 ^+ m2 N4 F7 w' _( Q