球球大作战

2744557306

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

; Q. h8 Y) _% r0 S& a在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
" D/ s2 c5 v4 t) E+ Y' h9 g
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
: z9 t7 ~; |2 ^$ H- z( L
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球

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

玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
& X- a8 J1 }3 B# B" L3 x* m# J
% h& o3 M" j3 ?. s0 E# B+ iai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
5 {$ J+ f: w! h4 c. D3 i4 X
接下来，我们将通过以下几个步骤来实现这个游戏：

+ o( Y$ L3 `3 A9 k, {! k初始化游戏界面和小球的信息。
. v( M. l( h- J  J6 t
处理键盘输入，实现玩家小球的移动和加速。

: p* N1 B. }9 \4 |; J9 Y生成足够数量的食物小球。
1 Q5 i" M2 f5 [0 `6 w% Y
生成ai小球，并控制其移动。

检测小球之间的吞噬关系，增加相应的体积。
4 w% Z0 F# u8 g" L4 e( H; C7 ^/ j
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
& e0 j" _3 ~/ o9 ~" r3 ?  W1 K
1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

struct Ball
7 U3 \- V' K7 n6 w5 K  i/ m' ]{
3 H0 |( o4 f5 \+ K        int x;
        int y;
# P, l: u: x0 e2 j% [+ I        float r;
# r- Z# Y1 i( K& d        DWORD color;
3 w& Z% R. {9 Y1 s, C};
' W0 C' }% M' ^, h0 ]' ]) U2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
/ Q2 D! O5 r, c( C
+ g5 q8 l! X7 ~( L3 ]  J9 B橙色可以通过RGB值（255, 128, 0）来表示。
- H5 B# F4 [9 p0 K  h# d% N2 c黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
" K" O: G$ `6 G7 o! H蓝色的RGB值为（0, 0, 255）。
! ?  {8 K3 [1 G7 \8 F$ Y% I$ d紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   / ^) ?0 D6 p7 r' j  P7 O1 V
2. {! }: R+ M\" X' ?2 T) G8 z
   
3.     //玩家小球
   # v/ T+ p\" H) d
4.   srand((unsigned)time(NULL));
   * w0 z' }) L9 j+ M$ ^3 f5 f
5.   player.x = Wide / 2;0 G% g& B/ v/ L1 I9 O  I+ P
   
6.   player.y = Hight / 2;
   # c) J* E; F6 c/ i+ T+ Y
7.   player.r = 10;
   3 e6 R2 G8 l\" y- S
8.     //食物小球
   1 t1 e& J$ Q$ @; U/ b# K
9.   for (int i = 0; i < Food_num; i++): u( d5 x4 b* _6 c# j) x7 {
   
10.   {
    * K( ^; P& ^4 D/ ^$ F
11.     Food[i].x = rand() % Wide_map;, q\" |4 H+ ?' N7 w' N2 O3 ]) Q; T1 K\" {
    
12.     Food[i].y = rand() % Hight_map;6 m9 `5 Z3 s6 p1 ^
    
13.     Food[i].r = rand() % 5 + 1;  D/ r* s/ P9 J$ v0 x( @
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);; ]2 }! K4 b) O8 B/ n7 K
    
