球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
' H: ]& X; d" K2 G: [  ]. {( b
3 a$ L! i) X" z0 P- `" u在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
+ ]; u5 U* e$ ~: e* _2 K; c0 t
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

& \" U6 }. ~9 d其他小球：其他小球又分为食物小球，和ai控制的小球

6 U: j6 s/ m) f% z. `体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
* a: ]% M- B- r3 ?. O0 C% l1 S
# P  l& C' w7 C6 ^& t  m玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
* r, ]7 R) E3 Y, Q) F! X. `
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
9 p+ ^9 q3 M; O7 I+ L5 N
5 a* {/ x1 a2 Q1 E" z接下来，我们将通过以下几个步骤来实现这个游戏：
% U4 b- g4 |( O6 @
初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。
7 d2 {$ B2 V7 e
2 Y8 j# g+ {. f4 A- m生成足够数量的食物小球。
1 l5 o% y% \6 z+ R& F4 O/ o0 a; }& V
6 q3 }$ p1 V% D# k2 S生成ai小球，并控制其移动。
7 n! v4 ~  k8 y
9 m9 ?: ^4 y" J. k% ~检测小球之间的吞噬关系，增加相应的体积。
4 i5 G4 h  z& }5 [0 R3 K" t
" `7 b% g/ j2 B- ?6 N  Y通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
/ C1 g5 g. t  C  J
1 Z/ V" i" G7 U2 x) o/ e1. 小球的要素
+ G7 X: Y+ h% }在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

. Z6 x7 r6 V5 O' `& F4 c1 L; ~struct Ball
{
: u4 N) @: U, H' a0 s' ^+ o        int x;
        int y;
& |. [4 p/ l# Z        float r;
        DWORD color;
: m! S6 }3 T5 X3 K};
2. 初始化小球的信息
  }, a$ B+ q2 N# C将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
) q$ L/ b" Q' O4 c2 n* J
) H. a' q- l6 a9 g9 q0 Z# ~: aRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

" H9 R; I  h) u2 R/ \# h橙色可以通过RGB值（255, 128, 0）来表示。
& y- X! C& k4 q+ |9 E8 n! ~黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
2 m. d4 \4 y! U+ ]' F3 P0 r" h. ^. X紫色可以通过RGB值（170, 0, 255）来表示。
5 ?' v' V9 M8 `8 r4 U黑色的RGB值为（0, 0, 0）。
) l* ~7 ~  W3 X7 }. G3 t白色的RGB值为（255, 255, 255）。
  ^/ A- \  X5 E灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()* C5 I4 O3 ]$ |8 N
   
2. {& a9 T3 j, |2 v& h, N
   
3.     //玩家小球
   4 {0 p4 U6 Q9 V( P& Z! @
4.   srand((unsigned)time(NULL));
   7 b6 O1 a7 I0 I' ]; z
5.   player.x = Wide / 2;
   7 }/ a5 E9 |  N6 Y5 j
6.   player.y = Hight / 2;% Z( j# o4 p$ s% Q$ M2 P
   
7.   player.r = 10;
   0 D' `/ a- i* ]' [: z2 v
8.     //食物小球' v1 V8 P+ v5 q5 g9 ?\" p
   
9.   for (int i = 0; i < Food_num; i++)! i) L& n, |* N& l) g0 t\" T
   
10.   {
    2 b& ]+ Z2 y. i: q0 ~3 \
11.     Food[i].x = rand() % Wide_map;
    0 }; a, j7 j) l6 H
12.     Food[i].y = rand() % Hight_map;8 S0 u6 s* c; t8 _  W* V+ h
    
13.     Food[i].r = rand() % 5 + 1;
    6 I\" a% D  z* J! C7 @/ g
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    1 [# q- M6 r' @8 X
15.   }: S: P! T7 R8 f
    
16.     //ai小球1 O0 D0 a7 M9 u( ^
    
17.   for (int i = 0; i < Enemy_num; i++)
    # s4 z+ S) [, y7 a/ V
18.   {* S$ P3 I9 q) z) b# `! w! L
    
