球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
* G0 q! ~6 n- O3 ?! x
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
+ g' I( a% B2 n/ `
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
& ]# d8 s/ |. w' e5 ]; C0 T* T6 c
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
7 H' M3 i- i1 s: k
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
9 K8 V0 k& S0 B# f' Y
玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
- |* T/ x" n" y) `
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
3 d2 f8 j3 `1 L
# g4 r: R; Q2 J+ o& X接下来，我们将通过以下几个步骤来实现这个游戏：
5 \! g2 U; u5 u8 k+ ?( I4 N, l' z
初始化游戏界面和小球的信息。

7 ^: y- I8 |5 D: _处理键盘输入，实现玩家小球的移动和加速。

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

, k! O. Z" X0 Z: F& M生成ai小球，并控制其移动。
3 x) S5 ?8 H  ?' G
检测小球之间的吞噬关系，增加相应的体积。
& |  R: C7 v( |" i
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

0 u: b, O2 A- v; ~& {5 B* T1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

& z7 |/ i2 I2 h* R' w4 r: H+ v8 Rstruct Ball
{
/ m% Y3 K! d, s, S; s4 |        int x;
# t# G8 }& f( c6 Y  j$ _        int y;
. F: s2 T: V* n/ m( J1 H" |        float r;
* g; v8 i# |) b/ p# Z) @4 B. z        DWORD color;
};
  P4 S) ?# q6 I  t8 ~: b) @2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
4 |' f$ r6 ~  S7 ?& s  w, n
橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
; k5 {5 o0 B( P/ y9 Z2 m5 W0 T8 j- B蓝色的RGB值为（0, 0, 255）。
/ ~; J" X3 }8 u! h* p6 k紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
# B8 f4 V0 ^4 n% P: E3 A灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   / w: T- _0 n+ z# d
2. {
   # }' |- V7 D; F% f
3.     //玩家小球
   - I# x- t7 _- A# N
4.   srand((unsigned)time(NULL));. i/ u$ t+ w% P$ ^+ `. I  `* e
   
5.   player.x = Wide / 2;' h* r1 q% s) X
   
6.   player.y = Hight / 2;
   , Y! G1 E6 C( _
7.   player.r = 10;0 J# y6 A# S/ O0 @3 w3 j% a' ?\" c
   
8.     //食物小球
   % w. j- d5 l' w: n! r8 X
9.   for (int i = 0; i < Food_num; i++)
   1 ^7 \7 i/ [3 V\" @2 z& a
10.   {* `( x$ u4 x: l# ^
    
11.     Food[i].x = rand() % Wide_map;
    9 H$ O\" U, v; D\" `5 h/ \
12.     Food[i].y = rand() % Hight_map;( z5 @1 c6 M/ i) [. a1 q$ q
    
13.     Food[i].r = rand() % 5 + 1;) p/ c# ], Y! J4 `. I( H
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);5 _7 r( ], C. a
    
15.   }
    \" ~5 _\" H/ q! C
16.     //ai小球
    # D  e3 {$ w) M7 J: @: d
17.   for (int i = 0; i < Enemy_num; i++)
    ( \; G9 c/ R6 _
18.   {, U; n( H: {\" p* X$ K
    
19.     Enemy[i].x = rand() % Wide_map;
    3 O\" W2 r! F4 G; q) N* O; E1 C
20.     Enemy[i].y = rand() % Hight_map;
    & x- r7 W1 ?6 o' {3 t6 Z
21.     Enemy[i].r = 10;4 H& |9 b+ V; I  g/ ?2 Y4 C, i. ?+ |- B
    
22.     Enemy[i].color = RGB(0,255,0);- U1 c0 p6 C\" v6 o% T7 l1 I! q
    
23.   }
    * I\" ~, @: U2 P8 y\" U$ x# l
24. & q$ w$ y( r8 G) M
    
25. }

复制代码

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

1. void Player_move()
   ! R- \5 `, n\" z  g' G( H
2. {9 M: Q- [( M4 D' L% C
   
3.   if (GetAsyncKeyState(VK_UP))
   6 O9 Y# W, A+ G$ g9 z3 w/ e
4.   {
   ; d7 ~9 @9 v$ v5 t  C5 a' |
5.     if (player.y > 0)% _. A/ s# G$ D3 |5 s' u
   
6.     {5 e! x8 B% @& V  ~( {3 O
   
7.       player.y -= player_sleep;
   4 W3 G( p! m- ?2 S
8.     }
   ! T! S7 u7 Y+ T4 T6 U' ?# M
9.   }+ J- O. C6 l8 q4 S4 i; n1 e
   
10.   if (GetAsyncKeyState(VK_DOWN))
    + l* P+ v$ S& w* q- h
11.   {4 s( h+ u' a6 [- Q* @/ J- h- Y5 D0 s6 j
    
12.     if (player.y < Hight_map)
    ( v5 J) s. {/ u* ~. y7 Q
13.     player.y += player_sleep;
    7 J1 Y3 g  x) E2 N
14.   }
    1 P! A: n/ Y3 F$ g* k& ~; V
15.   if (GetAsyncKeyState(VK_LEFT))
    2 U* M; O8 t+ b3 c3 K3 i5 M3 q
16.   {' |+ A- [# ?1 J
    
17.     if (player.x > 0)( |( P9 I5 W5 a! o! a2 X. [
    
18.     player.x -= player_sleep;
    ) o; g+ l! H: }3 z. n2 u
19.   }
    ) N# d- ]. E- {& E% }
20.   if (GetAsyncKeyState(VK_RIGHT))( {( `) _+ W. d6 }
    
21.   {
    7 C: ?% m/ u; n) `+ \$ \& @0 N
22.     if (player.x < Wide_map)
    $ S& k/ R. G0 O: r: H. }
23.     player.x += player_sleep;, {2 Q# r6 b( }4 b# b6 R# X
    
24.   }4 B9 {9 d$ X; Z6 A- @# K) M
    
25.   if (GetAsyncKeyState(0x20))
    8 b  n6 X9 ?8 ]
26.   {
    % D1 _0 ]  k: c6 @
27.     player_sleep = l + 5;
    + [: E' @8 _/ F' V8 ]% H
28.   }1 a/ T3 }& U2 E\" P/ r
    
29.   else
    9 f$ _$ D6 K5 v- G+ ?* E
30.   {
    7 M3 `3 r1 W. E4 g8 j) W
31.     player_sleep = l;- ^* E9 T2 J! T/ i  a/ ?
    
32.   }* O4 w+ |9 e& ?& H
    
33. }

复制代码

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

1. void Show()& S$ S$ O! W1 l5 W; X2 s
   
2. {! d4 u& J; ?: X7 b' j
   
3.   
   ( c1 t6 x9 i: M
4.   //设置地图+ x( r+ Z1 @' l1 B: X2 V: k
   
5.   SetWorkingImage(&map);$ m+ ?+ ^4 a* O& }* g
   
6.   //清屏# X, i; J$ t2 }
   
7.   cleardevice();\" l  ?& i2 F0 m  m3 A# v. T
   
8.   //背景颜色0 F3 ]: U6 U& m5 `
   
9.   setbkcolor(WHITE);
   8 P' }' _' l' V$ t) }' C- S) ^
10.   //划线颜色
    % {/ O. K: p) `# P9 x
11.   setlinecolor(RGB(230,231,239));
    7 m, d3 a0 H, y& I1 P8 q  u- |
12.   //划线2 B. O* J0 e5 D6 k  j$ f
    
13.   for (int i = 0; i < Wide_map; i += 10)$ `1 G/ z5 ]2 s$ G
    
14.   {' l7 ?5 }7 W/ T# d
    
15.     line(i, 0, i, Hight_map);
    . x6 R& r0 b! a1 o\" y& [7 {
16.   }6 K. ?1 `% Q- ~8 T
    
17.   for (int i = 0; i < Hight_map; i += 10)
    ; l: R, J9 h) v! T! \3 b% d
18.   {8 `& |) C' [: f2 A0 j$ V' O. u\" R
    