15.   }: ]% @& Z( b2 l+ H
    
16.     //ai小球1 q2 C5 ?* y0 r* J\" A; {, a  _
    
17.   for (int i = 0; i < Enemy_num; i++)1 g% {, P, r# K8 \1 Z
    
18.   {
    / M; C& I) g! J9 R& f9 S7 {' C8 v
19.     Enemy[i].x = rand() % Wide_map;
    $ Q9 J1 }; D1 C5 t
20.     Enemy[i].y = rand() % Hight_map;2 Y8 G+ [/ U. V- m) T4 @6 p( M+ [
    
21.     Enemy[i].r = 10;( f: m6 w: b/ T9 a
    
22.     Enemy[i].color = RGB(0,255,0);# E' [2 n! x( F2 e
    
23.   }
    * K$ ]9 ?% y6 B
24. # L1 u\" W# R& x  s1 M$ P6 g
    
25. }

复制代码

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

1. void Player_move()  r) {8 n, F$ X1 l( C7 y7 u; R2 T\" B
   
2. {1 @3 l\" y* c9 V' k. [& A  y% Z
   
3.   if (GetAsyncKeyState(VK_UP))* W9 O. g5 X* J* z$ L
   
4.   {
   9 l\" O# ]/ p- e# x
5.     if (player.y > 0)
   % B9 @  L. u0 O& r( z/ }; @
6.     {
   8 q; U4 N' E' N( I- ]7 d
7.       player.y -= player_sleep;
   ) Q5 G, T3 S  j8 z  O
8.     }
   3 Q  {; c- e# N9 w# m\" }0 r+ R6 [
9.   }- O! H: V1 C# K+ N
   
10.   if (GetAsyncKeyState(VK_DOWN))5 P! t0 f7 e  m
    
11.   {
    ( ]5 @' Y$ g$ h8 r% e
12.     if (player.y < Hight_map)7 S+ J! H4 F/ |' e' G
    
13.     player.y += player_sleep;
    % l$ u, G2 n( m  @. u0 `, W
14.   }3 {3 j( B$ }. w8 j, P) m, M- v
    
15.   if (GetAsyncKeyState(VK_LEFT))
    . {% b. y\" t\" [; I6 S
16.   {
    3 K0 S# m+ a* J- i7 w5 h2 h8 d6 O
17.     if (player.x > 0)9 a- T5 F( n% @1 W( H
    
18.     player.x -= player_sleep;& \3 B. \* J# I4 Y4 @& Z! ?3 `5 R9 w
    
19.   }
    : ?6 @/ w$ s0 _( ?2 s4 J
20.   if (GetAsyncKeyState(VK_RIGHT))
    2 c+ \& ~# ]+ X$ `
21.   {5 U* K% z2 j8 U5 b- \. L
    
22.     if (player.x < Wide_map)/ c2 z. Q, w, M7 p5 Q
    
23.     player.x += player_sleep;! u$ a4 o& ]0 K& D
    
24.   }
    + B# ]& ]! j; t
25.   if (GetAsyncKeyState(0x20))* U3 G6 D' Z9 ^9 `0 i) f% R7 E
    
26.   {
    9 [0 t: @! G5 o0 R\" L; c1 j2 n  Q/ |* A
27.     player_sleep = l + 5;; u+ e* N9 x. b3 Y+ a; W
    
28.   }
    ( V- d7 V1 e9 h
29.   else
    ) h/ M( I* S8 G: [3 y& T
30.   {: R% I6 q9 H. m, y# ?
    
31.     player_sleep = l;
    7 N7 z5 H* _/ O1 m) M+ e
32.   }
    - l' ?: z! h& \) w4 ]
33. }

复制代码

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

1. void Show()' D1 W& P: _1 G& x2 g$ Y9 j
   
2. {: p% K. o* h/ n. X7 y- ~9 [1 j/ h$ R
   
3.   
   $ r2 |0 ?* F; O
4.   //设置地图& r0 n5 }. X( ?& d# B' q/ b
   
5.   SetWorkingImage(&map);
   ; e4 P0 W3 y0 L  X4 [
6.   //清屏0 f# b. a' ?' R. L
   
7.   cleardevice();3 _' c' o6 @$ r
   
8.   //背景颜色. L% F6 E& R1 D! e' K
   
9.   setbkcolor(WHITE);& K8 a  }) M# X5 r) ]$ b( _
   
10.   //划线颜色! B) n7 `4 A) p- m6 ?1 I
    
11.   setlinecolor(RGB(230,231,239));: B$ {# ?$ s7 {4 r' t+ `
    
12.   //划线
      u/ k% M5 _8 f; ?! ?7 i0 i2 @
13.   for (int i = 0; i < Wide_map; i += 10)  M& }5 K3 W# ]5 V
    
14.   {
    . j& t% Y, ~; U, K6 ]
15.     line(i, 0, i, Hight_map);
    \" @8 G\" S. L6 z' M* z7 |# T
16.   }
    : W6 ]( i+ G* O
17.   for (int i = 0; i < Hight_map; i += 10)
    * r+ S, a1 q# R# P; e
18.   {/ k1 @, W! O0 R+ c
    
19.     line(0, i, Wide_map, i);' |/ n* X$ y8 r5 u
    
20.   }. p; H0 s, f\" e) r+ A
    
21.   //食物
    6 S( F* K) b6 `7 Y' o7 K
22.   for (int i = 0; i < Food_num; i++)! J  m: G- Y( I
    
23.   {6 p$ s) @, r( I$ F
    
24.     setfillcolor(Food[i].color);' W) p  ]7 K; J3 ?
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    6 N4 {  u/ N5 I. U, l% b, M% l
26.   }
    7 e1 N0 B5 s4 ^; R\" P
27.   //敌人
    9 n* v\" m' @, n0 _: L$ L( o& D  p
28.   for (int i = 0; i < Enemy_num; i++)% x/ D% q! R\" m% h# I
    
29.   {: i\" Z% R1 \( p) P
    
30.     setfillcolor(Enemy[i].color);
      o. q\" _& ?: m- q. _. S
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ' `8 Y* L# |; ~
32.   }8 w2 r- W# s$ ]6 ?( Y
    
33.   //玩家/ K- J- ^5 f, n. A% m
    
34.   setfillcolor(RED);3 {% e* X3 y8 [9 W4 N
    
35.   solidcircle(player.x, player.y, player.r);
    5 S% S% W4 y0 `4 T
36.   SetWorkingImage();
    0 Y- O- m- _  s+ w& V4 A- r1 j
37. 
    * K9 T/ }. K2 F4 i& H! ~2 H& Y. l
38.   int x = player.x - (Wide / 2);: P( a3 x/ e% N' x
    
39.   int y = player.y - (Hight / 2);
    \" P. h7 |! @3 e! M6 M! ?! o
40.   //防止窗口越界7 B8 S! o  f8 ?* B4 u
    
41.   if (x < 0), `/ R+ ]9 X8 T1 H. t! ~, ], L
    
42.   {
    % p: z. C: r1 U1 [* c7 u
43.     x = 0;
    \" u5 ]1 S0 F; Q8 |  `. }$ v
44.   }) e( U% E3 G  h\" `
    
45.   if (y < 0), l( X: K# u& t
    
46.   {
    ( B  g  i5 C( d* |  z
47.     y = 0;- b& _$ g# n9 J8 c4 d
    
48.   }
    7 B) v4 b  R) N% y; }, ~5 O
49.   if (x > Wide_map - Wide)
    : l0 U- U8 t) D' t9 V. ?5 E6 y1 l
50.   {
    4 i/ D( e$ X+ r8 h
51.     x = Wide_map - Wide;
    8 ~$ o: _# U1 _9 d$ D/ a) x\" R; e2 @$ r
52.   }. X) p* u0 |& r, J! v
    
53.   if (y > Hight_map - Hight)\" x5 }5 v# u6 ^! |7 p2 H; e( N
    
54.   {- G2 Y: G# c: f
    
55.     y = Hight_map - Hight;- g* ^3 X8 B: L+ C
    
56.   }
    , J; U6 Q- r7 r6 i1 B8 V+ j' {
57.   //把map输出到窗口上
    5 e& W' T5 q4 q% |: B2 i
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    2 g1 L1 q7 K0 E$ t
59. }

复制代码

5. 生成地图
! q* s' z: f4 |6 O可以使用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. //防止窗口越界0 I3 B' R8 j/ t$ I$ l
   
2. if (x < 0)
   1 t; H. F& }: N' {: @
3. {3 h2 p) j1 M0 i& T: [/ \
   
4.   x = 0;
   : D% P: ~) I; Q: i% Q/ R* l
5. }/ v/ l1 p; D+ u* e% j' g6 a
   
6. if (y < 0)
   5 \! P' t5 u& ?( h
7. {
   3 k% r5 t0 v& p# g6 l! f; G, K
8.   y = 0;
   8 {' _3 G2 a* w! U+ s, `
9. }
   * z: t( K% S+ B  X' H9 s% b3 F8 c0 Z
10. if (x > Wide_map - Wide)
    % v+ Y0 h( t4 g0 H1 ?$ ?; j
11. {
    # {- L0 j# Z5 w( l: O. b: C% `
12.   x = Wide_map - Wide;
    \" i. E4 F1 g3 E
13. }% F1 c* \% r4 A; I& o* u% r9 J
    
14. if (y > Hight_map - Hight)5 {\" i3 X8 s! I4 G! o0 t
    
15. {
    5 U% e) x' E1 @7 _! }: E
16.   y = Hight_map - Hight;( a6 L$ s0 B4 X\" l8 Y3 Z) O0 u+ m! W, v  ?/ V
    
17. }

复制代码

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

(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
5 S9 a0 o( P( F" [
Wide：这个参数指定了要绘制的图像的宽度。

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

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

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

& b6 Y$ Z/ ]# Q- O- cy：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
4 H& c: x, F. L1 e) O6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   ' l/ c9 N7 \. x) p$ k
2. int Distance(int x, int y, int x1, int y1)
   ) ?; K/ J0 ^( B3 |! a
3. {
   : S3 e! `. N. \# Z
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));; C0 `$ U, r4 c8 y\" W% g; P8 `
   
5. }

复制代码

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

1. void Enemy_move(), Q* a2 G, @& k/ k' d* K
   
2. {
   7 K% ]9 v# q1 j$ }* g
3.   srand((unsigned)time(NULL));\" \8 {& j\" T$ u  t\" @
   
4.   for (int i = 0; i < Enemy_num; i++)
   ; F8 h1 k9 g7 P
5.   {7 q( h. N3 _/ H+ }/ R; ]
   
6.     int direction = rand() % 4;
   0 n' t+ q1 J/ o0 p4 i  s: c+ j
7. 
   : `0 \. G) y\" J/ l9 u2 j3 d
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50); ^- y5 K5 I) T, D
   
9.     {& W, C0 S$ b9 |( A& h) N
   
10.       if (direction == 0)) ]: F2 s, A% J\" _
    
11.       {
    . h7 h4 B6 Q% U) q. b( J
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句6 p2 N: p\" U+ n. ^! b5 y1 z
    
13.         {
    3 \* u0 t1 T: F4 {, m0 e
14.           Enemy[i].y -= enemy_sleep;7 L: R/ H7 \* K0 v: }
    
15.         }
    ; n& ^. d- C5 \! Q1 B2 |& Y\" D( O
16.       }
    % @4 r- [: w5 G1 T  N
17.       if (direction == 1)! S! O  A3 B3 B) u1 @4 Z
    
18.       {7 g7 P1 ?+ v$ w. `9 t( x
    
19.         if (Enemy[i].y < Hight_map)  f2 T1 Q9 ^5 a
    
20.           Enemy[i].y += enemy_sleep;
    * K0 K. I4 G% L2 }( Y
21.       }
    . [- X0 s4 r/ @. W0 E1 l
22.       if (direction == 2)4 z\" k* E+ \& E6 P0 _: G* ?
    
23.       {! L- K1 b$ d( o4 g7 t( }) [
    
24.         if (Enemy[i].x > 0)
    . f$ M+ _. A! G8 F
25.           Enemy[i].x -= enemy_sleep;0 @1 q: W( `( j- ?7 S6 m, Z\" v8 l
    
26.       }
    * o3 G+ Q# j3 q/ E; ^
27.       if (direction == 3)
    ! Z6 K2 _0 ^\" I7 ?
28.       {
    . T8 y2 z- u% Z\" w
29.         if (Enemy[i].x < Wide_map)6 L# |! w: L0 k9 X) }& t  P
    
30.           Enemy[i].x += enemy_sleep;\" M% `! D, i' G! ~+ N7 g5 W* a- q
    
31.       }9 z4 t/ v! |1 _5 E
    
32.     }
    , h# C2 n5 c7 }# L$ ^8 m$ L5 P
33.     //敌人追击玩家
    \" z6 ?7 T- v) U( h: ~! G' A
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)3 t2 n5 Z9 R; G* |; X
    
35.     {
    % h; B% k4 H\" T8 v
36.       if (Enemy[i].r > player.r)4 {5 y% q- `6 v4 s+ V+ L$ r6 \
    
37.       {
    & d/ J0 [, k% D4 s* i% b
38.         if (Enemy[i].x < player.x)- L; f$ x6 J) w- m: G6 l
    
39.         {
    6 P1 d1 Q. i6 w1 F5 ]
40.           if (Enemy[i].x < Wide_map). f. L! \' W9 }; y
    
41.           {0 ^0 }  G* Q+ H
    
42.             Enemy[i].x += enemy_sleep;+ O5 Z2 t, b  k* N8 E4 f7 b2 q
    
43.           }; Y1 m$ z$ ?1 o9 i+ P! M7 \
    
44.         }& H5 x$ k2 a2 t2 C0 Z0 Q$ t) y
    
45.         if (Enemy[i].x > player.x)+ b/ K% l  ^$ }+ b
    
46.         {( v% h& Y4 f3 J5 o& k# \
    
47.           if (Enemy[i].x > 0)
    ; r9 ?& N: F; k9 j3 q7 z0 n$ k8 X3 [
48.           {$ k7 i  ?1 s) }& {+ a1 g
    
49.             Enemy[i].x -= enemy_sleep;
    : s; P- c\" X1 @+ r. |, m2 q
50.           }
      k1 `, r! k& o! }/ U; W( L
51.         }
    ; P0 V' V) f4 r3 q! p; G' L, l% ]8 _
52.         if (Enemy[i].y < player.y)
    ; e7 V3 j* e' U) V' }+ {
53.         {/ a\" r. w$ f  M0 x9 f+ V. t8 v
    
54.           if (Enemy[i].y < Hight_map)
    ' y! {2 i# N3 q* d
55.           {
    / u& R$ A+ ?/ D
56.             Enemy[i].y += enemy_sleep;
    6 d$ D3 j! Q/ I) d. P
57.           }5 x6 p4 P1 @) H# ^8 I+ W- e0 S4 O
    
58.         }
    % h7 k) [4 p8 a1 r0 Y
59.         if (Enemy[i].y > player.y)1 {6 i\" K4 @4 S6 J+ E\" b0 {
    
60.         {# s( S' f* `# [\" j, O
    
61.           if (Enemy[i].y > 0), }8 e8 S: Y' q! c2 s
    
62.           {
    7 O8 |/ b, E: Z* Y' G
63.             Enemy[i].y -= enemy_sleep;% B6 @6 M) W; m: G6 f
    
64.           }
    / {; x/ e\" Z. u1 M0 K
65.         }
      u. U+ X; f  h/ s
66.       }
    # ^( [9 b# w9 B1 i+ O
67.       //敌人逃跑
    . l' Q! c5 a* C
68.       else& @0 ?3 q4 c  f8 y0 }* a
    
69.       {
    ) C, ^! f' g+ t0 Z7 {' d, f
70.         if (Enemy[i].x < player.x)2 W% e, T9 r  n8 Z/ W) _
    
71.         {( G0 c2 w. A% X) {0 U
    
72.           if (Enemy[i].x > 0)\" P4 Y6 @: u8 ^# R! @+ I
    
73.           {
    7 E  y8 b7 \  Z$ E) v. y/ Z
74.             Enemy[i].x -= enemy_sleep;, T' b$ c  o9 i( [1 H\" o
    
75.           }
    * z9 ?( }8 J; y9 w
76.         }+ N7 I% @, Q  h  `$ p, ~, E) l/ H
    
77.         if (Enemy[i].x > player.x)4 S* e- ~0 @. U1 b; n) O' z
    
78.         {' I) @6 @+ @# T. h4 `
    
79.           if (Enemy[i].x < Wide_map)
    8 o* Y' K/ @$ n4 }# t9 Y
80.           {% X& k1 X, S. p7 E; ?
    
81.             Enemy[i].x += enemy_sleep;1 o( V, W, F) k' f% U5 g) K4 Z
    
82.           }2 P# P, |) R6 z8 ]
    
83.         }# A( z5 B. A, F& e, E
    
84.         if (Enemy[i].y < player.y)( O+ v& ~/ l% L$ o/ o
    
85.         {+ C$ p4 f9 H+ X( h
    
86.           if (Enemy[i].y > 0)
    + f8 Y/ m) k8 y. g8 |: z
87.           {
    2 g$ y9 g7 p/ ^$ [
88.             Enemy[i].y -= enemy_sleep;* ]3 i  ?) C. ~: y
    
89.           }( A$ J. S2 {% ^$ |3 \
    
90.         }
    4 U! W, _& e& O% C6 e: z
91.         if (Enemy[i].y > player.y)  i2 w8 {9 z/ |$ K  W
    
92.         {
    % G1 ^. q9 T  E2 x2 _0 S\" L6 q. x3 b
93.           if (Enemy[i].y < Hight_map); C2 j6 G! A5 c% F
    
94.           {\" O3 Z) O  B; f9 p! O8 I6 E& r
    
95.             Enemy[i].y += enemy_sleep;0 j/ p1 g9 T; B2 A9 l4 Y% E5 q1 l
    
96.           }) D1 m* H* b5 w0 K, X% ~/ A  M
    
97.         }
    ) c\" N: g0 M& G
98.       }
    8 n+ ^+ ]; D9 Z8 C5 L3 f
99.     }7 t( d& U- ?- g\" s, \: j: X
    
100.   }  V3 t, o2 _  y8 O8 ^
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   - ?& G  s+ S5 m: s/ ?\" l% P
2. {# s/ O6 o6 n* s' v0 V/ _! N: L\" q
   
3.   for (int i = 0; i < Food_num; i++)  [7 E* N6 i; C\" h/ P
   
4.   {
   $ Z8 b! D4 }* l2 b4 U
5.     //玩家吃食物6 j\" H( F9 S( A( I8 C* V) ~+ z
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r), D# a% N8 V7 o; }\" q; e
   
7.     {
   3 c! ?9 ~) j: B' `; i
8.       player.r += Food[i].r / 100;- D$ K7 f\" J$ Q
   
9.       Food[i].x = rand() % Wide_map;! @( k: ?3 t1 e6 k! h: \1 w2 T% m/ v  l
   
10.       Food[i].y = rand() % Hight_map;
    % E0 l1 s& L1 w3 v\" k7 D% t
11.       Food[i].r = rand() % 5 + 1;
    1 u- ~5 {+ t+ w9 T\" G7 L
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    + A9 G7 d- S$ v4 X
13.     }
    / c; A- O/ h- q0 K. f5 [5 T
14.    
    % q- u, p9 G; m, j$ J2 E
15.   }% ]3 \\" N' e2 n1 Z\" b
    
16.   for (int j = 0; j < Enemy_num; j++), b0 y8 Q\" F$ B) y- G9 r% |( f9 _
    
17.   {7 c! C6 A* R7 `' ?
    
18.     //敌人吃食物
    0 Q; p# C2 P, Y) ?+ A: K! u' ]
19.     for (int i = 0; i < Food_num; i++)+ w- i4 `( K+ K4 D& H; R8 n% D
    
20.     {
    , t8 O' T( z+ V\" U, E
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)1 R0 `) N2 c7 R4 b) e1 }
    
22.       {
    2 {  H6 H) J+ |, W, [9 \
23.         Enemy[j].r += Food[i].r / 50;
    ( ~4 k% w9 n+ g2 E3 U
24.         Food[i].x = rand() % Wide_map;' A& f\" I$ [6 L; G1 }
    
25.         Food[i].y = rand() % Hight_map;
    & l0 o. `( A# p' u! o
26.         Food[i].r = rand() % 5 + 1;
    / F. V! [! _+ k/ x
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);* `1 `+ q/ N' `) U, g\" A  n5 R
    
28.       }2 p2 J1 n7 R, m; h% V* M\" j& K6 d( s
    
29.     }& }7 V\" }/ m3 w) X% Y3 M\" m
    
30.     //敌人吃敌人
    ! U/ \, v9 C, i+ l! {- M1 e& ~
31.     for (int i = 0; i < Enemy_num; i++)
      J8 f, W) }! [9 p% r$ }1 O
