球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
* w4 {" [# |5 X3 a! @  @
# e% [1 [3 i! K$ ^$ T- R# o: j在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
& A+ X. V0 H8 Q1 ^4 Y. f  Q
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

5 r& s; X! S: b2 Q9 T其他小球：其他小球又分为食物小球，和ai控制的小球

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

玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

, H9 U/ w+ X, y5 fai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

% s! z( {- J7 _) w7 s接下来，我们将通过以下几个步骤来实现这个游戏：
0 j2 g' i$ I7 S& s6 G; ^
初始化游戏界面和小球的信息。

% F, `1 q+ N8 `2 k5 _处理键盘输入，实现玩家小球的移动和加速。
, u  n- d% x" Y  l
: b0 `. M/ M* z生成足够数量的食物小球。
* a7 Y( h0 N0 S3 _$ A
) y% O' D. T, P, |) Y+ c生成ai小球，并控制其移动。

- v# I6 E; w) K% g6 R% }4 X检测小球之间的吞噬关系，增加相应的体积。
: a% T1 N/ r) b3 d7 ^5 Q
6 d1 H8 h9 d/ r* F通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
; q+ \7 b/ X/ B
7 b0 j4 ~3 `& I. Y; F1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
! K. _* R' p( U. o3 R) x
struct Ball
, j# V% l" t% |% _) [; E. ?{
        int x;
        int y;
# {/ v+ p0 v8 H5 }* ?' M) x% b7 v& D        float r;
        DWORD color;
# j( w- C* J. f2 i};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
& t$ b1 H  e9 ^) I3 n
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
/ h! u+ R% A$ j+ A) s
; b, v0 |+ k2 c2 f% K3 E. w橙色可以通过RGB值（255, 128, 0）来表示。
8 ^: ]6 y" }5 {黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
. P% S  x% ~% \8 N  Y" V. M白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()/ |9 m4 z5 W4 P* g4 w
   
2. {5 O# s\" H0 G/ ^4 O, M
   
3.     //玩家小球9 g% d& Z, T4 ]
   
4.   srand((unsigned)time(NULL));
   ' N# [! X, L4 J\" Z2 h! Z$ g
5.   player.x = Wide / 2;
     A3 ^5 b% v* ^, ]
6.   player.y = Hight / 2;
   2 m, N- ?1 D9 ?3 ]6 \
7.   player.r = 10;4 S/ [8 c6 E$ `$ l( i
   
8.     //食物小球
   # c; a; d3 H% X- ]& }\" C7 s
9.   for (int i = 0; i < Food_num; i++)
   ; V1 G0 A( [2 w; B
10.   {) Z8 O$ V4 u! [7 h) U' N
    
11.     Food[i].x = rand() % Wide_map;
    6 E5 V, r4 K9 ~& W/ j- A  g( Y( s/ r7 ?
12.     Food[i].y = rand() % Hight_map;
    & `6 T' j- I\" J+ C! y/ v
13.     Food[i].r = rand() % 5 + 1;
    6 w' p0 E8 ~! L, ]5 `\" w
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);5 I\" u) V; U4 G! N3 t( p9 K* v
    
15.   }
    0 R& U. o* X9 z$ Q! i) C% f
16.     //ai小球- K' a\" }7 O1 h# p6 [0 z! |
    
17.   for (int i = 0; i < Enemy_num; i++)& |1 Z4 u/ C0 J; d5 O$ Z8 Z0 ?; y
    
18.   {4 u! E- G. t# S- S1 X
    
19.     Enemy[i].x = rand() % Wide_map;
    4 [1 K. b/ o$ s7 Q$ Q
20.     Enemy[i].y = rand() % Hight_map;\" [0 O( U0 F5 a6 S& Z# p
    
21.     Enemy[i].r = 10;
    + v3 Q0 o+ i; S) i
22.     Enemy[i].color = RGB(0,255,0);' c& i9 ^: h2 C
    
23.   }
    - t% R/ O2 A; }5 [3 J' i
24. 
    . k. ?0 h* p! \2 A3 \+ }. L
25. }

