球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
) x! |* g* f/ W
4 f: G8 f; ~; a- V$ P: e: S在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
9 x; e8 Y- E$ x4 x
8 E* s' W! `6 ~5 e9 l! |, o: _# M. g5 D游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
! f9 A3 v+ ~/ i6 `, V9 i. a
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

9 M- l; e! l8 S, q0 N其他小球：其他小球又分为食物小球，和ai控制的小球
6 d- o9 t, u/ b
3 u/ G- [# I( u* ?( r体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
" n+ R2 N6 ~- t8 S
% \4 D" N1 I: ]4 K: R玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
7 r1 i; o* u/ K6 Z* q3 ]
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

! X3 h$ S" k0 Q& k, E% E& Y接下来，我们将通过以下几个步骤来实现这个游戏：
( Y( F, ^' k" y) C# x8 o% L: n3 }# |2 _. [
初始化游戏界面和小球的信息。

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

$ \, `- P6 ?  ~生成足够数量的食物小球。

生成ai小球，并控制其移动。
# D+ [# _' s; O& J1 G  S7 l: s
检测小球之间的吞噬关系，增加相应的体积。
  \% B5 m: h! k& d
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
9 I9 @4 U7 \; B6 g; [
% M# m0 l0 q4 D9 V2 `  R4 Y) Lstruct Ball
* d6 {; v; Z4 a" R# b$ j8 ?{
8 Q* r' Y/ w6 \* X1 O% Q, W; I        int x;
, T- i$ a5 O0 Y. ]        int y;
        float r;
        DWORD color;
};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

7 v+ Q+ a$ X1 ]) F( _) dRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
% _& _% e  q$ u6 }% ]蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
( q! f2 X" N8 @3 D) ^白色的RGB值为（255, 255, 255）。
0 w1 U+ L! Z6 b0 U4 @+ e( j灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   ! ^2 ?6 s1 g% ^
2. {3 t/ z\" ?* {; e9 B; U5 y
   
3.     //玩家小球
   3 _. W8 M( b9 r\" d+ R( \
4.   srand((unsigned)time(NULL));& O4 s- Z; S# f) p5 ^& e
   
5.   player.x = Wide / 2;
   7 r$ ]% g; x6 y  F3 P9 @; D& Q\" u
6.   player.y = Hight / 2;
   - O7 L8 e; F, T, x) Y
7.   player.r = 10;  v\" I1 l6 [* f\" c. V: H+ X\" i
   
8.     //食物小球8 @  Z! J6 K: X) T& y4 e) P$ u
   
9.   for (int i = 0; i < Food_num; i++)7 M8 f. C- E5 `7 {( w+ F6 m' ^* _
   
10.   {
    ' y0 W  M7 x3 W4 q
11.     Food[i].x = rand() % Wide_map;
    . o/ I\" N) ~0 M- v% V* h3 I% \6 P! c. S
12.     Food[i].y = rand() % Hight_map;
    3 C  t9 X/ U' n) C) T
13.     Food[i].r = rand() % 5 + 1;
    9 E2 f\" D8 g4 K5 }$ Q- p
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    5 g! F! n. @3 f% W# a' i
15.   }
    0 K9 \% h# B+ z$ n$ H
16.     //ai小球
    3 f: S: e\" w+ C3 |9 y$ p
17.   for (int i = 0; i < Enemy_num; i++)) z: H1 C; [4 ?\" j, ]
    
18.   {2 p' j1 {4 N2 L9 m# Q' q' |+ c\" u
    
19.     Enemy[i].x = rand() % Wide_map;
    7 S9 d) ?; z2 a\" A6 I0 A; {
20.     Enemy[i].y = rand() % Hight_map;( }5 }) z3 h: B% D% P
    
21.     Enemy[i].r = 10;8 I; N0 R! E& V7 N3 U
    
22.     Enemy[i].color = RGB(0,255,0);
    ) j- ^$ n7 [; o8 S: \- ]
23.   }/ E7 G# u7 L/ A- \) {! l* d8 i
    
24. ' f' T) I% `( ]3 v& t/ P. i  m& S
    
25. }

复制代码

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

1. void Player_move()0 r0 h  `+ Z& V# u+ q$ v
   
2. {
   8 y\" u2 \# S\" o6 G3 M
3.   if (GetAsyncKeyState(VK_UP))
   5 B( {$ c\" J$ g  Z* v& k0 h) Z
4.   {5 H: i/ |* X. n! m* G7 u/ T
   
5.     if (player.y > 0)
   ' F6 c+ a5 e* o/ X5 v' _
6.     {
   : _1 K2 o2 i% f
7.       player.y -= player_sleep;
     z# }! X# [+ ^4 |* _( X
8.     }7 w9 {) }& J) G! ~* M
   
9.   }: m8 k0 N; u% p9 q$ o; C  _8 D1 z
   
10.   if (GetAsyncKeyState(VK_DOWN)). V) S1 U6 Z& ^& W4 z6 \7 W
    
11.   {
    5 D/ H( @6 I( g! y& d
12.     if (player.y < Hight_map)# d& w+ K% c# g0 }5 H3 E2 ^, a* ^
    
13.     player.y += player_sleep;) F/ l7 m% Q( }2 g* o. ~
    
14.   }8 t# T! {- Q6 \6 I( V( r
    
15.   if (GetAsyncKeyState(VK_LEFT))- J5 S3 c; n# Z+ u: j
    
16.   {
    4 i: [2 D7 M4 i
17.     if (player.x > 0)
    ( W, L$ c: g: p* O9 c- n2 ^
18.     player.x -= player_sleep;
    : V9 a) R7 p4 u6 H
19.   }
    $ k& a6 w3 ^: k/ Z- M' @
20.   if (GetAsyncKeyState(VK_RIGHT))
    4 r  n1 ^0 o8 H- u
21.   {
    5 n2 Y9 L; V( C8 c
22.     if (player.x < Wide_map)1 Z7 t% A% G9 M5 F. \
    
23.     player.x += player_sleep;/ m' U9 G& h/ D# S  u# Y+ h
    
24.   }
    , |  A; o6 q( p\" C, j
25.   if (GetAsyncKeyState(0x20))9 T6 O! a7 Z( ?- l
    
26.   {
    : V8 C5 L$ D7 L9 ^* b- h3 V
27.     player_sleep = l + 5;
    8 S  d& E( B) O1 V
28.   }* D: D: O  @' O* |# n
    
29.   else
      Z* o3 h2 T1 f$ S
30.   {
    : @+ r: w$ Q1 u: t  B1 @5 ?: F
31.     player_sleep = l;8 e\" A0 c  F$ l7 d- |
    
32.   }
    & u$ @* ^! `# i9 H1 x/ Q
33. }

