球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
& H  a$ A& i( t
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
  {! s% D2 p% [1 l" }
  p  ^4 o8 [( B. C3 R/ z' C4 X7 r7 _玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
; A5 N8 y: I0 M7 X( \; I
/ o1 ]' [! \( ?& h1 d7 _! _其他小球：其他小球又分为食物小球，和ai控制的小球
7 v, ^: D3 N$ w# h2 n# _- O
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
  M2 `, g9 |( T9 F
) X8 x; v) N* @4 a玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
' M" x9 W+ c& X8 n1 x
接下来，我们将通过以下几个步骤来实现这个游戏：
# N% ]! A# m. P% \  [* r
- Y; D2 |4 K3 H4 ?' b$ Z, g. b初始化游戏界面和小球的信息。

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

生成足够数量的食物小球。
- M! ]0 ^+ ?4 T1 ^) x' M
  ^3 ?7 a2 ^) ^% C) z; p$ ?生成ai小球，并控制其移动。
3 q( P; S5 F$ ?1 _& F1 d  w
检测小球之间的吞噬关系，增加相应的体积。
  H# D8 t) U/ y
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
; e  ~! Z' E  w, H) E" z/ U0 A
6 t% O* V" g1 R# m9 u; v1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
- O- N+ x$ a/ d9 |
. c. b" u; e) @% {4 ?struct Ball
9 s, }! U  L# W9 c* j  U) e{
, _  j/ C$ v5 A4 e4 Q. r) M4 A        int x;
        int y;
        float r;
3 c/ y3 q7 o1 ~$ m- W        DWORD color;
$ q5 O" _: C. {9 m};
" L  n4 B0 u2 P0 u& |% B* Y- z2. 初始化小球的信息
' Z1 [: a3 O" K( J将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
2 A5 [' ~  [5 Z4 K3 {
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
' ^' l8 a' \) g+ z( K
  ?! G! m/ z3 O橙色可以通过RGB值（255, 128, 0）来表示。
, S/ w# W+ {. Y8 ]8 _  [# o5 s黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
& ?/ {6 G7 k5 y! R8 Y' Y! f" T蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
+ A: i' a8 T* L1 K- {7 \白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   0 O! |- K5 X5 W% F
2. {1 t3 B# o1 W* ^4 P
   
3.     //玩家小球8 B% k) A- K  T' m\" {% N8 a2 I2 g& [
   
4.   srand((unsigned)time(NULL));' P$ A- {\" |3 N. q
   
5.   player.x = Wide / 2;
   : z' ]7 c' Q3 t: L3 L
6.   player.y = Hight / 2;
   1 ]+ |3 J7 q& G, [  L! A: o3 O
7.   player.r = 10;3 u' l$ }9 h: J# N1 Z& t
   
8.     //食物小球. b& c* D+ X- Q  U1 ?
   
9.   for (int i = 0; i < Food_num; i++)
   + K) P# H/ h! y) h, f' z8 I
10.   {- N) S+ Z% g8 @; X4 z( v
    
11.     Food[i].x = rand() % Wide_map;' S  o, h# }! b( b6 }; W  h
    
12.     Food[i].y = rand() % Hight_map;
    \" f2 Y( C( A) Z. w$ r
13.     Food[i].r = rand() % 5 + 1;
    0 |3 b( [* N) S! N: W# w2 g
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);7 a! b! k( z( d! P
    
15.   }# U; S$ e( _/ f
    
16.     //ai小球
    0 e8 L- F$ f' d9 a
17.   for (int i = 0; i < Enemy_num; i++)
    . s2 B* F$ T% C: |: D
18.   {
    ! t- k, w+ m5 b3 v8 Y; @8 ]
19.     Enemy[i].x = rand() % Wide_map;3 [2 U% R$ N$ r+ X4 a6 |& Y7 u
    
20.     Enemy[i].y = rand() % Hight_map;
    # o3 G* `; Q4 d/ z* U
21.     Enemy[i].r = 10;  Z4 N* f/ e\" V: N8 N
    
22.     Enemy[i].color = RGB(0,255,0);$ O* r+ K/ P\" f& E8 B. z' f% Z) c
    
23.   }
    + a& B9 O' _4 O  |6 Q1 ^0 d, G
24. 
    6 d8 j; G, U# F\" B, t, p
25. }

复制代码

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

1. void Player_move()\" O- T$ }5 R2 b; P' o0 o! g
   
2. {$ |2 C4 V8 \. C& A\" l+ C9 H4 _; @
   
3.   if (GetAsyncKeyState(VK_UP)): e8 h( k+ p* ]  r7 M+ P
   
4.   {# D7 a$ f. m5 S( d$ C4 S8 @* O
   
5.     if (player.y > 0)& d; ^/ r0 V7 I' x) j
   
6.     {
   / b3 `! ?0 i9 |; J: j
7.       player.y -= player_sleep;
   1 L% \2 i* }. c0 C% z' g/ z
8.     }, S6 }6 ~: {! r7 {
   
9.   }
   + ^- F& T+ s9 P6 b7 S* y. L
10.   if (GetAsyncKeyState(VK_DOWN))
    $ P' z1 d\" O( L' j5 c  ~1 N* i
11.   {
    * t% N8 `: Q  F# w3 N8 B
12.     if (player.y < Hight_map)! Q6 \4 z* q4 P. t) C+ D
    
13.     player.y += player_sleep;9 ]& p( f4 @: d, }0 g
    
14.   }* g( a2 b4 V8 K5 C& Q+ k8 N1 r5 c
    
15.   if (GetAsyncKeyState(VK_LEFT))
    - z6 [8 w4 B1 t\" H9 D' f
16.   {2 Z  u. k6 v) C, p
    
17.     if (player.x > 0)
    6 q- r& B% G\" d8 D
18.     player.x -= player_sleep;8 H4 I3 q0 s. b) R1 ~4 P* t, U
    
19.   }6 |) J; I0 O7 h1 N7 O3 ~
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    # F  u+ f# ]' U0 [3 f
21.   {- r( p\" v( o: N( Q+ ~$ k! V
    
22.     if (player.x < Wide_map)
    3 l) o5 v! Y) s0 [6 W
23.     player.x += player_sleep;
    2 P; P4 R* V; U2 G: {2 g3 m4 Z3 J# U
24.   }, x3 l5 A% V' [. t: t
    
25.   if (GetAsyncKeyState(0x20))' f( r/ k3 B# U\" A# H
    
26.   {
    % U6 L0 ?# L$ q* p% y3 b- {
27.     player_sleep = l + 5;
    8 X8 R6 \\" M( L; E( \2 C
28.   }( N6 b. Z\" _3 h  g8 X! u\" k- {
    
29.   else
    7 {9 F: O- ]% g; i  Y
30.   {1 r$ L& @! W0 h1 f6 G8 Z$ L5 c
    
31.     player_sleep = l;
    6 M/ w6 s$ O/ r. s3 q) a% U
32.   }
    ! H, m- V! O1 R1 c
33. }

复制代码

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

1. void Show()3 l( ?$ N5 p* @! \, ~+ R! S
   
2. {; X( z3 f0 K9 F
   
3.   4 L2 |# C. K3 K9 r: P+ g
   
4.   //设置地图$ l* k* J# s& M! z
   
5.   SetWorkingImage(&map);
   ! L8 F0 N2 L\" a- T/ Y# `' V$ O
6.   //清屏
   9 L. |. g- a: y2 ^8 f
7.   cleardevice();\" u, X' ]' k5 V( C# Z
   
8.   //背景颜色\" e' D. T  v4 L8 f( a* D2 @. K4 Z3 I# i
   
9.   setbkcolor(WHITE);9 n; g3 R6 l: G; h
   
10.   //划线颜色
    # T0 i: g* h( r9 q& n
11.   setlinecolor(RGB(230,231,239));
    4 `\" F3 C0 G0 }* F% k- F# r/ g
12.   //划线# T& ~* [) Z) l9 I% }7 X
    
13.   for (int i = 0; i < Wide_map; i += 10)
    7 P/ _0 n$ ~- z) U% S) Q4 N$ S
14.   {
    0 Q3 n$ p* b( ~% X% u0 X# a3 ?
15.     line(i, 0, i, Hight_map);+ `2 r2 o, c( |* P# D( ~
    
16.   }+ m+ ~; L  M\" y' O( o1 X3 E1 ]1 @
    
17.   for (int i = 0; i < Hight_map; i += 10)6 C( Z& G: e' P1 m
    
18.   {
    $ `5 p; F9 P' h. o* @/ U
19.     line(0, i, Wide_map, i);: e- Z* p! d# o\" e
    
20.   }/ s6 l. ~5 g% J2 o- \3 D5 [4 k
    
21.   //食物: }: j. A\" L9 `7 O6 x) C5 d2 h
    
22.   for (int i = 0; i < Food_num; i++)- ^# K' I+ L7 b% F( \
    
23.   {
    % J/ I\" [1 n2 \* i: L6 j- `
24.     setfillcolor(Food[i].color);
    # Q7 V$ P. \/ W4 f* `3 x
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
      U& a- a/ Z7 E; N8 u% r
26.   }
    & S* Q( l4 a' G  @
27.   //敌人
    6 C% b) M$ x$ ^
28.   for (int i = 0; i < Enemy_num; i++)
    : M5 J1 B8 f6 ^\" s: \
29.   {
    ' \  V. O& R1 w' G& a5 H7 [
30.     setfillcolor(Enemy[i].color);$ j( |, S' J5 ]* C
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ; L1 b# Z6 ?' L$ o3 ?5 u8 H  }
32.   }
    + p( P; S6 B$ S  a% L; N0 _, y3 I# o
33.   //玩家
    * y  e6 s4 J\" O0 P6 D
34.   setfillcolor(RED);. U% ?0 x8 }6 K0 G' C' d
    
35.   solidcircle(player.x, player.y, player.r);# b5 Y: \2 _$ {. o, m8 N4 G( D1 d
    
36.   SetWorkingImage();
    9 |\" {: e- n/ l% w5 o7 o6 r& W
37. 
    1 i) g7 D) X: [: E7 q/ `2 @
38.   int x = player.x - (Wide / 2);3 @6 K$ Q5 }- j
    
39.   int y = player.y - (Hight / 2);
    , A) q2 x% `: }5 }
40.   //防止窗口越界. y, |/ P# u# ?9 g1 b
    
41.   if (x < 0)
    6 j\" s- Y) r3 H5 w8 u\" z
42.   {
    - k+ W  Y$ A$ p* W) [2 a8 c' e$ S
43.     x = 0;
    + M4 F9 E' S( n0 ^' U
44.   }/ `- h8 b! B+ c
    
45.   if (y < 0)
    + r# @' }/ r8 K
46.   {
    8 }, _- s8 K7 O; [: r
47.     y = 0;
    7 M  p! V' ?& c& t7 {) u8 U8 E
48.   }
    * R! E) L/ M. P; M. Y* g/ C
49.   if (x > Wide_map - Wide)- d2 z4 q7 k; o# x% j8 l+ @5 W
    
50.   {
    . O7 W5 s6 D# S* j0 s# f1 C
51.     x = Wide_map - Wide;
    : ]\" m  Q3 g$ X' O* U( L; [
52.   }8 q( M: _0 [# V, ]- G5 q
    
53.   if (y > Hight_map - Hight)
    $ I- H: o# P$ f. [- V, w
54.   {! l6 s; W- T: X/ i
    
55.     y = Hight_map - Hight;- Z\" g. p6 i6 t% E
    
56.   }4 a! e\" I* I4 e) s& D+ _9 b/ B
    
57.   //把map输出到窗口上7 r! ~! X; M( T, U
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    8 W: m: k$ ~+ w. a
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. //防止窗口越界
   ' h5 g# Z& d3 `0 u$ G
2. if (x < 0)' i! L8 {; F! Z6 ]
   
3. {
   3 T2 v& Z, E\" h& E% m
4.   x = 0;
   1 c: z/ g1 Z+ O$ I) }# m) i* z
5. }8 b6 q- a  m# @9 z( [. Y
   
6. if (y < 0): ?5 x4 s$ Z& H1 H; z
   
7. {
   ( c' o5 u) G7 @) b* D
8.   y = 0;2 E; @+ g& R$ Z0 ]# N0 [* Z
   
9. }1 y2 R\" F' Z2 v' J; f8 `
   
10. if (x > Wide_map - Wide)
    ( |6 v2 A9 o, M: F3 {4 h
11. {
    % p. Z3 K+ G7 f% l
12.   x = Wide_map - Wide;- Y  T: a& I& K3 q1 N0 D
    
13. }
    , h, Q  w\" m# e8 `8 ?3 v: O
14. if (y > Hight_map - Hight)* J6 k5 K\" ]- F+ J) f
    
15. {. j3 K( ~+ O* M\" G: R: t: x: |
    
16.   y = Hight_map - Hight;) Z& S\" b* n' C: k4 Y# _% @$ k
    
17. }

复制代码

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

(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
# }  `' j! l) \5 [- p# Z0 j
Wide：这个参数指定了要绘制的图像的宽度。

Hight：这个参数指定了要绘制的图像的高度。
8 I' h) p9 f0 w( \5 v9 G
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
9 j& M( J+ e, ~2 x: c% }5 A. Y
- I4 p& ^7 y' W& dx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
# a/ Z- {. o. O1 o4 K  D8 y
2 O" q/ v& T) Iy：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
: y( q( E1 V: d7 ]& x6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   9 P\" H' c9 z8 b9 n, V. v3 |
2. int Distance(int x, int y, int x1, int y1)
   : W/ f. l% \2 ]8 v# F) y
3. {) V) W, R4 G3 C* B  Q! }6 q& ?
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   ) Z4 _1 l: q3 b
5. }

复制代码

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

1. void Enemy_move()
   8 ]2 T) R6 \4 B/ e  D0 m
