球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
0 r% _0 ^; l, O9 `' a
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
/ `/ {3 T" P1 y1 G6 T# x
0 n" m; V  j* b( P; ^游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
, f8 T5 B/ L  W+ w
* |9 L! }9 `1 R' N: v玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
2 f; K# A& f7 [' S# m0 P! B
其他小球：其他小球又分为食物小球，和ai控制的小球

体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
  K2 F1 o; [0 b+ W/ L3 R7 y
. u% e6 D" l4 c; [; \2 C玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
" K( H. p. M3 {: Y5 W* N3 g: R8 g
接下来，我们将通过以下几个步骤来实现这个游戏：
# @6 c( q1 t; s0 ^# q. V
初始化游戏界面和小球的信息。
- D! s# b: M  W# Z1 t
, K( _! ^  m! ?4 A处理键盘输入，实现玩家小球的移动和加速。
( i2 k6 b" G3 _3 K
6 Z! O7 l& w) e/ L- U生成足够数量的食物小球。
  i0 a; y" j2 Y. Z
生成ai小球，并控制其移动。

2 R, u- Y4 e7 o5 `检测小球之间的吞噬关系，增加相应的体积。
! o5 ], \; l2 Y% `$ `4 \4 E
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
5 ~( x5 g4 T% K) C( g
! V" P" v4 b( T1. 小球的要素
" G/ J2 u* D. G$ X在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
- [2 _; Y4 H- Q
struct Ball
{
        int x;
1 B4 R  \- h  b. D% I: e        int y;
9 T2 f0 J+ B- R: U4 r2 f+ Q        float r;
3 P$ W) j5 y6 T6 c7 \        DWORD color;
  y6 w& y9 h3 M' \9 Z. Z7 |0 x4 F};
" {9 y8 s$ a  ~. c) T2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
+ C6 ~9 D0 n* g' C/ e2 Z& \) m
橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
& _6 t, J( B" N, B5 p4 Y. Q0 I绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
( U( J5 f, D. C, b% _0 r# r" H4 X: k紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
5 ^' P5 a* i- P# |/ x白色的RGB值为（255, 255, 255）。
3 U  p( J2 _# {) \+ z灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   0 Z& }) x! N0 a0 H  j3 D( {
2. {
   2 K4 z$ J7 c8 O& ~) l
3.     //玩家小球\" _2 r\" b; Q' d! _+ J: Y
   
4.   srand((unsigned)time(NULL));
   & L% p\" a5 R3 ]8 J# |9 ~1 J0 _
5.   player.x = Wide / 2;
   # k1 \' x4 Q! U! d6 c1 [
6.   player.y = Hight / 2;\" @\" ~! W* |: T% C\" J' r( I
   
7.   player.r = 10;( j- U3 g- J( a+ u& D
   
8.     //食物小球
   3 k& Y  G  w! H5 h0 U/ X; Q\" f2 O
9.   for (int i = 0; i < Food_num; i++)3 S, i4 l1 B0 }! ^
   
10.   {( k- B2 R0 L6 a& Q
    
11.     Food[i].x = rand() % Wide_map;
    8 J6 ?7 _3 b/ ]# W* C: L9 M
12.     Food[i].y = rand() % Hight_map;
    ; H; y\" `: T! l, y
13.     Food[i].r = rand() % 5 + 1;) ?! y  i* j7 @$ L- [+ u
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    5 \& m3 j  m1 x! {
15.   }. ^6 R0 E! Q/ ]/ k% ~
    
16.     //ai小球, C7 `6 i, B5 `( A
    
17.   for (int i = 0; i < Enemy_num; i++)
    ( w2 U& \, E& Y# \# B
18.   {8 O4 R\" t: T8 n
    
19.     Enemy[i].x = rand() % Wide_map;0 i& O\" G* U3 Z/ Q
    
20.     Enemy[i].y = rand() % Hight_map;\" Q4 K\" p$ k3 V1 c5 ?9 H7 @$ n
    
21.     Enemy[i].r = 10;* A5 L2 R0 L( C+ d
    
22.     Enemy[i].color = RGB(0,255,0);
    2 V# p8 d1 b0 A7 \# \# @4 z7 ~\" j
23.   }
    % p! N) q' E: q- a! @
24. 
    : U: \$ {# Z$ F
25. }

复制代码

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

1. void Player_move()- y* s$ ]0 ^6 O( M  P
   
2. {# M; [( O$ b+ E% l
   
3.   if (GetAsyncKeyState(VK_UP))! r9 x- s) h; d3 U
   
4.   {5 Z7 |, {, `- z  W  G+ w1 a  S$ f
   
5.     if (player.y > 0)
     P: e  a! f/ {  i
6.     {
   9 E8 c: d# [2 d( T! B
7.       player.y -= player_sleep;7 D0 C  J\" j# s9 n5 }2 ^( T
   
8.     }
   & G* W. \5 t9 ], ^* Z- f
9.   }8 |# Z( `1 t; T3 {6 i' R/ c( Z3 z
   
10.   if (GetAsyncKeyState(VK_DOWN))' a$ l- Q  [% W: o* Y* T( ~
    
11.   {
    - G! U) j$ F, L/ l; N) H
12.     if (player.y < Hight_map)9 {, v% U; Q5 l. U3 B\" e\" I4 A! c
    
13.     player.y += player_sleep;\" }7 @; \2 w. T# D2 J: ]% q& r6 s
    
14.   }
    1 D7 N* k3 Q! Y. Y
15.   if (GetAsyncKeyState(VK_LEFT))
    8 W! V$ W* g- F6 u
16.   {: d\" R) U7 e8 K$ M2 h0 O
    
17.     if (player.x > 0), J$ s0 z  G2 g
    
18.     player.x -= player_sleep;
    8 a\" b$ h* ~6 P1 y) d! m
19.   }. s8 X% s# L$ l# C' @% f$ ?/ e# _* g
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    0 @8 F* H$ P. E0 C8 i: j
21.   {
    % J+ R7 e8 o& H7 H7 Y2 \
22.     if (player.x < Wide_map)
    , G1 |' ^3 H' s- E6 U$ c
23.     player.x += player_sleep;
    ( r: N% R\" j3 s' J: M
24.   }
    $ V$ D' e0 p! C- h- e! q& h
25.   if (GetAsyncKeyState(0x20))6 @6 p* @6 K\" k9 ^' Q/ q1 e- e
    
26.   {
    / v6 v& C7 ?% m/ _5 y
27.     player_sleep = l + 5;
    \" A6 D) Q3 s* q! O! q$ m
28.   }
    5 I\" k; g* e$ w' u
29.   else
    + t3 y% L4 H' ^
30.   {$ D5 u* K9 L3 I2 i/ |3 w
    
31.     player_sleep = l;
    7 D0 g& I) f0 f+ }& n
32.   }
    \" k0 G8 d9 t  F\" e* T
33. }

复制代码

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

1. void Show()) h; A5 z2 k& C: v5 [/ k- {$ i
   
2. {
   ) S\" R0 j7 a9 i* Z\" `2 W! C- A& S
3.   % T' \3 i8 y8 a/ m+ P
   
4.   //设置地图
   . ?  n3 J0 N0 o( `\" y3 K+ u
5.   SetWorkingImage(&map);
   ) t! e4 M5 ^6 w5 T0 A# T% U7 U
6.   //清屏
   ; V! z& B: Y6 l5 {! f
7.   cleardevice();; X8 V8 z. J, E# d2 q/ m
   
8.   //背景颜色
   ' O5 l% K5 T; `% b+ q  z. [
9.   setbkcolor(WHITE);
   1 P# i2 S1 b* O( G
10.   //划线颜色
    8 A- }* D5 h8 b0 S4 Y
11.   setlinecolor(RGB(230,231,239));- ^5 o+ e+ n5 x* C- J, _
    
12.   //划线
    0 m8 Y0 @) o3 y1 M5 S- S
13.   for (int i = 0; i < Wide_map; i += 10)7 [, M, D5 Y' j6 n2 r5 q+ @
    
14.   {
    . R, |( B; F! N* f
15.     line(i, 0, i, Hight_map);
    * @! T3 a6 y1 [- s9 H7 k
16.   }$ }; [8 O\" o; K2 T8 R- ]; w. d
    
17.   for (int i = 0; i < Hight_map; i += 10)1 O1 v3 e, f) X* J) V2 s7 j
    
18.   {
    ' w, H5 J9 n\" b  b2 Y2 j
19.     line(0, i, Wide_map, i);1 D  m3 \& v- _: \
    
20.   }0 p2 D5 G\" S1 _' S2 v7 O) B; c
    
21.   //食物
    . Z9 k$ {. c5 \4 \  t6 |
22.   for (int i = 0; i < Food_num; i++)
    5 E* d  c2 J$ I
23.   {- t( Z  ?5 A# E( L# s5 A3 Q
    
24.     setfillcolor(Food[i].color);
    & K' U6 s# B2 A3 Y  Z
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);\" ~\" _, |; t0 q* z' m; s# q# x/ v3 C
    
26.   }7 v3 b$ v\" E\" b+ `) ]$ o6 m
    
27.   //敌人0 B: h$ c, O' M8 _6 V+ a( T& i9 m
    
28.   for (int i = 0; i < Enemy_num; i++)
    ; G* r  w/ u8 U4 |6 U
29.   {
    + i7 T5 y1 c1 C) J7 s' {- ?
30.     setfillcolor(Enemy[i].color);
    3 Y6 y8 T* Z# f( D
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    , m: r6 V2 H2 ~% e! {\" O2 U
32.   }
      {, y/ C/ B) h
33.   //玩家# V5 b' }/ N1 M& j2 h
    
34.   setfillcolor(RED);
    5 x- z7 T& Y5 P6 i
35.   solidcircle(player.x, player.y, player.r);( |1 Z' `% [; e+ f7 }
    
36.   SetWorkingImage();9 y: J2 ?2 S- p\" B: a- P  \
    
37. % J  t) T5 Z, ]7 n
    
38.   int x = player.x - (Wide / 2);
    9 g\" v5 P% q. r9 k' J% k7 X
39.   int y = player.y - (Hight / 2);
    ) C& `( ]. L! d
40.   //防止窗口越界
    * f6 Z# _$ F- S. y; ?7 A' k4 t
41.   if (x < 0)2 q7 W, f( U+ ]8 [7 F
    
42.   {; e$ s2 Z+ u& v! W9 o8 T
    
43.     x = 0;5 m+ x! l( G# d\" a5 a
    
44.   }& _. G. W. c, h+ Z% m
    
45.   if (y < 0)# X8 H6 Z5 M% |4 g$ P; l
    
46.   {
    0 ]% p+ F4 @' |* V1 p3 A4 z4 S
47.     y = 0;9 d$ r/ x9 B. J1 z( s
    
48.   }. y* n! l+ }% T$ Q
    
49.   if (x > Wide_map - Wide)
    ; z. X+ v* L3 v
50.   {  m2 g* w- J! p* H
    
51.     x = Wide_map - Wide;( F$ D0 T6 ?! [
    
52.   }
    ; _9 F/ a\" I5 Q, o
53.   if (y > Hight_map - Hight)9 E. w+ x1 [$ ^\" O! B! h
    
54.   {; W/ b6 l/ D/ t
    
55.     y = Hight_map - Hight;
    ! c0 E' I, f0 Q* a3 s% o
56.   }\" b2 F% o' x) L% X6 [1 s
    
57.   //把map输出到窗口上
    2 Z2 F' w/ j3 x2 k
58.   putimage(0, 0, Wide, Hight, &map, x, y);  L; B# D7 \/ K4 O( p  X! j
    
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. //防止窗口越界5 H  Z- r, x4 J: g% O: f
   
2. if (x < 0)
   / \4 S- m' E, _
3. {
   ! i; s$ G\" k& S8 d% X, J$ e
4.   x = 0;
   3 ]  m4 g+ ]8 C8 D; t
5. }- ^5 b* W, w8 H& [9 D* O% g
   
6. if (y < 0)
     d: ~! V! [7 D8 }\" f- y+ C5 ?
7. {
   9 {9 Z! c8 c; N: J9 r! p3 Q& y
8.   y = 0;
   % G1 g# q2 s9 g2 ]
9. }& \  W% e9 t5 H4 Z' b; c& k
   
10. if (x > Wide_map - Wide)
    - g' F( _* R$ U4 n; z3 ]- R' @% u
11. {
    4 K& J7 H  z- g9 X
12.   x = Wide_map - Wide;; a2 A\" |# u3 O( L5 ^3 x* m+ J
    
13. }( t( D; V7 ~$ C
    
14. if (y > Hight_map - Hight)\" D, s3 i& S! h2 q7 S$ d\" V
    
15. {( O0 _8 C6 o1 W
    
16.   y = Hight_map - Hight;
    ! m\" M) S+ J& |$ f
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
0 |4 O& N; X8 a/ X+ Z! E. Y
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
( y' r, p; m0 i! O+ x: p0 L
Wide：这个参数指定了要绘制的图像的宽度。

* S) H6 \3 S1 @Hight：这个参数指定了要绘制的图像的高度。
; J. \# R& s5 I( L
' a) Y. g% o3 J- x! Z&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
- W  O5 e4 @0 n. V, R' I
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离1 `* A. e# Y) E$ u4 k$ W
   
2. int Distance(int x, int y, int x1, int y1)) T2 s5 v2 e  n8 C
   
3. {
   ; i! F$ S+ Y* u% a; m: X4 N
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   \" R\" E! e* H! l# w3 U
5. }

复制代码

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

1. void Enemy_move()
   & Q' ]7 u3 z+ W* S+ L: I
2. {+ N. x5 G! |6 \9 [' v
   
3.   srand((unsigned)time(NULL));
   ) P% S7 c! B3 x; ~1 W
4.   for (int i = 0; i < Enemy_num; i++)
   - |/ V! h! M. z+ ?  |* p  c1 d
5.   {: g\" F% a8 ^2 v5 {  w7 F\" r
   
6.     int direction = rand() % 4;\" Y( j; k/ B: i9 ~3 s4 t
   
7. ' }% W: }$ u; g6 [) `
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)5 P3 S# x1 s1 q\" j9 p  X- A
   
9.     {
   ; n3 z1 F( y( q0 p) K
10.       if (direction == 0)
    ! k4 n7 j1 L# V6 L! b! P
11.       {
    7 b. Q6 ^: I* Y% @9 _
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句- S: I9 s: a! F6 S  L6 T3 f# ~: ~0 y( H\" m
    
13.         {1 d# |$ @$ V: L4 o' ~2 n! h
    
14.           Enemy[i].y -= enemy_sleep;
    & X5 {4 M+ }6 Y+ B! K
15.         }9 G  Y4 T* I8 X1 u) C% e3 G) t: z
    
16.       }9 ^5 n% m' W% q/ L1 Q- X$ N
    
17.       if (direction == 1)6 V; u, g# Q. z, \7 z' z\" D9 N( T' s- g
    
18.       {
    0 @* i# B' _' J
19.         if (Enemy[i].y < Hight_map)
    2 o' a8 ~6 @' i. W\" x* i
20.           Enemy[i].y += enemy_sleep;\" w* ?5 }+ @) {+ |
    
21.       }
    6 V6 J  H/ Z& h; u& S2 ]
22.       if (direction == 2)
    9 @9 X& d! _) D: M/ |
23.       {
    ' e. {# _% `. m; J* `. B
24.         if (Enemy[i].x > 0)
    0 c) V/ y/ O/ a% M, B( U4 i) O% t
25.           Enemy[i].x -= enemy_sleep;
    1 a. x# g5 e! B7 t  [# @' d* e7 l
26.       }
    . n5 `/ ]3 {- O( J0 B  o( i
27.       if (direction == 3)
    9 F! S$ I% E* q* b& D1 R+ E. ?4 \. @
28.       {5 l\" r  X; R5 ?% @: j
    
29.         if (Enemy[i].x < Wide_map)
    % Q$ q( ^$ ~7 T
30.           Enemy[i].x += enemy_sleep;
    9 w. [7 }6 b( w, n. K. }  y* S
31.       }
    # n1 X5 C% |. A8 D
32.     }, t! w$ u# z; A$ m
    
33.     //敌人追击玩家, [6 }5 P: K6 f. O\" n, ]
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)( {. \6 B$ P: ?7 Q: z
    
35.     {# u! j4 H6 c  N* y* e+ [# P
    
36.       if (Enemy[i].r > player.r)
    . ~5 O# c3 ^' w9 y2 s, V\" U5 H3 f
37.       {
    / L7 ?. E3 s! S
38.         if (Enemy[i].x < player.x)
    0 _5 ]2 H+ |# C' d2 K( u0 X
39.         {3 {7 p, Q) l& k% a) E3 D
    
40.           if (Enemy[i].x < Wide_map)
    5 R0 \7 Q5 i) E$ }2 S3 O9 R
41.           {
    . A\" C* n2 v4 x( g$ N
42.             Enemy[i].x += enemy_sleep;
    7 Q1 v' {* w* J! H0 M8 W
43.           }  s  |3 d8 w8 C) U/ T# s5 R
    
44.         }
    2 ?* B5 _# V/ o6 w
45.         if (Enemy[i].x > player.x); L$ T\" H# y) ^0 N, a
    
46.         {5 q6 v5 Q7 R( _9 j; Q
    
47.           if (Enemy[i].x > 0)
    . ~# y\" N* F, x2 ?2 v7 ?5 |1 }2 N2 ?' u
48.           {
    2 P5 W* Q  K7 W( w
49.             Enemy[i].x -= enemy_sleep;3 |5 ]' s6 u4 G/ e% Y
    
50.           }\" q% v% [& K2 ^  K. T
    
51.         }7 s8 P$ Z\" A: P1 w) [
    
52.         if (Enemy[i].y < player.y)- x: F* i. X4 R0 q. r
    
53.         {2 V# N% x# W& a+ r2 }) Y# _
    
54.           if (Enemy[i].y < Hight_map). W' Z- G% X* `2 x/ S: p2 u' P* K
    
55.           {7 d  y3 T- c6 |/ j1 ^7 E
    
56.             Enemy[i].y += enemy_sleep;
    0 J& x. g2 m4 c\" q  _/ d) M( [
57.           }8 W  o/ W+ U# M: u, {; x\" W; C; Z
    
58.         }/ X) c  r& q9 i0 N( n/ B4 |
    
59.         if (Enemy[i].y > player.y)# d! S' Q- N$ b+ E( h# a3 g
    
60.         {
    : Z2 g5 |6 v, @4 d5 X\" V
61.           if (Enemy[i].y > 0)
    3 q4 ]/ h7 x- n0 J# d  n# z8 U
62.           {
    \" F. W- s* q' S5 L* U
63.             Enemy[i].y -= enemy_sleep;
    3 H/ ]2 O' q\" H3 {) W  E% q
64.           }
    4 G$ A1 u: K( ~$ M2 [3 \5 Z
65.         }! E\" `7 H1 [9 A: V4 J
    
66.       }2 t8 @! P- f8 ?2 W$ e. \
    
67.       //敌人逃跑9 ]- y& L% R- x% t8 [\" X
    
68.       else\" {3 r- x9 M! C$ D0 Z- o
    
69.       {6 c1 u  M, [4 s# f
    
70.         if (Enemy[i].x < player.x)0 `) V$ d: O, b3 f$ o
    
71.         {6 R4 V+ \( M5 x\" }7 Z; {\" s
    
72.           if (Enemy[i].x > 0)
    2 q\" _. s* z6 z. _$ J. F! E
73.           {
    ( A* o# A  x( N9 ?) v( q4 z  b
74.             Enemy[i].x -= enemy_sleep;4 o- C\" X7 x$ }- e9 ^) O
    
75.           }; e# n. S/ g* Z; N5 u) n. W' q8 M
    
76.         }( U7 Z* r. J, P8 ^$ w0 i: U
    
77.         if (Enemy[i].x > player.x)2 N& K+ A2 o* o: o. I
    
78.         {% }2 j- S4 k/ p
    
79.           if (Enemy[i].x < Wide_map)) g( y; U( f8 i5 Y4 X
    
80.           {
    , F\" |5 v+ i9 |! f1 z+ d, P/ l
81.             Enemy[i].x += enemy_sleep;1 m! I5 E# D) v! m
    
82.           }
    ' m1 O1 y, a* u
83.         }
    ; ]9 p\" }2 p3 c$ i9 E& K
84.         if (Enemy[i].y < player.y)
    ' h, X7 R. F- S$ ?3 @8 n
85.         {% D1 x7 [9 H, t- h# Q. z4 H+ N$ g, i
    
86.           if (Enemy[i].y > 0)1 F4 L$ T6 m- o, P
    
87.           {/ K! b- i* r1 e' m  H6 k
    
88.             Enemy[i].y -= enemy_sleep;
    , J  e+ p0 I' @/ z
89.           }
    9 N- T2 r+ G, C4 X
90.         }
    5 l0 o  \& P  L3 U% r# d8 n3 U
91.         if (Enemy[i].y > player.y)* t: y( b& R! m+ U
    
92.         {
    : i3 a6 ]* y. J* B
93.           if (Enemy[i].y < Hight_map)) c6 Z2 a9 k+ ]8 Q
    
94.           {$ u6 U0 r8 o) t! k( l$ _* ]* ^
    
95.             Enemy[i].y += enemy_sleep;\" e7 o* W5 N  Q4 |7 M
    
96.           }: Z, o9 w/ i\" p/ P$ `' j2 b\" r
    
97.         }
    7 a5 }9 P+ M' i5 [, \8 r; {
98.       }' ]% @) h- V( b, ?* q! j4 V
    
99.     }
    6 ^9 J0 @. j\" Q9 j2 |  L- E8 Q
100.   }
     ( ~9 F: D5 k\" s$ A
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   ! U8 g6 n+ C7 r+ |/ d% w$ Z
2. {, m9 Q: @+ z3 x& q9 n\" u
   
3.   for (int i = 0; i < Food_num; i++)- b, ?; T4 l7 I\" v7 i
   
4.   {
   - @2 P7 y; o, `5 U+ e- q8 y) m
5.     //玩家吃食物* K& {\" F: C; N+ ?( U( D, Q
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r): [: V# r. ]$ O
   
7.     {5 Z' C( x1 z# k  a6 Y3 X
   
8.       player.r += Food[i].r / 100;7 [9 p7 R8 e9 `7 N
   
9.       Food[i].x = rand() % Wide_map;$ ~* d4 c2 U+ q  U& z
   
10.       Food[i].y = rand() % Hight_map;. H6 m. S0 A0 k- N. k  ^
    
11.       Food[i].r = rand() % 5 + 1;9 K3 D) S& y8 E1 [- B9 [
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    8 T: u4 K( J2 k% M4 N2 ^# P
13.     }
    . R0 s$ t& c. K8 M
14.    
    2 W\" D7 O; d5 D) [! Q9 U( _
15.   }
    6 E0 D1 R. O4 A\" D# j# |
16.   for (int j = 0; j < Enemy_num; j++)
    & F) i2 K) m- I# Y: W$ `, ^# }# e
17.   {: N' _' C. B5 E) B6 B7 R# j+ E# M
    
18.     //敌人吃食物
    . d( o, W9 D0 n' Y% h( \9 X1 d
19.     for (int i = 0; i < Food_num; i++)
    2 ]\" E, T. }5 ]
20.     {% v$ j5 N9 r* `  @1 Z
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)/ s  Y  V8 N; g! K4 P8 U
    
22.       {
    0 A! y* S2 ~/ z/ O: h0 W  \
23.         Enemy[j].r += Food[i].r / 50;\" c  b6 F& y0 f) i6 ]) }( ^# ~
    
24.         Food[i].x = rand() % Wide_map;\" T8 k) J. F\" e( A
    
25.         Food[i].y = rand() % Hight_map;* U0 j1 s/ E) k, \
    
26.         Food[i].r = rand() % 5 + 1;
    ) P4 m, ^: S+ P! i$ W' H
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ' W7 {8 ]% L\" Z\" F: K
28.       }
    * Z* ]% O& R& v: x\" K8 T. d* K+ R
29.     }
    - a, h) n; Z8 L! h* _
30.     //敌人吃敌人
    ) v9 U' V5 i# V; f
31.     for (int i = 0; i < Enemy_num; i++)
    8 v3 G* m$ {9 j1 @
32.     {% }% K8 s; t7 P* G' [4 g# I/ P
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)9 \  s4 ~5 b' e4 _5 |/ D& J: R
    
34.       {
    7 Y7 ]8 w% Y2 u% K  y
35.         Enemy[j].r += Enemy[i].r / 10;
    4 j1 j( O, U5 n1 _! U
36.         Enemy[i].x = rand() % Wide_map;
    3 B+ y# h; g, w) A4 {% z
37.         Enemy[i].y = rand() % Hight_map;
    & A8 I& j' q/ Q5 E& n
38.         Enemy[i].r = 10;- \& A* ]- M/ Z; [7 s
    
39.           Enemy[i].color = RGB(0, 255, 0);
    ! n% j* G8 y8 t9 e3 i6 Z8 z: V
40.       }# C7 e, T! y5 R# x) X
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)0 c- N9 X! O+ c1 f' Y
    
42.       {\" K& r; f\" Q  q' f' y
    
43.         Enemy[i].r += Enemy[j].r / 10;9 G6 F: b& J: h8 M, U
    
44.         Enemy[j].x = rand() % Wide_map;
    6 B! d# Q; u, M2 g3 a
45.         Enemy[j].y = rand() % Hight_map;9 `9 ?9 S2 `) w
    
46.         Enemy[j].r = 10;5 |+ D2 u( e/ R
    
47.         Enemy[j].color = RGB(0, 255, 0);  G) W+ Q9 N( J. H% O' F* P
    
48.       }2 Z) v( y' q; n+ E9 L/ |0 s6 F+ h6 B9 C
    
49.     }5 s9 ]4 u: s# H. r2 m. b0 [* t  \\" i
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)\" w+ I- z6 x6 r
    
51.     {+ k8 F$ B\" H8 D& C
    
52.       //玩家吃敌人7 C$ r! u6 K: ?\" m$ z& [: Z
    
53.       if (player.r > Enemy[j].r)+ `3 }9 [& H7 e& {. d& v3 t
    
54.       {
    + P& l: s/ `6 U( [5 |
55.         player.r += Enemy[j].r / 10;
    , s7 Z5 h: O; }$ Z) X! @# ?: w
56.         Enemy[j].x = rand() % Wide_map;# \5 P8 K4 I) {) K6 `9 Z- V1 O
    
57.         Enemy[j].y = rand() % Hight_map;
    6 E/ v; J0 E0 Y$ c+ `0 u/ V
58.         Enemy[j].r = 10;- V8 h0 Y+ p& p4 a( u
    
59.         Enemy[j].color = RGB(0, 255, 0);
    & N& z\" i4 s6 o% A) b6 N
60.       }' {, `- K' |- B3 D* v9 O
    
61.       //敌人吃玩家' M8 V) M1 Z& T2 k
    
62.       else- ~: }4 F$ m% v  T! k
    
63.       {
    / K% h  i\" E$ D) `1 S
64.         if (invincibility == 0)1 j- ^; D3 D\" w4 I
    
65.         {; _1 S\" X\" |\" ]
    
66.           Enemy[j].r += player.r / 10;# _0 J( D, N\" R5 `
    
67.           player.x = Wide / 2;; }0 d; K\" e8 s\" D  O% U
    
68.           player.y = Hight / 2;
    , B* \' M) y3 q7 N% x8 C3 S6 p
69.           player.r = 10;
    , K- W2 ]) p7 p  y2 A( t
70.           invincibility = 10;1 i8 S% G: Z3 _$ W9 A4 c\" x
    
71.         }# \7 b+ Y\" U. O- C
    
72.       }\" {* h& L# r: H9 }9 k
    
73.     }
    2 C- s8 V8 x/ K6 J
74.   }
    - I5 F! `! Q2 {5 v
75. }

复制代码

完整代码见附件：
5 m# B* L7 o  B  f  n
' i' f9 T% t$ g$ S2 _6 q