32.     {
    8 U, u5 {$ y; `\" {+ s& K
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)5 u6 |+ g8 o2 b0 C% C) z; |
    
34.       {
    * {5 y% R1 D- q. Z  T
35.         Enemy[j].r += Enemy[i].r / 10;% |9 C5 [0 ]4 e
    
36.         Enemy[i].x = rand() % Wide_map;
    % m- W- m6 ~; [  `4 @8 O
37.         Enemy[i].y = rand() % Hight_map;6 `) Q. P\" z7 q7 S8 ?' v/ n
    
38.         Enemy[i].r = 10;- r' B7 m$ p; \/ {8 C
    
39.           Enemy[i].color = RGB(0, 255, 0);
      r5 b7 Q, g6 q6 i7 D4 f0 c4 D$ Y
40.       }
    : o1 l6 z3 G\" V; W9 z9 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)4 |( {% W5 R8 t, e3 U
    
42.       {9 U\" x% ^% w# T) u
    
43.         Enemy[i].r += Enemy[j].r / 10;
    9 O2 Z* M; @( L& g; m6 G* V* r2 u' a
44.         Enemy[j].x = rand() % Wide_map;
    9 y7 G4 U- D! a+ G
45.         Enemy[j].y = rand() % Hight_map;
    ) l( h% D% e7 f) Z+ g4 i+ B
46.         Enemy[j].r = 10;! j! t5 f5 l9 G
    
47.         Enemy[j].color = RGB(0, 255, 0);
    . l3 D; k; R, B2 \  @
48.       }6 y& N, @9 G0 b6 l( C6 Z
    
49.     }/ k& g8 v% e' L/ Z
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    / R$ W4 H) Y. m. X! P+ \
51.     {( a+ C' d0 n7 R& t/ @8 x
    
52.       //玩家吃敌人: n2 c* W5 V! d8 N
    
53.       if (player.r > Enemy[j].r)
    7 v6 [. ^$ l% m\" V9 H
54.       {) `0 _  n$ z+ ~7 U' c  Z
    
55.         player.r += Enemy[j].r / 10;( ?8 K0 d# u7 h
    
56.         Enemy[j].x = rand() % Wide_map;
    - j& l7 L' Z5 W  t7 \! S  q
57.         Enemy[j].y = rand() % Hight_map;* P/ n, g( J' R# C% o
    
58.         Enemy[j].r = 10;' i  A4 X* M& L
    
59.         Enemy[j].color = RGB(0, 255, 0);
    : t* s1 \2 F* }. w
60.       }8 G* h+ A7 ]& k8 m& G0 J
    
61.       //敌人吃玩家
    6 Z: f. ^8 I7 g! G! {
62.       else
    - e3 ~9 n  g' i\" {
63.       {6 I/ ~; l7 {8 G/ }  I$ t8 m
    
64.         if (invincibility == 0). d; ], v; k- a+ _& k$ }
    
65.         {4 T, V& i/ k\" B7 J
    
66.           Enemy[j].r += player.r / 10;\" O6 _* ]3 c( @\" V5 P
    
67.           player.x = Wide / 2;
    ; b& L/ Z! O: i. w* N
68.           player.y = Hight / 2;
    % t+ f- g% U$ o0 U
69.           player.r = 10;+ Y1 F; ]1 |; j) s1 p/ C
    
70.           invincibility = 10;7 A\" V7 R% |( q6 a* c: y
    
71.         }
    ( g9 B2 j: L: A
72.       }+ P8 B$ t6 u( K1 N7 b
    
73.     }6 z+ B* O* b  Z% L
    
74.   }4 h6 |: V3 Y\" K# {3 L) f/ }2 |
    
75. }

复制代码

完整代码见附件：
! T, ]4 q! {4 g- U  A9 o$ ~

0 U2 k# L/ w+ f9 F9 l
) O0 e" {  a! f  w- e: T& p