球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

7 c& {. |" ?, x游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
1 H: i9 i3 h. s3 L, m& x
其他小球：其他小球又分为食物小球，和ai控制的小球

/ D* o3 d6 b5 `( x" V6 ^0 M3 R体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
! @: G" s. f- {! }, o, h- M2 r
玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
2 d$ S* Z; z6 W/ G
0 V; O$ c8 X( E5 lai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
% N4 @4 ^: H0 v+ r4 ^
7 G; L7 f: |* f3 Q3 s: b接下来，我们将通过以下几个步骤来实现这个游戏：

1 t: T  u/ |, y初始化游戏界面和小球的信息。

! ~9 r4 e* b' U1 U( N处理键盘输入，实现玩家小球的移动和加速。
+ q4 c) N; l) A
生成足够数量的食物小球。

% _# V, `/ S' O. X  a生成ai小球，并控制其移动。
& l$ A" u8 V+ B/ U8 J
& I9 E) N2 t8 b' R/ T2 ]检测小球之间的吞噬关系，增加相应的体积。

通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
# K8 L* \% D1 x3 E/ o( l- [
1. 小球的要素
0 o+ |6 D! B  I: ^4 d: O! d! M在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

6 B" x2 o8 ?$ Gstruct Ball
/ s3 n) b3 j  T  b  B{
" l( d) v: S) M% H& S1 q        int x;
7 F: ^5 n1 Z6 L        int y;
        float r;
        DWORD color;
};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
) `) ^! n' ]6 s6 r; ^) q, ?$ W
- @% K- ?/ k% U' c; ~RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

2 v1 c1 N6 N; F橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
! A8 e9 j7 V: y5 ~5 V绿色的RGB值是（0, 255, 0）。
& a5 R. V5 h( ~/ O6 P9 \& F* `蓝色的RGB值为（0, 0, 255）。
  }9 [" Q8 q2 N; v2 t; r3 B  T0 K# Z紫色可以通过RGB值（170, 0, 255）来表示。
4 u: N/ P6 u& z0 C& ]) F( V黑色的RGB值为（0, 0, 0）。
* x5 P/ C. {0 g( W% y白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
     W/ m, z5 r  D# w1 [/ c
2. {+ a# D% i2 L9 c2 ?, q9 l
   
3.     //玩家小球5 |& p  T; N, [5 K6 w2 v* E& [
   
4.   srand((unsigned)time(NULL));- x. ?, z8 h0 }& Y5 ]\" G% ]+ [) V
   
5.   player.x = Wide / 2;
   + V1 s7 F4 y/ K+ I/ A# I
6.   player.y = Hight / 2;
   # V; D$ ^. e9 H+ W
7.   player.r = 10;
   3 M4 u; q0 v2 x2 R
8.     //食物小球
   : K* `\" e4 J- @
9.   for (int i = 0; i < Food_num; i++)( t! o8 v\" P\" T- h
   
10.   {
    * O8 T+ ^2 W8 ~. @# l
11.     Food[i].x = rand() % Wide_map;
    5 N* s7 H7 h8 c. s* `
12.     Food[i].y = rand() % Hight_map;/ R6 K* {4 b# t7 k
    
13.     Food[i].r = rand() % 5 + 1;0 t* H% b% `* Z' ^9 W3 [: O: y; e$ w
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    - h4 Z\" d: V* d5 ~
15.   }
    * t$ `0 N( d' _8 U; {3 x
16.     //ai小球4 F2 d* v# ]5 N3 _# s! m  M8 H
    
17.   for (int i = 0; i < Enemy_num; i++)# O% v  p7 o6 S! @
    
18.   {
    # e: \* U( ?3 R% P- ]
19.     Enemy[i].x = rand() % Wide_map;
    ( t6 H0 P0 z. ^9 E% v, z4 ]! f
20.     Enemy[i].y = rand() % Hight_map;
    5 `% {7 j$ A$ ]
21.     Enemy[i].r = 10;: _  V2 d) Q- e2 W+ \5 i
    
22.     Enemy[i].color = RGB(0,255,0);
    & f: q0 z1 T' W8 N
23.   }
    4 c+ N4 G, f( P; i1 Q/ m5 B
24. ; Z* c& b* P  m9 ?3 Q, M
    
25. }

复制代码

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

1. void Player_move(), E/ z4 G) J- h
   
2. {
   / r5 R/ O$ \+ _8 W/ o; m
3.   if (GetAsyncKeyState(VK_UP))
     H2 C( U3 I- G5 p, y3 i
4.   {( q) P1 ]& F0 ^- m+ W' g
   
5.     if (player.y > 0)
   4 M; f2 ?8 r$ u; M% d% v) R5 b  b
6.     {% v, p1 l- i  x. \% W' M. N
   
7.       player.y -= player_sleep;
   0 C\" j9 J8 m* a- N& ]
8.     }
   : I, |) i\" G: D: a4 V
9.   }/ n* m  i. l* i\" @# f! I6 m
   
10.   if (GetAsyncKeyState(VK_DOWN))
    / {5 v2 j- j* w  _' ]* Q
11.   {
    \" Q! }  y; J; d
12.     if (player.y < Hight_map)0 d* w/ N; Z$ B: ]\" Z/ j0 a; L2 o3 R
    
13.     player.y += player_sleep;! u# K# h  {# d\" }7 w# O% x; u
    
14.   }% @1 R' W3 R! L! e9 ~
    
15.   if (GetAsyncKeyState(VK_LEFT))
    6 v( z6 j+ x3 Q  p6 o* [\" }' k
16.   {' y9 c) ~  t( f3 U* I
    
17.     if (player.x > 0)
    8 w6 z5 Z# r/ H\" t* A( u8 F5 ^
18.     player.x -= player_sleep;$ p, v) i8 l. Y
    
19.   }
    # A9 r( @6 ]) {7 C& y
20.   if (GetAsyncKeyState(VK_RIGHT)); Q& S7 C4 e& b1 ]
    
21.   {- r8 F6 E; n  Y\" A! B# L
    
22.     if (player.x < Wide_map)
    ( Z\" F# y/ ?( `0 T
23.     player.x += player_sleep;
    / T; s  X/ i' w) x3 o* j
24.   }! N4 `6 E: X# j1 u/ `; G( R) _
    
25.   if (GetAsyncKeyState(0x20))
    & M% s  q* V/ n( ?: h7 J2 j) G3 ~
26.   {  n% y; H7 W* Q2 k3 k. C' m
    
27.     player_sleep = l + 5;
    % c) q3 @; a, _1 q\" N& e( d% C' ^
28.   }* }7 p$ g6 ~, |$ M$ G
    
29.   else! G4 S+ W6 ~7 U! N7 M3 r
    
30.   {6 C6 T2 s0 M6 E9 Q
    
31.     player_sleep = l;# {$ P& \* H! f5 w& C/ Z
    
32.   }
    # d( S+ [2 ~! A) i1 |8 v( v
33. }

复制代码

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

1. void Show()
   5 m3 N2 [* c7 j' `. n8 x8 {
2. {: r+ Z- x1 Q, \\" [. I
   
3.   % b) F- [% Z7 q% z* ?; {* r$ E) Z
   
4.   //设置地图
   - \8 K. }, h# W
5.   SetWorkingImage(&map);
   ) d$ g\" Y& S. S$ x  T\" h
6.   //清屏
   ( v- L9 F1 j# C8 p7 [: B5 O# }
7.   cleardevice();
   % Q# m* f$ ~' g: |, X
8.   //背景颜色
   ' |: `* R# o; ]: u1 y: @- U
9.   setbkcolor(WHITE);
   * H1 R8 d6 u: C1 F/ V
10.   //划线颜色, p  _% _$ g/ ]6 R) \6 P
    
11.   setlinecolor(RGB(230,231,239));5 ]! q6 }\" y* p4 D8 P3 k
    
