球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
+ |5 H/ i- b& o$ E, |2 _5 y. J
% w' k% W8 C, }在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

& y  k: r1 e3 A) @; _游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

; H, J  V9 T& S1 O5 N% B玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
0 W5 U- R% C- ]" }  x0 f/ e
' e3 W+ L; e2 s' m: \其他小球：其他小球又分为食物小球，和ai控制的小球

体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

2 G+ h4 {5 N9 m) ?, Y' L/ V3 R& K" D7 X玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
/ a) M  _' N% `9 n2 U5 s' H
" w3 I/ U- k9 D, D) ~2 ?" s接下来，我们将通过以下几个步骤来实现这个游戏：

7 H8 J; G3 Q1 a/ ^. P初始化游戏界面和小球的信息。

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

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

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

& N; k  B( v! c$ \检测小球之间的吞噬关系，增加相应的体积。
: t( ~' W" n; I! J: u8 P
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
; Q! A3 {$ K9 x
  x* K* N8 m8 I4 h" Z2 G& ~1. 小球的要素
& x, _8 T1 T  `) i在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
9 C* |* X; q" B9 ^/ y
- j4 @6 J- {- u' h! n* }+ zstruct Ball
+ F( y3 I3 [2 v: ?% B) e{
        int x;
        int y;
7 g7 X2 o! W- w        float r;
7 o0 B2 S7 O* S0 J' a& T" A4 _        DWORD color;
};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
, j; {$ I& T5 k- {
6 z- t( e. }/ n. WRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

) G% S0 g  q% o橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
% t9 N& I  @/ D绿色的RGB值是（0, 255, 0）。
6 |+ H1 [1 T9 I" k' w蓝色的RGB值为（0, 0, 255）。
( f6 X: F4 _, b' P紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
8 `+ K( \, r0 N& d# `白色的RGB值为（255, 255, 255）。
7 J0 J+ g4 i. R灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   # F2 W' C& O5 ?; B( J
2. {, O! n\" a- L8 z/ |
   
3.     //玩家小球7 p/ E0 g7 {, B8 h* ]1 P* y5 l
   
4.   srand((unsigned)time(NULL));
   : t# W\" {  f' W: l
5.   player.x = Wide / 2;- }4 Q7 ]0 l$ z, I
   
6.   player.y = Hight / 2;$ T$ B( J  C' \
   
7.   player.r = 10;6 N5 _2 i5 w2 c, h2 t, z: A3 @7 [4 Q
   
8.     //食物小球' L. M$ k) y% S* O. @
   
9.   for (int i = 0; i < Food_num; i++)
   2 ?$ t7 Z* g5 G; Q3 v  s  [
10.   {  `. u7 s& s' ~\" b
    
11.     Food[i].x = rand() % Wide_map;  W\" Y\" t% J1 o) _
    
12.     Food[i].y = rand() % Hight_map;) Z6 O9 E- I0 j
    
13.     Food[i].r = rand() % 5 + 1;
    # l2 C7 x0 w1 N4 z
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    \" s- _) l1 y\" Q  z\" N; D; J; l
15.   }
    & i, R9 F2 a7 E* U$ p0 T' i, f
16.     //ai小球* Q* W\" u3 `7 p; n0 r$ u2 V$ Y& T7 \4 [
    
17.   for (int i = 0; i < Enemy_num; i++)
    ; C' X3 k2 A7 Z5 x
18.   {$ N$ |* `1 b. u( G& l
    
19.     Enemy[i].x = rand() % Wide_map;
    : P8 Y6 G* Q$ k2 O1 w+ u3 p\" v
20.     Enemy[i].y = rand() % Hight_map;
    1 @' B- z2 X( {1 Y7 r8 r) }
21.     Enemy[i].r = 10;! O& M( k; @' i) B$ z: X\" Z
    
22.     Enemy[i].color = RGB(0,255,0);8 y\" ]/ y0 \4 ]6 i( [& G
    
23.   }
    , J- |9 W( \8 J0 h2 d0 a; O
24. ) S. p& G! c, S- J1 S
    
25. }

复制代码

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

1. void Player_move()- b8 {* e! m& V2 s4 ^
   
2. {0 I8 }* J; g9 o- ]
   
3.   if (GetAsyncKeyState(VK_UP))
   / \3 g7 G: C) j/ a. H
4.   {$ d: [# ]8 t9 y1 ?2 l4 c
   
5.     if (player.y > 0)
   # v+ s0 [3 j( T0 r& d, c$ j
6.     {( B) d: ?4 P4 ^7 `7 {% y0 p
   
7.       player.y -= player_sleep;1 s' v. Q# D& n6 T, b
   
8.     }! P! b0 A6 u\" K1 N! y2 w- G
   
9.   }
   0 C3 t7 a% I1 ]& d. k  p
10.   if (GetAsyncKeyState(VK_DOWN))! W5 P0 [/ c7 L
    
11.   {4 O7 F. T* U  I
    
12.     if (player.y < Hight_map)
    & i8 c7 {& m# V# e
13.     player.y += player_sleep;\" c( |$ A2 y5 |
    
14.   }/ L6 \! H! _- S9 m( w
    
15.   if (GetAsyncKeyState(VK_LEFT))9 e9 D# n. ]' b+ n( f
    
16.   {
    + s! ?2 b9 o9 w\" [) I, h7 K2 A
17.     if (player.x > 0)
    / ]( y8 T2 V& O4 T  H\" M
18.     player.x -= player_sleep;/ ^, C6 |0 m2 d) c8 X9 g
    
19.   }* d0 G% F. T7 G
    
20.   if (GetAsyncKeyState(VK_RIGHT))' ?% M) z% Q# @; z
    
21.   {3 L( C6 u0 e3 H\" o
    
22.     if (player.x < Wide_map)
    ; _3 V8 `; a. \! L7 W. c
23.     player.x += player_sleep;
    * t! l+ n$ x' ^8 ?8 B
24.   }5 ]1 A) X/ F3 G. E/ ~
    
25.   if (GetAsyncKeyState(0x20))
    7 y# D- Z; B$ B8 ]4 E( r
26.   {
    . U, Z9 g3 L: k8 `* C( r/ K
27.     player_sleep = l + 5;
    8 T7 v5 b( p% n$ k/ X4 ^$ d
28.   }
    , A: v8 F& Z/ z; r5 o
29.   else
    3 n& X0 w5 `1 {  i
30.   {( y4 K* U1 ?  {+ r8 B# h
    
31.     player_sleep = l;\" P. m: U# X3 f% [' Y. d- I
    
32.   }
    + T% k9 k& d' s( f0 l7 G) q
33. }

复制代码

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

1. void Show()
   ( O, Q& A$ Y! c0 o
2. {& J: l8 v+ ?6 `( t/ V+ ?2 Q) F( r3 R
   
3.   
   . E  F$ E$ q5 B+ {
4.   //设置地图
   0 T6 v! H6 J' w! ~
5.   SetWorkingImage(&map);; l! `) g, X- m( E3 G( m1 y4 h
   
6.   //清屏
   , H8 P* S' }1 R& h2 c. e! |# @8 n( E
7.   cleardevice();\" l, w) b9 ^\" ^$ c$ J
   
8.   //背景颜色
   + `# ^3 f) }8 z
9.   setbkcolor(WHITE);% \  d' E# C2 ?8 q9 S* p0 N
   
10.   //划线颜色
    8 Z! R$ M9 c- p. {0 q8 V& D/ m
11.   setlinecolor(RGB(230,231,239));/ S. d9 {8 |. Y* `% C6 Y% v
    
12.   //划线& ~  E. g! ~9 a1 K* }5 |: y! u
    
13.   for (int i = 0; i < Wide_map; i += 10)& r/ O4 m8 ~\" e- e\" R5 b
    
14.   {9 s1 P4 \# z. J+ L' E) [# A  f) k
    
15.     line(i, 0, i, Hight_map);  }: ^& |( E& {, o  u) J
    
16.   }/ j: X% e/ h4 r2 e, u+ ~' A
    
17.   for (int i = 0; i < Hight_map; i += 10)1 C# m1 J1 k* c$ h4 J/ k
    
18.   {
    9 K: U. j% M6 Y- s0 @( g/ r
19.     line(0, i, Wide_map, i);9 l: {- t. G7 q, V
    
20.   }
    / A- @\" I6 w4 h  S7 U
21.   //食物: ]7 A3 N! W$ _4 r! F4 |
    
22.   for (int i = 0; i < Food_num; i++)
    ; w, X* G6 U' _4 X0 \
23.   {
    5 e% ~3 y\" x. m* j# E
24.     setfillcolor(Food[i].color);1 b, F$ Y  F9 d- ?* r# u
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);0 k5 `! ]* o3 ~) a# L- ?* _
    
26.   }
    3 K! O  f# `; a1 c5 [  G
27.   //敌人
    . ^, r4 x- i) T1 s5 @+ ?! K+ a, w
28.   for (int i = 0; i < Enemy_num; i++)
    . o6 T  \' G; W# y
29.   {0 ^2 x3 G  k- U9 {* ~
    
30.     setfillcolor(Enemy[i].color);
    6 ~/ l3 p8 O3 ~; p: O! Q  v: q
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    - I/ ~) u4 m1 e+ ^( M$ T8 P: A( `
32.   }
    . S5 C' v, m8 R+ ^  G
33.   //玩家
    5 `# I, E) I\" S
34.   setfillcolor(RED);+ u! M1 N; S& P; c( Y( X
    
35.   solidcircle(player.x, player.y, player.r);
    $ p1 Y# f0 l* C\" H
36.   SetWorkingImage();
    ! d& p) i& R$ ^/ {, Q; o2 X. I
37. 
    7 C1 x5 I; y- Z; h- m
38.   int x = player.x - (Wide / 2);
    7 G) l) w4 f3 f+ S4 g
39.   int y = player.y - (Hight / 2);* \. I2 F, d% I( o
    
40.   //防止窗口越界
    3 o6 M5 R2 d6 x. ?6 ^
41.   if (x < 0)  r, ^! t7 p: \; Z2 j# _5 d
    
42.   {+ I\" s\" j% W\" n+ _
    
43.     x = 0;1 Y2 h% u$ v9 `' t: F
    
44.   }
    4 K9 ^  F; u+ @! {5 F
45.   if (y < 0)' O6 t; k& D9 M
    
46.   {6 \$ f# |* R; X' ?4 ?. b
    
47.     y = 0;3 V  W( T0 `. f
    
48.   }  e3 c\" |% s- `' F; H
    
49.   if (x > Wide_map - Wide)8 c! L$ f* `3 P9 _8 q( {4 N, p
    
50.   {
    & d: s\" c7 ]/ N$ P
51.     x = Wide_map - Wide;- e/ M, o  A! c( W/ u6 R( S- z8 ^
    
52.   }. ?! G9 e- E$ ~; M\" J, ?% q
    
53.   if (y > Hight_map - Hight)5 U! w. {. M& _
    
54.   {2 J( `6 Z1 b$ n9 w& a% Z' r6 d
    
55.     y = Hight_map - Hight;
    ( F( {8 M% t5 ?' j/ ]$ W: ^4 V3 o
56.   }
    $ K( S. y& A; ], D
57.   //把map输出到窗口上
    4 G5 w* d0 W. P; l9 B
58.   putimage(0, 0, Wide, Hight, &map, x, y);& q, _3 s4 p% o
    
59. }

复制代码

5. 生成地图
. U3 m+ E; Q# A$ J6 [' ]可以使用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. //防止窗口越界
   ) F/ p* y2 h: T% d, E9 Z
2. if (x < 0)) U$ h3 I5 K4 M\" h6 k& ~3 k5 n
   
3. {6 ]6 \& q( m8 v7 d3 n/ A. \
   
4.   x = 0;5 H! M- e( @) J' V7 R1 D1 E+ `
   
5. }7 p! L\" Z( z3 z1 j# J+ e4 Q# o; Y
   
6. if (y < 0)
   8 q) a4 q( H7 {; U. G' l
7. {
   ) y1 C. x3 ~7 I# Y: s2 @, l
8.   y = 0;. G- o7 u$ X* b
   
9. }1 |: ^! L8 {' ^) U' s
   
10. if (x > Wide_map - Wide)' p0 J# k7 q7 u5 P, Q+ K# B
    
11. {
    4 F, V1 T% }, Q% r& O
12.   x = Wide_map - Wide;& Z+ |: T& x+ R* b
    
13. }, i% M4 H, L! D1 x7 {
    
14. if (y > Hight_map - Hight)
    + H5 b6 v& H9 b  {1 S2 |
15. {' [) z6 c# e% t7 i- I# w\" n
    
16.   y = Hight_map - Hight;1 ?$ R( x+ {5 c
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
. O3 }* H+ Z6 m6 O+ T7 c( z, s2 B
- D9 l) N9 E: k; U* H9 Z(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
$ b- k/ X& @6 ~2 ~$ S) A5 l
! H) U! E" M7 }( T; E$ g( QWide：这个参数指定了要绘制的图像的宽度。
6 n2 R7 F3 I6 w3 y
! X5 S) n4 f9 q8 X. k7 x$ oHight：这个参数指定了要绘制的图像的高度。
; F1 H9 T% Y6 F
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

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

1. //距离
   & `- x& W7 ~$ S+ B
2. int Distance(int x, int y, int x1, int y1)
   3 g4 v& @1 s9 y/ \! L& ~% }
3. {3 G5 M5 ]4 N  g. l, W
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   ) A. |2 ]5 D. D% w# o) \
5. }

复制代码

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

1. void Enemy_move()
   7 p. V; }# H* m
2. {\" a\" F: ~  g% k
   
3.   srand((unsigned)time(NULL));  d. k$ w% g$ n6 B! Z! R9 y7 \% M
   
4.   for (int i = 0; i < Enemy_num; i++)
   1 L% e6 H9 }3 H- k& K$ z
5.   {# r/ @' e* y, t
   
6.     int direction = rand() % 4;
   - W- S\" q9 [1 Z- U3 \7 L% S' k) ~! E
7. 2 r/ s8 l, c+ V
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   1 P5 s\" N& U. Q' s$ I$ l
9.     {
   ) t8 s: q! S; ^
10.       if (direction == 0)
    8 Q  R% r; O- p5 |& u  `
11.       {
    ; o! d! k% Q2 ?
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    5 a$ U- p) ~9 X
13.         {
    5 V* D1 E6 j$ I$ Z, u1 m
14.           Enemy[i].y -= enemy_sleep;7 u; H, v, e$ p  a! m9 ~1 [1 c. E
    
15.         }
    * ~5 |$ _1 J7 L# @4 g\" {9 w5 f/ W
16.       }
    & \0 O. H8 R1 a2 o5 W4 |% W6 ?  Y
17.       if (direction == 1)( Y* `0 U8 z* X& E% o
    
18.       {
    1 v5 ?# M) m6 F6 H. e8 w+ m
19.         if (Enemy[i].y < Hight_map)6 y9 _! }( X7 k7 C# F; u
    
20.           Enemy[i].y += enemy_sleep;
    ( {+ J0 r' n* I
21.       }2 w6 P. s  M2 \! q+ S  x; B
    
22.       if (direction == 2)
    0 j# Z1 a' F- @8 K; |: z
23.       {
    * t+ ]0 f) ?& B5 V/ ~2 \6 t  n
24.         if (Enemy[i].x > 0)
    # w1 W5 L- m- t+ F
25.           Enemy[i].x -= enemy_sleep;
    * g6 U8 H7 g5 ~' n6 z% A. S
26.       }( K& \! U5 c9 \: o\" M/ F# v
    
27.       if (direction == 3)
    3 T2 e4 g& y7 Q0 ~  o& l# A3 P2 L0 j
28.       {& X. z' d* F; A* c, X$ x7 E
    
29.         if (Enemy[i].x < Wide_map)
    8 i$ z+ \# ]/ w( Q
30.           Enemy[i].x += enemy_sleep;
    * y. V) A) d7 V( i  E
31.       }
    2 o  H0 R; K( U\" T8 g
32.     }5 s! a& f! n# C  E! @
    
33.     //敌人追击玩家
    2 F: ^\" s) n  F% U
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)% I. e9 n5 o\" W: n' s! h' a$ o8 d
    
35.     {\" `( W. e* y4 o$ \3 J
    
36.       if (Enemy[i].r > player.r)% _\" i% J\" C* O8 Z6 ^6 A; e
    
37.       {
    4 c/ Z4 s% M- _' h# C, G* j4 W- h
38.         if (Enemy[i].x < player.x)
    ! f8 }7 C# D, n  B: g0 F0 `
39.         {0 \5 q8 t, W- p0 v2 u
    
40.           if (Enemy[i].x < Wide_map)
    - ]& ?6 o  j+ `3 I: L6 _
41.           {% j; U5 T) `: x1 R. I! L, j3 P
    
42.             Enemy[i].x += enemy_sleep;
    % s: a- B1 ]' ~# b& C. n2 P
43.           }/ j- W1 a5 W) B: F. J& P
    
44.         }6 j7 n9 c& @\" u# d
    
45.         if (Enemy[i].x > player.x)
    + k/ d; t% X4 v- [
46.         {4 Y+ m+ v  ~* W6 A* N. c
    
47.           if (Enemy[i].x > 0)
    . c2 ^9 f\" @5 `( f6 ]: `
48.           {3 H, k8 A4 K& f7 r7 h# Y: z
    
49.             Enemy[i].x -= enemy_sleep;
    1 A3 U7 q4 F. ]' B2 f1 _2 u
50.           }9 d$ U6 Y$ I! _2 F
    
51.         }8 Y/ n3 s. Y) d6 t
    
52.         if (Enemy[i].y < player.y)
    . E/ {; f) l) X2 g7 M
53.         {
    . Q9 S1 a. U4 o6 T
54.           if (Enemy[i].y < Hight_map)
    , k& i9 u: y% ?1 t6 d% b
55.           {2 ]2 G, e4 h/ u- m6 f% L
    
56.             Enemy[i].y += enemy_sleep;
    % @1 B7 W8 x* |$ v  C4 h4 @
57.           }
    ; a1 @* B+ M2 B# F# _
58.         }
    ! P. k7 \' b. _\" l9 M
59.         if (Enemy[i].y > player.y)
    2 M/ E# s! B* g' P
60.         {# J0 @& {5 D' g5 g
    
61.           if (Enemy[i].y > 0)# T0 T' l5 f/ l) H: K* C9 o
    
62.           {  P/ |) ^: N  i
    
63.             Enemy[i].y -= enemy_sleep;5 a. i5 R0 v  [1 H+ V2 Y
    
64.           }0 m7 e0 p* }( j- g5 }
    
65.         }* z* V: H' C\" p, X  K
    
66.       }
    2 M, G6 m( y0 T( [\" Y
67.       //敌人逃跑9 k, |1 s4 C% s; s2 w
    
68.       else$ [4 d( L$ S# R  {; a5 x9 a% g+ Y
    
69.       {
    * Y+ E4 M. b, n* Y* Y3 x/ x
70.         if (Enemy[i].x < player.x)
    ) R+ f- L# s+ c3 \, [
71.         {
    4 J7 q9 [! P+ z, Q
72.           if (Enemy[i].x > 0)
      y3 p; ~8 Q% T$ ~( e. U+ W; M
73.           {
    & w8 B& h8 ], Q/ r
74.             Enemy[i].x -= enemy_sleep;* M) p+ c* p3 H
    
75.           }- D1 `\" ?1 S- j- k
    
76.         }
      D, K/ E2 D) v* m! E4 j% v
77.         if (Enemy[i].x > player.x)
    ; ]& P, W* d% d( ]
78.         {
    $ f% ~0 J( B: B: q' J* U
79.           if (Enemy[i].x < Wide_map). j: X4 ?' ?' i* S( m$ |4 U
    
80.           {* L\" a' \3 |\" n' \. f
    
81.             Enemy[i].x += enemy_sleep;4 A# a1 p$ U4 n- S
    
82.           }$ p+ ]\" C* w6 `5 j/ W7 b0 ]
    
83.         }
    ! Y  E  W  Q, C3 r# |: [7 q
84.         if (Enemy[i].y < player.y)
    # b& o4 d0 g7 P; ?/ f* W1 @  |
85.         {
    $ ?\" n  {; R: A7 R
86.           if (Enemy[i].y > 0)  f: b4 ?% i8 |' Z
    
87.           {
    , i8 n  [8 v* |, D! @
88.             Enemy[i].y -= enemy_sleep;. c\" R8 b\" f( M; e
    
89.           }
    : G1 T1 {1 B, q
90.         }
    ! D4 q+ Q' y+ X9 e, l& E  @/ |
91.         if (Enemy[i].y > player.y); z6 a& I3 g* T! |) j
    
92.         {
    + |\" r# W9 V9 I+ X) D  ~- ^6 `4 P( i
93.           if (Enemy[i].y < Hight_map)4 Z; D1 b\" M' K3 A# `/ D
    
94.           {0 T1 o% Z\" p1 _4 M& U
    
95.             Enemy[i].y += enemy_sleep;+ o4 P' V7 e! p7 L
    
96.           }% a  ~* b4 N: a* o# C
    
97.         }
    8 h, A. I3 [/ i) e6 Q: [
98.       }
    : [* J& E2 [9 F\" W+ `
99.     }
    0 D' t+ ]  Q5 I! o
100.   }4 U5 f7 Q% Q. {5 w  X: `( F% H
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()( q. E\" f. A0 O# \# y2 Y
   
2. {
   \" w, q3 E. |6 o2 V
3.   for (int i = 0; i < Food_num; i++)
   6 I\" Z4 }* T) m, y: `
4.   {  h$ h( Z& [+ H) y: `
   
5.     //玩家吃食物# Y5 B  B, s+ [6 ~7 F  W0 v6 ]
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r). N5 U! {' k2 ]. u% G  k/ b8 s
   
7.     {
   0 U( x0 v/ _5 p6 R5 s, C
8.       player.r += Food[i].r / 100;
   1 N( z; z; h7 l- M9 N
9.       Food[i].x = rand() % Wide_map;
   ( k7 I7 f+ K9 G- v5 f\" r$ G
10.       Food[i].y = rand() % Hight_map;, ?0 ?6 P$ h- U( V
    
11.       Food[i].r = rand() % 5 + 1;
    \" W/ k# d* @& Z/ p/ }* \
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    7 N' ^! ^0 ]' p8 }0 n
13.     }
    ; j( E) ]7 }. a5 s4 P2 J' Z
14.     . L7 t) y, G6 J1 d5 N& p! x
    
15.   }
    . s3 _* r  x\" c! o1 P9 e
16.   for (int j = 0; j < Enemy_num; j++)
    . {0 Q  u0 O, H( T
17.   {
      L& s5 E: A8 t; M
18.     //敌人吃食物- Z7 E5 t# T7 o/ k, s4 T# X
    
19.     for (int i = 0; i < Food_num; i++)3 K3 ^) c2 a3 R% |, J) m3 ?
    
20.     {
    , w1 b. V1 G( q+ k
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)( p& p4 o9 A: u2 j5 B
    
22.       {; O6 x, r6 ~$ p, S* R% G% N
    
23.         Enemy[j].r += Food[i].r / 50;8 }6 d: y0 j* N$ V( v* V
    
24.         Food[i].x = rand() % Wide_map;+ Q4 L, a3 |+ e3 j  r! `
    
25.         Food[i].y = rand() % Hight_map;
    ) z$ e- F. q# y2 k) j6 ^
26.         Food[i].r = rand() % 5 + 1;\" i# `; g+ e4 s5 A/ z+ _& z
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
      ^. ?/ y7 u6 D0 V0 g  M* i
28.       }
    * _& r7 t3 u' h
29.     }
    3 l, f) c4 q9 W0 H2 a' f
30.     //敌人吃敌人
    : K6 a+ @/ K* l6 f/ G
31.     for (int i = 0; i < Enemy_num; i++)1 ?5 T* f0 I9 C
    
32.     {+ Q/ J+ h5 S1 C! X+ G
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    1 O3 |$ ]$ F- U2 B/ x6 j; @: N
34.       {3 f\" q2 y# G2 l+ J
    
35.         Enemy[j].r += Enemy[i].r / 10;
    , w: c\" X$ F. `- z
36.         Enemy[i].x = rand() % Wide_map;! ~2 ~: X\" I+ ^. C
    
37.         Enemy[i].y = rand() % Hight_map;
    & i5 I. |5 m5 X2 N% ?& K
38.         Enemy[i].r = 10;\" }/ R- n0 E  E* A
    
39.           Enemy[i].color = RGB(0, 255, 0);\" e7 o# R3 B& o2 h
    
40.       }$ U$ r3 O6 a5 K/ g' w
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    / `# B2 u\" e+ I\" w4 [! D3 \
42.       {
    . o1 @& a3 ^5 `3 H4 V8 |/ C1 Q0 S
43.         Enemy[i].r += Enemy[j].r / 10;
    , g+ ^0 v$ i! q/ T5 e
44.         Enemy[j].x = rand() % Wide_map;
    / k! S9 U' \# {  \- S
45.         Enemy[j].y = rand() % Hight_map;9 N+ y5 u8 ^& }! k
    
46.         Enemy[j].r = 10;
    ' S% t5 Z) g' P\" ^
47.         Enemy[j].color = RGB(0, 255, 0);
    $ O6 H  M% Q6 I2 y; \
48.       }! {: S/ S/ [1 e, z
    
49.     }' ^0 t) B5 A' L/ k& o# ]  y$ [
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    # V\" ?, s! F9 U9 b; ~
51.     {
    7 j  r8 I& t4 A8 g
52.       //玩家吃敌人2 c5 h9 j) ]: W3 y. R: V
    
53.       if (player.r > Enemy[j].r)8 |& `! G. [9 D: j  y  J) J
    
54.       {+ i\" k5 \\" e' d9 J
    
55.         player.r += Enemy[j].r / 10;$ Q7 ~/ }1 K/ j# g0 Y6 {* i
    
56.         Enemy[j].x = rand() % Wide_map;\" M; s6 _% t4 G  P4 Z0 d- F( \5 I0 n
    
57.         Enemy[j].y = rand() % Hight_map;
    , k8 W9 f$ i; u9 u5 g
58.         Enemy[j].r = 10;
    1 A1 Z$ r' r0 v& A4 D$ Y
59.         Enemy[j].color = RGB(0, 255, 0);6 ]6 a$ K% M  c) L1 b. V
    
60.       }) `* K% g7 g  H1 {, b! s' Q3 w
    
61.       //敌人吃玩家
    9 [/ v- p4 }3 H, ?  N. e
62.       else6 A# t: w4 M% ^; J5 @% Y, `+ v
    
63.       {0 e2 l+ u, b4 Y% l. J: w( X0 D( v\" \- l\" z
    
64.         if (invincibility == 0)
    7 B) i2 f2 R) z
65.         {
    7 w( T8 u: s\" M2 d) y& E, c
66.           Enemy[j].r += player.r / 10;3 q. Q& p, ?2 H8 @% p6 F$ L
    
67.           player.x = Wide / 2;3 L, W2 y; \; f2 \
    
68.           player.y = Hight / 2;
    9 E1 ^7 ]0 T\" G# ]
69.           player.r = 10;
    5 Q\" P, c$ I8 }+ h+ q7 y
70.           invincibility = 10;! b. \( R8 v! \8 f9 Q
    
71.         }: i) w( [! V\" x3 |
    
72.       }
    ; f6 Q4 F# |# r) @' x
73.     }
    ! G5 ~* g* |1 r  C+ W
74.   }* G. D3 y9 F/ \- `' F
    
75. }

复制代码

完整代码见附件：
3 l6 p) ^+ G  w% E% _4 B