19.     line(0, i, Wide_map, i);+ Y4 D3 q; P4 s2 ~
    
20.   }
    ' z0 P( T  @  k\" `8 z; z
21.   //食物1 @/ F* {3 m1 O) f, }$ H% M. ~
    
22.   for (int i = 0; i < Food_num; i++)
    7 k( C$ o( E9 F' ]
23.   {8 N& u, p3 Z: g  K0 T
    
24.     setfillcolor(Food[i].color);, Q5 ?- A\" D* K: {/ I; S$ h
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);2 q; H7 u1 l! |
    
26.   }
    - l3 T6 y1 z( x/ j0 p
27.   //敌人
    ' L7 s/ @& z. U3 u( t7 q  p; R
28.   for (int i = 0; i < Enemy_num; i++)
    0 z  X6 X1 d& A: ]
29.   {
    ' t% s% [. @, r% P
30.     setfillcolor(Enemy[i].color);
    & U/ g' V! U: T- K8 W6 i; M9 {8 c8 _3 D/ g
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    $ H8 Q: o0 h+ G! P8 R
32.   }6 o; Q5 p) L2 I- h) R
    
33.   //玩家, y\" L$ `2 w6 f# A
    
34.   setfillcolor(RED);
    & m$ H( m. [$ P' _8 H: h\" z% {- S! @# t
35.   solidcircle(player.x, player.y, player.r);* _6 J* u3 @\" r3 J+ \6 {
    
36.   SetWorkingImage();\" n; ?+ Q/ j7 d5 b7 l- p
    
37. 
    * n; x5 y! q: T# G1 v
38.   int x = player.x - (Wide / 2);
    ' Q  A) k2 J! O
39.   int y = player.y - (Hight / 2);% e; e! |+ W1 r/ B
    
40.   //防止窗口越界
    5 U9 Y3 |2 w; A# Z( t1 g
41.   if (x < 0)
    / T- Z- H. d\" ]2 G
42.   {
    ' `- ?5 d! k* I) E; Z4 ?4 [( Y9 |5 W
43.     x = 0;
    + c2 }2 A5 y7 P3 G
44.   }, m/ B4 b/ f4 [9 P% {
    
45.   if (y < 0)0 x  [1 Z! o# i/ E6 s! E9 b5 Q
    
46.   {% ?$ ?9 }% N! \; T3 d
    
47.     y = 0;8 F  h7 ?$ r# o6 ^: v
    
48.   }
    \" u; `* d9 _( l+ m6 A4 T' Z/ \2 ?
49.   if (x > Wide_map - Wide): N' w  U/ u1 s# {2 [
    
50.   {9 V, R: r! P8 }2 ]5 Z5 g- y  z
    
51.     x = Wide_map - Wide;
    ! d+ I; L8 \6 |1 Q
52.   }
    . \3 {# K, M9 }  y5 y0 E+ O
53.   if (y > Hight_map - Hight)
    2 V6 e# J/ p5 y! I9 J- D
54.   {
    5 C( L# T9 c' n4 P# n
55.     y = Hight_map - Hight;
    * n$ f4 G\" {0 a
56.   }
    : J8 E: _& ^: f9 g7 }' W\" v
57.   //把map输出到窗口上
    ( i- h7 U3 d8 e\" x+ A
58.   putimage(0, 0, Wide, Hight, &map, x, y);
      o0 w# P0 D7 _' L5 n* H' ?# c
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. //防止窗口越界. w9 P. Z' R, @, Q
   
2. if (x < 0)
   ' M2 o. {6 I( G& [( d
3. {
   4 Y, K; o, g7 R2 M% V& W
4.   x = 0;
   7 f$ v# _7 A0 H6 Q- c/ p1 j3 ^6 ^+ p& q
5. }
   % @. L. |% m% s+ `; I; \3 W0 H- F
6. if (y < 0)& L0 @\" [\" u; R, u* u
   
7. {/ s1 Q  @+ I) Q8 s/ [\" \  Q* _
   
8.   y = 0;
     d( I\" v! S' T1 x( n
9. }
   3 M: o7 G: {) [! |$ ?+ P1 j
10. if (x > Wide_map - Wide)6 X1 M% k1 m\" g) F
    
11. {/ `6 j9 J$ E0 z2 j* }/ N$ J/ I1 K, B: L
    
12.   x = Wide_map - Wide;7 Y8 k3 b\" O3 x9 O7 k
    
13. }
      u% \  H% |1 W# y: W\" Q
14. if (y > Hight_map - Hight)+ E% g4 z. A: Q- j: ^& V
    
15. {* j8 b+ H0 o  Z( t$ T/ m& t( A
    
16.   y = Hight_map - Hight;, N, }- h( z( l6 t- _3 U; o
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
6 |, _4 [0 G- D2 x/ E0 S* I4 \' N1 B
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
" ^# t. [  h3 p+ G9 m
+ t* I: J; `# M4 j2 p" p. {# RWide：这个参数指定了要绘制的图像的宽度。
# t/ K2 K  v. L/ N$ |# ]9 I
2 x; ~9 G2 D  a1 o/ D' sHight：这个参数指定了要绘制的图像的高度。

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
' J7 \: X1 [. \6 n8 [  L
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
4 K1 l: r, o* c4 U- Q  |
2 u1 h( x& A) }5 p' `6 W+ V( ]y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
; ~- V7 o9 H8 F; D6. ai小球的移动
3 ]- l6 M  n/ e# j  |随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   5 a! F% K0 ]/ v! }1 o8 G
2. int Distance(int x, int y, int x1, int y1)
   . N8 {+ q1 ^0 m$ t
3. {
   - g; O0 b' l3 {6 }( l  [, r
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));% u& I: B6 Y8 G6 t- i% K
   
5. }

复制代码

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

1. void Enemy_move()
     r8 Z. X# k' t( H$ {0 }: T$ f0 b
2. {  A8 t1 y: f0 W
   
3.   srand((unsigned)time(NULL));
   ( m  ?9 O7 L\" M
4.   for (int i = 0; i < Enemy_num; i++)0 p0 O/ H$ [* [# u* d2 C2 \
   
5.   {( I6 Q# q) K7 J. r. A, v
   
6.     int direction = rand() % 4;
   8 ^\" }* G* Y& L, e2 I
7. 4 b: n5 k* k' E8 r! a0 s- F' |
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)0 H% g& u( s& w
   
9.     {
   % B2 v7 y1 h! M- a
10.       if (direction == 0)& C1 B% M& i+ s% J4 p& B9 l5 y
    
11.       {
    7 x$ y2 B  _; S
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    ) A( A0 i& l; j1 G: V) x
13.         {
    ) C5 H( ?. ~\" Y6 R
14.           Enemy[i].y -= enemy_sleep;$ `7 }\" y- w/ I9 E: U7 V& h
    
15.         }
    3 Z- [3 a/ N, q! _- G
16.       }  F! M) I0 }+ L0 u2 V1 u
    
17.       if (direction == 1)
    ' c' g3 o$ X  A. V2 ^
18.       {\" F/ a7 u3 B6 T) r
    
19.         if (Enemy[i].y < Hight_map)
    7 A\" I/ [! ]( y* W3 ]
20.           Enemy[i].y += enemy_sleep;
    3 r- m# R/ F  m7 @
21.       }
    * R\" K  ^8 M% r* X0 a, o8 P5 U% z
22.       if (direction == 2)$ S\" T3 e4 ^) d9 b/ F; @
    
23.       {; s+ h$ D  d& X* J: I\" u2 j
    
24.         if (Enemy[i].x > 0). g' d\" T6 G# f5 m0 i* c
    
25.           Enemy[i].x -= enemy_sleep;
    * s+ ^- r4 c/ x) P. l5 \
26.       }
    0 e  |+ P- m, R& q$ ^; K
27.       if (direction == 3)
    \" |) H! x$ r+ Y1 {, t9 Z
28.       {! D5 j# W7 F  u! M% P: h8 l* O5 ^
    
29.         if (Enemy[i].x < Wide_map)
    + E0 y7 ]: P% }- Q; a
30.           Enemy[i].x += enemy_sleep;$ ]8 z$ ?/ [1 k
    
31.       }9 o; ~9 X$ e9 k\" s
    
32.     }
    , Q* E1 j% n' P! z, Z* T
33.     //敌人追击玩家% E$ S' K/ F% E( M$ [
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)( u2 d' p# E, R
    
35.     {
    $ S0 C3 \; D' D: o  E+ A1 X' O9 j8 o
36.       if (Enemy[i].r > player.r)
    . a7 T6 E6 }2 H' @  ]* d
37.       {+ }* Z- C' o& @& {5 Z2 f$ s
    
38.         if (Enemy[i].x < player.x)
    8 Z. N5 _* `( }( I$ N
39.         {
    $ i2 I# V! _4 M& w% s( M
40.           if (Enemy[i].x < Wide_map)1 z3 y) n$ x3 u& y7 d! v
    
41.           {
    $ f/ X( b: c9 H8 ~7 }/ Y# P
42.             Enemy[i].x += enemy_sleep;
    & L7 ?7 F; r9 V) P
43.           }. o7 L# N3 W\" T5 n2 h2 u\" [: Q% r
    
44.         }( ^3 P, \6 t  r# b: `\" W7 g
    
45.         if (Enemy[i].x > player.x)5 e9 M\" P1 A) Z; F+ l\" k/ q
    
46.         {% ?9 Q% l1 }3 Q6 {0 d
    
47.           if (Enemy[i].x > 0)
    9 X- W8 \1 c; B# M
48.           {/ \$ p' w1 r' C* u0 R- @4 `
    
49.             Enemy[i].x -= enemy_sleep;! E' d* |# q# M6 R$ y' E5 Z
    
50.           }9 L  f2 a+ u1 j+ {: f# ]+ w' F; d
    
51.         }8 g* O. ~8 ]3 }, |
    
52.         if (Enemy[i].y < player.y)3 ?5 t3 g2 @2 U! N
    
53.         {
    ( c- d; U  E, x8 C( s
54.           if (Enemy[i].y < Hight_map)
    : Q+ c6 Z5 k; m9 F! H. t1 _( {
55.           {
    . R0 m1 B% S2 m\" D  C% F
56.             Enemy[i].y += enemy_sleep;$ |5 r4 Y* U4 V
    
57.           }$ z3 b: |\" e9 D: c3 m- Y# w1 C
    
58.         }
    : e4 L2 J1 \5 d! ]1 f6 C
59.         if (Enemy[i].y > player.y)
    4 a' g' g& h6 y6 B4 r; N
60.         {
    % d8 N4 U8 {( H
61.           if (Enemy[i].y > 0)8 M/ ]7 o4 o. k( M
    
62.           {* k4 h) U( o/ Q# r5 o. }# I2 Z
    
63.             Enemy[i].y -= enemy_sleep;1 L+ D# V$ j) Y9 U* b
    
64.           }8 U: Q% {* ~/ d: o
    
65.         }
    ; o, O, u( S! t7 H
66.       }
    \" g\" e3 ]1 M% l1 `/ d, U# }5 a( r
67.       //敌人逃跑
    $ z1 d0 N( I. R5 @0 `
68.       else' }6 e) z5 I) `# l\" l- a8 S
    
69.       {
    4 S; F! \$ Y\" q# V& J' x
70.         if (Enemy[i].x < player.x)$ p; E, g. o% E6 ?4 C
    
71.         {
    ' G' c; N' w& F) P, y2 R( D* Q8 s1 h
72.           if (Enemy[i].x > 0)3 T3 w1 v% y7 v! w/ z- O
    
73.           {# w) Q% t% H\" j$ \\" c
    
74.             Enemy[i].x -= enemy_sleep;
    8 r/ g$ ]\" Y5 |' ^# e; l- @
75.           }7 S! U8 s0 \: `
    
76.         }
    8 i4 a\" Y$ m& S
77.         if (Enemy[i].x > player.x)- t: X1 C\" L4 ^! n
    
78.         {
    3 k; n2 F1 I6 u; P. h9 o! {, @- s, Q
79.           if (Enemy[i].x < Wide_map). Z: X( O3 W' d0 ]  q
    
80.           {
    + M* ^+ I6 W. I5 ^9 B9 W
81.             Enemy[i].x += enemy_sleep;  P) z5 ^% O4 j/ J; Y  v\" g1 N
    
82.           }
    , k2 z2 t' |/ w: W5 E. y( r) V6 p7 ~
83.         }
    - D  R8 m3 u: C, b% Z
84.         if (Enemy[i].y < player.y)
    / |$ Z6 a' Y* e\" j  j
85.         {
    / W# P( p: Q3 S! {4 r
86.           if (Enemy[i].y > 0)
    ! X  w7 L5 ~8 S! }9 p, m
87.           {/ `. u/ R* e( g$ o' R2 Q7 a
    
88.             Enemy[i].y -= enemy_sleep;
    ; }+ v, J0 t6 K7 q( W
89.           }9 v* O( ^+ X3 Q
    
90.         }; D+ u9 m6 S$ ~) L( j\" i
    
91.         if (Enemy[i].y > player.y)& e) J* {3 w- S! _+ t' S; h
    
92.         {
    & }: `% O& j1 b! B1 h) }: M4 ?6 \
93.           if (Enemy[i].y < Hight_map)
    + k) v  g3 |0 O4 u: w- Q
94.           {5 J\" Z\" o' I' k0 n7 s6 g
    
95.             Enemy[i].y += enemy_sleep;
    , {. u% Q) k5 O( u
96.           }
    ) n% S\" K$ {- a! H$ o% c& K
97.         }
    9 C& `/ m2 a2 D, Q
98.       }' q1 _# G+ g8 D5 Q8 v
    
99.     }
    4 C* g% p; t5 B
100.   }
     $ |. `+ m' r; i7 J
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   3 A% n: L* d7 s3 h( Z) D
2. {1 H1 m. ^4 H$ Y# X# W\" S. `: p. _  l
   
3.   for (int i = 0; i < Food_num; i++)3 z% u$ {. E4 X1 ]+ k) R5 N
   
4.   {! B' Z\" }7 P% R/ G6 P' }
   
5.     //玩家吃食物! a3 A5 X4 m0 \2 L( u# @, |, J
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)0 U. Y8 {  l\" {+ P
   
7.     {
   + H\" U$ O1 {! Y: D9 V
8.       player.r += Food[i].r / 100;3 S\" n* `( A9 z4 i( A0 O/ D3 H
   
9.       Food[i].x = rand() % Wide_map;
   , ~$ I3 ~# j7 O& A4 N1 \& r
10.       Food[i].y = rand() % Hight_map;
    . o/ F% o) \# k8 }
11.       Food[i].r = rand() % 5 + 1;
    * j3 ?, Q; t0 a3 `, J$ ^( v, |
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    $ N8 r& K# N0 [% e
13.     }
    # n! e. R/ [9 \
14.     , x# ]: K: w' q( I7 J
    
15.   }# B$ _# E# s\" N) \. |! S
    
16.   for (int j = 0; j < Enemy_num; j++)3 }& U! |5 v8 U, Q
    
17.   {. l' D) E' E/ b7 k8 p5 K/ w: q
    
18.     //敌人吃食物
    : D& l' d: Q: @$ w9 [& P9 ?
19.     for (int i = 0; i < Food_num; i++)
    ( F' j# F3 Q4 p( R\" f) g7 ^
20.     {
    6 o( Q! @) h2 ^\" k\" y
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    $ N) _; a3 @% [! t7 @( f\" T$ @
22.       {( s; `+ F5 t- M$ I$ G
    
23.         Enemy[j].r += Food[i].r / 50;
    7 l, `! ]6 A* I
24.         Food[i].x = rand() % Wide_map;
    * `' c! c; y- B& C) b0 @\" a& c* Q
25.         Food[i].y = rand() % Hight_map;7 K* j2 |: j5 p% y& A& |; q
    
26.         Food[i].r = rand() % 5 + 1;5 D5 E- W% G2 M0 q; O$ ~3 G
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);* ~5 c  P6 i. @2 O
    
28.       }
    7 Z! h& q1 S7 o: u$ L+ Y% w8 \0 l
29.     }2 m/ O% Y( A( ?: Y* l
    
30.     //敌人吃敌人, c6 }0 X2 W* n+ C
    
31.     for (int i = 0; i < Enemy_num; i++)
    + x; J( o3 c4 H' H8 I, d
32.     {
    - X# p1 `! U1 }; a
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    / [! x0 o; E  a) y2 b
34.       {7 u\" v. p7 x2 }! ]
    
35.         Enemy[j].r += Enemy[i].r / 10;/ \9 Z9 \5 k1 z, E! n
    
36.         Enemy[i].x = rand() % Wide_map;1 A, }  W( P: P- l8 V9 `9 l
    
37.         Enemy[i].y = rand() % Hight_map;0 M8 n2 W% h, \: V
    
38.         Enemy[i].r = 10;7 H1 u, k! q2 a% ]4 [
    
39.           Enemy[i].color = RGB(0, 255, 0);8 j7 {( C8 g\" v/ L
    
40.       }4 [$ k4 G9 f4 Y! z\" x+ a! M
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    : A- `$ |4 t' ~% R8 E; z7 P1 Z/ P
42.       {% @) p0 M9 N1 S8 t) @
    
43.         Enemy[i].r += Enemy[j].r / 10;  }) _: U! O! y3 w( v  S) J
    
44.         Enemy[j].x = rand() % Wide_map;
    % t4 z/ h: M\" L$ ^+ `
45.         Enemy[j].y = rand() % Hight_map;
    \" @( J! C5 ?8 N$ V- M0 z
46.         Enemy[j].r = 10;
    & B' ^2 V/ I. V; W: U( A
47.         Enemy[j].color = RGB(0, 255, 0);
    ; N6 T% i. r\" u
48.       }6 a. ?- w* i8 E/ I8 L# [% v4 G
    
49.     }2 O6 G9 e, f3 f; L
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    % b; Q0 z3 J# Y1 b
51.     {
    1 T1 V0 p7 W: Y
52.       //玩家吃敌人
    6 _\" d& W$ P0 }  L; \/ P
53.       if (player.r > Enemy[j].r)
    , D\" H8 ^* U2 h* b
54.       {
      N  c% C7 h+ U; d* \2 [
55.         player.r += Enemy[j].r / 10;0 [( E' ~$ C\" ^9 P\" v; {' G
    
56.         Enemy[j].x = rand() % Wide_map;$ X- B8 R2 M  B, `5 \1 I$ P9 I! b  W
    
57.         Enemy[j].y = rand() % Hight_map;$ v8 ^\" t' M* a1 H* E
    
58.         Enemy[j].r = 10;
    7 ]- |7 C% C2 {& k9 A! G
59.         Enemy[j].color = RGB(0, 255, 0);
    3 |\" U4 a8 x\" M* X' }/ k
60.       }# A4 S2 a1 V) w$ Q& l
    
61.       //敌人吃玩家
    3 ^  h! `# D$ k3 H/ X. `( W8 a5 M
62.       else: ^, M& _, k2 x4 q  i! k
    
63.       {
    * [* w4 N7 B* [2 Z0 `, Q% @- A
64.         if (invincibility == 0)
    % N1 D  n- \+ f) D! E3 l6 ~# h/ P
65.         {1 S3 @$ j* t1 z8 Z
    
66.           Enemy[j].r += player.r / 10;  J. |8 y, ~; M4 o5 L
    
67.           player.x = Wide / 2;# H( ^; Z) n; t
    
68.           player.y = Hight / 2;' J% I9 F% y3 N! n6 `9 M1 W) o
    
69.           player.r = 10;) W+ H& I+ l1 A) j\" H
    
70.           invincibility = 10;
    % j- I2 k- N  |. g2 H* r
71.         }
    5 g9 A6 a( f/ ^& d. q0 N7 b
72.       }/ I0 p, q1 ?' M6 i
    
73.     }
    + W, {0 }9 S6 [$ W/ ^5 ^
74.   }
    5 u3 b7 Z& m, Z9 [6 Q* B# W2 d
75. }

复制代码

完整代码见附件：
+ Q* _, ^1 U3 G. C3 P

/ e* t0 y* {8 A; a+ h/ M/ s% R: W, E
6 t0 |, m8 W: s1 @. ~