19.     Enemy[i].x = rand() % Wide_map;
    + {6 m# q6 o! O
20.     Enemy[i].y = rand() % Hight_map;
    - J, P7 n2 P* D$ A  c
21.     Enemy[i].r = 10;
    ! @3 j( p# ~+ g3 a8 m7 m, b( [9 C
22.     Enemy[i].color = RGB(0,255,0);8 e) _7 T4 a( p' U# @9 l0 R4 ?3 ~% s1 o
    
23.   }
    # X, B1 s7 W! ~1 O
24. 
    \" @0 M' O8 W0 }6 B% x
25. }

复制代码

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

1. void Player_move()5 P\" D8 ^! e( [- e7 }
   
2. {
   4 U2 J0 B, p7 K9 U
3.   if (GetAsyncKeyState(VK_UP))
   + q5 @& g! J& \, R8 F6 Z
4.   {
   : @' M2 }( W% l6 u- s1 t
5.     if (player.y > 0)* f+ P( Y  U, h5 B; a
   
6.     {2 Z7 x( ?9 E6 Y3 z& K' n2 Z
   
7.       player.y -= player_sleep;( [! c; \, {; p2 a
   
8.     }. y6 }# V: @7 u6 N8 B5 |1 _6 B: v3 G
   
9.   }- j0 d' v; j3 E* z3 t  w1 |3 U
   
10.   if (GetAsyncKeyState(VK_DOWN))% c/ h5 ?. g% K7 [  X- Q1 n
    
11.   {) ~  p$ M8 M: k2 D
    
12.     if (player.y < Hight_map)) y5 j6 h' @7 @0 O* {8 ?9 k7 \
    
13.     player.y += player_sleep;* x! m/ c4 F. Y% Z  G! F- `
    
14.   }+ |# y5 j, p\" s  M9 K( W. m% W
    
15.   if (GetAsyncKeyState(VK_LEFT)), `  w! k5 ?: `/ x9 [
    
16.   {
    ; u6 {+ z; O. M6 n9 A; ^8 J
17.     if (player.x > 0)& q# W( w5 Q# t! L: a9 @2 j- K
    
18.     player.x -= player_sleep;1 I+ t0 X* P$ V  k. c
    
19.   }! W& x3 e% w7 x6 V6 z\" [
    
20.   if (GetAsyncKeyState(VK_RIGHT)); f: v* u1 N/ R1 K
    
21.   {! H: U) L8 g/ I2 p. M: W6 I* S* g
    
22.     if (player.x < Wide_map)
    2 ]4 p( `2 h- I: ?* C4 b4 S
23.     player.x += player_sleep;; Z, L* F3 o, U3 }/ Q
    
24.   }
    4 f  N6 K- |1 u  A  H. {* {
25.   if (GetAsyncKeyState(0x20))6 `3 X  N4 Z2 M5 G6 Y$ E
    
26.   {) E% ]\" w5 v0 }: \
    
27.     player_sleep = l + 5;' R4 k* c7 S2 J7 g! e
    
28.   }' ]9 A) N* P. |/ t
    
29.   else
    8 E( f/ L7 C\" m* x' @/ J' \
30.   {9 c# R5 ~& s2 _4 J\" v+ w
    
31.     player_sleep = l;
    $ c( x1 I0 J\" F. k! e
32.   }
    8 u- L/ s0 F1 `0 k  w( |! J
33. }

复制代码

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

1. void Show()4 `4 c+ d. k* x4 a( C2 B
   
2. {
   # J- C4 x, j* K( t
3.   
   \" w6 ^( ^, _% ^* u3 d  s$ E
4.   //设置地图
   5 i  m% T2 @3 c7 ^, p& D6 c
5.   SetWorkingImage(&map);
   \" M3 O8 s, A\" Y5 D- }. `/ n  k
6.   //清屏& B  Y3 T! B% M: @) \0 s7 k. K
   
7.   cleardevice();
   : ]; ?: a( }4 r% \5 s
8.   //背景颜色
   7 P* x  a7 O' N: i6 G: S
9.   setbkcolor(WHITE);0 W8 N+ R/ B! W( M1 j4 o6 {
   
10.   //划线颜色
    ! R/ u3 P) w8 w. E0 q( \
11.   setlinecolor(RGB(230,231,239));% G& i4 i, R* v$ U  n. `
    
12.   //划线
    \" M+ q% I# S% `0 Y( c( {$ \
13.   for (int i = 0; i < Wide_map; i += 10)2 x- Y0 J5 E) y# ]/ h\" o* _
    
14.   {
    - d8 \: @* Z\" k3 `$ Y; ]+ ?
15.     line(i, 0, i, Hight_map);: `/ j! q, z5 Q' U
    
16.   }
    3 O+ W+ G2 L# [  }  V
17.   for (int i = 0; i < Hight_map; i += 10)
    3 ]! l1 T% y  C' }. v) j8 R
18.   {# p' p\" U3 }/ k( H
    
19.     line(0, i, Wide_map, i);2 g5 C* D. f\" p7 D* y
    
20.   }; G- `5 N7 D\" Z/ U0 {9 }; f
    
21.   //食物$ |/ [  I. k+ {8 U
    
22.   for (int i = 0; i < Food_num; i++)2 p9 w# H+ S6 _
    
23.   {
    + S2 |\" N0 F3 a
24.     setfillcolor(Food[i].color);
    \" E5 `) z. e\" X: h& ~! x* I
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);+ Y) J% L7 X2 q9 h
    
26.   }
      n6 j/ \& ^8 y$ _0 f
27.   //敌人
    - d& w\" z! |/ q\" E
28.   for (int i = 0; i < Enemy_num; i++)/ ]' {! \' q1 I7 e) p1 C2 z
    
29.   {
    5 Z# X% U; \! [/ T
30.     setfillcolor(Enemy[i].color);
    4 X# V6 V0 L5 q2 p' W+ v
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    % J# Y6 K2 I% J- x
32.   }
    - v/ Q! E& W5 {  s6 M
33.   //玩家
    \" {! |0 }* x2 J9 @: D5 c( h1 ~
34.   setfillcolor(RED);( |1 k: f$ K( @* Y
    
35.   solidcircle(player.x, player.y, player.r);
    5 v& Q9 ^* I7 S  y+ u/ [6 d
36.   SetWorkingImage();
    $ i3 d1 W# `% Q, a9 i' `
37. 
    - {+ Z9 f& w6 z. u0 h6 v; e) t
38.   int x = player.x - (Wide / 2);/ O, v\" I$ U; Y! F2 g' e
    
39.   int y = player.y - (Hight / 2);; g) A1 Z\" G/ U( A7 H  B
    
40.   //防止窗口越界0 U' }2 q  M9 y
    
41.   if (x < 0)! C* V\" g- ^$ F' f- H
    
42.   {
    % H, A8 @- c1 N2 c) D  m) A2 J
43.     x = 0;3 A7 J+ a  o+ U2 _* U
    
44.   }: i; z* G+ G6 B6 a
    
45.   if (y < 0)
    ! g5 Z1 x) |5 U7 K* O0 n3 L# I1 n
46.   {  E; y' o- N0 A) k2 y
    
47.     y = 0;
    & L# F% R6 e4 P# I4 ?( N# b
48.   }/ I$ G6 w1 V  I2 \: ]
    
49.   if (x > Wide_map - Wide)
    % l9 }: a# H, B9 |- q/ d5 n+ A
50.   {
    - Y. Q* j- b0 R  P- r
51.     x = Wide_map - Wide;) {4 p0 s! L) p7 o
    
52.   }
    $ c\" ?0 _+ C+ L
53.   if (y > Hight_map - Hight)' c7 p8 j  T8 P0 I7 r
    
54.   {% z0 _5 y\" {$ [) s7 h/ @# S8 j
    
55.     y = Hight_map - Hight;4 z, e: o8 l0 C- J
    
56.   }
      c  E2 |! W3 N3 m5 `! c
57.   //把map输出到窗口上
    5 t6 O& m6 F4 N& `1 h; I* a
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    2 ^\" F& b' j4 H: f
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. //防止窗口越界: B: o( @- U7 R3 H5 `$ c
   
2. if (x < 0): q# g) t8 v, v- F! x2 r
   
3. {* n) q/ o$ h' {* `! O5 w9 L( C
   
4.   x = 0;
   , [8 {9 p# _8 a5 p5 c* U
5. }& @2 N7 z5 W! }; n7 [7 r
   
6. if (y < 0)% y' j+ u& e+ `5 y. S: {; T8 s
   
7. {; U# [+ T# V  m1 x) H/ t
   
8.   y = 0;% V9 v1 ~$ I0 ~5 f) J
   
9. }
   9 O+ x0 |1 }. I1 Y. D' y) n* z
10. if (x > Wide_map - Wide)& [: K\" g8 e8 y% c- ^) ^1 R$ l7 k
    
11. {
    5 z) g' N7 b' E
12.   x = Wide_map - Wide;
    \" S: k8 j2 Y  ^0 |6 m! F3 I
13. }  x- {) B8 m* u( D9 e: z
    
14. if (y > Hight_map - Hight)/ q  c7 K7 P5 H7 G4 s& O
    
15. {
    ' W8 `5 e+ ^6 y1 `
16.   y = Hight_map - Hight;
    : ~9 M. i* H. {' A* ^* g2 o
17. }

复制代码

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

(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

Wide：这个参数指定了要绘制的图像的宽度。
, _1 P0 O* I1 m1 W' V
! [/ ^+ f8 L- X2 ~/ [* l2 xHight：这个参数指定了要绘制的图像的高度。
0 s# B2 b& ^% |
! d4 D2 b, C- \: O, \/ O&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
5 s$ G. \, y  H1 T% {* \) L
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
0 B* I7 R) k0 c$ A& M5 H9 v% A( o
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
5 o) {% _; R" ~/ l& ?, T( s9 m6. ai小球的移动
/ a9 k+ Q4 ^& G2 Q  Y1 o: R随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   % E3 p4 b% }' F
2. int Distance(int x, int y, int x1, int y1)
   9 N: M+ l& G( d2 b: b, B
3. {\" i2 v4 P# J7 X4 v
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   $ t6 U1 g4 X, t& e& q& V5 u+ J
5. }

复制代码

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

1. void Enemy_move()
   8 O- B2 G. ~( z) K$ z; k/ H( ], K+ c
2. {
   5 P$ b3 D7 S# L\" X: Y\" f
3.   srand((unsigned)time(NULL));
   # d% E\" n5 h5 B. h' R
4.   for (int i = 0; i < Enemy_num; i++)$ @2 t. Y6 H( |# }9 o9 h4 [: i
   
5.   {
   + Q) Z- ?) `/ j0 c* B
6.     int direction = rand() % 4;
   5 w2 ]0 C) I6 h- l% ?( N# V/ K
7. 
   \" w! o! T* A( K# c
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   ! H0 C- ~! ?& C
9.     {
   * ^3 {( B4 y( [3 l) X8 Y; t+ X! K
10.       if (direction == 0); d' _3 K, J5 u\" q! M& Q+ A8 S
    
11.       {, P. l: Y/ G- A1 v% _- U\" M
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句9 w\" |1 F4 J( x0 v, U8 l+ J
    
13.         {7 [( a9 S( G4 m1 C
    
14.           Enemy[i].y -= enemy_sleep;& ?& ?! X  @3 z- [
    
15.         }& N+ x( l' i# t8 n
    
16.       }
    , R: q9 ~# Y& A
17.       if (direction == 1)0 E: ^2 Q1 f* u' ]1 h
    
18.       {
    / U$ |- o5 y) p+ }' |) J8 y
19.         if (Enemy[i].y < Hight_map)% M/ o5 b6 w1 J\" _\" ~\" C7 t
    
20.           Enemy[i].y += enemy_sleep;' u1 M* J7 E1 p; s7 h. |
    
21.       }5 J5 q% e$ U0 @7 Z
    
22.       if (direction == 2)$ Q8 Q1 W$ R* Y7 B6 e; Y% J6 {# }
    
23.       {! Q: w; y) M0 G7 d& b. j, ~
    
24.         if (Enemy[i].x > 0)& a( l  B4 v( ^4 v, I
    
25.           Enemy[i].x -= enemy_sleep;) H: B$ x& w( z
    
26.       }% g7 h* o# \, ?+ v\" K& U! F0 q
    
27.       if (direction == 3): K1 z* E, |0 g5 U! }
    
28.       {1 G+ m# H1 _2 K& V1 _
    
29.         if (Enemy[i].x < Wide_map)
    5 }( b3 r' F7 c6 z+ {+ {
30.           Enemy[i].x += enemy_sleep;
    , h, e7 V2 P8 I6 m7 n# r! X+ ~
31.       }
    2 I$ Q4 c! C: n! I3 C) S
32.     }
    + ~( @* ]( Q. r8 [( i3 d) V
33.     //敌人追击玩家
    ! E: s. S, Y\" s$ ?& _5 F! _
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)& \1 ]! D: H$ b/ z2 {0 L- k5 y+ J
    
35.     {% P2 d0 a, D$ W) Z5 H1 o
    
36.       if (Enemy[i].r > player.r)0 i5 I( _9 F1 t\" M% B1 U
    
37.       {
    , ^$ J- ?* q, _; r7 L& |
38.         if (Enemy[i].x < player.x)
    ! h3 Q0 R3 X5 C\" h
39.         {3 `' {* }\" K: m5 l$ p, {  q- A
    
40.           if (Enemy[i].x < Wide_map)
    7 `$ S0 M7 @' H, p
41.           {
    ! v8 A. Y* A. s- e/ y7 Q' x+ X' X
42.             Enemy[i].x += enemy_sleep;+ v% T6 x/ z+ O6 m# a8 q0 _8 W
    
43.           }
    1 Q& z& ^% j3 \! F/ R) W6 _
44.         }
      a  |! j. _( L' s
45.         if (Enemy[i].x > player.x)
      _: X* h* }  T8 v\" v
46.         {
    5 }$ X1 A4 o\" H: |/ o
47.           if (Enemy[i].x > 0)
    \" B8 J) `, i# h+ m! l! [4 G8 i8 a
48.           {
    # e$ w) f( m& y) T1 l- Y5 X
49.             Enemy[i].x -= enemy_sleep;
    9 ~- e' P& }- x- \+ N4 U5 W
50.           }; j0 p7 e8 y! Q  a/ F) C% t
    
51.         }0 V; ]5 F2 ^# B5 c
    
52.         if (Enemy[i].y < player.y)  k8 R6 R\" ^* i# O2 E
    
53.         {
    8 I3 ~/ U0 Q, r  L2 Q
54.           if (Enemy[i].y < Hight_map)# z. }$ O1 n0 B0 H0 G
    
55.           {
    - q/ A4 i  F& g8 [2 |0 ^
56.             Enemy[i].y += enemy_sleep;$ }5 [6 N! r6 r1 P% N& ?9 o
    
57.           }
    7 X/ c/ k7 _' a! m
58.         }
    ' X: S/ V. y* s& Z7 q+ z
59.         if (Enemy[i].y > player.y)
    * w$ [\" Q0 R- S& C
60.         {
    # q& r4 U  m( z\" R! L
61.           if (Enemy[i].y > 0)0 q# ]  T' i3 }' L: k
    
62.           {
    % `1 b) q1 m0 Z% {' D
63.             Enemy[i].y -= enemy_sleep;
    ' a. _) O8 ]0 ?$ d- \
64.           }7 l, e5 d& ]$ ]* m1 M
    
65.         }6 r. F+ U! t* ~/ _# ~- p' g( Z7 S1 A6 Q
    
66.       }
    ' e& W3 Z. o! s& V$ K: l
67.       //敌人逃跑# T4 p! H: |# ?/ V9 e
    
68.       else
    $ t* j' s3 Z3 @; k  b; r$ W
69.       {, o; K7 O4 M0 U\" m6 {/ ^
    
70.         if (Enemy[i].x < player.x)0 u( l8 H  l! l) L
    
71.         {
    3 V% @2 O; Q\" e- A, k\" D3 E
72.           if (Enemy[i].x > 0)
    ) |, A. j  @& X) N: p' |0 s
73.           {
    % A  ?4 ]6 C4 ?: D( _( w1 y0 D; V
74.             Enemy[i].x -= enemy_sleep;
    9 ^' X4 }9 a2 l
75.           }, [9 T+ M. R2 _/ ^+ T: K
    
76.         }
    ! `8 @2 K6 ]# l7 Q2 z& O
77.         if (Enemy[i].x > player.x)
    $ \0 U% @( y& N, `
78.         {
    + v) B' M$ C! ?( y) B( x# T/ _
79.           if (Enemy[i].x < Wide_map)
    . M6 e0 a% z2 o. V# ?- m0 t
80.           {& D$ M, v. N3 S3 j: G# }
    
81.             Enemy[i].x += enemy_sleep;
      ^3 P' _6 f  ~2 c5 Q2 s/ u# `! e. J
82.           }& T5 ^2 z3 ?2 Y) Z0 y: E0 r. s
    
83.         }4 D! a) V\" ?( P3 v\" U5 r  M
    
84.         if (Enemy[i].y < player.y)
    5 G: {+ P1 F2 t
85.         {* H\" H8 B3 x$ _# _\" O
    
86.           if (Enemy[i].y > 0)
    ' g$ u$ t% Z$ u
87.           {1 q. D2 C5 L6 P
    
88.             Enemy[i].y -= enemy_sleep;
    . P6 `8 N0 E8 U, [/ W8 J
89.           }5 M# O3 s3 ]' G% |
    
90.         }
    % x4 O9 K+ H: p6 y& @* p% V
91.         if (Enemy[i].y > player.y)8 F0 E- e2 u' }# z
    
92.         {
    ' S, H8 D+ j\" V( F. p
93.           if (Enemy[i].y < Hight_map)
    , H! N; z/ I; x0 K; |0 f\" m
94.           {
    8 n0 o, M& }9 F: \: J0 F2 v
95.             Enemy[i].y += enemy_sleep;# g- O  U. Q* r6 f' b
    
96.           }6 u5 n: J( E$ z! Z' j3 c# I
    
97.         }
    : i! \0 A9 O9 l+ a3 G1 _$ |6 `
98.       }- t3 w6 f) H' Y- F
    
99.     }' W1 r4 r% W# X/ }% b\" C% y$ [
    
100.   }; x8 W9 S. M  }1 V1 _3 R$ j
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()/ c+ j/ Z* K, G9 c
   
2. {
   9 x( |# J# O8 B) s# [; [
3.   for (int i = 0; i < Food_num; i++)
   5 H& z' X, |- A6 Q1 w
4.   {& k. B/ V2 {+ ?; v. c
   
5.     //玩家吃食物
   6 O! x! }1 {) n0 T1 w# [
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)# U3 E+ x3 }! N1 |; ~8 P. A) T
   
7.     {
   ! H$ p) m$ E# j
8.       player.r += Food[i].r / 100;
   5 ]/ D+ C; u1 P% W! [$ K( o
9.       Food[i].x = rand() % Wide_map;
   , a$ K# D* `9 y8 ]+ I  k
10.       Food[i].y = rand() % Hight_map;
    9 [& y8 M  _$ f7 c* [, G* P, b
11.       Food[i].r = rand() % 5 + 1;4 [0 b6 \+ R1 g$ r' L\" L9 F/ g% a
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);, X! \3 L  d6 J& b0 D8 p5 u
    
13.     }
    3 W/ G3 D8 [. c- i4 F
14.     , n4 L  z8 Z0 X5 Q; f
    
15.   }
    ) E' P, M# ^- J6 e' o2 R
16.   for (int j = 0; j < Enemy_num; j++)
    + k2 U/ ^$ }  r# M) K
17.   {' o1 i4 L: }* ]* j( h+ H1 R8 {% B. ]$ K
    
18.     //敌人吃食物; F& ]3 v1 ]& w5 C% |6 h: t. _\" }
    
19.     for (int i = 0; i < Food_num; i++)
    6 l3 F$ E( q7 a\" i
20.     {
    / r: G7 L5 {9 q2 Z8 R) y2 h
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    ( D2 C' P/ k* _/ R* _
22.       {: i* z! k\" k  [! ]/ |7 d5 g: T8 w3 q) y
    
23.         Enemy[j].r += Food[i].r / 50;
    ! x' Q& Q7 l5 Y. u' J
24.         Food[i].x = rand() % Wide_map;
    ! J8 J# y; Q: _
25.         Food[i].y = rand() % Hight_map;
    , e9 S6 j. h$ Z
26.         Food[i].r = rand() % 5 + 1;$ c9 y# o0 P+ C8 O& T9 a2 K
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    # u) N\" T6 u' l* P# `\" r
28.       }
    % y3 r5 X  B* E5 l1 N
29.     }\" ]3 c' w( j; B5 f* ^# x0 [6 a
    
30.     //敌人吃敌人
    , p$ P  f' ]/ b! O\" y- b- P
31.     for (int i = 0; i < Enemy_num; i++)! b7 J' t6 S: h
    
32.     {6 {; z' \4 a4 f3 M) L
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r): V4 }9 U8 f0 D5 F# e& ?, T9 r
    
34.       {
    ( G8 a! b\" }; ~. N( J
35.         Enemy[j].r += Enemy[i].r / 10;
    5 }: c$ X\" b$ E
36.         Enemy[i].x = rand() % Wide_map;1 h\" v/ z7 k. S& y
    
37.         Enemy[i].y = rand() % Hight_map;) G- y* h' K! v) M& J
    
38.         Enemy[i].r = 10;' N; |% O6 Z5 X
    
39.           Enemy[i].color = RGB(0, 255, 0);
    % M; y  Y\" o1 ]1 g9 {1 S
40.       }
    : P8 Q8 b0 P: D7 W9 b& 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)! g; }6 N8 e$ f- J  |
    
42.       {* `9 a, s\" `5 H! S8 [% c% V
    
43.         Enemy[i].r += Enemy[j].r / 10;0 T. }$ y8 T( h* g\" g/ v# ^
    
44.         Enemy[j].x = rand() % Wide_map;
    7 P. T, i: S, b9 \8 W0 a7 |; h
45.         Enemy[j].y = rand() % Hight_map;' @4 x/ s, q4 f  u7 j
    
46.         Enemy[j].r = 10;
    1 J. @, k\" O6 {5 X$ T& ?
47.         Enemy[j].color = RGB(0, 255, 0);1 g* N4 I  o( U; o- f
    
48.       }& P& q; s/ z  L7 v\" X0 `
    
49.     }+ W( \/ K2 _5 [5 t7 ~; }
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)7 q& Y\" U! K; I' F5 `
    
51.     {
    % O0 P; m7 J* w8 |
52.       //玩家吃敌人
    ; s7 p) r! \* ]; W+ `1 Z' J
53.       if (player.r > Enemy[j].r)
    8 Q) U+ _5 K6 q5 g) H& [! b
54.       {
    - j+ W; I/ ], n. \& [; g
55.         player.r += Enemy[j].r / 10;3 f\" \, P; G: Y5 e, f1 J/ f
    
56.         Enemy[j].x = rand() % Wide_map;\" c8 o$ Y4 D6 y9 R# b
    
57.         Enemy[j].y = rand() % Hight_map;
    & i- p/ E' g- v9 b! p
58.         Enemy[j].r = 10;
    ( T7 ?5 c; k/ p3 L
59.         Enemy[j].color = RGB(0, 255, 0);; I  ~% y: I% l# z. i
    
60.       }
    \" @' ~\" \3 Z) r2 W- x- E5 [
61.       //敌人吃玩家6 n% v0 z) D3 P$ w4 ^/ t
    
62.       else
    1 {0 e) ^0 T+ f( _
63.       {  F/ _* \\" f0 }0 Y
    
64.         if (invincibility == 0)1 _/ V  a\" R9 Q5 X
    
65.         {
    & [/ c; r  I9 _( s- ^
66.           Enemy[j].r += player.r / 10;
    . }) C& s* [) F! V( n6 h
67.           player.x = Wide / 2;7 c* U# c3 d$ [7 z
    
68.           player.y = Hight / 2;4 ]  I& H1 E: s. |
    
69.           player.r = 10;
      l. h  i6 k( u' K
70.           invincibility = 10;
    # [$ a. Q$ }6 _% a& }
71.         }
    * z7 }- K0 ]- ~
72.       }& C: W; G% |' i% @/ q7 z
    
73.     }: X% X0 i4 c7 n$ H  W
    
74.   }( u9 |6 w0 M& ~- l
    
75. }

复制代码

完整代码见附件：
9 u; @; ]( x6 }# W  G. O4 s
& I: b7 Z3 B8 ?+ u$ ]  k( q
+ {: N2 r% l  ?9 d3 M( @0 w