复制代码

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

1. void Player_move()5 D8 Y) w5 p2 _! I% q6 I
   
2. {
   , u7 c% I; S2 u2 P$ T$ G! m
3.   if (GetAsyncKeyState(VK_UP))
   \" \; k8 e& z- v: y
4.   {- L; Z0 R5 A. K: U( L
   
5.     if (player.y > 0)
   / i1 P0 w: y! S, r6 i, @8 Q
6.     {/ _4 K5 U' v\" F/ q
   
7.       player.y -= player_sleep;; W2 X3 m. D' u& a7 g' X3 C
   
8.     }
   ' A3 w\" A0 C% d& Q\" k
9.   }$ o3 j' Q, P+ _' g. }3 O) d
   
10.   if (GetAsyncKeyState(VK_DOWN))
    3 Q2 D! C! ^0 H' o) j3 n
11.   {: X# k( g& l* i0 r* a' K
    
12.     if (player.y < Hight_map)
    % Q3 e+ E6 c/ F\" C, _( R' H
13.     player.y += player_sleep;2 R5 c+ d1 m\" s) D3 }; x' y& ?
    
14.   }7 H( J! d& i) F. I
    
15.   if (GetAsyncKeyState(VK_LEFT))( d1 Q- i5 \/ t5 H( M1 a5 K
    
16.   {
    ; U/ D9 T2 l$ ?& n3 I
17.     if (player.x > 0)
    ' ~# V) ~2 _; t) s; w+ c
18.     player.x -= player_sleep;  Z& A& P7 t: _2 o( @\" S; I
    
19.   }5 B* M. x6 A, v; m\" ]& v: J3 X8 h
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    % m1 h4 e7 [# ?2 A
21.   {
    9 V' u9 b$ S1 M; [9 ~
22.     if (player.x < Wide_map)! G% n) l9 b1 ?( \4 A
    
23.     player.x += player_sleep;
    4 b$ L/ B# R2 C1 o, y8 k
24.   }
    / ]/ t- i: L7 w2 N1 F3 d
25.   if (GetAsyncKeyState(0x20))
    , V& t# Y7 j: G3 |
26.   {5 X% i( U8 X. O
    
27.     player_sleep = l + 5;! A' U9 W6 ^4 m. S# ^* o
    
28.   }1 d8 ], L1 T* m, ]% V3 K/ M
    
29.   else\" F: `% ~\" [% S1 v: @5 L1 J) }
    
30.   {\" _: y( T$ c7 @7 `) `  O9 L* {5 u
    
31.     player_sleep = l;6 x% n9 I; \  E* ]. l$ b\" V
    
32.   }4 k% r# c' W\" t
    
33. }

复制代码

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

