球球大作战

2744557306

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

* |$ J; |, }) ^  k- b在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

0 s" A* D/ }0 |! `; E2 r游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

6 v% K, [. W* k1 y( W6 v% n. X5 S, K: C# R其他小球：其他小球又分为食物小球，和ai控制的小球
) g% N% Y! `8 _! S. X& ?
( W- y% o: |+ R体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

; U; X! Q/ ~: b玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
1 T7 U, o7 R6 G8 L4 G
8 {4 V# C+ t. a: eai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

接下来，我们将通过以下几个步骤来实现这个游戏：
9 G- {& H( o: w. ^! r: Q1 t
初始化游戏界面和小球的信息。
, o& P7 k1 k1 ?1 d
  _  A+ P% b& \处理键盘输入，实现玩家小球的移动和加速。
, n9 E  a5 Q' }0 p5 ~
9 u" v9 w) X! d3 t( j) W! W生成足够数量的食物小球。

生成ai小球，并控制其移动。
3 v9 l! X# @( x/ d2 |4 Z# y, t! [
4 ]6 }! m) S" {5 }* f& }2 I0 D检测小球之间的吞噬关系，增加相应的体积。

通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

: N8 I  }& B8 B  y& v+ r1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

- k( ~( i) t, @5 d- ~) k* V0 ]struct Ball
{
        int x;
        int y;
        float r;
        DWORD color;
) O' ?2 W. M: C9 }. a* Y};
2. 初始化小球的信息
* G& R" _. ?3 O% v) k将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

橙色可以通过RGB值（255, 128, 0）来表示。
3 \7 b, ~( T: X, i黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
& P) j2 y1 @5 ~/ e; f白色的RGB值为（255, 255, 255）。
8 F( b% s" g$ |3 H灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()  H8 ?\" j5 l: p3 m\" H6 U, i4 ~2 r) _
   
2. {  \9 g3 x+ ~/ |$ x7 T5 e; `) ]
   
3.     //玩家小球
   , o) m- Q3 j' Z: |( ]: ]
4.   srand((unsigned)time(NULL));- b1 b5 _+ X1 H8 I6 |2 S- p5 X/ U
   
5.   player.x = Wide / 2;
   # O. `0 p* g  ?6 m$ F7 G
6.   player.y = Hight / 2;
   # ?& Q6 P! j* m
7.   player.r = 10;7 E) R9 \0 o) h4 ^0 A
   
8.     //食物小球! B' Q7 S1 w/ T+ o  B) x7 D
   
9.   for (int i = 0; i < Food_num; i++)
   : e' w/ [' d3 H! ]4 n; B
