球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
# N8 A" G6 n; B+ L6 \0 k
1 I5 r2 c+ a2 _8 ]. y+ H在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
1 q+ E" u3 n! E4 T
) V0 z. u# R# X* A9 m# }) x游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

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

- t2 }6 J7 t: l, [, }其他小球：其他小球又分为食物小球，和ai控制的小球
  J$ X( Q2 R8 f- v( `  a) j/ R/ O
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

  a  G: y8 z, ^& F: l玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
9 Y- r$ T, w% k  o! T3 X7 P8 e
$ {  \, c6 v! R7 \6 f% t) u" Cai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

- V. z2 M  e" A5 e% U6 Q接下来，我们将通过以下几个步骤来实现这个游戏：
3 S& g/ j6 \1 _1 K
8 M. D6 I  t+ h$ v* w  l% Z; v初始化游戏界面和小球的信息。
, [7 O7 g$ p& N
0 `+ T5 G9 u% E, X1 U处理键盘输入，实现玩家小球的移动和加速。

6 c- {" e! q/ D$ _  n生成足够数量的食物小球。

生成ai小球，并控制其移动。
: Q' P& D1 k+ |9 P
6 S$ E& a2 }. D! j  \检测小球之间的吞噬关系，增加相应的体积。
1 P0 @2 }# B. t6 V3 t$ ^
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

. c7 z9 ]( C8 d+ T: \/ V+ _1. 小球的要素
, m0 o0 t9 P: b$ y在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

1 a: a  j5 `8 X. q" estruct Ball
4 H3 E. n7 c, X0 m{
# ]* j/ g: g+ |5 \+ I& }; b        int x;
        int y;
        float r;
7 `- W. w, A# k) v0 y. {        DWORD color;
};
! F; I0 R% V( U0 x$ M2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

橙色可以通过RGB值（255, 128, 0）来表示。
# Z# Q* m# ?+ B+ \+ R& a8 g, A黄色的RGB值为（255, 255, 0）。
2 {" y1 \% h0 j/ {8 O3 r+ }# f: ^绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
* G2 d: [1 B3 J) U1 C黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
5 `* d! h$ u+ N2 d+ ~3 ]- `灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
     W( ~8 ?3 U& ~/ }% b& z) ^: c
2. {3 o! C  D. O- a* K- d* R
   
3.     //玩家小球
   5 S7 t% q3 [, b* r) Q
4.   srand((unsigned)time(NULL));
   : f4 G( @6 m7 i: P
5.   player.x = Wide / 2;
   9 J4 d1 O% h! v: Y  [  n1 U
6.   player.y = Hight / 2;
     q\" g; K- L; S: g, G( g
7.   player.r = 10;) n! n& o; L& b
   
8.     //食物小球5 c! A; w\" n  i/ ^6 K( D. y4 |
   
9.   for (int i = 0; i < Food_num; i++)6 V& K( J0 q  K% e( u
   
10.   {: Z7 x$ W+ `6 J9 D( H
    
11.     Food[i].x = rand() % Wide_map;
    $ v' d2 @3 j+ r
12.     Food[i].y = rand() % Hight_map;0 N\" i! c' n& Q* D9 {( D
    
13.     Food[i].r = rand() % 5 + 1;3 @2 P7 Y. k/ U3 M  t( a
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    0 M8 j6 z9 H7 O1 z# b: T, q
15.   }9 `% `$ [9 ?7 b( k9 ^
    
16.     //ai小球
    1 f# V$ k& m6 H5 ^3 Z
17.   for (int i = 0; i < Enemy_num; i++)
    - Y/ P, a# x  _& b: \' J) q
18.   {
    1 L: }; V& B% e+ j6 ^0 Y' W+ {
19.     Enemy[i].x = rand() % Wide_map;) d\" z\" X) L/ u
    
20.     Enemy[i].y = rand() % Hight_map;\" z7 ^/ B5 m) V
    
21.     Enemy[i].r = 10;
    6 |4 h7 @7 ^' p/ N; ?
22.     Enemy[i].color = RGB(0,255,0);
    1 l4 c# N  r+ g) }
23.   }0 E# \0 F! k+ [# {; [' t1 _2 U; |
    
24. 
    + h  ^! a. S% V5 l! @; @4 y
25. }

复制代码

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

1. void Player_move()* w$ Y7 [6 o\" T
   
2. {
   ) D6 M: {* X) H5 Z* H( c
3.   if (GetAsyncKeyState(VK_UP))  x; @: S/ n- p4 |
   
4.   {, b8 \. r8 Q; @; b
   
5.     if (player.y > 0)+ x9 R: |! [  h/ v
   
6.     {2 c2 n. l& W\" K$ n% e6 M1 X
   
7.       player.y -= player_sleep;
     m- ~\" p- J5 ?! ^# e* w0 z9 J7 o- m
8.     }) h6 z2 k( ]% N, S. B% ~1 f
   
9.   }
   1 G: Q% I2 e: s
10.   if (GetAsyncKeyState(VK_DOWN))& T2 u3 A1 L! R- Y0 g$ }( c
    
11.   {
    ) w  m# n+ [$ j. q7 S7 O0 Q% j
12.     if (player.y < Hight_map)# N: h( e+ d) ~, b  e2 W' F
    
13.     player.y += player_sleep;
    ; x) M9 l8 c) q# E! ^4 ~* ~( `
14.   }% }. @! K% Z  D+ a; Y
    
15.   if (GetAsyncKeyState(VK_LEFT))& q\" M' B6 r' {$ G
    
16.   {& x) G/ R\" m6 Z
    
17.     if (player.x > 0)
    3 C. f2 D6 ~8 M: x1 k
18.     player.x -= player_sleep;
    7 j  z3 C\" w8 a% P\" P
19.   }4 j/ _8 n2 U( X6 K: F1 I( {/ ^/ s
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    6 Q7 l& J' C  I5 _/ v2 Z- C
21.   {% A& Y- z/ N7 m0 f+ \9 P8 }% P
    
22.     if (player.x < Wide_map)+ S5 z. j6 {2 h2 ^
    
23.     player.x += player_sleep;\" v, E* \# u( I& L7 k$ W
    
24.   }
    0 J0 B6 H7 l$ j8 i9 `# i
25.   if (GetAsyncKeyState(0x20)): {# G$ i4 S/ e4 B4 F
    
26.   {
    . m' L7 ]. V2 x8 }+ O. m7 j
27.     player_sleep = l + 5;
    ) P9 }2 S0 e& [, o6 Y5 j
28.   }
    5 ]9 X& u8 ~5 S
29.   else
    , W3 w0 n) p  i, B  K  M. {
30.   {/ b9 P9 K7 P* {  V
    
31.     player_sleep = l;; E# D8 P4 s) {5 M* n
    
32.   }' F; U- ]' k& K2 k4 l. _3 V- P
    
33. }

复制代码

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

1. void Show()7 p7 y! r5 h0 j
   
2. {
   ; }2 z. D5 ^% c. a( O% g
3.   4 F$ a/ P6 E) m7 P$ s\" D% I
   
4.   //设置地图
   & W$ w: L3 O# v7 c6 D. a
5.   SetWorkingImage(&map);$ |1 ~0 w2 R& G, o+ Z
   
6.   //清屏7 z5 I) e1 N9 C' V
   
7.   cleardevice();
   & q! M$ A- F1 j4 a! O* S
8.   //背景颜色3 s' Z2 }% n, o( `8 ~
   
9.   setbkcolor(WHITE);2 b6 q& C$ S) I' A: ^
   
10.   //划线颜色
    6 _( i+ F9 w4 m% s6 P
11.   setlinecolor(RGB(230,231,239));
    2 u5 P; t0 i) K( x4 |* S$ j: u0 r
12.   //划线/ W2 D: R6 A) _* r4 s  Z
    
13.   for (int i = 0; i < Wide_map; i += 10)
    ! D  T' _8 B* ^+ v0 h6 K7 O
14.   {
    $ D3 J5 @0 T- x' c; _$ F
15.     line(i, 0, i, Hight_map);' |+ |3 g6 H& d9 w: h% p) c
    
16.   }/ B8 n' G\" d7 w! {
    
17.   for (int i = 0; i < Hight_map; i += 10)
    : }. W\" s+ {- N! w' h* ^1 d
18.   {+ L* J+ T8 y9 i$ W( H3 g8 Y
    
19.     line(0, i, Wide_map, i);/ l$ X+ M8 m: ]7 v* c/ u1 k
    
20.   }
    ; |, T! [% a+ v  v; d  v' k
21.   //食物+ ~1 r, F  E7 w3 C5 `
    
22.   for (int i = 0; i < Food_num; i++)
    5 m9 P1 k8 M/ W
23.   {% z, h  \\" o/ j' Q
    
24.     setfillcolor(Food[i].color);
    ; L- e% K( @5 C: H5 U3 k
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    0 Q& `1 t) t0 s/ g4 ^! x& j
26.   }
    3 o* e! t+ Z2 f3 m, q
27.   //敌人
    ! [5 Y2 K: u8 [7 u. x( q! g2 Y
28.   for (int i = 0; i < Enemy_num; i++)4 O& Q1 w' m! x  e6 R7 K) Y1 T
    
29.   {- J5 g- ?/ z6 r
    
30.     setfillcolor(Enemy[i].color);
    % y7 F\" y7 ?+ h\" H% `
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ( ?1 Z! A& H, f& l
32.   }# V9 |  N, T. S  j
    
33.   //玩家6 t7 u* ]! e  S2 u
    
34.   setfillcolor(RED);
    . E0 L5 g# t# H+ G\" D1 [& l1 o
35.   solidcircle(player.x, player.y, player.r);& T) O1 N% M% \3 x9 t\" n
    
36.   SetWorkingImage();/ ^* d, d+ e2 }) g
    
37. 
    # h$ R& l7 A$ S  \; b
38.   int x = player.x - (Wide / 2);9 y3 M: i3 t% x- @
    
39.   int y = player.y - (Hight / 2);
    . U* N0 ^* a! m! O
40.   //防止窗口越界7 {, q% {; I7 I' y( C3 g3 u8 m
    
41.   if (x < 0)
    - z2 Y+ f9 H7 a  E4 X  h
42.   {/ ~$ T9 |) f# i% y5 h+ x* Y
    
43.     x = 0;$ s2 E$ Z: F0 v: j
    
44.   }
    $ G6 f. n& \8 q; k
45.   if (y < 0)& I( m1 t, U4 b
    
46.   {\" J+ j& R1 H( n0 f  P7 @- E8 k
    
47.     y = 0;6 ]2 A1 z3 W- G% e
    
48.   }
    # a4 s0 f! N5 C: I8 s
49.   if (x > Wide_map - Wide)( R. d: ^, F0 p& \\" K6 s0 g$ S8 ]
    
50.   {* c8 S) [# q& I4 x1 ]& R, G
    
51.     x = Wide_map - Wide;
    ) ?' h/ V' R0 k4 _! ^
52.   }
    2 ^% @  A. R$ f+ G
53.   if (y > Hight_map - Hight)
    + V7 c4 N: Q+ L) [) m+ |
54.   {
    9 x+ R- i7 _' Y+ n/ u8 \- v
55.     y = Hight_map - Hight;
    & r0 L9 [2 G+ W. H, Z\" O1 I! m/ O
56.   }5 R\" t, }# Q. o8 R! P
    
57.   //把map输出到窗口上6 m' {' z% f; |1 j
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);' }: K! Q, a1 K9 z
    
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. //防止窗口越界& z  b9 J1 r( \4 |- q3 Z
   
2. if (x < 0)- A( ]. |6 G. ]  d  W1 F$ E
   
3. {5 v. N, b6 Z  t; P! S7 Q6 Q9 e
   
4.   x = 0;
   7 l) @; G' N4 r9 w
5. }
   2 J. Y# d\" P3 D: P7 e- k
6. if (y < 0)9 Z5 ~! F8 p0 |5 L9 s, _4 o8 o1 `
   
7. {
   . v) K4 n- N% a9 Y3 U* b
8.   y = 0;2 x, q) R8 ~# C, j, L$ q' `+ o. T* X+ `
   
9. }
   4 ]. Y  l9 h2 v7 N8 U; W\" z
10. if (x > Wide_map - Wide)
    6 y  c* c7 ]. d5 H* n
11. {! l2 j, W+ ]. _/ T; S8 ^$ K9 E
    
12.   x = Wide_map - Wide;3 |5 E! A+ J- v
    
13. }
    - ^) |1 `. L  U' n% |
14. if (y > Hight_map - Hight)  z' p, e# a' k# c9 r
    
15. {, Y4 A4 n- S4 |, A8 o! ~% X& ]
    
16.   y = Hight_map - Hight;  X- z; w. R: @# x' C8 y+ g' L
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
' ^- W  L- m) K& q9 Z+ w
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

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

! ^( F# H6 X) ~, X" a; c- yHight：这个参数指定了要绘制的图像的高度。
% U& p/ Y) s9 u( i
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离2 J) {\" A/ e% L\" b  V
   
2. int Distance(int x, int y, int x1, int y1)+ g$ {# L6 Y# F
   
3. {
   , P& A/ a7 m, }( {
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   # ^' C, @- S6 O# K+ t
5. }

复制代码

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

1. void Enemy_move()
   . Y' U& T8 g4 R, ]- s
2. {5 G+ V* f0 g% N% o/ D+ V
   
3.   srand((unsigned)time(NULL));5 W5 x# b+ S7 P
   
4.   for (int i = 0; i < Enemy_num; i++)$ W# o3 o3 H3 k3 g0 c+ A+ U
   
5.   {
   0 ?5 e, H& y2 O0 K8 N& Y( Q0 A
6.     int direction = rand() % 4;; Y' H5 V! c8 e, N
   
7. - C, P7 {9 M0 z& z- j
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   ! C\" |2 D  ~, p5 E/ z/ W
9.     {) E\" W4 a- p( A! @
   
10.       if (direction == 0)% a$ i- s7 m$ A* m
    
11.       {
    ! e3 _% |\" p, \% b& I; m: c
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    ( r: f/ E1 J6 J: Z; C\" E
13.         {  U6 v% s  ]9 v% }' V) z' n
    
14.           Enemy[i].y -= enemy_sleep;1 G\" L4 y$ d5 N
    
15.         }
    0 G! o: q7 G! N4 ^$ s4 \
16.       }# ~! C, |2 _! y! N
    
17.       if (direction == 1)/ V* m1 h0 \: A
    
18.       {
    2 m, X5 U' k' g# a) p8 L
19.         if (Enemy[i].y < Hight_map)- ^6 x* k) P, @( l$ ~
    
20.           Enemy[i].y += enemy_sleep;
    1 g6 d) P% U9 a, z* C1 H
21.       }
    - R6 N. g2 l( i( j; M
22.       if (direction == 2)5 {7 P1 n1 t' _
    
23.       {
    ! Z9 f- ^% j\" E6 g\" q* f4 T
24.         if (Enemy[i].x > 0)
    ' l0 }) j  n7 g; s
25.           Enemy[i].x -= enemy_sleep;$ n7 L. _/ p1 N$ r* ]) V- h
    
26.       }5 N& L/ H. ~( u0 N
    
27.       if (direction == 3)8 o, }6 n$ p* D$ J, }# ~7 j
    
28.       {
    1 Q: _) O6 J6 p, S& g) i
29.         if (Enemy[i].x < Wide_map)
    / F5 j% \) v/ `: T% T3 }
30.           Enemy[i].x += enemy_sleep;3 p! r: r# u\" z* L8 {% X/ L3 A
    
31.       }# G9 ]) e( m, I% z& u+ `
    
32.     }
    % q1 B9 M! n& b. B/ j6 T4 _
33.     //敌人追击玩家$ r/ U7 L\" ^/ ]! r# _1 _, ]5 F4 g; G
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    6 w( ~/ e: r\" h+ J) T8 {
35.     {0 P' w* [+ T& b2 o) n3 u
    
36.       if (Enemy[i].r > player.r)
    ( q, F9 n9 w# Z/ J
37.       {: Y# \# D7 w\" {7 B
    
38.         if (Enemy[i].x < player.x)
    0 Y5 k* U/ z- \6 Q8 ]! J8 O& P
39.         {8 u4 `; y0 V* a+ i7 `' c( j1 i
    
40.           if (Enemy[i].x < Wide_map)/ Q5 d4 N2 G; `
    
41.           {
    2 d+ M0 ]& v' L9 V6 z% l
42.             Enemy[i].x += enemy_sleep;1 V2 H5 {  \  V5 w- f) y3 P
    
43.           }
    * I( H9 B- @  N* L6 o3 v; M) y
44.         }
    ! w# v. H$ u; O: p; O9 b
45.         if (Enemy[i].x > player.x). g& }: v2 O' M5 V7 E
    
46.         {, j4 e; \) ?* k2 s$ k+ f7 p3 T; h
    
47.           if (Enemy[i].x > 0)3 |  I  B+ M7 @  U
    
48.           {6 x! \! q4 V* t7 S0 ^3 @7 A
    
49.             Enemy[i].x -= enemy_sleep;
    : b\" J$ H& T! I' P# ^4 }
50.           }
    3 g; @5 k4 F8 E. s6 `
51.         }
    + D: `- W* a- x$ Y1 g5 j
52.         if (Enemy[i].y < player.y)4 N9 n, `, N3 j; M9 n& c) Z& c3 [
    
53.         {
    \" F/ N2 I6 O7 R0 ~7 R; D( l& t
54.           if (Enemy[i].y < Hight_map)4 j0 ^0 V5 X! H- ^, \8 L$ ?- B% y
    
55.           {
    5 R4 O( J; E: E
56.             Enemy[i].y += enemy_sleep;
    * _- s% O; L% h# h; r2 ?
57.           }
      O9 k/ c* \7 F( {# V* K
58.         }
    . e- a* c& x  g- }4 x3 M
59.         if (Enemy[i].y > player.y)$ }. u& |$ n* y$ N7 |! }9 C' v! ?' b
    
60.         {) w\" d7 v) b3 f\" K6 ^
    
61.           if (Enemy[i].y > 0)$ c% B, d$ x8 f  ^4 N) P3 V& w$ v
    
62.           {$ `; ]. T. g- }2 V( N  ]
    
63.             Enemy[i].y -= enemy_sleep;2 ]3 @$ T4 t* L- o* X8 w. X: n  k
    
64.           }* d6 B0 h% ~$ F( U7 s
    
65.         }
    . h: S: ?# x+ n' W7 f2 j% ^8 ~
66.       }. M# `$ T  g/ c2 p) M
    
67.       //敌人逃跑\" ^\" E: @( b5 [: d8 o* g1 X6 b7 Z  x
    
68.       else+ R  |. m: w* n/ F5 e# o
    
69.       {2 |1 X+ q4 v; M) Y4 i- r
    
70.         if (Enemy[i].x < player.x)
    \" b( W# ~- L4 o4 w8 _
71.         {
    2 C2 {  v\" \6 f4 z: T. g
72.           if (Enemy[i].x > 0)3 N2 Z. F\" E- u, ]
    
73.           {
    5 \( V* W: R% G7 K9 I* d
74.             Enemy[i].x -= enemy_sleep;
    ' R! \, e& V% A$ A% y! n& g
75.           }
    9 w( s2 g# }+ A7 |
76.         }
    0 v/ R5 |2 K* D5 g6 A
77.         if (Enemy[i].x > player.x)
    / C% c7 B9 `: A. e6 I4 w7 F, W
78.         {
    8 v: b, t- v$ ?* s: @7 l$ g
79.           if (Enemy[i].x < Wide_map)) ]  o' W1 W* L: j; l/ t
    
80.           {
    , x$ ]8 h* ^9 f6 T7 H0 Z0 V1 t
81.             Enemy[i].x += enemy_sleep;
    ' Q( n* @\" X2 e2 T1 n6 y
82.           }9 @8 D1 Q8 p* U* s
    
83.         }; Y6 d  c5 `2 i* f\" ]: y7 a3 X9 k
    
84.         if (Enemy[i].y < player.y); t$ E. Q& y/ J6 f9 K; K6 a; }6 r
    
85.         {
      a' Y/ Y, c1 k$ N
86.           if (Enemy[i].y > 0)
    : _\" u) k, _) F\" I4 L3 q% i; k
87.           {$ V% k/ L: Z- u& N\" E
    
88.             Enemy[i].y -= enemy_sleep;
    & X* Y# C; c- L0 }6 q: h
89.           }  N1 n: N! O+ r- [* E# g
    
90.         }
    8 o4 ~\" n0 G- H: W3 r$ s  B+ j
91.         if (Enemy[i].y > player.y)& I; U$ a' i' C8 x% w1 D3 G/ Q
    
92.         {6 `0 t+ o, h: E! g
    
93.           if (Enemy[i].y < Hight_map)
    . [! ^( F  S/ O/ n; v& f
94.           {% v0 s% d( a- ~
    
95.             Enemy[i].y += enemy_sleep;
    & W- y& g6 K% S: z8 |7 F
96.           }
    . y* T$ e! G$ a4 c- l9 F
97.         }
    , z5 Z+ S9 \. U9 O. y
98.       }
    4 @9 g% ]3 ~$ k1 S& p9 F2 `
99.     }
    1 Y2 y+ V! y+ ?
100.   }
     ; U% K2 X- @3 L7 J  R
101. }

复制代码

7. 小球之间的吞噬关系
: K$ v" r5 B7 P8 P5 v% W

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

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

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

1. void EatFood()
   ; ^1 ~: @, p7 X- Z  X% w- g
2. {
   2 ?+ {% f, V5 k$ |/ {9 u
3.   for (int i = 0; i < Food_num; i++)9 S3 j) u0 z$ @2 z) S0 p! [
   
4.   {8 z! S8 u. H* l3 V
   
5.     //玩家吃食物
   ! N1 N* D( K( `\" D9 q
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   2 F( I) d+ V) A, d\" j/ Q$ F  s# W4 w
7.     {
   , F7 R* a' \, a6 J* _) X
8.       player.r += Food[i].r / 100;# @. }- H; Z/ [0 \+ L2 G
   
9.       Food[i].x = rand() % Wide_map;
   : `$ `4 x) n* `. f( ?6 F- {1 K
10.       Food[i].y = rand() % Hight_map;1 f6 L1 ]* t  l
    
11.       Food[i].r = rand() % 5 + 1;3 }4 s% J7 e5 f$ Y: I; Z$ c
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    \" \; l- [) @2 r\" b$ `. N
13.     }
    0 n( I) T) ~+ n' Q$ [
14.     2 W. B' Y' s; g( G6 `' L6 a$ I
    
15.   }
    % J, r5 i7 t\" S% `. z
16.   for (int j = 0; j < Enemy_num; j++)
    4 b9 B- f' d3 x: h+ x: M9 B/ _  n
17.   {
    9 z% K- l9 r- S: x\" _
18.     //敌人吃食物
    0 d5 g% @% M- a5 l; W0 S
19.     for (int i = 0; i < Food_num; i++)* Z' P2 k. l8 B* l
    
20.     {
    % E1 O8 k: a3 |: Y, X
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)  O) c5 q. S/ D3 n& @( z; b7 Q, i  n
    
22.       {
    ' |4 J* `  n% \1 c
23.         Enemy[j].r += Food[i].r / 50;
    . y( A3 u. \$ o9 u
24.         Food[i].x = rand() % Wide_map;  ^* _( @9 o: l& H
    
25.         Food[i].y = rand() % Hight_map;7 H  E& J' ?* x\" J/ g
    
26.         Food[i].r = rand() % 5 + 1;
    4 \$ V6 X) d' X' P/ \- m7 [( A: `
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);1 |! L5 z\" t) T
    
28.       }
    $ k, B, |  M% {7 L: p/ D* H
29.     }. _% w, V5 F$ G$ y0 |1 |6 y1 v
    
30.     //敌人吃敌人) k& Z: ~4 q$ k7 \- e
    
31.     for (int i = 0; i < Enemy_num; i++); J6 d% K  G8 W5 q5 m  A8 E
    
32.     {, A( y1 Y' h4 C5 X
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)( G  M. h. L% d6 C( `  h. R; E
    
34.       {) t' A2 k& w6 l\" f, ]; {
    
35.         Enemy[j].r += Enemy[i].r / 10;
    8 m4 S  U/ n5 E8 s5 x% z
36.         Enemy[i].x = rand() % Wide_map;# C* O& a3 U  b) ^9 d
    
37.         Enemy[i].y = rand() % Hight_map;! z$ b8 L8 j  d/ @2 i
    
38.         Enemy[i].r = 10;
    6 M8 N! _2 i5 \
39.           Enemy[i].color = RGB(0, 255, 0);
    ' h8 c2 L% [, ~: U$ B
40.       }
    ; I% s4 W) N$ u; v5 ?$ X* K
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r). z, O6 {4 K$ `$ q\" }
    
42.       {
    ; O( q* ]; T! ]) E
43.         Enemy[i].r += Enemy[j].r / 10;
    * B, `' G  \7 @) b: k
44.         Enemy[j].x = rand() % Wide_map;
    4 b+ B/ `+ Q+ ^; W+ Z  b: i
45.         Enemy[j].y = rand() % Hight_map;
    ( X% \$ r0 E& s0 {
46.         Enemy[j].r = 10;
    ) y4 Z/ S9 ?$ R1 }4 G8 k. E
47.         Enemy[j].color = RGB(0, 255, 0);
    : K/ r0 i! c( f5 A
48.       }
    : I* v) G. M; S
49.     }8 U- }1 i6 @) Y\" N5 k+ @0 C
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r), z9 ^5 Q2 @: z0 b7 m  n
    
51.     {* c% v  V- ~5 k  E
    
52.       //玩家吃敌人7 w8 f9 p( b) a9 y8 @. X7 S
    
53.       if (player.r > Enemy[j].r)5 ~) t! c, Q- j  V: z/ a3 i
    
54.       {; w' q8 `+ D) r) y2 n# o3 R
    
55.         player.r += Enemy[j].r / 10;
    ' m# F& }; t$ V* Y
56.         Enemy[j].x = rand() % Wide_map;2 D2 j* M( ?* Y( g- y\" Q; v
    
57.         Enemy[j].y = rand() % Hight_map;  N; t( g7 {$ U% X8 a* [5 ]
    
58.         Enemy[j].r = 10;
    7 q8 n  E1 A- C8 m  g$ l
59.         Enemy[j].color = RGB(0, 255, 0);
    + \6 ]0 u  U) Q4 f  ^
60.       }3 o& X- V& i1 y, W! t2 T# x
    
61.       //敌人吃玩家, X9 R9 \9 c) f1 P; v+ B\" U5 L
    
62.       else
    6 ]; K& f: Z% [2 C/ d+ X/ r
63.       {. s) @1 X. ?. ?3 f
    
64.         if (invincibility == 0)
    * J, k3 U3 L% E6 {% z
65.         {
    ; o8 t1 j- `2 E7 Q7 g  `( [4 S
66.           Enemy[j].r += player.r / 10;6 G0 F# t\" d+ _\" y* r
    
67.           player.x = Wide / 2;7 }/ L$ z% W. e6 i: a. c- {
    
68.           player.y = Hight / 2;
    ! ^% \, y4 q! X% t9 M
69.           player.r = 10;
    , _/ B* Q' H% X* C3 r: z\" L7 d+ \
70.           invincibility = 10;
    2 O  s  V8 z  c! n4 ^
71.         }
    , f+ h! I% d! ~$ R2 w6 ~
72.       }' g8 U$ n7 i/ F1 O/ X: L5 `
    
73.     }7 r9 h% s; }- V: ~' O4 t. J( E
    
74.   }
    9 v# E, w( Z4 H2 T' w9 O1 `
75. }

复制代码

完整代码见附件：
3 c- }. M( A; R& e9 `
4 y1 v  o4 C" k( b+ h/ y6 w

3 Q, Z; ^, v3 ]. |5 O