复制代码

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

1. void Show(). D3 E7 X. ]( B6 X% M! _
   
2. {1 X: y+ _  E7 P\" r
   
3.   
   2 L; O. }: y\" ^\" Y- y
4.   //设置地图; w+ U/ n$ f* D. \\" g
   
5.   SetWorkingImage(&map);* s! D0 m% }8 s) P. X& h. N
   
6.   //清屏
   - u2 u6 H! ^$ X9 ^) z. e
7.   cleardevice();
   $ p  G; d& ~/ k6 |% E' _
8.   //背景颜色, c* @$ M8 p1 r3 d. H
   
9.   setbkcolor(WHITE);
   * [0 D& M* x4 E  b( I1 P) T+ s
10.   //划线颜色2 V7 E5 E. n) p' W+ F( u4 F$ a
    
11.   setlinecolor(RGB(230,231,239));
    4 q9 K4 x* o- y- m! h
12.   //划线$ z! f( V\" ?4 d' v3 y\" _# }0 g
    
13.   for (int i = 0; i < Wide_map; i += 10)9 v, i$ ]( i$ G- Y+ e0 K& q
    
14.   {
    2 X$ t& b! k% t
15.     line(i, 0, i, Hight_map);1 h/ c% o% j: e+ q9 X6 ]\" P
    
16.   }# m3 W* M! H; _7 ]) B: N) ?
    
17.   for (int i = 0; i < Hight_map; i += 10)7 ?5 _$ w, g3 }- X8 ?
    