2. {
   , f' t7 x3 C* ?9 U9 W6 b* M7 w$ m
3.   srand((unsigned)time(NULL));( [( k( O) p+ i3 X/ b; C
   
4.   for (int i = 0; i < Enemy_num; i++)
   ' r; P6 {; k1 r1 _
5.   {/ f; W% N. j& ]1 b
   
6.     int direction = rand() % 4;
   ' t; |8 N$ E. `4 b
7. 7 E5 a' N  R0 v$ t3 d# p
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)! U* V! F6 m1 R' V, D
   
9.     {3 o3 O7 |+ ^4 c- N$ {, ~- I
   
10.       if (direction == 0)
    ! R7 M. n8 a0 a; P7 X% Q1 c: v
11.       {+ C5 k6 a  H& H  c
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句+ R  N# D$ t, o
    
13.         {
    9 q; A& ]+ d3 q8 x% B
14.           Enemy[i].y -= enemy_sleep;+ [3 w6 i8 V( A
    
15.         }
    # k; M0 d4 C4 v& X9 K
16.       }\" r9 R- M. p2 I4 u# [2 V
    
17.       if (direction == 1)
      T, H6 J9 v; F
18.       {4 N  K5 w+ i0 {% Q\" N
    
19.         if (Enemy[i].y < Hight_map)
    5 ~! V, ?0 T/ {
20.           Enemy[i].y += enemy_sleep;
    / T) ~1 y# [& {0 c  p( s. h- s
21.       }
    ) ]1 T' J: Q7 c) n3 z% v, F
22.       if (direction == 2)& _! o3 i( ~' L
    
23.       {) p# M% {: ^* G; _\" a\" `
    
24.         if (Enemy[i].x > 0)
    \" P5 {* R7 I; ]
25.           Enemy[i].x -= enemy_sleep;! j/ b/ y# @+ R6 D' S
    
26.       }
    2 o# I+ {* B0 _& `/ h3 T
27.       if (direction == 3)
    ! K! F2 O9 h8 \% M: n% s# b/ ?
28.       {
    ; B# z/ N+ @; R' s0 J/ B' e
29.         if (Enemy[i].x < Wide_map)
    1 s6 X, i& Y+ n! O7 e+ w
30.           Enemy[i].x += enemy_sleep;2 A\" X5 E1 s1 F; J* `
    
31.       }1 v5 h( W* k* q  I; p
    
32.     }\" P5 O, N) z, X! K, J+ e1 {
    
33.     //敌人追击玩家
    2 m$ X5 z! V/ m
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)1 D( U9 s, B; @- L5 B0 J
    
35.     {
    1 Q  W' v9 z2 R* B5 ], [1 x
36.       if (Enemy[i].r > player.r)  ~0 F9 p. ~6 ?$ c  X9 Q. o
    
37.       {& O2 N' p6 f# `$ z
    
38.         if (Enemy[i].x < player.x)
    ) Y8 G: L6 V# w5 m\" L
39.         {6 [( h\" j7 [( Q! \+ G0 W) R; c# d
    
40.           if (Enemy[i].x < Wide_map)4 }4 t1 l0 N3 `  P! f) f* @* E1 l
    
41.           {  G! q* w4 i; j% j5 E3 C& x2 f
    
42.             Enemy[i].x += enemy_sleep;) @' ?% m6 F, }3 k! L5 O
    
43.           }\" {3 h  p\" D& V7 ^
    
44.         }* W\" X7 n$ c/ H7 {3 l
    
45.         if (Enemy[i].x > player.x)
    * F% A4 M\" a$ b1 J9 b0 L
46.         {2 `: T! }' {- U. G
    
47.           if (Enemy[i].x > 0)
    4 f% V8 ~* q1 ^
48.           {
    7 F7 c2 H  k( `) u  L
49.             Enemy[i].x -= enemy_sleep;
    # s! `; n! c% r: d! B7 D! ?
50.           }
    9 c. L7 Q5 t2 D6 b' N
51.         }
    0 a\" s5 u  W) y6 F
52.         if (Enemy[i].y < player.y); x& p; O  f: q2 }( z6 B, e
    
53.         {\" q( b3 ]3 T- y- m4 |
    
54.           if (Enemy[i].y < Hight_map)' n- ^2 e6 s7 s- _3 c5 e. i
    
55.           {
    3 l; _/ @$ Q0 u
56.             Enemy[i].y += enemy_sleep;+ ]( d- [' h( d0 f+ G# @
    
57.           }/ N! P) g\" f- u+ k* o
    
58.         }
    . h; ^! c9 z- l2 S' G
59.         if (Enemy[i].y > player.y)
    4 B( l8 y/ |( d! k
60.         {! C, J' L* \\" E/ o: `& J
    
61.           if (Enemy[i].y > 0), R- i2 L7 E* N- L6 N6 Y
    
62.           {
    & ]0 _* r% w$ ^2 |% z/ s
63.             Enemy[i].y -= enemy_sleep;6 Y+ T. y# H& l* K8 Q- Y8 b
    
64.           }# K* ~4 d7 l* V, L
    
65.         }- g$ x8 R$ _, Q) i( {
    
66.       }8 c0 z' M6 _4 l% H( A  n$ q
    
67.       //敌人逃跑  B! Z; J/ g9 ^' {3 S: b
    
68.       else5 k7 O  Z, b  t* T/ M( `% n% V7 b
    
69.       {
    & t1 J2 V1 V; V6 P
70.         if (Enemy[i].x < player.x)* r5 d+ P- h( h& @1 C
    
71.         {\" S4 f6 R; `! b2 \+ d0 u8 R  P
    
72.           if (Enemy[i].x > 0), _  J8 M: |. z3 }* j6 u
    
73.           {
    6 C/ B! v, }& b; u5 u
74.             Enemy[i].x -= enemy_sleep;5 X& k% M+ r- m/ y# B7 Y
    
75.           }8 v! V1 V, R0 f2 [
    
76.         }2 Q. }0 M5 W\" p* ~3 C& q- }
    
77.         if (Enemy[i].x > player.x)3 [$ B1 l; ^\" e. F4 L- P
    
78.         {& a+ e) l) H# }- B
    
79.           if (Enemy[i].x < Wide_map)+ }4 ?0 t* Y5 V  x
    
80.           {  W! n7 e  {: f7 A2 C/ H( i
    
81.             Enemy[i].x += enemy_sleep;
      D0 ^' g2 J9 d\" J% I
82.           }
    ( Z3 `! j( c- M0 }) @
83.         }
    0 _3 l6 _; J1 B% e: {6 T6 u
84.         if (Enemy[i].y < player.y)( `% Y% S* S4 O1 W$ o
    
85.         {
    4 r! |0 C( @5 l( @9 q
86.           if (Enemy[i].y > 0)
    ) @8 Q; q' |* M& n  Q! \) |3 g
87.           {* @\" N6 ?% l9 e% h) W7 o
    
88.             Enemy[i].y -= enemy_sleep;& S, W- Q9 z6 [# F3 u
    
89.           }
    2 d% }/ O0 J6 ^$ t9 X$ [
90.         }' T' B, w  a! i+ a# }  O\" ]5 R
    
91.         if (Enemy[i].y > player.y)
    : z4 u. f2 E! L; G' T7 m  z
92.         {
    3 l' L  x( s! x  F  Y% x
93.           if (Enemy[i].y < Hight_map)
    1 o\" ^1 I& |' s: ~/ o
94.           {
    + j% L9 l9 m0 U) s6 P3 K9 p/ N0 Q) B
95.             Enemy[i].y += enemy_sleep;
    3 W7 c\" J: X* Y% K# X
96.           }% C2 j: s! U6 t7 A6 K( h! I
    
97.         }
    # X\" e7 Z. K& P2 p2 |
98.       }
    7 S* y* Q0 H9 Q& J+ T
99.     }) D- z. I+ m. f\" e9 k3 ~
    
100.   }
     % E/ O\" D2 L5 d$ w' J6 f! s
101. }

复制代码

7. 小球之间的吞噬关系
7 v* F  J. @$ p$ i5 \* r

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

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

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

1. void EatFood()
   0 ^1 [, {/ N, |! P( R2 u. O6 }, ?$ S* q
2. {
   % O% h  t( Z/ P& G/ s; g+ j
3.   for (int i = 0; i < Food_num; i++)
   1 R3 L; P# s) y4 z0 W* K; i
4.   {
   ) g9 C. X9 l+ B. V3 A
5.     //玩家吃食物
   9 u7 `& s: J1 }9 Q6 U
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)8 Y+ U6 W) s9 T+ V
   
7.     {
   5 k+ X1 V+ _$ Z3 e6 o3 G
8.       player.r += Food[i].r / 100;
   7 r/ Z' o# Y) ?2 C
9.       Food[i].x = rand() % Wide_map;3 R6 p9 w% D' J4 Q* s, q+ O
   
10.       Food[i].y = rand() % Hight_map;
    . F5 R' q/ ~, t0 b2 M8 {% R% A
11.       Food[i].r = rand() % 5 + 1;
    5 W. s3 r/ V7 y. i6 j+ G( Z7 M
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    $ @3 _, O5 B/ R! w$ S
13.     }
    ; m1 `$ D, |( Z. q/ S+ c
14.    
    % ?$ ~4 j* I6 T
15.   }7 Y& T( x2 U% u  [( k
    
16.   for (int j = 0; j < Enemy_num; j++)1 D$ R+ I( u! l6 H; E+ `) I
    
17.   {3 ?4 Y# @  a, ]\" {* ~4 }- T) ^2 {
    
18.     //敌人吃食物
    : s$ \0 ^3 }+ o& C& j2 M6 f
19.     for (int i = 0; i < Food_num; i++)
    * `/ D) Y$ g# t: J# n8 P
20.     {
    : }( G3 c\" U. ^
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)! S) a* a4 E: x) U  o5 ?7 j
    
22.       {* X; X* B4 l, ]. G
    
23.         Enemy[j].r += Food[i].r / 50;
    \" }6 {1 F. }  U2 l. g
24.         Food[i].x = rand() % Wide_map;
    . D, ~/ y! h  l
25.         Food[i].y = rand() % Hight_map;
    ) {. n4 n+ r! H
26.         Food[i].r = rand() % 5 + 1;\" B/ K: _% |- `3 y: R# R
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    8 Q$ K/ X+ o% ^. N' X
28.       }6 G6 W/ j. u' T( ]% r/ p! R
    
29.     }
    8 F7 h\" e& }! p2 ?
30.     //敌人吃敌人
    \" y5 X8 F' w& ?\" `. \0 ^$ _) e
31.     for (int i = 0; i < Enemy_num; i++)4 P1 X# w- Z8 c5 o0 b- c
    
32.     {
    8 g9 ^* t/ G- r% b* V
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 F! E: i1 ^9 W1 R. |
    
34.       {( }9 i1 I' ]) b& E* }! a5 p
    
35.         Enemy[j].r += Enemy[i].r / 10;\" ]! M( T  h! ^3 Y) Z
    
36.         Enemy[i].x = rand() % Wide_map;% B, y( b( l0 |7 J/ ^2 ]
    
37.         Enemy[i].y = rand() % Hight_map;
    / x2 h' M3 p+ d' V6 t6 e\" z
38.         Enemy[i].r = 10;9 f% S+ _+ e* r5 `+ S9 R\" P
    
39.           Enemy[i].color = RGB(0, 255, 0);
    / t1 {6 }& j% Y9 ?  {; H
40.       }
    ) V/ {7 y5 O2 k0 S; z5 s$ 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); ?% P$ q( Z( Y* a- P
    
42.       {* h6 |  y, t' O4 y, ?/ K
    
43.         Enemy[i].r += Enemy[j].r / 10;! W# r+ w' E: p
    
44.         Enemy[j].x = rand() % Wide_map;: w2 }+ W) g; T. ^
    
45.         Enemy[j].y = rand() % Hight_map;3 P4 p% @4 \4 i
    
46.         Enemy[j].r = 10;
    , |/ |% W! b. L. D
47.         Enemy[j].color = RGB(0, 255, 0);  t- p: d) J& U. z
    
48.       }2 h6 X0 B  Q' V0 R% x
    
49.     }, x5 k+ X0 ^# e  E# r
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    / `+ Y' B- S8 W' D
51.     {/ \7 s9 y, T1 X. F
    
52.       //玩家吃敌人
    ! b  J* ?' P' V
53.       if (player.r > Enemy[j].r)& S; M- h; ~/ |
    
54.       {8 I\" n\" O9 F6 E9 F( N# r
    
55.         player.r += Enemy[j].r / 10;  I( f1 o5 X4 c+ J. Z) {
    
56.         Enemy[j].x = rand() % Wide_map;6 @9 v9 H3 P5 u) s: u# J: b
    
57.         Enemy[j].y = rand() % Hight_map;+ K' {0 X\" Q2 q$ A% ~: q+ O
    
58.         Enemy[j].r = 10;. S& C7 N+ ]\" F! U# ]) f
    
59.         Enemy[j].color = RGB(0, 255, 0);
    8 o* K+ ~4 S4 S
60.       }8 d$ N8 o; d& e; Q
    
61.       //敌人吃玩家
    1 k+ d0 f/ I& T1 c! p, v) m: K
62.       else
    9 A1 K. [( G: ^4 o
63.       {
    1 x; @: T3 N2 v5 I5 {
64.         if (invincibility == 0)7 Y5 Z7 V+ i- C( w  G* G9 Y8 l  X, ~
    
65.         {
    : w7 p9 }6 E$ q% @+ p$ w
66.           Enemy[j].r += player.r / 10;1 }6 k+ o$ B6 }# C* z# _
    
67.           player.x = Wide / 2;
    0 k/ p- P. Y' Q2 H: i
68.           player.y = Hight / 2;& G/ p  u+ ~) |8 ~% H& A. Y0 H
    
69.           player.r = 10;+ m  [7 D7 p/ D
    
70.           invincibility = 10;3 f* r* H3 J  B, c% `/ D, n+ h2 d
    
71.         }# a/ _$ w7 F* T9 s, X) S
    
72.       }4 z$ t( D3 k\" T
    
73.     }
    2 k- ^/ Q3 c3 C
74.   }/ q5 O4 m1 Q/ ?( j/ e
    
75. }

复制代码

完整代码见附件：
; Q) P+ C- A7 z( F. K
* `2 u( @) m8 m$ c2 q0 {/ S+ G6 T
- r: m2 }( X6 `) u% M# D0 e
* r0 O1 S  [( t2 |