10.   {
    $ \8 {: B7 _: L, S# `% ?
11.     Food[i].x = rand() % Wide_map;0 f6 Z$ H8 i1 B5 i& P
    
12.     Food[i].y = rand() % Hight_map;
    - T9 @, X5 A( Q
13.     Food[i].r = rand() % 5 + 1;
    . ^  G+ Z. b; C6 z! D
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    $ E: w0 t. [! j. c0 v9 Z
15.   }
    ( [\" n4 x/ |( p' c5 P7 b1 m% x
16.     //ai小球; {& }2 y6 G; ^2 i
    
17.   for (int i = 0; i < Enemy_num; i++)( b$ C, H9 w' _# v
    
18.   {
    / [7 y+ m  F+ \4 h8 J1 m6 F0 R
19.     Enemy[i].x = rand() % Wide_map;. [' C7 t; k4 |3 [+ ~+ s
    
20.     Enemy[i].y = rand() % Hight_map;
    ; P2 I' {% c# M0 R5 l
21.     Enemy[i].r = 10;
    6 y& Z3 ^  z# E8 Z+ o! h3 A4 g2 w7 [
22.     Enemy[i].color = RGB(0,255,0);
    % }, H( x) v+ E0 [# I: n
23.   }
    : F9 S$ m5 \  G# v1 @/ s
24. $ Q0 Z; C\" ~: C& W% b
    
25. }

复制代码

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

1. void Player_move()4 i7 {( D  F! Q7 }
   
2. {
   / ?; v* b, ?# ^8 O) w1 ]
3.   if (GetAsyncKeyState(VK_UP))
   # d, B5 G9 q6 m4 ?
4.   {
   , c/ E! q! g# z2 m! B
5.     if (player.y > 0): l3 ?* L7 I( o) V* k7 N$ ]  v+ f
   
6.     {
   ! |/ i, l8 J2 u
7.       player.y -= player_sleep;# t2 d! l2 k2 o' j) z% p: ^% ~
   
8.     }
   % _# C3 K6 Q) }% n\" P\" {2 A$ D
9.   }
   2 b# ?# z  t/ T9 |( \
10.   if (GetAsyncKeyState(VK_DOWN))1 a2 I2 y( l. \9 n
    
11.   {0 ?7 I) l8 J# K4 g
    
12.     if (player.y < Hight_map)
    2 @7 e8 W; Q* e
13.     player.y += player_sleep;\" h; R6 S3 w) b9 n# Q
    
14.   }
    0 [  a9 m* v* u0 l9 c6 K) f* c\" _8 o
15.   if (GetAsyncKeyState(VK_LEFT))
    2 b. R& `! m; G/ m\" S
16.   {: [- e( ~- Z6 v* y6 z+ j
    
17.     if (player.x > 0)1 z& f8 j2 E: T\" d0 V# Z
    
18.     player.x -= player_sleep;
    ! V- k& x/ r+ q0 J% v
19.   }
    : U0 {4 K6 z# p! P& D6 l
20.   if (GetAsyncKeyState(VK_RIGHT))
    # G\" S2 Z  i$ G) }
21.   {
    / g2 L5 s& W0 l* d7 w* _% `3 c
22.     if (player.x < Wide_map)\" i* S6 b2 E' F2 x4 O\" @* y
    
23.     player.x += player_sleep;) m6 N2 P* Y  a& D1 Y- U6 O
    
24.   }
    9 H4 \4 d2 x) B1 v
25.   if (GetAsyncKeyState(0x20))
    - X5 D7 ^1 ^+ h
26.   {
    2 {7 u) e( p- t- g8 W+ h/ W( x) w
27.     player_sleep = l + 5;- v2 N8 T+ k% B0 `: t4 W5 |& c\" P
    
28.   }* D! t: H6 ~\" h9 s\" {
    
29.   else5 a( k! a! q4 U+ T. I- B' I
    
30.   {
    3 q( l9 u: e- {) ?' ~
31.     player_sleep = l;) F4 b+ ?( _, \; w. l3 b4 L, n& G
    
32.   }
    + {1 N: T\" L/ l0 j8 P  H1 K9 \
33. }

复制代码

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

1. void Show()0 t# ~0 T% d# p- a: G
   
2. {1 x\" C1 ^- w% W& l
   
3.   . ~& a, x/ v8 y\" E\" O* p1 M. L/ S
   
4.   //设置地图
   # V+ u\" i) L5 v
5.   SetWorkingImage(&map);
   ( a# A# I9 K2 q/ m
6.   //清屏4 ~: s. k  S& C7 P
   
7.   cleardevice();
   ' y* V- Z3 N+ G
8.   //背景颜色: x# i( N9 g/ U
   
9.   setbkcolor(WHITE);
   / u' w9 ~: C; h$ H+ ^$ K
10.   //划线颜色
      C- Q( e% Z; {) m
11.   setlinecolor(RGB(230,231,239));
    - i0 I; Y& v' _% t
12.   //划线7 o+ C: t. i' [: ~9 s5 x- c! Y  ]
    
13.   for (int i = 0; i < Wide_map; i += 10)
    . |3 ~2 Z! ^. t, o4 x2 E6 c
14.   {$ V2 V2 R& U/ ?+ V
    
15.     line(i, 0, i, Hight_map);
      d! G+ _, |( Y
16.   }9 u% u! i3 M8 H3 g
    
17.   for (int i = 0; i < Hight_map; i += 10)
    ' f% m- F\" o7 l/ t. |: }
18.   {, l$ @: b4 a  z8 |
    
19.     line(0, i, Wide_map, i);7 Y; n; S! o7 c( L' Y
    
20.   }9 J( `& }2 E3 k$ b1 ^
    
21.   //食物
    & J1 b1 N2 G  x
22.   for (int i = 0; i < Food_num; i++)2 N' E; L) @4 N# _- ?! V
    
23.   {\" S2 P7 S9 }' ]0 {4 W1 T$ K
    
24.     setfillcolor(Food[i].color);
    6 Z8 i; _4 K; L  v
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    8 {% F0 k9 u  i7 ^: D  c
26.   }: @7 r, c3 b  F- L! u$ M- ?9 L
    
27.   //敌人
    $ Q. ]6 z$ G# h
28.   for (int i = 0; i < Enemy_num; i++)
    7 p- c& ^+ f4 x- V) y( r, E
29.   {) n' a5 |% n- l3 x' Z
    
30.     setfillcolor(Enemy[i].color);' M) q+ M) s* r) r- b7 d- n
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    8 {! E6 P, Q2 z1 [
32.   }5 h: U# k\" L1 y: n/ f, C
    
33.   //玩家1 u3 p$ {$ ~5 V% r; f0 e1 W
    
34.   setfillcolor(RED);; M, \  X+ }$ L
    
35.   solidcircle(player.x, player.y, player.r);
    4 q* h. m3 _; @' p, S
36.   SetWorkingImage();% w! {) Q- w* U3 |
    
37. 3 Y1 q7 v: M; D3 G3 d
    
38.   int x = player.x - (Wide / 2);4 s: G5 L$ P7 P3 S, u' g' e0 K3 p
    
39.   int y = player.y - (Hight / 2);' i. p  x9 F: B- Y
    
40.   //防止窗口越界# C3 B* s1 n2 y\" e
    
41.   if (x < 0)
    9 C* I; ^  ~$ N( N, w  i  b
42.   {
    ; K4 x3 G$ i6 u\" {
43.     x = 0;$ l: y, q0 L) p. ?2 N
    
44.   }8 V3 b& \6 Z  |5 B9 `
    
45.   if (y < 0)( P7 i, m. M1 L5 S: U! q: T
    
46.   {
    9 y8 S6 i7 {7 V
47.     y = 0;
    0 X- T- K; F5 T' A2 y
48.   }
    \" s0 T: ?$ K* G& f- G
49.   if (x > Wide_map - Wide)
    4 r+ G; C9 i9 Y7 y% K' [
50.   {: q9 r; J/ H  n& {# X6 ]( X
    
51.     x = Wide_map - Wide;0 I\" T3 D# u6 }$ d( w, I1 O
    
52.   }7 @7 u\" Y. G* [/ q
    
53.   if (y > Hight_map - Hight)' o+ p: n) R5 D
    
54.   {& I5 f; m0 O/ Z# U6 b
    
55.     y = Hight_map - Hight;
    ' I0 d+ M9 o, W6 I7 l
56.   }3 Z6 Q8 U8 Y: n: Q9 A5 ]
    
57.   //把map输出到窗口上
    5 i# }' v1 p( w- G0 ?: i1 k
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    ) D7 c1 D8 K4 K\" Q; j2 v+ {* Y5 s
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. //防止窗口越界7 N$ Z6 D: I0 L0 @
   
2. if (x < 0)/ D6 k  ]8 j\" [. e
   
3. {0 w- s- x' Q, h* ?* \
   
4.   x = 0;  j+ r! b) S* _8 L$ ~# b9 Q0 Y- G
   
5. }1 d( M& G& L$ ]4 \# q
   
6. if (y < 0), y$ U1 x1 _5 u3 X2 V3 |
   
7. {6 f; ]* h& x$ O9 P: e* S* q
   
8.   y = 0;
   0 r1 ?4 G2 i% k1 x7 h/ a! ^# s8 ]! Z* T+ E
9. }. G& R' x: q' M/ o) h
   
10. if (x > Wide_map - Wide)
    8 E5 T' M\" \6 U( b; A
11. {
    \" d- R, ~! B& U/ w  e* G4 P
12.   x = Wide_map - Wide;# c2 n( b$ J7 b6 R4 e
    
13. }
    . Q' T) E7 M+ r9 T3 V( V
14. if (y > Hight_map - Hight)2 b5 i/ {0 x7 \; R
    
15. {! I, y( b: K0 r. P* W) M
    
16.   y = Hight_map - Hight;1 g% k; q\" W+ d  X& \. t, T: j# E
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
% |8 g' H* v* I6 {9 @
2 S1 p) P0 z* B- w1 ^% }(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

9 Q* Y( V$ Z2 |( j8 BWide：这个参数指定了要绘制的图像的宽度。
% W2 \# v+ H' F& c
& A6 j; P  A0 V' d) S9 K" ?0 bHight：这个参数指定了要绘制的图像的高度。
' A1 a& M* O: ]8 R: w
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离
   7 N* w% {5 x/ T3 z  d9 k+ y/ S+ R
2. int Distance(int x, int y, int x1, int y1)
   / e% K6 h# L) D) Y1 G2 j9 E
3. {- O( _) v0 ]7 Z* d) V' o: A. \6 B9 w& I
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));. J( ^- G1 C4 T, ?  u
   
5. }

复制代码

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

1. void Enemy_move()
   . s% N# a\" |& ?9 R. F2 ^0 z: B
2. {
     _- T) N0 a1 B+ ]! {8 n2 d& w
3.   srand((unsigned)time(NULL));, U6 U2 i1 v8 E/ m2 [# B0 T- _7 w0 n
   
4.   for (int i = 0; i < Enemy_num; i++). L) ?1 h. P) D$ ?6 s) V
   
5.   {9 o5 T- {- k7 O# ^1 E3 b; [0 n
   
6.     int direction = rand() % 4;; K9 F( s* B: A5 F/ d# z- }
   
7. 
   . G' n3 h1 U# E
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   / t1 v# }: ?7 K% _\" B7 F
9.     {
   ; g- ]; q  Y7 W  @0 M9 L1 f6 ^7 E
10.       if (direction == 0)3 s) H, K/ o. G( b% w8 g
    
11.       {7 s, Z/ b6 q1 g
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句4 K2 |5 e! q1 ^
    
13.         {, U: d! m& n0 L( E% y1 l' d\" O7 z( G
    
14.           Enemy[i].y -= enemy_sleep;, y; U& R) h2 Y) ?6 n; P) }5 t
    
15.         }
    9 q- ~9 H2 j+ D, E6 Y
16.       }
    / c) ?( e; A\" x, t; Y% y# L
17.       if (direction == 1)! w- A0 Q  r: q! R+ {  e5 e6 G, H
    
18.       {( g% ^3 d1 r3 T7 W! G9 K) b3 [7 I
    
19.         if (Enemy[i].y < Hight_map)6 L' E! f. F# N2 k
    
20.           Enemy[i].y += enemy_sleep;* d6 K+ Q9 X7 O. o\" d+ C
    
21.       }( b8 e, i; D1 E\" W\" d. b
    
22.       if (direction == 2)1 p, F, @! [8 x+ G0 G$ a. u
    
23.       {
    1 G  j0 l8 z. x0 A1 x
24.         if (Enemy[i].x > 0), H4 o% ?\" d' Z3 T
    
25.           Enemy[i].x -= enemy_sleep;1 l6 v6 \1 N, F
    
26.       }
    ' _: s% C+ [  W& A\" X! v9 J
27.       if (direction == 3)
    ( p2 A3 q\" l. p: H5 g1 F9 ]- ^
28.       {
      c7 t+ J\" W* i+ F+ p; H
29.         if (Enemy[i].x < Wide_map)
    * ]. F5 u: |& E) p$ W0 j) g
30.           Enemy[i].x += enemy_sleep;* P& e9 \! @: o$ a
    
31.       }' @8 E( s5 H3 S9 K5 o6 }
    
32.     }
    9 @  a: D2 s7 W! s2 |2 y  b\" D
33.     //敌人追击玩家2 R  n% h3 w& F' O7 e
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    % M5 A1 W% c$ V. |
35.     {
    * ?' d1 f1 Y\" z4 f, G6 _# l
36.       if (Enemy[i].r > player.r)
    , ]/ k7 b; c8 i, k
37.       {
    & i0 z0 }& M! a0 E7 d. m6 u
38.         if (Enemy[i].x < player.x)4 W  k6 C' r7 N1 M) Y
    
39.         {
    6 F& J, K: B) O0 |\" t
40.           if (Enemy[i].x < Wide_map)
    # E* ?' j; _% C8 @5 i
41.           {
    $ M5 n1 O. z# q, `) o3 `) ?# B
42.             Enemy[i].x += enemy_sleep;
      G: |. D7 A! V3 ]. v
43.           }
    3 H# |6 I+ j3 C) B; ~
44.         }/ e. p' i  ^5 e+ ^! ~8 O
    
45.         if (Enemy[i].x > player.x)
    ' }! q3 C9 a( `+ ]* `9 N% M: R
46.         {
    # o; p4 T% n( J7 R9 ?: y
47.           if (Enemy[i].x > 0)
    % d/ F3 D( p: b\" U- K& y
48.           {7 g7 Y4 v& n1 j
    
49.             Enemy[i].x -= enemy_sleep;\" f+ o; @# U\" a- z& Y
    
50.           }2 N$ C2 f4 y6 Y
    
51.         }
    / u\" J\" b; a1 j! L2 R* k: |
52.         if (Enemy[i].y < player.y)
    4 K# {  [6 U7 i8 G5 p# R& C0 k4 d
53.         {0 s8 u' l0 K+ U4 [
    
54.           if (Enemy[i].y < Hight_map)
    0 n2 V% w0 v: k5 V
55.           {
    . \: `; H+ Y\" ^2 f
56.             Enemy[i].y += enemy_sleep;
    3 M( t. A( W$ e: T, |- m
57.           }
    . Q1 C3 v$ ]4 H0 w8 b3 ?( j% b( H
58.         }
    , P; s3 T6 i5 N! v
59.         if (Enemy[i].y > player.y)
    6 r: t3 g. ~3 o6 a# ^& w
60.         {
    \" m5 Z1 m' M1 m  W* h
61.           if (Enemy[i].y > 0)
    ' N9 A  g0 t9 @7 ?/ b\" r; B, _2 U
62.           {( [0 H! F5 o  [  ~/ f: H
    
63.             Enemy[i].y -= enemy_sleep;
    ) w. O& |' b4 b$ T: n: K* |
64.           }$ O, b* n8 g, G3 c2 A+ ]- E
    
65.         }1 m/ \: A0 u- p( x2 X
    
66.       }, ?1 m\" k- W0 z' z  f4 f9 u
    
67.       //敌人逃跑\" s, k6 e1 ]# _* H# g
    
68.       else
    ! L- ]1 t2 n) r6 ^8 A5 I
69.       {
    $ J& ]: ^4 J8 ^+ R% f2 _* A
70.         if (Enemy[i].x < player.x)  }3 N8 ^+ x, O6 {$ {$ J
    
71.         {
    3 v1 {% }; A  Z* F+ v& x' ^! m
72.           if (Enemy[i].x > 0); D8 k' v$ R- ^\" D9 z
    
73.           {# v7 N8 c5 t/ M) t/ N6 x! Q$ K
    
74.             Enemy[i].x -= enemy_sleep;
    - j4 a8 @! B6 f' b
75.           }7 i- ]; {. U1 h; Q6 Y% P& \% K
    
76.         }
    + d) j( l' U7 @8 [4 x\" Y) q$ K  x
77.         if (Enemy[i].x > player.x)
      B' E4 ~1 v. y* i$ m1 s
78.         {/ N  \3 z, J6 |  s8 j. e
    
79.           if (Enemy[i].x < Wide_map)* j; d! y) ~1 y0 ~
    
80.           {
    % k# B: T8 n\" @. @) d) e4 }
81.             Enemy[i].x += enemy_sleep;
    % f7 z* t% l. a* A/ W9 l1 g
82.           }
    . C* ~+ d+ r; V. _6 G, ?
83.         }- _2 t# r. e+ s  `, B! N
    
84.         if (Enemy[i].y < player.y)! Z- H- ]( y1 r( k. T2 U
    
85.         {
    / L/ _) @9 f9 ~; n
86.           if (Enemy[i].y > 0)8 r5 S. r. g4 a. U1 c
    
87.           {$ O5 }0 x$ r4 L8 }
    
88.             Enemy[i].y -= enemy_sleep;( p# v* }7 ?+ p\" M6 v- Y4 u* F4 D
    
89.           }
    ! ?' y* B( l& T$ b
90.         }
    4 z/ ^- O) a9 @; I( v
91.         if (Enemy[i].y > player.y)& |. B4 U9 `! u# p7 l% q
    
92.         {+ D5 E! Y4 T! ?- t) g4 @
    
93.           if (Enemy[i].y < Hight_map)) s( j2 c  }4 n+ S
    
94.           {# ?6 ~1 y2 y& d6 w, {
    
95.             Enemy[i].y += enemy_sleep;
    : I! D1 w& y4 w5 m8 {
96.           }
    1 p; U+ p9 t+ u1 ~9 k
97.         }$ J+ a' m) T  F5 `% [( s+ u8 i
    
98.       }
    1 `$ Z0 W; h  j  |* p( V9 G  m! `
99.     }- `8 F6 v. }8 A. e5 F: n
    
100.   }
     ' _/ o+ ^( ?, n  f9 @9 ?% m* X' T
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()2 ~2 b$ |; Z1 Z# q0 g
   
2. {1 a- w5 c) L4 R4 ^\" T: }
   
3.   for (int i = 0; i < Food_num; i++)' m3 v9 r9 p0 t1 r\" Q  i\" t! U2 c# g
   
4.   {# A& r3 M  J9 v* ?, y/ ?* b' [( `
   
5.     //玩家吃食物3 x! `. h/ W% B: O# X% Q. q
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)\" T! @4 c8 A# D
   
7.     {
   2 m2 b+ u9 W0 u2 A4 g! {
8.       player.r += Food[i].r / 100;: y2 L& |, }) O+ W* W/ T6 ^' T
   
9.       Food[i].x = rand() % Wide_map;
   + b! o& {\" M$ x: w, }
10.       Food[i].y = rand() % Hight_map;, S5 {4 W9 z8 s6 d
    
11.       Food[i].r = rand() % 5 + 1;& [7 d7 I3 }: q
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);9 {& H/ e. }3 q& k8 Z# Z: [% [
    
13.     }/ E0 C. i9 ?\" G. w! n
    
14.     $ m6 @: I9 |/ F% [! h( q
    
15.   }  c$ U( G8 B7 V& c
    
16.   for (int j = 0; j < Enemy_num; j++), P0 i2 Y# g  o% I
    
17.   {! [$ c, H( i! \  U
    
18.     //敌人吃食物
    0 w9 U! D/ m0 T$ `' z
19.     for (int i = 0; i < Food_num; i++)# @4 q9 r\" V: y7 }3 f
    
20.     {
    6 s\" F' X/ u- L5 B
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
      |1 S' X9 ^/ v1 M
22.       {
    4 o. W' ]# C( h- a. C8 x
23.         Enemy[j].r += Food[i].r / 50;9 c0 k$ i, c9 }! k2 p. U$ L
    
24.         Food[i].x = rand() % Wide_map;
    2 ~6 ]4 O' s$ o9 B9 o
25.         Food[i].y = rand() % Hight_map;
    $ O& B% u( |1 c- U3 W$ @7 T# H3 \) Z
26.         Food[i].r = rand() % 5 + 1;# _+ Z\" m# |- s+ z, C
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ) J8 s8 r+ Q% }0 I4 I$ O9 ?( b7 }- [
28.       }
    5 J, j- X4 t3 H3 b+ J- ]
29.     }
    % g5 Q, F\" |* q5 Y( U
30.     //敌人吃敌人! L/ H8 I2 A1 q# |. J
    
31.     for (int i = 0; i < Enemy_num; i++)0 d! k\" B* f; d
    
32.     {
    + [6 r: i4 b, j1 J2 y7 l, C
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)! P  P\" {; A+ f( G3 \- g; x
    
34.       {
    % `' q2 E6 F+ j% ^' M9 N# ^0 Y8 P\" ?
35.         Enemy[j].r += Enemy[i].r / 10;5 w- ]/ k' N: Y: G' a0 E
    
36.         Enemy[i].x = rand() % Wide_map;0 i/ W8 T! A/ t4 D% I: T
    
37.         Enemy[i].y = rand() % Hight_map;( r\" K\" T/ ]3 s9 f+ ~9 J3 ]# g* R
    
38.         Enemy[i].r = 10;8 t7 O8 s3 r0 Z$ x8 u
    
39.           Enemy[i].color = RGB(0, 255, 0);. n! e/ H2 d0 A6 y: g0 c
    
40.       }; v8 S: M- e  C  S3 R
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    \" u& W) x6 l\" S5 w% p' m
42.       {
    . x1 \: b/ F, W! t) B* w) Q
43.         Enemy[i].r += Enemy[j].r / 10;1 _9 K4 T! A; b  ~
    
44.         Enemy[j].x = rand() % Wide_map;
    . A6 S. z. R, C
45.         Enemy[j].y = rand() % Hight_map;
    & t* X' c+ g0 D8 ~4 @, M. g
46.         Enemy[j].r = 10;+ e( o, I+ Z: _$ |9 Z* L
    
47.         Enemy[j].color = RGB(0, 255, 0);
    # Y* D# k: _$ u9 h$ Y
48.       }9 C- F- X4 s& h
    
49.     }
    $ Q' @: |0 t3 X7 y) ^0 ^: ?
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    6 `/ |  n' n\" }( ]; o
51.     {& @$ {2 t4 b& a. \6 m7 A$ P
    
52.       //玩家吃敌人2 e# ]; z) w! c' }( v
    
53.       if (player.r > Enemy[j].r)
    ; Q0 q/ J7 ?% w9 F2 s) a3 [; w2 o
54.       {
    \" o7 x\" ?8 z- \' B) @, ~1 J
55.         player.r += Enemy[j].r / 10;
    / |5 l/ P7 ], m2 D
56.         Enemy[j].x = rand() % Wide_map;
    & }\" P8 J4 b, \, T1 J0 f
57.         Enemy[j].y = rand() % Hight_map;; K+ S$ K9 D$ z% y2 O, {
    
58.         Enemy[j].r = 10;- J+ D* Y% k! o; O; C6 h
    
59.         Enemy[j].color = RGB(0, 255, 0);* L# @  \9 L8 z
    
60.       }
    6 w$ k3 H* P- P+ }, u
61.       //敌人吃玩家
    6 w7 u: K% d1 L; n3 P6 T
62.       else
    3 s/ v) q4 o+ f7 l
63.       {( o1 M4 i2 W' z
    
64.         if (invincibility == 0)+ {5 k, n. n  R  K\" W- M
    
65.         {\" r0 S7 M5 K' z* E0 ^
    
66.           Enemy[j].r += player.r / 10;
    8 k* t- c* ]. x& }
67.           player.x = Wide / 2;3 D\" _) k$ B8 ?) V. ]- _8 t
    
68.           player.y = Hight / 2;/ J  r' ^. J8 S, X  |
    
69.           player.r = 10;
    5 y1 ^' t$ B9 t+ m% L
70.           invincibility = 10;
      D\" Z  K( ?$ {0 i- i
71.         }
    $ N- H3 \% x7 i3 I0 b8 h  A, N$ o
72.       }* P) U8 V\" h- E
    
73.     }
    5 T- V# n2 A3 L% C7 T
74.   }2 C+ b7 I, c. k# S  ]
    
75. }

复制代码

完整代码见附件：
, l- C" a  i- L+ f: k3 T! }
1 e8 z  P* ]! \! ~
; `* r+ e& d2 M2 D) W
  P- F( v- d. v0 e