18.   {' P$ S3 Q( O\" y+ u7 \/ w
    
19.     line(0, i, Wide_map, i);\" \: Z- h\" L+ J. o4 t! A
    
20.   }9 B5 H  N. f  U( k. G9 i& M& v
    
21.   //食物
    9 T' t3 s0 |1 Y5 f\" _- l7 d! T; A
22.   for (int i = 0; i < Food_num; i++)
    , T2 F) O; a0 G
23.   {
    2 ~5 L$ F  E- q\" V* x
24.     setfillcolor(Food[i].color);0 r# R- |9 r( p2 s0 _
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    + p' E8 e. e$ O* ^5 f7 H
26.   }; Y3 j8 @) I0 g
    
27.   //敌人# X\" P5 r) \4 ]. ?  X/ p  t$ o$ B
    
28.   for (int i = 0; i < Enemy_num; i++)
    0 s4 Y  e  z' ?% a. t. L8 Q0 a
29.   {% D9 I) p* |, G! y) Y5 N# k  F
    
30.     setfillcolor(Enemy[i].color);$ g4 ^- [0 `/ T, d4 e# ?/ y
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ! t# }\" m0 C3 X
32.   }3 h0 Z8 z. Q8 }$ c5 g
    
33.   //玩家# P4 q/ d% }) Q\" F0 M4 b: @- ]
    
34.   setfillcolor(RED);7 M8 [3 a/ Z# j( U
    
35.   solidcircle(player.x, player.y, player.r);
    7 C/ ^, [$ W2 R. }' G
36.   SetWorkingImage();
    3 D/ `# A\" A\" X; ~/ F5 e- S, S
37. 
    3 T2 h- @4 a9 ~3 O
38.   int x = player.x - (Wide / 2);
    0 w( Z1 ~' F: ~) j
39.   int y = player.y - (Hight / 2);\" X4 \& D+ {  `( N/ u/ s6 y
    
40.   //防止窗口越界
    ) F6 d3 r9 R7 s
41.   if (x < 0)
    5 t; n% f) M- q4 i, M% W: X% T5 n
42.   {. F2 Y1 H8 Y* Y4 p7 N; q3 L- e' C6 B) c
    
43.     x = 0;
      ]% r% l% W* f$ r/ ]
44.   }  W7 C! e3 W1 x1 t0 B
    
45.   if (y < 0)
    , D: j* g9 A, P; u* ~
46.   {
      s) o1 C5 D4 e' c. t
47.     y = 0;
    , z7 A2 h8 D1 f; \
48.   }2 Y4 L9 V! u\" c
    
49.   if (x > Wide_map - Wide)
    6 A- T6 M# v\" R
50.   {
    : r\" d5 x1 t( \3 R9 t3 y# b, O# f8 Y
51.     x = Wide_map - Wide;
    ; i. \! o  `$ d% d% v
52.   }9 i\" l! j! [+ H- C5 y\" ~
    
53.   if (y > Hight_map - Hight)
    7 {: h' n! _. D% x  v4 N
54.   {
      I# `6 \+ i' S1 ^  S. _8 y7 `0 m
55.     y = Hight_map - Hight;
    6 H' K7 C/ k% T' N
56.   }; z0 \5 w6 P$ I
    
57.   //把map输出到窗口上. b/ ~5 A! J4 i% H! W% u0 o( g0 R
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);8 i- O* |, c8 g7 ]* T* `
    
59. }

复制代码

5. 生成地图
2 ^) f1 g& C  B( u6 b9 N, ^可以使用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. //防止窗口越界
   9 _\" \2 Y- I5 {; v$ ^# n) W
2. if (x < 0)2 V' N$ X& c- Y0 p1 B, t' Y& f. @
   
3. {
   9 o  u! M& L# Z) z& ]4 F
4.   x = 0;
   \" F: O8 r; L! O/ b3 B
5. }# E7 r* f  u/ t! S2 i4 Z, x
   
6. if (y < 0)
   + i: N\" N1 |% B
7. {
   / N, u1 l+ K- `1 Q\" i6 r9 `, p
8.   y = 0;- \3 u, W+ y\" Y: W, L
   