1. void Show()$ \( a1 B  ^1 ^* ~0 x& C7 s
   
2. {
   ' M6 M& G% W1 h$ m! k\" ~
3.   
   5 M& H7 }4 x* Q# O
4.   //设置地图\" e( j2 c7 |1 A
   
5.   SetWorkingImage(&map);9 r0 k/ K& h. S( k) r
   
6.   //清屏
   & l; U% f7 X6 k' m( M
7.   cleardevice();
   $ ?, m- r, C\" x
8.   //背景颜色
   ' D' _* L2 n: |1 p2 H
9.   setbkcolor(WHITE);* E9 K3 K$ c/ {% d  c
   
10.   //划线颜色% Z7 L9 _3 L. i' z% H
    
11.   setlinecolor(RGB(230,231,239));
    ( b% q/ J/ q' W% Q
12.   //划线
    ( F  Q# }- B8 z  a: {& g; M0 m
13.   for (int i = 0; i < Wide_map; i += 10)$ S- w$ M4 [* u, N, G( }2 s! O
    
14.   {& D$ J3 E3 z3 \5 G! ]
    
15.     line(i, 0, i, Hight_map);
    4 a4 p5 t$ u5 [* z
16.   }) s& d( G% b2 ?
    
17.   for (int i = 0; i < Hight_map; i += 10)
    ! u) m& F2 ?# k% ]; z% Z0 b
18.   {
    \" C# b3 Z$ ?' `
19.     line(0, i, Wide_map, i);
    0 \' D* }% S  f. M& ~
20.   }0 ]: }% W* p# N1 y9 {\" v2 @
    
21.   //食物
    . m. a9 p/ \/ Q* `% j
22.   for (int i = 0; i < Food_num; i++)6 Z* t4 A8 Q) c. I5 H
    
23.   {9 S\" s: s1 y! z
    
24.     setfillcolor(Food[i].color);
    ) q- @4 q' Z& [1 f
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    \" ^: a- q; x( W% f, O
26.   }
    / ?* ~3 P+ U) z3 w\" K\" A% X
27.   //敌人; N/ ]  |. V7 A: J: N
    
28.   for (int i = 0; i < Enemy_num; i++)0 ]\" h. S) H  M$ c* Y, Q
    
29.   {
    / Y4 L  j3 O# @8 i. Z- D
30.     setfillcolor(Enemy[i].color);  [: }+ _7 o. A- q* G
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    2 D/ K2 h. `$ M/ N
32.   }: L. v( _& L$ A4 w8 b+ ?) O
    
33.   //玩家, x( [* H7 M( U' c- W
    
34.   setfillcolor(RED);9 V; v& g' m  A6 N3 g) L! Q
    
35.   solidcircle(player.x, player.y, player.r);
    $ N3 L$ H' n+ \( v4 R% S5 z
36.   SetWorkingImage();% y2 ^( ?& c& c* W; Q  K6 _4 I
    
37. . `, E9 W0 F- `0 N/ m. S- \8 ]
    
38.   int x = player.x - (Wide / 2);9 M. |% ]8 X4 ^2 U. I* W
    
39.   int y = player.y - (Hight / 2);2 y9 q  n( z+ H) H  b6 s! v, ^
    
40.   //防止窗口越界5 B/ o& \3 O0 }0 _
    
41.   if (x < 0)
    - p3 S' N6 ]* L# z
42.   {
    ! I. D; b! I\" Z7 _# H! H
43.     x = 0;0 g8 M( F- X8 Q. ]) T% @( Q
    
44.   }
    $ H8 `- i8 ?+ L* s7 ~2 W
45.   if (y < 0)& l; u; m9 K; v1 v
    
46.   {& a1 G5 _; E# h5 b' r% [
    
47.     y = 0;
    ' ?5 g\" O7 u% N$ f) b
48.   }
    / X/ Z; c6 W5 @+ m
49.   if (x > Wide_map - Wide)
    1 k6 _0 H+ }' d\" h' K2 k
50.   {/ J0 }\" y; v( c. Y
    
51.     x = Wide_map - Wide;
    % d. Q4 G8 r7 Z2 b- m' y
52.   }
    2 j- Z9 N7 |' h/ }5 i
53.   if (y > Hight_map - Hight); }/ C0 e; O  |& H: _- o! U
    
54.   {
    % R& @( o. F  y0 e1 h. z
55.     y = Hight_map - Hight;  o7 L3 j9 _) B! E7 K
    
56.   }! C9 S. a, g) Y\" o( ~0 G/ |. P
    
57.   //把map输出到窗口上\" ?4 F9 Q9 V8 q( e$ j
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    5 w( h1 v0 W4 ]5 T  j) t5 I
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. //防止窗口越界\" w- u; Z* ]5 \  x% r; F6 ?
   
2. if (x < 0)
   9 ]3 v* f. |( \: i! w7 u
3. {
   0 p+ O/ c9 t6 b3 R; G3 k
4.   x = 0;
   # \( {  Q1 P8 [! ?: U
5. }
   ) {1 I: V+ d: i; f
6. if (y < 0)$ l. Y' p) U  u
   
7. {
   1 w6 F! n, S* a6 T& A7 m* t' r+ p8 V, b& c
8.   y = 0;* d' o# S8 |9 s% q/ n\" O* ~\" n
   
9. }1 p4 y  m, v3 R+ E\" Y* D& a
   
10. if (x > Wide_map - Wide)3 g! J: ^! C, g+ a
    
11. {
    0 o( ~. @8 p0 b. J: B
12.   x = Wide_map - Wide;0 O& b; n- v0 A- ^6 ~' W# N\" {7 g
    
13. }
    + o4 V8 m, `1 ]# x& c2 x