12.   //划线
    7 C  P, h1 c) [  d
13.   for (int i = 0; i < Wide_map; i += 10)
    ! [9 A; i: `2 ^% k2 Y+ k% {
14.   {( y1 Q: v' ]. r
    
15.     line(i, 0, i, Hight_map);
    / g: X1 o1 Z# |( f
16.   }
    ( w* H5 d9 T5 C
17.   for (int i = 0; i < Hight_map; i += 10)2 h$ W6 X: P) Y0 i3 l8 g5 C; e- f
    
18.   {. e9 b\" d# h4 L; u
    
19.     line(0, i, Wide_map, i);% w/ H% B, R+ z% _/ T6 x
    
20.   }# X( `) h; Q\" i8 Z1 }4 t( T
    
21.   //食物1 W/ J4 Y2 C4 l, [- g( ^* @$ c
    
22.   for (int i = 0; i < Food_num; i++)
    0 m7 o( l' G# l* X3 U8 J
23.   {
    5 P* o& ]3 H, \4 l, S
24.     setfillcolor(Food[i].color);5 \% _* m' Q; M$ l7 h: v3 L( V/ K
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    # s5 N9 k( d2 L
26.   }
    3 ?/ ?( w! y3 m
27.   //敌人5 p; ^8 o6 B+ Q1 l. ?1 q% ^
    
28.   for (int i = 0; i < Enemy_num; i++)
    ' G+ D0 m- M$ A7 v; h
29.   {
    . w0 b, M$ ^$ }. A7 y' ?
30.     setfillcolor(Enemy[i].color);$ T! h\" o9 d* E% K1 A2 M% j
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    6 S9 Z7 f' K/ z7 m
32.   }
    4 m) ~# r9 p# t9 J0 N$ u( `