9. }
   - w; z% m! L6 n% Q% @- E1 A$ s( N8 s
10. if (x > Wide_map - Wide)
    4 C: `+ J( l1 {( K8 Y8 ]
11. {
    / O/ y  E\" b$ w; [0 r+ T. v& [5 f. W
12.   x = Wide_map - Wide;- A+ V# F2 {; `  i! K! Z
    
13. }; O- u' J$ C, K! d: w! A+ T
    
14. if (y > Hight_map - Hight); {2 x0 J) D* n/ U: n6 {/ D0 a( \
    
15. {9 i5 V8 @% [1 r0 o  N. v  K
    
16.   y = Hight_map - Hight;! Y9 k, F$ I$ s% A& l% k
    
17. }

复制代码

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

(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
5 \! B; J2 P1 X
3 {1 ]* J, d1 M/ `3 b% Z0 T3 U0 PWide：这个参数指定了要绘制的图像的宽度。
+ `1 A" Y8 U9 ~  B+ v! Q
% j, K$ q* S; S+ ]9 A) [Hight：这个参数指定了要绘制的图像的高度。
+ p! ]9 i8 U, H8 Y/ M
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
6 P. m8 Q! k; c! |1 O
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
/ d$ m1 W/ U; }2 L: o
7 e5 F. O. D  u  h* K2 Dy：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   2 `: G! s6 j  `1 v9 V9 Q
2. int Distance(int x, int y, int x1, int y1)
   % F! ?6 m+ N7 z- |. L/ ?7 s6 |/ n' F
3. {5 J, ]/ e( V$ m* N2 a  T
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   8 j6 `% U7 k. C5 h
5. }

复制代码

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

1. void Enemy_move()
   % `) x8 V: |\" g, v1 s6 N8 r' Z% ^
2. {
   $ S0 G! q\" v+ x. F
3.   srand((unsigned)time(NULL));# J  y\" E( S9 X6 K
   
4.   for (int i = 0; i < Enemy_num; i++)1 ^% @2 T' i- o, ]4 a
   
5.   {
   * u$ B  X& _  ~/ E6 T- r6 B0 I
6.     int direction = rand() % 4;& n/ H0 y( O' }$ w
   
7. 0 b9 N+ ?6 q/ C* f8 k$ B
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)  O9 t* R2 m; `; V  N& U) _
   
9.     {$ N3 O  {8 W/ E5 X
   
10.       if (direction == 0)9 H& f( g5 v4 Y* W/ R, k5 J% {6 v7 R
    
11.       {
    ; b8 f6 M1 r' R% _6 a- p' E
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    ; s# B. x$ c) ^& G
13.         {
    1 N( P% T- I6 f% ]
14.           Enemy[i].y -= enemy_sleep;\" X/ n; D0 q* Z8 |
    
15.         }
    7 Y$ C1 n7 h6 _* ^2 d6 k
16.       }6 N+ K1 H+ M# _
    
17.       if (direction == 1)
    ! I+ \2 C+ h2 k9 b5 A$ k- T
18.       {: [. Y- K* S3 k  M! x
    
19.         if (Enemy[i].y < Hight_map)) ^& K! G+ u3 W: k( d& F2 {: Z
    
20.           Enemy[i].y += enemy_sleep;
    , p& ?$ s+ @# u* H4 ?/ l
21.       }# [1 R: `. y; W4 j  o+ k
    
22.       if (direction == 2)
    * X) m1 F- c* {; ]7 V. `& g
23.       {: J4 ?8 E: V6 e7 k( |
    
24.         if (Enemy[i].x > 0)( Z. m& {\" K& ]
    
25.           Enemy[i].x -= enemy_sleep;
    \" r; Z' R# m; s9 l4 u( j' v
26.       }
    # o4 N+ o! w6 O8 d6 {
27.       if (direction == 3)
    9 B. f$ W, J3 F4 P* o
28.       {1 l' W' F$ l- O* t' k- i
    
29.         if (Enemy[i].x < Wide_map)1 }2 {. {$ k8 K
    
30.           Enemy[i].x += enemy_sleep;3 q% ~7 H3 G/ p8 [1 T
    
31.       }8 x, b0 m7 k9 r( i. \
    
32.     }
    / s9 `4 q: O& A2 `\" Q
33.     //敌人追击玩家( M/ s3 t; I9 j3 y4 x1 L
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    7 N4 A5 z6 X+ M! @3 [6 r4 V( M
35.     {
    , k0 Z% ^- k# j0 b
36.       if (Enemy[i].r > player.r)
    # _3 I\" `: q7 k
37.       {6 z9 X\" u! |- m$ h
    
38.         if (Enemy[i].x < player.x)9 m$ `8 d& |- t  p; i' n. q
    
39.         {
    - h7 K3 w* J& J% o/ s' D
40.           if (Enemy[i].x < Wide_map)  a9 M4 r& f! ~+ Z: T
    
41.           {
    ) N- p1 _: g' J$ N0 w1 x7 Z, o* S
42.             Enemy[i].x += enemy_sleep;
    \" f5 _- Q5 ]; c( X, Q, q/ W
43.           }
    - n. Q7 F' w; N* w$ C# ~
44.         }% J- A. e; l( A( L6 c( A. N
    
45.         if (Enemy[i].x > player.x)) O- H& V0 x) ]% x# _. c; q
    
46.         {
    3 `% }0 p5 x\" f) H3 m; V1 o
47.           if (Enemy[i].x > 0)3 Y  l6 ^9 {# A# z: B4 ^
    
48.           {
    % S\" L2 A3 |2 K( y  A
49.             Enemy[i].x -= enemy_sleep;
    ) C6 i' j; J3 q% o, `
50.           }8 O& j& K1 O9 D3 b
    
51.         }
    # ?- [6 h$ R( Q/ d9 u0 M0 P
52.         if (Enemy[i].y < player.y)5 w/ j4 [1 l( o0 E; \1 ^8 u
    
53.         {( f: Y* H0 h- A) p& d2 F& J9 s
    
54.           if (Enemy[i].y < Hight_map)\" ~/ f' w6 A6 S0 r! ^. A0 Z8 O
    
55.           {
    4 p* Y, ^0 \4 J- [
56.             Enemy[i].y += enemy_sleep;
    0 D) E# h! p$ C6 n$ c/ U! o
57.           }& |2 v& c* y, ~. k4 T& q4 {3 R
    
58.         }
    ( L& ?) y  h0 ?\" q) t  t- j' t
59.         if (Enemy[i].y > player.y)
    4 ?+ ^7 w% P# V& C+ U: t
60.         {
    + u. b; |1 t5 _$ x$ }
61.           if (Enemy[i].y > 0)
    0 w* s% A. v1 f% ~5 b
62.           {
    . R; v  |# u2 q7 ~
63.             Enemy[i].y -= enemy_sleep;
    8 j8 j5 S; l1 O6 O6 M
64.           }* M8 m9 p4 E' s4 N
    
65.         }
    ' q0 z. O% \3 {' E9 q
66.       }
    3 t0 ?! O( F\" Y! P/ E4 \
67.       //敌人逃跑
    8 U' w0 B6 Y9 R7 ?/ `, E
68.       else& O/ t: f: r- l7 G
    
69.       {& D0 N1 y\" P+ y! ?! ]: z
    
70.         if (Enemy[i].x < player.x)4 M5 S) t5 K  {8 y$ z% N* E& x# _
    
71.         {0 O  c! K# p. i4 N
    
72.           if (Enemy[i].x > 0)
    + D\" A* y, K' L6 y7 N2 J
73.           {\" z1 O* `1 ^1 S0 H7 t. |9 }' j/ W
    
74.             Enemy[i].x -= enemy_sleep;1 L( F2 ^\" g/ H/ Z& x* \# D
    
75.           }; Z+ \+ `% [$ A  s2 H3 B, Y
    
76.         }, X  n2 ^- o4 D$ z
    
77.         if (Enemy[i].x > player.x)
    ! n3 r6 \# e1 x
78.         {7 i3 N! \& L- G5 W) @/ H% w
    
79.           if (Enemy[i].x < Wide_map)
    ; B\" Y# }$ U5 V/ a& C) s
80.           {+ v$ \2 h) X( {6 w8 g# z; `5 X
    
81.             Enemy[i].x += enemy_sleep;
    2 ?4 ^7 N! y* N; |$ q) X$ p
82.           }
    8 _/ o3 [6 A# r; f' [
83.         }# D4 M/ H% b) y
    
84.         if (Enemy[i].y < player.y)
    7 f7 }. j( \3 c; ^7 c
85.         {& A# v\" K5 K; W8 q
    
86.           if (Enemy[i].y > 0)
    3 U' A8 V/ J0 {2 W# v3 ~, s
87.           {
    . t* f' F$ w( ^5 K\" c+ S7 s0 r
88.             Enemy[i].y -= enemy_sleep;8 j0 e& t, Q) H  e
    
89.           }7 ^9 x& I3 ~7 @1 U- Y
    
90.         }
    8 ]# v1 E% U) Q/ c2 \, J7 ]) W* Q% _
91.         if (Enemy[i].y > player.y)
    ( x  ^3 h$ X( k! p3 m) w
92.         {
      |. j: L  N& s) P/ z( a; ~7 M9 [% p
93.           if (Enemy[i].y < Hight_map)6 L\" V5 x6 E* r* V8 w. ?5 w' D6 K
    
94.           {
    8 {# L  A( x7 q
95.             Enemy[i].y += enemy_sleep;8 Q5 V6 P  s& I$ h2 t6 |8 F2 Y
    
96.           }. N3 Y# N) H# e& t$ Z4 Y0 s
    
97.         }$ x. L+ A- }- _9 z3 i
    
98.       }
    0 d% E: f  c7 e8 x: }
99.     }' @) j8 D9 T8 z* T0 _+ H) n2 l3 K8 q
    
100.   }
     & b1 D+ o' m( W+ h, L, Y, Y
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   0 F. _& i# N' h
2. {* q' z8 H8 h9 \' u: ~5 s' G
   
3.   for (int i = 0; i < Food_num; i++)- Z: U# ]# n) t( i; d! o& m( D- l
   
4.   {
   5 b3 }% G. R3 m7 w- N! \4 y
5.     //玩家吃食物
   6 C' O' O3 @+ r  m\" g& z
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)8 ?' j7 J) U1 u* F, H' o* S
   