14. if (y > Hight_map - Hight)
    & M$ {- L. d3 y  `* q4 P2 [
15. {4 y  J' l0 G! a\" F
    
16.   y = Hight_map - Hight;
    ) w: G- t4 g; y
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
$ u: S1 X7 j9 X1 r* I+ }1 T
: ?! U+ h; ^) ~. P$ M(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
1 v2 r4 k- z5 [/ ^3 U
Wide：这个参数指定了要绘制的图像的宽度。
4 T- k# k" T3 @# n  s
Hight：这个参数指定了要绘制的图像的高度。
1 I# n5 L# r3 d+ n% e
) L/ ~* B7 ^: f; ?&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

( I1 Y; G. K6 h$ jx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

7 t9 O7 Y1 h$ X1 ?& S5 [y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6 d1 T$ p, P" e, {6. ai小球的移动
5 {0 A! m( E6 Q随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离4 w( n) \& M4 p0 Z6 B% ~1 @
   
2. int Distance(int x, int y, int x1, int y1), R8 M1 X0 w& S6 L. b* L  R
   
3. {% L\" ?, x. Y5 k0 A8 ]
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   * E9 n# K- {6 H0 m! D1 \
5. }

复制代码

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

1. void Enemy_move()
   % a, j) @% ]( C
2. {
   % {( b! P1 a* u7 G# G1 r
3.   srand((unsigned)time(NULL));
   - u. h2 a/ R2 T* a* m
4.   for (int i = 0; i < Enemy_num; i++)
   1 n) s0 O5 w6 |3 o! S
5.   {& G- C* H( n' _* R2 o+ `
   
6.     int direction = rand() % 4;
   ( {& P1 e5 Q  a5 R9 ~\" Z1 X
7. 
   \" e* j. D) w# _4 T' o9 M
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)$ z& x$ ^8 r) J, N5 Z: s6 t
   
9.     {, ]8 X  {1 f0 C2 v/ g/ S4 b
   
10.       if (direction == 0)- ^7 d0 h% Q( t% K
    
11.       {  V4 y. l& o9 @5 v$ L  X
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    $ Q% S1 n; t+ ^3 w: t
13.         {
    2 ~4 t! g* F6 ^3 ?* h- i
14.           Enemy[i].y -= enemy_sleep;
    9 m* s' M# L\" a( X
15.         }: u) q4 j9 I- R/ [' b
    
16.       }/ u. T- k5 H8 T5 x% J7 u- z
    
17.       if (direction == 1)
    2 D9 M& @\" f  e$ X9 |$ Q
18.       {
    * n5 {+ s5 f; F4 x( O# _1 e9 F) \\" Y& b
19.         if (Enemy[i].y < Hight_map). R* D% u4 P- X- e4 g
    
20.           Enemy[i].y += enemy_sleep;
    & Z# ]# T/ g$ A8 I
21.       }
    . k' i2 ^/ {7 A' P9 E# b
22.       if (direction == 2)
    + G; S. f0 {# B6 L0 D
23.       {
    % \- T# }' {2 |1 ]\" N9 g
24.         if (Enemy[i].x > 0)
    ; F9 f0 u# U8 a
25.           Enemy[i].x -= enemy_sleep;
    3 F) X( U6 j5 |8 H5 }' t
26.       }
    & ^. D; Y: p8 l# Z! I! w
27.       if (direction == 3)
    8 _7 z5 T. {! J2 F4 y* |6 r+ v
28.       {- R( r4 r& y7 z; O: k1 f7 d
    
29.         if (Enemy[i].x < Wide_map)  @* h- H, x2 m& }+ G' k9 S, t
    
30.           Enemy[i].x += enemy_sleep;
    : e% O6 z( }5 t# G2 t. l, t8 E
31.       }
    2 U# Z0 Q\" ?- D  f% \& f, |) x5 w' n/ g5 [
32.     }
    / k( q' V& x# _; ?1 o8 }, c
33.     //敌人追击玩家
    * u3 b5 n- r: i. B: R
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)% m1 k\" L: O( A0 s+ c/ f% u' v# I
    
35.     {
    , o! N4 ~\" V, E, V' N
36.       if (Enemy[i].r > player.r)
    ) J\" H6 g- F: y$ w# K9 \
37.       {
    3 J5 L; P' ?% D3 C* P5 u: G
38.         if (Enemy[i].x < player.x)
    ! q4 c- H5 A% n. y0 w
39.         {; I/ _4 m& ^\" E) l+ b
    
40.           if (Enemy[i].x < Wide_map)) J+ N$ C* M: Q% j+ @: Z7 ~# P0 N1 \
    
41.           {
    ( R3 {8 ?; ]+ L- q$ z
42.             Enemy[i].x += enemy_sleep;
    / f5 O$ Z% ~6 M& E5 D) ?+ n$ r\" g
43.           }6 M5 T% [2 `( q& P3 k& ]6 a
    
44.         }
    5 D  X) _. {$ N3 j
45.         if (Enemy[i].x > player.x)
    % K: J+ Y5 m\" F' i5 D! C
46.         {
    % B! K4 s: U/ R( a4 O: W
47.           if (Enemy[i].x > 0)% b( t9 o; a# l: j# I2 n6 Y
    
48.           {
    # c$ P& R0 G  v8 M5 C
49.             Enemy[i].x -= enemy_sleep;
    . s  y1 `+ u. j# B5 e; i: y
50.           }\" ^+ F! v- ?4 G\" L
    
51.         }% L2 [- Z! o  P9 u% ?
    
52.         if (Enemy[i].y < player.y)
    # |( T$ ?5 z8 @( i3 O5 u5 F
53.         {
    - w* M) @4 \. X\" A3 Z( Q
54.           if (Enemy[i].y < Hight_map)
    * ~# x8 W3 z- W# _
55.           {7 @$ G& t* |1 Y; O/ @  s
    
56.             Enemy[i].y += enemy_sleep;
    $ a1 A0 h  l' q( W9 i
57.           }
    / c! C\" u& m# i/ q2 U9 f( F
58.         }
    $ v0 _6 t0 J/ r- s
59.         if (Enemy[i].y > player.y)4 i/ S' @: |. w4 L, j- o
    
60.         {
    5 W5 s$ ^5 o  t+ \8 y9 ?1 E7 Y* a
61.           if (Enemy[i].y > 0)
    0 C9 ^- ]/ o. U: A, Y
62.           {: ~# s8 ?/ q7 A
    
63.             Enemy[i].y -= enemy_sleep;
    6 E6 A/ M. B. a8 R( V- G
64.           }. u$ C+ E, ~& M5 u! o
    
65.         }
    ; O8 i* O7 S4 L9 w4 e  g
66.       }
    , {$ u8 F* b7 O! I- y
67.       //敌人逃跑
    , T$ j- u9 \) g+ K
68.       else
    # F, p* w! a4 ~0 |5 n. Q( @! _
69.       {
    , c1 j5 b0 x0 I1 ?\" {5 h6 j
70.         if (Enemy[i].x < player.x)7 K/ g. I: Q* S: O; W4 A
    
71.         {9 v/ o, Z( ~+ Z& P* t. o
    
72.           if (Enemy[i].x > 0)
    2 w: x. y' y\" o) y
73.           {
    ! F; i4 l* ~6 e! O+ p
74.             Enemy[i].x -= enemy_sleep;
    5 `  d) h7 i6 a
75.           }
    ' G\" g4 ~% e\" |$ [2 |. ?7 f\" E! B6 h
76.         }- D( `( v6 X- C4 w7 f/ w- ^2 j
    
77.         if (Enemy[i].x > player.x)
    # l7 |/ v6 I. Z; P# L$ J# Z
78.         {
    / f/ [- G* {( [* W4 i
79.           if (Enemy[i].x < Wide_map)& b$ m: o* [( R( X- d& @% S
    
80.           {
    ) B( O+ ~2 G; \3 W6 j& Q
81.             Enemy[i].x += enemy_sleep;2 u/ N+ v* ?% E- d0 U$ m: D
    
82.           }
    \" z$ @* t) b: w+ R' e3 f
83.         }
    3 D! Q/ g- q\" D! j; _% n# M4 |
84.         if (Enemy[i].y < player.y)
    ) g4 V1 b\" T9 k. M; }! @& e
85.         {
    * \+ y/ x0 o( z4 a5 e
86.           if (Enemy[i].y > 0)) A( ~5 q7 N! d% b/ ?
    
87.           {
    0 C4 V\" J* B2 C  t3 u, s
88.             Enemy[i].y -= enemy_sleep;
      Z4 W/ t* M: Z$ _
89.           }2 i5 t! O$ i% R1 Z4 H\" H
    
90.         }
    % j% b3 t! v3 E5 @\" n4 u0 S
91.         if (Enemy[i].y > player.y)5 P. E\" M\" x7 Z+ m5 v
    
92.         {
    6 A\" {, p' A4 ]) h
93.           if (Enemy[i].y < Hight_map)+ f2 K( S/ h9 r: R- Z0 S
    
94.           {
    2 h+ H* N0 N6 ^% a, e) Y\" a6 R
95.             Enemy[i].y += enemy_sleep;+ ^4 w0 e! G7 q5 R
    
96.           }( u2 U% f0 k/ R2 ^. P. D
    
97.         }3 v0 j9 j% f5 ?
    
98.       }( s! N, R* M* J$ P: s8 x
    
99.     }* I: n' ~( s; D/ l
    
100.   }
     * f: p+ t7 @% t
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()# f2 H. V* ~9 _+ ]
   
2. {
   9 E  Z9 R! S\" V7 I  @6 K$ u1 ?; W  v
3.   for (int i = 0; i < Food_num; i++)
   ' j- P; E1 o6 I
4.   {
   - I7 X( {: G- d3 x/ x7 b' Y$ G2 e
5.     //玩家吃食物# X, P3 n$ S$ z
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)) H- E: E* e7 G\" c5 p& J
   
7.     {
   : G* e7 F4 z0 D% T8 W5 Y
8.       player.r += Food[i].r / 100;
   - m' X) N' w2 M' b9 U7 Z
9.       Food[i].x = rand() % Wide_map;$ }( }! w/ V+ u, q
   
10.       Food[i].y = rand() % Hight_map;\" F* C; I% g. e
    
11.       Food[i].r = rand() % 5 + 1;' d, l; |$ f& Y. n1 j
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);! c, L; g) s$ N7 u/ D4 t$ Z
    
13.     }
    \" \% M% T# ^- ?
14.     8 r, b7 {8 o4 r% @2 E
    
15.   }4 a! }( h0 D) x( c  Q
    
16.   for (int j = 0; j < Enemy_num; j++)9 j' S! z3 z7 }( S+ [6 b3 ^
    
17.   {; w4 c3 u. N* d
    
18.     //敌人吃食物% E. u; A: q9 s3 f
    
19.     for (int i = 0; i < Food_num; i++)9 Y9 ]# \2 K- M* h6 I
    
20.     {
    , u4 W\" y& Z+ `# i- U
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)* }' W% q6 L& U! C4 D
    
22.       {
    7 @1 k: p  h; R
23.         Enemy[j].r += Food[i].r / 50;
    2 J7 Z; m; g9 l
24.         Food[i].x = rand() % Wide_map;
    5 C; l8 h( U3 @1 _! q
25.         Food[i].y = rand() % Hight_map;
    ' w* Q+ y6 P6 F4 Z1 g
26.         Food[i].r = rand() % 5 + 1;3 [; H+ S- H* C4 M% h* T+ {: D
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    . j* U7 ?9 \! k$ z3 ?5 c
28.       }) A: \/ I5 _: s5 c3 m5 x\" x
    
29.     }/ m, k1 l( V\" r* Y- Y5 P5 v
    
30.     //敌人吃敌人
    1 R9 e: g9 W3 ?: W$ m, M% m0 o
31.     for (int i = 0; i < Enemy_num; i++)
    . y\" S% R. I2 l: K7 Q
32.     {
    * W3 [( \6 @5 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)
    ' ^3 j3 u0 w+ b7 O
34.       {
    & b$ D1 c1 b/ E\" h! L
35.         Enemy[j].r += Enemy[i].r / 10;
    0 Y+ Q, |0 F6 b% a  \\" J! p& z( ^
36.         Enemy[i].x = rand() % Wide_map;
    9 M6 S3 Y# x) V2 F\" ?$ \% o$ d  d# P1 G
37.         Enemy[i].y = rand() % Hight_map;* U- v5 Y4 H5 h
    
38.         Enemy[i].r = 10;5 T, H. z9 S3 Z/ p( w/ c- R
    
39.           Enemy[i].color = RGB(0, 255, 0);
    2 d6 e5 y( i# d+ }
40.       }4 u0 k& _# R! t! I\" 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)8 b4 }; g( r\" R- Z2 N( T8 ?  V
    
42.       {& p- ^) H( T/ W* T; P! \5 G8 Y( U. j
    
43.         Enemy[i].r += Enemy[j].r / 10;
    # r' P\" W2 }& y1 |
44.         Enemy[j].x = rand() % Wide_map;: B) ]1 ?7 i4 s. {
    
45.         Enemy[j].y = rand() % Hight_map;% k$ a- A8 X$ S! X* [3 B3 G
    
46.         Enemy[j].r = 10;
    ! v  U! ]  g) R3 [6 o3 w- X' k
47.         Enemy[j].color = RGB(0, 255, 0);
    % ^$ d1 J9 m0 f3 L4 }, {; e
48.       }
    2 I+ R; J' e7 K9 {
49.     }5 q* w! a$ f' s/ A  u* F
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    \" g4 f\" I. y6 l/ V
51.     {  o: ?+ T+ m) I3 v  j; `4 k, h  s$ G
    
52.       //玩家吃敌人
    ( R( n# Y0 }+ Q
53.       if (player.r > Enemy[j].r)
    / X8 M9 z( f. B. `0 v
54.       {5 O% `  x, Y# s# I
    
55.         player.r += Enemy[j].r / 10;
    2 a% Y) w3 Y' I& X
56.         Enemy[j].x = rand() % Wide_map;
    4 P8 _8 h6 i& P! F- f/ q
57.         Enemy[j].y = rand() % Hight_map;3 q* I- q8 p) y
    
58.         Enemy[j].r = 10;
    ) ^! E3 b8 O9 W  B
59.         Enemy[j].color = RGB(0, 255, 0);
    + ]4 p3 l* F* m/ D! h
60.       }1 m  [  R7 u5 B: D- o3 ?
    
61.       //敌人吃玩家  ~; a* l& x+ S+ G8 v! m/ f; }
    
62.       else7 F0 @; f; V, }) o- c$ i
    
63.       {
    \" `3 E- p) w6 S\" {) r6 i9 g4 M$ H
64.         if (invincibility == 0)
    - @& _/ u2 B0 V3 I4 ]
65.         {
    $ s) n7 h- Y( U
66.           Enemy[j].r += player.r / 10;# U* g* V8 p6 ?\" a' w5 I
    
67.           player.x = Wide / 2;
    $ r; s) r& w9 n
68.           player.y = Hight / 2;
    3 I/ d, T# d* g  h
69.           player.r = 10;5 H+ X. i7 u4 m
    
70.           invincibility = 10;
    0 `# F' _2 r4 }! {8 Q) |
71.         }
    ; D9 T$ {( l) Z' Q
72.       }% ]- n. b. f3 P+ {4 V, g
    
73.     }% Q% B# r3 V- c* n; K
    
74.   }
    , m2 R6 O2 @2 V: ~  p; u- z
75. }

复制代码

完整代码见附件：


" [  c" \5 z# y8 Q/ ]