33.   //玩家% \# t8 _9 @, r, Y% C3 S1 |# H
    
34.   setfillcolor(RED);: |% q) K) c. F\" }: V# f
    
35.   solidcircle(player.x, player.y, player.r);
    $ x0 X9 _3 E4 `\" U9 `4 y
36.   SetWorkingImage();8 k$ U! P8 n7 F# b  q
    
37. 
    # N+ A7 ^. }) C
38.   int x = player.x - (Wide / 2);
    0 F6 C+ G  X  g3 a
39.   int y = player.y - (Hight / 2);
    8 P: e( n) f; t3 @6 D
40.   //防止窗口越界
    4 t; Q9 n6 M* N' x+ J3 a% p6 H8 V
41.   if (x < 0)
    , _- h) n9 u7 H) L5 \) a1 i5 e
42.   {8 @; z\" M8 R9 X7 P& O0 X
    
43.     x = 0;
    \" Y+ q, _+ v\" _6 x. G
44.   }) @) L9 n5 s% Z7 W
    
45.   if (y < 0)1 ~, d\" Y1 z$ E8 q1 }& B3 U- K
    
46.   {
    * g4 d+ Q( U8 x# R& d
47.     y = 0;. o0 j3 [9 w6 ^! R
    
48.   }3 X* G\" P$ `1 b2 V, B- \
    
49.   if (x > Wide_map - Wide)
    9 ]5 ~. l6 H+ m\" Z: ]# r) k, c
50.   {( G$ t6 E# t, `& L
    
51.     x = Wide_map - Wide;6 p9 O) \( H* p0 k. ?8 R9 ?
    
52.   }* C/ m& O( j1 r* x9 C1 E6 P5 l
    
53.   if (y > Hight_map - Hight)- G/ A% V3 o+ A& Y
    
54.   {
    7 R  q1 \  `6 y& \
55.     y = Hight_map - Hight;
    1 A# F/ {\" M+ b6 a  p
56.   }
    ; y. x$ j/ s1 L4 {) p) Z
57.   //把map输出到窗口上3 r0 H2 _* T. J! C2 E$ F4 T% d2 o
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);7 v/ b& p* j# y8 J  c$ t
    
59. }

复制代码

5. 生成地图
, ^, E9 v. x; F/ i可以使用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. //防止窗口越界- [2 B# m- b0 C0 o- g+ O
   
2. if (x < 0)
   ( K7 z2 l7 h( x. l: z
3. {' M  y\" h3 I  l1 _' h/ f! u9 e
   
4.   x = 0;
   ' q\" ?; @. e9 s% }1 H
5. }
   ' M# D& c  p1 j+ H/ I  I7 w& s+ |: X
6. if (y < 0): ?# P* k4 M6 h3 M4 _. @( Q5 q
   
7. {
   9 o\" A) T; _: Z. s
8.   y = 0;2 u3 Z% \2 y& |2 M
   
9. }2 o4 l\" `8 E) |2 e4 f
   
10. if (x > Wide_map - Wide)
    ; R\" s\" y: x% s
11. {
    + U5 b3 R  k* d# x% F
12.   x = Wide_map - Wide;
    3 A/ P5 W$ M, d$ h5 z, Q
13. }
    \" t+ `7 d& n3 I+ D0 D8 M0 W
14. if (y > Hight_map - Hight)# P: ~+ |9 I9 D' D: s\" B2 U
    
15. {$ I/ J! k3 M( S8 }) B: a2 C! e
    
16.   y = Hight_map - Hight;( Y8 @\" Q6 T  _/ z# b4 u, @2 H
    
17. }

复制代码

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

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

/ D2 @: }6 {8 d% @( G" jWide：这个参数指定了要绘制的图像的宽度。

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

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

9 t9 S' f& K) w7 I* K! sx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
* p8 A! i% c) h. m
: Y: \' N) U  U: X* c7 y! W% d% my：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
2 v, u$ c2 Y1 K+ T3 m6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   8 @0 [6 _+ L# ]: U  h$ M, u$ }
2. int Distance(int x, int y, int x1, int y1)* Q7 w, F- p5 M/ }+ f2 B+ Q
   
3. {* i% g# z. g% E\" P+ [) t. z: Y  T# Q
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));) [- |4 |. T$ Y
   
5. }

复制代码

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

1. void Enemy_move(). E6 D  t% Q  a# s  z: C\" q  R
   
2. {6 k: l; n; m& Y0 ~2 L( t, [
   
3.   srand((unsigned)time(NULL));
   \" o' x( |8 O7 R  p( P/ i* T
4.   for (int i = 0; i < Enemy_num; i++)
   9 G/ t- R; D% A; p' A$ v; c2 F\" E9 S- ^3 }
5.   {
   \" K# `& Y+ t! o$ K* z- n* _
6.     int direction = rand() % 4;7 J! t2 G9 _/ N  Y* Y. U
   
7. 7 F5 o7 ^1 b/ q: d
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   : k; H# ?5 m+ Y3 j& V
9.     {# b- y) Z4 [, D% [! x: L
   
10.       if (direction == 0)
    / F8 ?0 S( ^+ s  @/ p
11.       {# j; Y1 U# \) I6 ]  d
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句4 M- P' n  Q& B' e' B( o1 m, P
    
13.         {
    ; k. i% V2 P7 s0 f/ |# w
14.           Enemy[i].y -= enemy_sleep;
    # n& _% R6 x( R4 X2 {% z
15.         }
      I' E# ^# D: F5 K5 w
16.       }
    ' J6 y\" q9 w\" p& |6 v
17.       if (direction == 1); z/ C/ q& x  q4 @- M$ t- S
    
18.       {; U/ u- U2 o2 v* Q
    
19.         if (Enemy[i].y < Hight_map)
    . ?* S9 O  ?  b' Y) F
20.           Enemy[i].y += enemy_sleep;
    ! \. |' z6 _: N+ p0 e6 }
21.       }% z; l) @) ]( c6 W( {/ s( }: M\" j
    
22.       if (direction == 2)
    ( b3 O9 y\" ~0 H, Y- \- n1 r* P
23.       {* `  C# r2 G6 Z2 Z8 d: J$ Z- p; T
    
24.         if (Enemy[i].x > 0)9 |' R! V# d4 w  S\" }: [3 a$ I
    
25.           Enemy[i].x -= enemy_sleep;6 |% T- p9 _7 m6 N3 I$ r- o2 p
    
26.       }
    ( [* K2 J( U8 j8 n' C7 ^; I
27.       if (direction == 3)\" U4 L+ K\" q7 k/ F
    
28.       {) y* T: a: r\" ?5 s
    
29.         if (Enemy[i].x < Wide_map)
    ( h$ e# C0 p. q
30.           Enemy[i].x += enemy_sleep;3 M+ G4 @* }# A: U/ l
    
31.       }
    * t# w0 y' d2 `6 \) h+ e
32.     }. I' U\" s3 |5 L, H9 a5 t# i  w
    
33.     //敌人追击玩家$ u. P\" c; E# ?7 Q7 f# v6 s
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    ! v, m  u& p: M& \
35.     {
    2 q8 [8 k  y5 A! J; t
36.       if (Enemy[i].r > player.r)
    0 _. M! D% V. k& g( k. c; t( X
37.       {/ R5 ?1 _+ Y6 @: C) X, H: Z7 d
    
38.         if (Enemy[i].x < player.x)
    7 z1 m% D; z; e+ N
39.         {
    \" ~3 a/ E0 f8 N3 N% J% z. b* M
40.           if (Enemy[i].x < Wide_map)+ O: L0 e7 t& D' X7 q\" k
    
41.           {, q% X9 F8 R( G; ~9 L0 f
    
42.             Enemy[i].x += enemy_sleep;3 B0 ?8 G* P/ J% I  [
    
43.           }
    # i  i$ i) E6 r5 f9 A
44.         }
    * u% j: v8 x) G: v4 E7 ?% {, P/ ]
45.         if (Enemy[i].x > player.x)
    ; V0 ], z- [4 \2 O6 M
46.         {
    $ U8 d- a5 ^- p( e9 E' t
47.           if (Enemy[i].x > 0)- J# j: B/ }2 Y) x2 `0 ~
    
48.           {
    7 W$ b& c2 @+ l. K* ~3 Z: s\" H
49.             Enemy[i].x -= enemy_sleep;0 B, ?: K  W  L% z( f3 z
    
50.           }
    $ N, m3 A- p2 P3 X# J) |3 @. b
51.         }
    5 f& z+ y6 T) W, a0 y0 \0 ]2 N0 U
52.         if (Enemy[i].y < player.y)8 h1 q$ V. h% {, }' q, m1 L
    
53.         {- a- [8 G1 i6 ~. @
    
54.           if (Enemy[i].y < Hight_map)! S0 `% n) f) S8 u& h- l; `$ W. k
    
55.           {
      M0 b$ Y\" s- Q1 r% o5 t, y/ h
56.             Enemy[i].y += enemy_sleep;
    , o* r' y2 }( K) ~
57.           }
    * e. k0 X' f* s. A/ U3 T
58.         }
    ) G% X9 Z0 y  [7 O6 ^; |\" m
59.         if (Enemy[i].y > player.y)
    ! g) D! P7 \. V# j' M' _+ K  w
60.         {% c\" T& U- p1 g! e3 s
    
61.           if (Enemy[i].y > 0)
      F5 W$ `* a1 R0 T0 z4 ]) R
62.           {
    * N! ]; [, j* z( D( u
63.             Enemy[i].y -= enemy_sleep;
    . [) y7 h\" Q% _! k% a) Y8 K9 Q
64.           }# o6 B1 g3 T. |2 D
    
65.         }
    # d8 W$ _7 s3 p' E\" @9 z\" x* r
66.       }% g6 k) ^+ v+ ]. }
    
67.       //敌人逃跑5 a\" h+ Z- _4 e5 R
    
68.       else
    ) |& w' G- C! t/ U- k- }  x
69.       {
    # u3 g0 T\" P$ \
70.         if (Enemy[i].x < player.x)4 _. C2 q) S0 [% i\" Z# M% X8 p
    
71.         {
    8 Z+ i; J! g8 c# E
72.           if (Enemy[i].x > 0)! s# G5 ?6 x0 y, ~\" k$ E# c
    
73.           {2 I2 q2 S, b4 l$ f- R* k0 ?! M2 K
    
74.             Enemy[i].x -= enemy_sleep;/ Q1 d2 d, E. a5 h
    
75.           }& a5 D5 Q8 y& W
    
76.         }
    $ z9 h( W  ^5 W/ w2 c6 a/ h
77.         if (Enemy[i].x > player.x)
    4 r& i0 b+ |3 F+ i* D
78.         {: q4 w+ b4 l& [9 y  R! q1 V
    
79.           if (Enemy[i].x < Wide_map)
    % D7 M  P0 X# ?
80.           {. `3 }, o7 X. C
    
81.             Enemy[i].x += enemy_sleep;2 O; P2 ^4 }( o
    
82.           }3 q/ f* e+ Y8 ]# \; f' h3 H
    
83.         }
    + [6 z. T5 w) t
84.         if (Enemy[i].y < player.y)
    7 H/ K, R& I1 I! w  ?3 J
85.         {
    + ~4 y) a% N5 V- s& W
86.           if (Enemy[i].y > 0)' c' B7 Y, S$ o2 ]1 Q' Z! O
    
87.           {
    % s, P( [% K) a$ n
88.             Enemy[i].y -= enemy_sleep;9 M/ K6 U+ I, d
    
89.           }. m1 h3 C/ N; Q' a1 s2 q. e
    
90.         }0 @% O9 m9 c: C$ K& e
    
91.         if (Enemy[i].y > player.y)
    0 G' Q: r( B/ {. l, C- _. G
92.         {
    4 ~; e4 e: u* b( M6 _$ a9 O& i
93.           if (Enemy[i].y < Hight_map)2 t+ u. ^( l( H8 o* H2 c$ J( q/ A
    
94.           {9 O0 J3 i6 G: I
    
95.             Enemy[i].y += enemy_sleep;/ u0 w! s2 Z6 H; k3 o$ T. a0 x
    
96.           }
    \" M$ V( m# K\" `\" L5 }9 B( S
97.         }
    & [/ u9 U/ ^3 F% t5 J. r* n2 b
98.       }
    8 p4 x3 s% j/ F\" \% X5 q
99.     }
    : k1 ^' b. i# E, m, t& B; b9 I
100.   }
     \" l, `% ^' ], v! h! b2 x
101. }

复制代码

7. 小球之间的吞噬关系
6 r: g. w6 W1 w, M! y, @

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

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

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

1. void EatFood()
   1 h5 R6 z4 I/ P$ F! m/ N, A0 k
2. {
     Y3 s\" o# G, b. j6 p
3.   for (int i = 0; i < Food_num; i++)
   6 A  T9 W/ ?- }8 k9 B: m# U# d
4.   {6 s) o& o* y% k$ A( A1 R8 f7 Y* h
   
5.     //玩家吃食物
   - \4 }& @( W$ `$ R
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   * q, H  e9 K) ~* `+ J/ Y
7.     {
   4 l4 x# [8 U$ c4 ]. l3 L5 {5 I: M
8.       player.r += Food[i].r / 100;
   , M: L) M8 j6 K, r# X
9.       Food[i].x = rand() % Wide_map;
   % k$ M8 o% [; U8 R$ g
10.       Food[i].y = rand() % Hight_map;
    . ^; r. p7 u& h  C/ W
11.       Food[i].r = rand() % 5 + 1;' y5 T2 w7 i- L; P0 I! r; R0 S
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);. ~; j+ D$ q. ?. k* ~
    
13.     }
    5 _$ z- o- E5 V% g+ V
14.     : k* d5 s% _* o/ T
    
15.   }/ ]: s4 o- L2 R# z, {- c
    
16.   for (int j = 0; j < Enemy_num; j++)8 v% Q5 t/ L+ V% X
    
17.   {; I  W0 y! M+ p
    
18.     //敌人吃食物
    1 ], {( U\" d; w5 F
19.     for (int i = 0; i < Food_num; i++)
    0 |& N5 K' i* Q6 p7 Z
20.     {
    4 E; [, t3 @6 L' d, J8 U: `
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)/ i+ G4 C. \& H! i' z
    
22.       {
    1 k, ~+ U4 V2 h\" P0 y5 c  {; H
23.         Enemy[j].r += Food[i].r / 50;
    / M0 D* {& T! W% F
24.         Food[i].x = rand() % Wide_map;* O# C& O7 J* l; ~/ Z
    
25.         Food[i].y = rand() % Hight_map;9 P: W4 U6 {& U, }9 Y/ R2 Q, @2 t8 B
    
26.         Food[i].r = rand() % 5 + 1;  _& h, l% _! X
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);9 y5 |1 v+ a7 e& T
    
28.       }* ?4 O7 Q1 g9 C. {4 ]1 S  F4 t
    
29.     }! R/ ~  d6 @# ]
    
30.     //敌人吃敌人
    ! H: n& O% M+ t0 V1 S5 p9 n5 n
31.     for (int i = 0; i < Enemy_num; i++)2 J  G+ P( A$ N) \; y; A: g  t
    
32.     {
    3 Z/ b, n* H, r8 v$ I. p* C& M, q* 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)
    / Z\" e/ x/ i, F  v. ?! T
34.       {8 \& B: j  g0 M/ I! S) U
    
35.         Enemy[j].r += Enemy[i].r / 10;
    : r+ u) H- o: n4 Z& t1 Q# ]
36.         Enemy[i].x = rand() % Wide_map;- @0 G1 }9 i# P. Y
    
37.         Enemy[i].y = rand() % Hight_map;
    8 d  H  o) B/ H4 V) ^6 d3 k; }1 g
38.         Enemy[i].r = 10;
    ( O$ O' m, E$ ~( D5 y
39.           Enemy[i].color = RGB(0, 255, 0);
    5 G# ^\" A3 _9 U7 @: Q+ d& T\" N
40.       }( ^6 Q$ _' D+ y* Z3 g- L% z
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)* w# f5 B8 x! F: g! S0 I( `
    
42.       {  a7 H7 S, o, n; j, t/ m, i' {
    
43.         Enemy[i].r += Enemy[j].r / 10;
    4 s; C9 i* N\" h/ A
44.         Enemy[j].x = rand() % Wide_map;0 U8 w! _2 F6 s9 V- U* W
    
45.         Enemy[j].y = rand() % Hight_map;
    + r9 J7 W9 _! o
46.         Enemy[j].r = 10;8 _! r* R. D2 `. B9 A: L: ~  F
    
47.         Enemy[j].color = RGB(0, 255, 0);
    6 `# e- i0 M. }
48.       }
    ) E5 Q9 E9 S! }) N' W
49.     }1 a3 M, ^\" h- _% T2 C5 ]4 j
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)& J4 C) h, i; w0 Y$ l) @( G
    
51.     {$ C) N: i$ V' e. O) P4 P
    
52.       //玩家吃敌人
    ' U$ E0 j8 U+ p! I; a- @\" V
53.       if (player.r > Enemy[j].r)
    ( w9 N4 ^  z/ o/ v: M& W. h
54.       {0 w# _' ~' L$ k! o
    
55.         player.r += Enemy[j].r / 10;
    ' |; h7 D# O, V* E. A6 n
56.         Enemy[j].x = rand() % Wide_map;
      l. F7 V9 f3 B
57.         Enemy[j].y = rand() % Hight_map;
    ' O+ I\" s! x+ p) j0 Y' T! P+ ^
58.         Enemy[j].r = 10;. K3 A( X' K1 ^8 H# F/ x% w
    
59.         Enemy[j].color = RGB(0, 255, 0);
    9 O9 t& @\" Q; E; u$ e
60.       }
    & o$ ^5 ]4 ^8 Y/ R
61.       //敌人吃玩家
    / N% S; W3 x' _1 {
62.       else# w! J/ q, [$ }$ J7 j: @
    
63.       {2 k: g$ w8 w/ S
    
64.         if (invincibility == 0)
    8 @# \0 @* Q6 u  n
65.         {: q4 E. m$ I9 B
    
66.           Enemy[j].r += player.r / 10;
    7 q/ a/ M3 q0 [1 {$ R6 C
67.           player.x = Wide / 2;
    / @, a0 f' q( _: G: s, `0 M
68.           player.y = Hight / 2;
      b' P9 A: I7 A! G3 _& x# u, q& l  k( O
69.           player.r = 10;  F, ?* P; o! y0 i) u4 b
    
70.           invincibility = 10;
    % k. x; f+ q6 l1 t4 U# O# F% O
71.         }7 q\" ?, t( S- |8 `
    
72.       }
    * |5 R% c& s+ _. r) U
73.     }% i! F: S( f9 Y  [( I5 }
    
74.   }
    . o$ z+ ]  `1 `: i7 ]4 f' g
75. }

复制代码

完整代码见附件：
$ O) n0 ]* R/ Z7 g& ^$ o  m
$ s; _, l7 W" m1 j
& M  ^) B7 `% D; P# {4 M+ [
; I5 a) L* v8 k( f$ }6 ]3 m