7.     {9 i- @- l. d' k$ x3 c$ v; o+ C$ n* ^
   
8.       player.r += Food[i].r / 100;6 y( a3 S, ]% O1 {
   
9.       Food[i].x = rand() % Wide_map;
   + l7 M' m  z8 D% x/ u
10.       Food[i].y = rand() % Hight_map;8 I4 c6 F3 g1 V: E
    
11.       Food[i].r = rand() % 5 + 1;
    & u/ L- N% E( y: I' y8 |, T
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);4 i9 _- h; Y4 B3 g  _, K
    
13.     }
    ( e; B4 [5 i% h  G
14.     6 o% b0 |( V! e# H5 t
    
15.   }; v1 u: ^1 ?9 U: }; }1 U: W
    
16.   for (int j = 0; j < Enemy_num; j++); U\" _2 }\" ^% Z
    
17.   {
    , M; H( V- P6 \0 s: t0 ^, m& ?+ H+ d
18.     //敌人吃食物
    : ^: a% A1 ?) _\" w5 `) z
19.     for (int i = 0; i < Food_num; i++)
    : }; V\" R# T( s; g1 ^
20.     {
    . f. K  P0 y- F4 g( {: z/ q% r
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    6 z# m( g6 ?3 Q' g! y6 ~- H# N- \' M
22.       {( _: L6 D% {5 n! M
    
23.         Enemy[j].r += Food[i].r / 50;. C1 P' @& E( O' E3 J6 r% g\" ~
    
24.         Food[i].x = rand() % Wide_map;0 Z2 p- b! K9 f( N4 J\" U( U
    
25.         Food[i].y = rand() % Hight_map;
    5 d# \5 h- h, }5 l+ t9 r
26.         Food[i].r = rand() % 5 + 1;. o4 p, c6 W1 ~3 U0 [5 g! @0 z
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    $ b& m% T; w; x7 r/ O# _
28.       }
    ! P( E, w4 {0 i0 z6 J
29.     }! D) w5 }/ I$ B\" L
    
30.     //敌人吃敌人
    + Z, t% p/ P# k  K- N9 t5 H! ?
31.     for (int i = 0; i < Enemy_num; i++)
    7 u; W4 E+ Y3 W0 e
32.     {2 H. P4 u) v% t) o! }! s
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)  F8 I& o: s9 \! U5 G\" o
    
34.       {
    5 O8 m0 G/ h) _6 D
35.         Enemy[j].r += Enemy[i].r / 10;5 C\" a$ ]  J5 R5 \3 N
    
36.         Enemy[i].x = rand() % Wide_map;
    4 H- S  |/ i0 r8 Q$ H1 Z
37.         Enemy[i].y = rand() % Hight_map;5 w2 B\" Y\" C) b0 |4 f% i
    
38.         Enemy[i].r = 10;
    : v+ c\" t: X8 B3 r+ L
39.           Enemy[i].color = RGB(0, 255, 0);. W4 s5 _, b/ t+ ~* q1 Y
    
40.       }' Q% h. ~- R$ T$ a8 }! U
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    1 {* {. }+ X/ ~\" S; Q
42.       {5 i) {! u4 C. g' r, y
    
43.         Enemy[i].r += Enemy[j].r / 10;
    ! B! S: u\" n5 j
44.         Enemy[j].x = rand() % Wide_map;
    0 \5 {( O, L8 V\" i: o: W
45.         Enemy[j].y = rand() % Hight_map;  g0 v7 Z% {! r1 v+ a& ]. R$ P( l
    
46.         Enemy[j].r = 10;( d6 D7 F2 i4 Z# O+ r
    
47.         Enemy[j].color = RGB(0, 255, 0);% M' v4 V4 L/ D0 {( I/ F7 x% i- g
    
48.       }  G! n8 \- L/ w
    
49.     }0 D' l7 l# U: w) }  b
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)1 N5 w# t( {9 V0 v
    
51.     {0 f) G\" |; w1 f9 A$ v8 d: i; R2 B0 E. x
    
52.       //玩家吃敌人
    * \# B0 g) X+ D) ~; D. A; g* {
53.       if (player.r > Enemy[j].r)
    % P- Z0 X+ i9 t7 H  R
54.       {$ D6 E4 q$ H- m. v. p, S) [
    
55.         player.r += Enemy[j].r / 10;/ ?8 T) R/ \* i0 D) {: `& L( d! Y& C
    
56.         Enemy[j].x = rand() % Wide_map;. G& ?! E  o$ L+ N! G2 X* L\" N
    
57.         Enemy[j].y = rand() % Hight_map;
    3 p/ q' N  _. p6 u2 S\" h
58.         Enemy[j].r = 10;% q- ^  {5 }& |* I2 a# k, t& Q
    
59.         Enemy[j].color = RGB(0, 255, 0);9 Y2 o. {) F- ?1 J; c, t\" c
    
60.       }
    & z2 |- O# r& [. ?. S/ S
61.       //敌人吃玩家
    # ^( c1 O* B. o8 ~2 ~; K3 \\" ^7 R9 v
62.       else
    / w# C4 a4 Y; X0 u
63.       {
    - D! Z  M' q7 Y- A9 `; Q2 v# A! j
64.         if (invincibility == 0)
    7 F, M+ f# E. @5 n\" o( F2 K6 q: K' M7 P
65.         {
    . h8 q) v: ]  J5 V/ S
66.           Enemy[j].r += player.r / 10;+ i8 ?0 G5 U0 o6 l
    
67.           player.x = Wide / 2;# T% e0 z: n: ]
    
68.           player.y = Hight / 2;
    ' }1 \# a  l2 z& n9 W' [& Z
69.           player.r = 10;
    \" B  `/ ]: j3 z, O
70.           invincibility = 10;, Q# }% q) q0 K3 ]3 ~
    
71.         }8 Y' o8 c( t5 y& ^# j0 l1 F$ L
    
72.       }
    - c! _# C$ Q# a& u# w. H- A  R) j
73.     }
    9 R* ~9 m& O4 Z) D\" I
74.   }2 w4 p: z0 i! @9 Q6 M- z# R( J3 k
    
75. }

复制代码

完整代码见附件：
4 L$ F" q8 y0 D