球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
* C# w7 a$ q- h7 a8 Y
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
+ E2 ~+ K0 N3 {
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

/ n# d  ]( d' T- s其他小球：其他小球又分为食物小球，和ai控制的小球
: W! t; c1 C0 v5 `
* j, |+ E. t. f体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

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

$ Y1 @  E# C) M$ ^ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
% D# I. s) U3 W+ W! D1 g( u
接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。
" r9 G" M# N* S
处理键盘输入，实现玩家小球的移动和加速。
* G$ t7 u+ M: K1 l' E
3 Z( w  Y4 {6 M生成足够数量的食物小球。
1 }2 L9 s4 J+ Q
$ Q2 Q7 G3 H( S* B生成ai小球，并控制其移动。
: x) ~, C/ I5 w. U* W  I0 g' z
检测小球之间的吞噬关系，增加相应的体积。
2 u- N1 O0 M" O/ V, ~, p: Z
% L  M' E& z1 ^4 L, n通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
7 t6 H, B/ K: D% q/ E8 t
* h& ]8 X# }2 x/ ystruct Ball
8 R+ F6 ?: c& V. h+ x( `7 u{
        int x;
& q) G' g/ }9 X/ K; n+ o8 T        int y;
- t3 e( ]" F: D: ^8 O        float r;
$ f( G1 S! R+ Y% C! }: D) h2 c  g7 {        DWORD color;
% J; N: Y" M1 v* q1 n* e1 a3 |# @2 S};
* N' m" W5 V2 C, E+ c7 t$ ^2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
+ @: b* S4 l) L; U& T! `. F* q
/ ?& t" d- B8 A: R/ rRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
1 O7 a2 t# A5 l' Z. a* X9 N2 P: f
4 s7 `2 t* q4 v; A  D, l* G橙色可以通过RGB值（255, 128, 0）来表示。
0 `/ V$ S* ]; S3 E4 U黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
4 Z  D0 l4 ~' k; H  x4 {紫色可以通过RGB值（170, 0, 255）来表示。
- T4 X- ]& n, ^; T黑色的RGB值为（0, 0, 0）。
, d8 b/ T# `% h9 G; _白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   + j: ]9 M; [, \5 Y' U- Z4 i8 p
2. {
   / r; L9 `% z! Z( ~: X( E2 d: C
3.     //玩家小球
   / ]4 D4 e/ l# ?, ?9 m! W! v
4.   srand((unsigned)time(NULL));
   \" i4 ~% l# F& A3 `' r\" ^. M8 s
5.   player.x = Wide / 2;
   * u: }5 \3 f4 Y5 f' `: F9 `4 s
6.   player.y = Hight / 2;
   3 [- \% y3 D6 h8 C9 R, G( N
7.   player.r = 10;
   ( `- u4 v( w8 `2 C6 f\" R9 u+ I
8.     //食物小球
   4 F( V  V6 M9 p' H( ~
9.   for (int i = 0; i < Food_num; i++)
   \" P  D: O2 R4 M1 m! ^/ E1 D! K
10.   {$ O$ h1 @\" P3 g/ W4 m$ p1 n
    
11.     Food[i].x = rand() % Wide_map;
    8 L8 c* J* q7 K( y
12.     Food[i].y = rand() % Hight_map;
    : g7 w1 O5 q1 P0 ?: _
13.     Food[i].r = rand() % 5 + 1;\" i- t- s) H\" h* Q- t3 k
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    3 J0 v6 k, V* X0 L
15.   }
    - u- w! q5 |5 U
16.     //ai小球' @4 @, H2 w2 f: Z9 W
    
17.   for (int i = 0; i < Enemy_num; i++)* Z: x. n: O: p. A3 m  w! z' V% U
    
18.   {, e. ^2 }& V2 u, P# R
    
19.     Enemy[i].x = rand() % Wide_map;, n4 m; X, W+ w' y  d) W; F
    
20.     Enemy[i].y = rand() % Hight_map;5 h! C, s4 l7 w9 N1 t0 [  n' \3 m0 U. a# f
    
21.     Enemy[i].r = 10;1 X: g( `9 v& c\" a6 D: u: I! e
    
22.     Enemy[i].color = RGB(0,255,0);- J8 X: s: q& z, m
    
23.   }
    # p4 u( i3 V  }- V* M
24. $ N) F5 d: x! o! u/ }: s% d
    
25. }

复制代码

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

1. void Player_move()& }! t7 c+ `5 i: M. S* n9 y
   
2. {. N7 H) X% o( ]  V6 l. G
   
3.   if (GetAsyncKeyState(VK_UP))) W5 O. x( H2 h& U& Y; {
   
4.   {
   3 E3 Z\" V0 [8 Z4 J9 ^- i2 C
5.     if (player.y > 0). K. D9 v  c9 S
   
6.     {4 U6 B' i3 Z- X( b/ w
   
7.       player.y -= player_sleep;
   ( f8 ~1 Y6 Q3 K8 w/ y; M; p  V
8.     }
   : v$ Y8 L3 m0 a4 f- V
9.   }4 @. S# L7 j8 |' |
   
10.   if (GetAsyncKeyState(VK_DOWN))
    . X4 w3 i& g- O3 x
11.   {3 c8 g9 J0 Z' J! k\" k3 N- c
    
12.     if (player.y < Hight_map)
    3 n7 T/ h6 Q* N2 i( Q
13.     player.y += player_sleep;5 R9 q& ]) W! k6 R7 H# k& k
    
14.   }
    8 M! `  _: ^3 w  z+ }\" y0 ]
15.   if (GetAsyncKeyState(VK_LEFT))
    ( c  z9 m, w0 X( U7 t+ r
16.   {# _\" q! S: `) h+ V5 b8 f
    
17.     if (player.x > 0)
    2 l7 ?# o, Y) Q. e. @
18.     player.x -= player_sleep;! }+ f$ D) Y4 I& i
    
19.   }
    \" `% D5 ~2 B8 E8 M7 W$ S3 ?$ D
20.   if (GetAsyncKeyState(VK_RIGHT))
    + e: p( ?$ t\" d4 O; P\" M, \! a1 o6 t
21.   {( h+ P  r( U& r/ ^; M$ t  x
    
22.     if (player.x < Wide_map)$ I- U! c7 P' ?* O# H
    
23.     player.x += player_sleep;
    * F5 G& c# ?: V4 Z# Y& w) {7 f
24.   }
    ! x  t2 f+ A/ v* b5 x: ^
25.   if (GetAsyncKeyState(0x20))
    9 Q5 L2 a# ?; R/ H
26.   {
    * l  `/ S! P7 S; ?
27.     player_sleep = l + 5;5 J8 i/ F7 ?& P& ?# U: r
    
28.   }
      r5 `+ c* G8 z, d6 c7 _
29.   else- T( e9 S6 M9 t: |
    
30.   {
    . K! t+ n' [/ C
31.     player_sleep = l;6 u( p9 r3 L/ t7 o; i
    
32.   }( `( o( j& g5 {7 O! L2 g) w8 y
    
33. }

复制代码

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

1. void Show()4 ^# ]! V4 a: Q
   
2. {
   - ^, I' K9 o# ^( K( U
3.   * Z\" g) z- l6 f4 k
   
4.   //设置地图
   + |0 i5 f) l9 Y- S9 J1 e& i8 c
5.   SetWorkingImage(&map);
   ! g1 N4 Y- P) k' }6 d& I, U
6.   //清屏
   # ]+ d! A3 m0 F5 O  [
7.   cleardevice();! R+ n4 O5 S( T+ G% f
   
8.   //背景颜色1 Q. z: M' K0 m! u3 s6 B/ x# n
   
9.   setbkcolor(WHITE);
   & R/ x+ E5 ^; D( r( i
10.   //划线颜色
    : @1 ?3 t; l1 |- n, E
11.   setlinecolor(RGB(230,231,239));
    / B$ _. e7 E- N/ G
12.   //划线. s4 F% z$ ]9 f! w6 L
    
13.   for (int i = 0; i < Wide_map; i += 10)* o# ], Y/ v! o% I9 U( ^
    
14.   {
    ; |% n; V1 ]: W\" }& g5 K! v0 h
15.     line(i, 0, i, Hight_map);
    8 G) O5 |  a' L6 b% b! E% s
16.   }
    . y, y0 {3 h4 @1 L
17.   for (int i = 0; i < Hight_map; i += 10)
    2 K* g0 n: R& h
18.   {
    ! k1 _% X% G/ |! ?% l
19.     line(0, i, Wide_map, i);
    8 K5 Y: v  p5 b6 }8 D+ p
20.   }6 L! H! e, D: O8 O/ U
    
21.   //食物, f) x\" F\" P; u- X; j2 j% i
    
22.   for (int i = 0; i < Food_num; i++)) b6 s0 r2 Y% Z# c% [
    
23.   {\" {- `$ m$ Z- G
    
24.     setfillcolor(Food[i].color);- q) K* E! e& m8 l  l. f- A# c% i
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);+ c$ [8 n/ Z# ?9 X5 h
    
26.   }
    9 R% n: N# s# g9 Y
27.   //敌人
    0 R% |\" e% h4 d3 t\" |
28.   for (int i = 0; i < Enemy_num; i++)
    $ b4 W  C/ [; v8 g# v- x3 h9 Y( R
29.   {
    * X! G+ e2 U) W1 p
30.     setfillcolor(Enemy[i].color);2 M0 n9 y7 ^& r* b6 c7 A  C
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    $ Q% ~& {9 i. ~. y2 M' g1 I
32.   }
    9 }: T# I5 M7 D- Z: K3 F; j; M1 Q
33.   //玩家
    2 \9 b* n5 w, C4 o3 f
34.   setfillcolor(RED);
    ' y! E! o! v$ |( R, I( J7 |
35.   solidcircle(player.x, player.y, player.r);7 N3 |4 R% u4 }  t6 s* `# W! q) C+ ]
    
36.   SetWorkingImage();
    1 Y# k8 S. t! y8 Z9 U, |
37. 
    ; W9 y$ D! q. B+ O, p
38.   int x = player.x - (Wide / 2);
    ( H7 ]0 v9 S1 ~
39.   int y = player.y - (Hight / 2);
    & g* A) W% O, }$ B) N
40.   //防止窗口越界
    \" m, D2 J5 s8 ]8 C9 x7 W: j
41.   if (x < 0)
    $ f* @  G* ?; r4 D. R) M
42.   {
    - `+ p; G7 v  C/ }3 o
43.     x = 0;( t. n. N! t5 E# b. U, F: j8 Z
    
44.   }
    2 h$ j- l' {- i1 k
45.   if (y < 0)\" k\" Y3 X+ ]# Y  F+ p, m6 L. `
    
46.   {
    + O9 N( q& x' c7 G\" j4 G4 S
47.     y = 0;
    * V\" v( c( E2 {
48.   }, u4 P' C: v8 W; K- A% J1 k
    
49.   if (x > Wide_map - Wide): S+ P$ s* f4 K\" f7 Z\" Y. c
    
50.   {
    ( f8 j: A* x& L\" ?6 t
51.     x = Wide_map - Wide;7 \' n/ y) `: a; n3 u
    
52.   }
    $ }% E5 _: i: c5 N
53.   if (y > Hight_map - Hight)
    + Q/ f\" p+ Y( X9 W9 U
54.   {
    ! g* M\" q% _6 @) Q9 I
55.     y = Hight_map - Hight;
    ; O7 p0 c. S* M& r
56.   }6 N0 m) ]& n8 B5 ^2 m
    
57.   //把map输出到窗口上
    $ C5 F3 A4 n& Y: J- P, K
58.   putimage(0, 0, Wide, Hight, &map, x, y);\" s0 x  ]1 o4 C0 W* y
    
59. }

复制代码

5. 生成地图
* S! g6 G* G1 b+ m可以使用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. //防止窗口越界
   # X( j- a$ V2 q6 ?  y5 h\" x# e\" ^
2. if (x < 0)
   \" r- i8 i\" c5 Q- w: y
3. {
   ) M. @3 ~% d6 q6 ~* F0 F: D9 S( |
4.   x = 0;7 A' f6 d+ k9 e: O8 F
   
5. }8 F2 W3 H9 f\" z' B
   
6. if (y < 0)
   1 l+ F/ y* Z  x! _' f: L. n
7. {7 v' O% E3 @3 f4 `% W
   
8.   y = 0;( t' G$ \* _$ z# t$ \
   
9. }. _& i$ t) g6 w8 K1 w- F\" b
   
10. if (x > Wide_map - Wide)/ J% A7 b7 ]4 W( H2 f6 d& A0 ~! Z; p
    
11. {/ C5 ~# Q$ m\" F6 ^5 M2 J6 X% x
    
12.   x = Wide_map - Wide;+ |4 d( \; d* }$ {. r
    
13. }8 q/ P: {3 Z- z# H2 P( s$ n
    
14. if (y > Hight_map - Hight)4 ?2 _& c  o* f5 n: O& |
    
15. {
    ' ~* P% z: S8 d
16.   y = Hight_map - Hight;( W( y6 E8 G  h' m8 Q8 a
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
% d% `' M  T2 x5 g9 ?, t
8 ?; S! F% V8 ?, M: q* ~(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
+ |& C. o; X; B4 q: d
Wide：这个参数指定了要绘制的图像的宽度。

Hight：这个参数指定了要绘制的图像的高度。
0 R1 `7 G0 V; M- s9 E& Y* K; l
9 T! P, G  D8 u% ?, k& G&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
. F8 s0 M8 X8 P6 @: b9 E, }
. Y, ^) d: g/ W. U, O+ Vx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
7 \0 |0 o6 Z% `: L% @3 U  {
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离* k* p0 |# ^) Q- h8 ]* T
   
2. int Distance(int x, int y, int x1, int y1)* Z, \4 G. X, z
   
3. {- w  [$ c; t4 |& Q0 u: E; F
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   : C7 B! y) h- }, d
5. }

复制代码

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

1. void Enemy_move()
   8 h/ E: U- @. z
2. {  @' l6 e. P9 r, }
   
3.   srand((unsigned)time(NULL));+ L3 K5 X, }1 q7 M+ N. Y( Q& H; ^
   
4.   for (int i = 0; i < Enemy_num; i++)
   ' I6 ^5 ]: b* M# g- f* \5 w
5.   {7 q/ l\" b+ b9 B( {
   
6.     int direction = rand() % 4;
   8 L4 J4 W5 |  b8 P/ ?
7. 
   % }* T! B. L. h5 j) ^7 p
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   5 Z5 w& i! w+ m
9.     {
   ' H3 X, m) `& A- d2 V& S
10.       if (direction == 0)
    , A$ }6 W2 }# t+ S, h' V+ P6 D
11.       {0 p( K9 t! h+ H% E
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句0 v/ B! Q1 S. Z. m& J
    
13.         {  i+ i) L; Y! h* I
    
14.           Enemy[i].y -= enemy_sleep;
    6 M2 h; j+ N\" P! m$ S; T* `. N
15.         }- Y$ k3 p1 o1 J* R6 w. a& Z
    
16.       }
      d. h. k) _/ p& f  J5 a4 n
17.       if (direction == 1)& M7 f# [; x\" _% o  p$ K, V  f
    
18.       {
    . [9 ]( B9 b* t1 s+ P. b+ n
19.         if (Enemy[i].y < Hight_map)
    2 n0 n+ L) l/ \/ c+ O% l: a
20.           Enemy[i].y += enemy_sleep;0 L& k8 W3 ]4 B  _
    
21.       }
    / O9 a* @! I  g2 O! t* w
22.       if (direction == 2)
    1 n9 ~\" h% r# j- Y  {( u* h
23.       {) i# q7 ~; R, k: K) J& k3 m
    
24.         if (Enemy[i].x > 0)0 a  ^0 q& P; [$ U
    
25.           Enemy[i].x -= enemy_sleep;
    9 v7 C\" K) _8 g( B3 n
26.       }
    3 p, H9 G$ c. d2 Z% }( c7 Z
27.       if (direction == 3)
    - H6 F8 ~* j& X8 _/ X8 K' }
28.       {
    8 r& Y) z' }\" q# n
29.         if (Enemy[i].x < Wide_map)+ `8 U, Y4 _, ]+ `
    
30.           Enemy[i].x += enemy_sleep;
    7 t: v! T- p$ K* V9 c
31.       }
    : r4 n6 k/ p# e! i3 o$ G) n/ B
32.     }& B: |2 x) b2 _1 a7 c: a/ j
    
33.     //敌人追击玩家. {# N# M3 L\" [5 m& j
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)& c, F$ o7 u  k0 C% `; V
    
35.     {
    : B( m, ~  @0 E! t9 G
36.       if (Enemy[i].r > player.r)& B/ X2 h. N/ t2 Z& b4 R, ]
    
37.       {
    9 ~& d' m+ Y1 |1 n4 X7 z! O
38.         if (Enemy[i].x < player.x)( ~- O! i9 F6 N7 @) e+ i
    
39.         {
    5 d6 h5 X5 @, y7 E! s3 B5 V$ [
40.           if (Enemy[i].x < Wide_map)
    5 O/ Q% x* {6 J! D\" Z4 e
41.           {
    ; f. L# T! e6 D( e; D' ^/ F) S. ]7 a
42.             Enemy[i].x += enemy_sleep;
    / |: d0 T& z6 j7 E  }\" I4 A4 n! q
43.           }9 J. g( |4 n6 T2 i\" X% T' N8 E$ c
    
44.         }, [( j! }) M; S, ^0 i
    
45.         if (Enemy[i].x > player.x)1 S& N! U; ^! j2 h# z/ ]) |\" I\" j0 }
    
46.         {
    3 K2 s; c9 q9 ]( ~1 W1 x; a
47.           if (Enemy[i].x > 0)
    - W5 D2 w  ~! ~
48.           {
    , ~, n; U% _\" F8 [: n* B
49.             Enemy[i].x -= enemy_sleep;
    1 x4 H4 R& o( K' r  G( B
50.           }
    2 c6 Q\" a. P. S9 b; ?
51.         }
    ) m4 J9 J. r2 z: P\" s( z3 ^/ c
52.         if (Enemy[i].y < player.y)/ K: f4 Y7 q# Y5 a# R8 _
    
53.         {. J* G; Y4 n* ^! p( n
    
54.           if (Enemy[i].y < Hight_map)
    0 S2 c  [$ w# O- k% w; W7 R
55.           {
    . B. G. H+ E3 H; a7 R3 S9 O$ I+ q. q
56.             Enemy[i].y += enemy_sleep;. F4 {1 g  C+ Y5 X& }  [
    
57.           }
    8 a, y  R$ a, o! {
58.         }5 D4 X0 @* G. Y9 @& L' {: _- [+ s
    
59.         if (Enemy[i].y > player.y)
    $ p\" M% u! p$ E% f
60.         {
    $ x8 B* @+ b* r5 r0 P. s
61.           if (Enemy[i].y > 0)2 ?7 Z( y0 e9 [4 P  ]$ J! @3 h
    
62.           {3 \; G% N' E9 A! R- p% G. @) X1 L
    
63.             Enemy[i].y -= enemy_sleep;
    8 j2 P# q3 Q6 x- M5 z
64.           }% b, W' ~' c. e& c
    
65.         }
    - g; ~# Z/ M! R; D
66.       }$ V+ M4 l! L& r9 Y
    
67.       //敌人逃跑6 M/ E- r. R' |8 f6 X& u: l+ a
    
68.       else
      A/ I* H7 l9 ?8 x. S- o
69.       {
    . X, |0 r( f3 ^6 S) l4 s
70.         if (Enemy[i].x < player.x)
    # Q. x4 r' u7 c' b. L
71.         {
    / r\" A\" F) |$ O+ \5 L4 S
72.           if (Enemy[i].x > 0)% R) x. S5 T4 [  I# x
    
73.           {) x8 n. A! C: e: Q\" ~3 F
    
74.             Enemy[i].x -= enemy_sleep;
    # n6 n# J  d7 z7 l$ }0 x
75.           }/ y' H4 U$ R6 _6 S
    
76.         }! z) s1 G) L# p% C
    
77.         if (Enemy[i].x > player.x)
    4 d* T3 T7 V5 o8 ~
78.         {
    8 G2 x# i2 u( R
79.           if (Enemy[i].x < Wide_map)
    - L/ V6 b5 E( |5 B8 w* i+ m- u
80.           {6 Q\" D( y' k* p5 m7 G! W
    
81.             Enemy[i].x += enemy_sleep;
    ! v$ E- f- A+ K) H, O
82.           }
    6 Q8 n4 ~5 n  r5 X8 @4 z
83.         }
    3 @$ Y0 A* G8 d6 e. {
84.         if (Enemy[i].y < player.y)
    8 n/ _' J\" l. }4 I
85.         {
    * u\" V% ~/ l' ?0 p: _
86.           if (Enemy[i].y > 0)5 r6 @* _0 g3 G; E
    
87.           {4 E* W8 u+ u. x+ g: E9 }- y
    
88.             Enemy[i].y -= enemy_sleep;
    % d6 G- e# @5 u& U
89.           }
    + R. z7 l& ^& f# G
90.         }
    * D# o) t, A. [/ q& {
91.         if (Enemy[i].y > player.y)
    6 l$ g( u2 V+ ]5 u4 k0 {
92.         {; T0 ~% V% v6 t  h) o5 u9 a7 c; z
    
93.           if (Enemy[i].y < Hight_map)
    9 g+ y- X% B5 O* k' f4 G
94.           {: h2 K\" m0 p! k8 |\" T2 H5 e, C3 y
    
95.             Enemy[i].y += enemy_sleep;
    / G0 O4 O; N$ c4 F3 k5 V5 Z
96.           }  t2 v* d1 U; l2 k
    
97.         }- h6 T8 V6 Z3 z) s+ S
    
98.       }\" z1 G% E; @2 E- F9 w! }; H0 [6 L
    
99.     }
    ) L. ^0 ?8 g* F3 x7 k, s) @
100.   }
     ! Z\" t! j' A/ ]8 M
101. }

复制代码

7. 小球之间的吞噬关系
& X$ O4 h8 e  ]" ?/ D

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

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

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

1. void EatFood()
   - _7 u0 v  I6 G. y6 V5 y
2. {8 V& ?2 _\" n/ e4 G! K
   
3.   for (int i = 0; i < Food_num; i++)( e0 j3 V1 B' [9 \/ t7 f8 T5 m
   
4.   {
   - S) y7 \+ x6 q% m6 F
5.     //玩家吃食物
   ) I5 i4 C7 a$ X1 Y
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   ( v/ t/ c) A. f; R9 a+ p' W, Z
7.     {
   ) X9 U9 Q3 {- {- d% f8 J7 y0 h6 K\" I
8.       player.r += Food[i].r / 100;' W4 ]2 X0 q1 _; P
   
9.       Food[i].x = rand() % Wide_map;
     L$ v+ P7 ~5 c\" l' R5 \' Q0 d6 E
10.       Food[i].y = rand() % Hight_map;* s$ a2 Q; u\" m
    
11.       Food[i].r = rand() % 5 + 1;: p5 ?8 O1 x: }' }' L8 P
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);+ \  i& S! l. b8 j& u\" i# t% Q
    
13.     }8 N) F4 s' N( \2 V* d' ?
    
14.     , N, N/ U9 I1 }# X0 q: C
    
15.   }. I9 P  E* M) D& ^9 G\" O9 [1 Y
    
16.   for (int j = 0; j < Enemy_num; j++)
    ' h$ P8 s7 R2 Y7 n$ p+ q6 c
17.   {, X, e/ u' R4 H! H- D- {( _
    
18.     //敌人吃食物
    \" \' N1 p  b$ g/ g( _0 t
19.     for (int i = 0; i < Food_num; i++)
    ! Q! f; q8 t/ A0 L
20.     {
    ) g0 F7 \\" J5 b, M5 X
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)* X9 X# C) q$ Y+ N; F2 G
    
22.       {& y3 x/ P, M; C5 M0 ?( h+ k0 _
    
23.         Enemy[j].r += Food[i].r / 50;
    , m% f8 U. d0 m3 G2 a+ A+ ~* z3 U\" ]
24.         Food[i].x = rand() % Wide_map;
    ' t1 K5 ?1 g; _; E0 t8 V6 Y
25.         Food[i].y = rand() % Hight_map;
    5 e. a0 O- D0 q- W  P2 m/ N
26.         Food[i].r = rand() % 5 + 1;
    6 z! ?6 X, I4 l% p! ?$ ?0 Q1 I5 a
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    6 H% S\" a5 e6 Y( B' u2 R: |
28.       }
    2 ~. ]. R' F# r5 e  m: j7 ^) B! f
29.     }
      ?' m! C( O6 c2 ]6 s
30.     //敌人吃敌人. ~8 R- M) e+ M4 n* q5 V
    
31.     for (int i = 0; i < Enemy_num; i++)
    & @# d( K  j8 ?; W- A6 O
32.     {! F' |0 W% O, B
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    4 r9 P4 b! U! j, _# B1 s/ M
34.       {
    / U$ H' D$ p8 }' a0 f  R
35.         Enemy[j].r += Enemy[i].r / 10;
    , C4 x. j2 R; d
36.         Enemy[i].x = rand() % Wide_map;2 F/ b\" F8 j) T! O9 d% ?5 Z
    
37.         Enemy[i].y = rand() % Hight_map;# V! o; J8 E% q% v- B+ d
    
38.         Enemy[i].r = 10;+ B8 R* f) O* A) p* t+ f9 v\" E
    
39.           Enemy[i].color = RGB(0, 255, 0);
    # i% k/ A& i3 t. D- ]
40.       }
    ' p0 u% N6 c% 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( l2 _4 v/ M( T4 Y9 s$ R
    
42.       {
    ( A& f* ]* S! T2 g6 Y- ?4 N) Y4 x
43.         Enemy[i].r += Enemy[j].r / 10;- _7 \8 k' g9 h/ `( c3 `0 r
    
44.         Enemy[j].x = rand() % Wide_map;
    . M% m# A8 X( ~- D  }3 t2 H
45.         Enemy[j].y = rand() % Hight_map;\" M* q( C, K1 R
    
46.         Enemy[j].r = 10;
    ' v7 v: F/ ?0 u\" ?% |7 D6 w6 O9 L
47.         Enemy[j].color = RGB(0, 255, 0);' u) J5 p' |% n8 ~1 s3 R0 ^
    
48.       }
    , j8 m: U; N9 ~: S4 d
49.     }9 ?( w: F4 |# p/ ~\" T
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)  h5 F+ g; S7 |& [
    
51.     {
    - b/ m9 w. @2 l8 y# }# L
52.       //玩家吃敌人
    3 N  ~# ~3 q' [/ N5 J- Y
53.       if (player.r > Enemy[j].r)! X/ h9 e7 l% b  G1 i: C2 j
    
54.       {: t# d' s% C; }0 R2 j
    
55.         player.r += Enemy[j].r / 10;8 ^* M9 H: M- s6 x. [. b
    
56.         Enemy[j].x = rand() % Wide_map;
    ) v+ j  }8 B+ h3 ^, Z  t6 {, q$ B
57.         Enemy[j].y = rand() % Hight_map;3 X1 A$ D( v\" ]% x
    
58.         Enemy[j].r = 10;
    4 E% K: q9 W- R5 N+ |( ~6 y
59.         Enemy[j].color = RGB(0, 255, 0);: N9 Z% U) B( ]4 T
    
60.       }\" j5 B4 t2 N0 N  T! s# @9 A
    
61.       //敌人吃玩家
    5 b0 J7 `\" F+ R\" ~' t- l9 ]/ t
62.       else
    ' b8 C! ]% U8 C& |
63.       {6 y* ]' x/ W' Z- H3 v
    
64.         if (invincibility == 0)
    6 r  i* `9 G6 {! g
65.         {4 s) d! L/ z9 n6 M% z0 [5 m
    
66.           Enemy[j].r += player.r / 10;' ]- r- v( R+ I
    
67.           player.x = Wide / 2;1 J/ @% n5 s9 R7 g5 h
    
68.           player.y = Hight / 2;
      Z* b' U4 ?8 B9 u
69.           player.r = 10;
    % F/ N- v1 l, b
70.           invincibility = 10;, g' U& E6 O+ p) i4 n. \
    
71.         }$ ?# z+ G. ~/ A) `: D, i1 s1 \
    
72.       }: j' `# d1 e* D7 A1 G/ c
    
73.     }
    8 }1 {4 ?3 [8 [
74.   }  J  |: i5 N6 p6 i
    
75. }

复制代码

完整代码见附件：


- v- g7 P; A9 l. [0 I
: {! ~6 j; D$ ^0 T/ F