球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
# q. ^* f. d; M# ]
% J" f( F: v/ a' P玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
0 }7 I- p+ C9 x) H$ m8 E1 ?! R
% Q7 a! A$ @' A体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

  |" h7 ^3 B3 X0 c. b玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

$ @# d: a- r1 ^1 n/ H% t; ~ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
* d2 j! m  A* z, A& K$ p: Y
接下来，我们将通过以下几个步骤来实现这个游戏：
* l( s. U. p( q& T  f/ ~7 `
初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。
  H* @/ b- @' C# _/ U
; \0 h7 r3 V% W2 Q生成足够数量的食物小球。

2 F. \8 }# h$ x. B生成ai小球，并控制其移动。

检测小球之间的吞噬关系，增加相应的体积。

8 z; ~5 N0 M5 G& |! j: v% e通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
  a0 ^/ W9 b, \, V; N3 u
8 P2 L# T7 N; j& d. ~! _1. 小球的要素
3 R% C/ [& `) I9 d+ ~. |在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

struct Ball
; O& I. b1 z$ l/ q6 w! J{
        int x;
        int y;
6 B" o# G& h6 P" e# c8 r5 _        float r;
        DWORD color;
};
1 G/ S& z8 J# S; S; G2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
" l, }7 }6 e% t( I* v( i; D: z
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
, P! \5 S/ J4 k5 z) J' s
橙色可以通过RGB值（255, 128, 0）来表示。
3 @  O# @7 H. J  {. H黄色的RGB值为（255, 255, 0）。
& a0 f/ s6 ]0 D; H* G! I绿色的RGB值是（0, 255, 0）。
2 @4 p( v" V  Y5 u蓝色的RGB值为（0, 0, 255）。
  h  O# e; Q  _  }/ _紫色可以通过RGB值（170, 0, 255）来表示。
/ M( }1 |5 o" W* H* Y# H黑色的RGB值为（0, 0, 0）。
8 \4 j$ s+ f! S" Q白色的RGB值为（255, 255, 255）。
4 z2 A3 Q  s% r6 q. J: ~. {8 y* L灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()& w9 y5 F; e\" d4 i4 ]9 i
   
2. {0 i& I; j' r0 C3 W6 [
   
3.     //玩家小球. A5 U3 a+ X: g0 f2 X, p4 m9 y* W
   
4.   srand((unsigned)time(NULL));! d. ]. C, W: j4 R% w  S8 q6 b
   
5.   player.x = Wide / 2;
   2 r' a$ b5 j$ L1 l
6.   player.y = Hight / 2;) q: t/ G2 {1 G, k4 g$ i
   
7.   player.r = 10;
     }# m& I9 \0 [
8.     //食物小球( Q5 X; a8 \6 G. D  t9 z1 |  S: w
   
9.   for (int i = 0; i < Food_num; i++)6 n# m  K$ b4 e' Y' K, F8 g5 {0 l. A
   
10.   {# A3 X. i/ ^! {% V+ X% r6 y
    
11.     Food[i].x = rand() % Wide_map;0 }7 g1 t1 c' h
    
12.     Food[i].y = rand() % Hight_map;  u( P6 ]/ |( T* X, Y( _
    
13.     Food[i].r = rand() % 5 + 1;
      Z1 h- U) k1 l+ N$ h# W\" [4 t
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);8 X* L\" Q: t' d
    
15.   }3 L2 d. s  i9 T8 H$ \
    
16.     //ai小球. _8 A# \, r$ |\" b  _
    
17.   for (int i = 0; i < Enemy_num; i++); S  @5 Y# ^$ _2 }, r
    
18.   {$ W$ {( e\" ^$ |7 R) m
    
19.     Enemy[i].x = rand() % Wide_map;
    / y& q: I7 W! U/ U8 H3 l
20.     Enemy[i].y = rand() % Hight_map;
    / A1 n' ]) [9 N/ T) G
21.     Enemy[i].r = 10;. B6 _( o0 l# B$ n  r* g
    
22.     Enemy[i].color = RGB(0,255,0);4 Q  Y& \\" n6 a; E4 _; A
    
23.   }
    2 F9 k, t0 G# S: X8 j8 r8 O! Z
24. 5 e+ y# e2 S# S1 l: ^9 `3 \
    
25. }

复制代码

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

1. void Player_move()5 }% b( Q! r: ~7 o& A0 W
   
2. {% N' `7 F9 p: J, a- A8 q/ |- f  Y# C  E
   
3.   if (GetAsyncKeyState(VK_UP))# a9 k1 p$ |& f3 J8 p2 R
   
4.   {
   * f/ l. P0 l9 f; ^\" q  m! l
5.     if (player.y > 0); E\" R; `7 Y3 h\" o/ d2 D
   
6.     {4 u2 I; ~! l8 K  b3 q1 J) X+ s
   
7.       player.y -= player_sleep;\" {- H$ R8 @: @2 i9 V
   
8.     }$ y2 X, W- ^2 B. m* c  X
   
9.   }, L4 `0 Y7 Y; s3 F9 c8 h0 |$ B
   
10.   if (GetAsyncKeyState(VK_DOWN))
    : O: \\" Y; k) @4 z& O- i
11.   {
    & x+ d* J* @' M6 M- u. z* C
12.     if (player.y < Hight_map)
    ) _\" {* Z9 W  H5 C; e
13.     player.y += player_sleep;' h, T9 l2 I* o( F5 d
    
14.   }
    2 C) l! }. Z4 v* I# l. H
15.   if (GetAsyncKeyState(VK_LEFT))! c' \: v5 T3 c: C% x9 j
    
16.   {+ {* @; ]5 M$ D
    
17.     if (player.x > 0)% L8 \. a( {- I, v' ?$ z* p* O9 P9 k. H
    
18.     player.x -= player_sleep;0 l9 b+ J% z2 K) Z- ~+ T
    
19.   }7 n( n7 k( z( j( k% a' g( {4 m
    
20.   if (GetAsyncKeyState(VK_RIGHT))/ W6 S1 N: g5 v4 L5 s2 {
    
21.   {
    \" n$ ~. t1 ^4 b' B8 X
22.     if (player.x < Wide_map)! g5 Y# y/ d7 [) s
    
23.     player.x += player_sleep;% _7 i# `& J  n/ y6 ~# m1 h
    
24.   }
    . {+ Y' x& {- c
25.   if (GetAsyncKeyState(0x20))
    ; g9 G1 w8 [2 E# y
26.   {
    & t) y! V0 W. M3 V7 L6 y9 X
27.     player_sleep = l + 5;
    ; @: l, @% {* N* d) t
28.   }
    ' I) U7 b8 s: O) i& o\" }
29.   else
    ) R, i5 _8 k6 f+ _0 E% R
30.   {- C# |( O! D7 w% `
    
31.     player_sleep = l;* R( }/ W+ f# B! P% _
    
32.   }' x; ~# i/ N, G
    
33. }

复制代码

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

1. void Show()
   7 x- }/ Z9 g0 O) B: E
2. {( P* L( ]2 i  U$ U% G! \
   
3.   
   0 ~2 ^$ [7 `+ A1 X! c8 \0 A
4.   //设置地图
   9 }* t; G7 B. [3 w
5.   SetWorkingImage(&map);
   / N! `3 K4 B4 v9 q7 D/ {' W
6.   //清屏
   * b0 T+ j8 I7 G' N
7.   cleardevice();; k% m+ ^& E7 o6 O# T
   
8.   //背景颜色' A1 i, [- p3 f* h$ o$ A  {7 B
   
9.   setbkcolor(WHITE);
   \" D) |* {+ A% J  @# M' Q) c
10.   //划线颜色
    0 U7 h9 j  @) Q; Y/ i7 S+ Y
11.   setlinecolor(RGB(230,231,239));+ ^3 K9 `7 k: P/ g! Q& f  W
    
12.   //划线
    : p+ ]8 X' J0 A9 t7 X) @
13.   for (int i = 0; i < Wide_map; i += 10)
    ; c5 z. T: ]$ I8 R
14.   {
    0 P) q- d8 H: @/ |
15.     line(i, 0, i, Hight_map);
    4 ~* @% n8 Y1 R3 S. y
16.   }7 R8 G) W$ [; `- @
    
17.   for (int i = 0; i < Hight_map; i += 10)1 v9 N( l- b: d4 c4 n  p\" X8 O9 \
    
18.   {
    8 Z' j7 ]8 B( h' y$ q/ b$ M6 U
19.     line(0, i, Wide_map, i);
    0 m, ]! i: ~8 K6 O1 m
20.   }. j6 U0 _/ e, C+ X# i# c5 z
    
21.   //食物# u1 X8 h9 a6 Y; T7 R+ z0 `
    
22.   for (int i = 0; i < Food_num; i++)
    - l% L: }\" E2 j) [
23.   {
    : t& W* l, }. J- i4 C1 b3 R
24.     setfillcolor(Food[i].color);
    - l; W7 C/ b8 J6 r+ m- b1 O8 e
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);+ `) O) k. ]* p- u8 U
    
26.   }
    & A0 G# b3 U4 O* G. k
27.   //敌人: G8 s7 |/ G! T3 U
    
28.   for (int i = 0; i < Enemy_num; i++)+ d) C+ S4 q; Z6 ?! e- R
    
29.   {
    / P0 K/ q0 v& b, [% [+ U4 o
30.     setfillcolor(Enemy[i].color);: I$ o$ a/ J$ R: |% w% C' R# X
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    4 @$ X7 G: z5 T7 F% m0 }% O7 ^
32.   }, _  t  Q6 B6 H0 J3 G- V
    
33.   //玩家7 ~1 p0 F9 J4 C7 V' v
    
34.   setfillcolor(RED);\" B/ G5 m  D/ v. {
    
35.   solidcircle(player.x, player.y, player.r);
    , o  c+ l3 G/ s7 B  X1 v
36.   SetWorkingImage();
    ! e$ B* r* z  c' r: W
37. 2 z+ Q, \; x* K% y; u8 _6 S# V1 V! b
    
38.   int x = player.x - (Wide / 2);
    + F0 s; v; j  N; G) z
39.   int y = player.y - (Hight / 2);
    ) ^# u; c% J$ p/ B( G! C
40.   //防止窗口越界
    - {! S/ I5 U5 q& r- B
41.   if (x < 0)
    8 e1 I\" b. G: Z6 X5 l, T. B9 |
42.   {  g: L2 b% c# F: I# H% d3 Z; s6 t
    
43.     x = 0;
    : P( H  Y, Q3 B8 D. ?6 c/ x
44.   }
    8 K) l% I\" x' A4 O3 ?# J( r( n
45.   if (y < 0)) d! v8 {8 G0 b. x$ C
    
46.   {; h* S2 B' K; U4 V( G\" O  C, c
    
47.     y = 0;3 X8 k. Q6 G' j
    
48.   }
    5 L, g6 H; t0 K& O: N- d
49.   if (x > Wide_map - Wide)9 C4 {9 L/ R0 u\" y7 J
    
50.   {# S1 ^( r. ]; Q; M- `
    
51.     x = Wide_map - Wide;
    $ m$ w; Y0 s\" h+ V, U) w7 n
52.   }6 ?/ V, U8 o# g
    
53.   if (y > Hight_map - Hight)+ \, c& E1 \2 K2 C( N
    
54.   {% w% L; U! Y6 f1 w0 p/ X
    
55.     y = Hight_map - Hight;
    ) x# @' V! J' T, }. P5 f9 T* C
56.   }# J9 f$ e; ~& l( y3 f
    
57.   //把map输出到窗口上) i8 p3 z- `; f+ T, p& h
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    & i0 D- g5 _! S& V% a5 o7 N
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 o0 D8 Z* }% z
   
2. if (x < 0)
   2 d* i0 Q, ^1 P' f- Z
3. {\" o  E  p) {9 u; p4 i1 o
   
4.   x = 0;
   % a+ p, T/ `2 u
5. }
   8 M, k2 V) U1 q
6. if (y < 0)/ v\" y: G2 B0 F+ a) C
   
7. {
   \" t, G2 q/ z- f- p
8.   y = 0;4 f6 P* Z3 S% y1 }) P1 R
   
9. }, {; `7 t\" f4 b9 [; O: R- L: o
   
10. if (x > Wide_map - Wide)
    ( v6 O! A6 ^8 v! g/ g
11. {3 v8 _; B* ^0 a& m\" b& [
    
12.   x = Wide_map - Wide;
    ; e% o3 q3 T) `+ Q. p4 ?
13. }
    4 H, h$ V1 y9 A% L; U8 }
14. if (y > Hight_map - Hight), p8 M; N# R4 j# `; J( h
    
15. {7 b5 p2 f) C! Q  w8 R
    
16.   y = Hight_map - Hight;
    3 P3 r\" z) x\" U! S
17. }

复制代码

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

. a0 ~8 [/ d2 `2 G3 _/ e(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

! C8 D+ n6 O7 b1 G/ yWide：这个参数指定了要绘制的图像的宽度。
) V8 _9 p: }" Y1 s: K( f
4 }1 v0 u7 G6 a) B2 s5 gHight：这个参数指定了要绘制的图像的高度。

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

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

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

1. //距离
   ( A& Y4 W& k) U8 g/ \
2. int Distance(int x, int y, int x1, int y1)
   ' R' e8 k; V. E
3. {\" p9 t; F2 W- |! t# l; F
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   ) \% ^; M\" S8 |5 u8 l
5. }

复制代码

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

1. void Enemy_move()
   ' ~- {* u2 ]0 T% `\" m# \\" B
2. {
   * T) G8 b& I\" R- ]
3.   srand((unsigned)time(NULL));: c! d  V, ^\" Z' k. j' p$ t
   
4.   for (int i = 0; i < Enemy_num; i++)* ]/ Y  u% |& |# r
   
5.   {
   0 C0 r5 M# V5 u) {- E$ S; X
6.     int direction = rand() % 4;
   $ R5 H* F7 E0 y4 N/ V/ V( V
7. % W( e; c& T% x1 E8 W, A' k
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   . G  z7 y- z, B2 C
9.     {
   4 m9 X9 L3 a8 N+ T% R! m+ P
10.       if (direction == 0)  Z: C! ]\" M0 [* `9 l
    
11.       {* l\" {' |- y0 A/ Q
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    ) [4 z4 J! |! z6 W
13.         {
    9 ^/ T1 v7 R; n
14.           Enemy[i].y -= enemy_sleep;
    9 r' G0 v+ K# Y
15.         }) p- y5 r: K\" l+ n3 ]  H
    
16.       }- P5 f7 v6 F- m! Y$ R
    
17.       if (direction == 1)/ [& q1 N& M& D! R- z) I
    
18.       {( \+ i4 @$ p9 l* i4 s# {
    
19.         if (Enemy[i].y < Hight_map)) ^0 P* ^1 T- F5 u1 H4 V6 H4 d- k7 S
    
20.           Enemy[i].y += enemy_sleep;0 E. O$ L  F9 o. {- J
    
21.       }$ v4 _5 h. t3 \0 O+ A) U
    
22.       if (direction == 2)
    : U& R\" f4 b3 H- q
23.       {
    ; v9 f+ D0 f4 J$ G- s. V, j2 x
24.         if (Enemy[i].x > 0)
    % ?) }0 F: ]( }- u* D3 ~
25.           Enemy[i].x -= enemy_sleep;% T6 r* a% O$ |) n/ @: I
    
26.       }% r; ~. T0 [8 D/ b; D* K
    
27.       if (direction == 3)
    8 e6 B3 Y& ^+ h- t, c
28.       {
    / I' P& c& g+ G+ c. ]/ d
29.         if (Enemy[i].x < Wide_map)
    $ G% [9 b6 n! C( W. s3 Z
30.           Enemy[i].x += enemy_sleep;8 H5 W# Y* ?7 g0 Y- J
    
31.       }
    0 G1 f# b) L6 K  ~
32.     }
    ( l! B; d& ]! b1 B3 J7 @
33.     //敌人追击玩家
    8 i9 V( G) y+ d. }1 k+ W
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    4 h1 q, G$ j9 [# Y% N; G
35.     {
    - ]\" l/ k3 I5 I7 W* e* `9 C\" ]
36.       if (Enemy[i].r > player.r)
    . s, I+ y6 }: V) ?
37.       {8 H. P) M# e) d+ U4 m! M9 q' [
    
38.         if (Enemy[i].x < player.x)
      A! ^' w9 h$ p' ~& S
39.         {' u$ }0 d# M( B4 |' W\" K8 P
    
40.           if (Enemy[i].x < Wide_map)
    3 W$ }, ~  s+ ^
41.           {$ y6 L2 I4 A\" ^$ Q7 f0 c\" |  h5 U
    
42.             Enemy[i].x += enemy_sleep;- a: _. N- G! P; \
    
43.           }2 U% l; \4 d, D1 M5 I8 B\" y
    
44.         }! U( t, V! X4 L) r3 E+ i1 Z
    
45.         if (Enemy[i].x > player.x). X; T$ g# k2 a# b
    
46.         {; O! t! f6 p7 ~6 x( S  i
    
47.           if (Enemy[i].x > 0)4 S: W2 A$ g5 f; ]& q\" w1 r  v1 H
    
48.           {
    . }$ \2 g8 M. B4 A) U3 ~5 a# V
49.             Enemy[i].x -= enemy_sleep;
    * }3 F' V, T: M9 y- `
50.           }% v\" a- \( ?4 ~) w0 R3 A$ I! L2 \! j
    
51.         }
    ' g) @2 M' T1 O/ `: h
52.         if (Enemy[i].y < player.y)6 y1 Z! P! W2 T, _/ H: q
    
53.         {4 K5 |/ m4 b! J6 o
    
54.           if (Enemy[i].y < Hight_map)
    ! |1 F( \0 {. y# f' `8 R2 B; s
55.           {
    * A* s! W# @\" s3 w8 h) W- }
56.             Enemy[i].y += enemy_sleep;5 @5 a8 L, [% D7 B% N4 k7 @
    
57.           }2 y: ~( j0 P0 m
    
58.         }
    ) B4 w; I* ?+ c2 A; N/ ~$ R( @
59.         if (Enemy[i].y > player.y)
    0 S7 `\" o7 f1 b0 Q8 k\" @
60.         {
    9 B/ Y* y: r+ t/ e8 o7 b5 K* R
61.           if (Enemy[i].y > 0)* q6 B$ H  @4 T/ n& A/ V
    
62.           {7 @5 m) E/ h\" I# k/ K/ S, t
    
63.             Enemy[i].y -= enemy_sleep;
    7 n! X; m0 |' z6 r) k% X1 B
64.           }) I0 R& z. e, d: a. c( S! ]$ k! X9 K
    
65.         }
    + j% r4 v4 |. o  ~. Q1 V
66.       }, i\" l+ s; \  W: ]4 _
    
67.       //敌人逃跑\" j$ g* K! ]0 ^) k
    
68.       else
    : \1 P1 n6 A( D* U: J
69.       {- ?$ o; J# G! g
    
70.         if (Enemy[i].x < player.x)/ a: x# y& R8 U7 u4 f& S
    
71.         {/ p* o# j* ~, i* ~7 W9 i
    
72.           if (Enemy[i].x > 0)
    4 Q6 U+ [6 B3 u- d2 {6 ?. b
73.           {
    ! i8 ^5 c! F5 _1 w5 c
74.             Enemy[i].x -= enemy_sleep;4 i2 p9 t/ _; _2 I9 p. g4 V
    
75.           }\" Q4 `5 T: j. ?: e\" m6 k9 j
    
76.         }
    . n- M. C+ P5 O4 I: F/ b8 n
77.         if (Enemy[i].x > player.x)
    1 a( m! B! r; t
78.         {
    \" ?9 \, i# u0 Z- e* ^. _
79.           if (Enemy[i].x < Wide_map)
    ; @# W9 m% g/ t
80.           {' C7 V) A- I; P* n+ l& ~* t
    
81.             Enemy[i].x += enemy_sleep;
    ! G0 b( i, a/ n
82.           }
    - V; ?! T! e3 ?1 y% I0 h
83.         }
    7 A8 _8 d% x  U; ]
84.         if (Enemy[i].y < player.y)
    9 \: t1 N7 g% N# r) X6 F
85.         {. J6 B0 g* t$ O  P' w6 s
    
86.           if (Enemy[i].y > 0)
    - ^/ j) \7 B7 C* B2 I4 z  j- D
87.           {- Z) Q\" r. h5 K0 P* |1 Z
    
88.             Enemy[i].y -= enemy_sleep;1 W! s6 z8 X7 X; l& b) `
    
89.           }
    9 ^6 D5 E* u5 z$ r' g
90.         }
    7 b1 T; w6 S: H+ ^' A
91.         if (Enemy[i].y > player.y)
    0 v& Q! T6 ]* T- l
92.         {  C( ^5 M8 Q8 I8 F
    
93.           if (Enemy[i].y < Hight_map)( j7 p% K* G0 D$ F% o5 K! }6 f/ m
    
94.           {+ ?9 W; [' ~& Y3 ~: f
    
95.             Enemy[i].y += enemy_sleep;
    . V\" I! q$ P! H! l4 ~
96.           }
    # S# P- _, c' p! ]$ b5 _+ Q
97.         }
    , X4 {2 C9 n, Q7 @/ }, `7 ]/ L; T+ r& U
98.       }$ `3 j7 [8 D9 G* q
    
99.     }
    : E\" E7 y+ K4 {1 j
100.   }7 c9 w4 l2 G1 c+ t& K0 x3 n
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()# }# a% h' h7 ]$ H$ S) M; z8 h0 Z9 E
   
2. {( C, j8 o) I9 _' L
   
3.   for (int i = 0; i < Food_num; i++)2 e! Z; {( p! K- j  r\" x: R
   
4.   {
   : M\" A- V) ~1 c\" m% |1 n
5.     //玩家吃食物0 h. D5 T+ `6 \' D7 V, m
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   8 V! T$ n  {$ ?, _: U- f
7.     {: G% u% x/ G/ X! N3 ^: R% I
   
8.       player.r += Food[i].r / 100;
   6 a3 X( x% R) C& s1 n: @
9.       Food[i].x = rand() % Wide_map;
   1 M$ k, y, E# }% B, k8 [( K2 G
10.       Food[i].y = rand() % Hight_map;\" h2 s9 E! t6 n/ t3 t6 f
    
11.       Food[i].r = rand() % 5 + 1;
    ! Q% @% _! G( g7 @- @) ^
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    # [; v& f) S4 R8 o
13.     }
    ; P$ b+ ^6 s' a: ], c, a7 q: ?- _( ]& p
14.     3 y$ O. b# S0 N5 G# c, s; l# a
    
15.   }
    # {' q9 F2 i5 T- L* g, ?
16.   for (int j = 0; j < Enemy_num; j++)
    9 G\" d* n) q! n
17.   {
    , ?& k  {) j0 I* w
18.     //敌人吃食物
    3 m0 |- J$ M9 a\" F
19.     for (int i = 0; i < Food_num; i++): P6 U: K) Z/ }  \
    
20.     {
    : m* q1 M- Q' h& ?4 o' u; t
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    ) I& T/ R4 E  o4 V
22.       {
    ! g5 l. c3 P6 B$ a# _% e$ d
23.         Enemy[j].r += Food[i].r / 50;* I: l$ x% v( i1 @# v
    
24.         Food[i].x = rand() % Wide_map;5 p2 b$ A8 Q- y8 u
    
25.         Food[i].y = rand() % Hight_map;
    ) ~  Z\" r, b- y, Y( T
26.         Food[i].r = rand() % 5 + 1;
    6 g: X\" f7 g# M. f3 i
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);, ~* [) E: k7 Q\" p2 X; M
    
28.       }, A+ h/ g2 j. t5 g
    
29.     }. C$ n% T) E0 S
    
30.     //敌人吃敌人6 F: B% x7 i0 c  T0 P\" W) j% d
    
31.     for (int i = 0; i < Enemy_num; i++)
    + s, j0 g- d' o+ t/ p
32.     {
    5 J! E/ A! y: P, H7 I. Y* o$ o
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    1 ~1 p* P2 b# r7 G6 y7 L
34.       {
    # S; x+ I  W- ]
35.         Enemy[j].r += Enemy[i].r / 10;) R% `3 M! o, \3 B9 o8 C9 {& ?5 m
    
36.         Enemy[i].x = rand() % Wide_map;
    * N1 N$ M% \* n0 |* h( U
37.         Enemy[i].y = rand() % Hight_map;8 H2 Y3 k% X$ I7 O. U
    
38.         Enemy[i].r = 10;0 J& |& o( ~9 R  j
    
39.           Enemy[i].color = RGB(0, 255, 0);- N  \8 r. I1 l& ~6 d* D
    
40.       }
    / P$ X3 b% f9 h  K5 J3 t5 e! P% Z6 v
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 K& f  O5 M' l6 D0 N
    
42.       {
    % r1 d& W\" O- I+ I) Q5 h( r
43.         Enemy[i].r += Enemy[j].r / 10;
    9 D! u( H1 u! |$ V) G# Z; \# T- X
44.         Enemy[j].x = rand() % Wide_map;
    ' {: L. Z* b) n
45.         Enemy[j].y = rand() % Hight_map;
    ) `& v% x( f- L! }  b6 X; F
46.         Enemy[j].r = 10;8 F3 _/ m# O7 @8 H
    
47.         Enemy[j].color = RGB(0, 255, 0);
    , t$ P5 L* J% B0 J. K* l9 r
48.       }- A# M& i6 ]' S- l9 a* f' M
    
49.     }2 F( J1 {4 }\" r  ?, F: N* |
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)) L$ F. M5 h7 O& z/ N. I  T% y
    
51.     {- g& `- ^# i* O8 x7 S6 _
    
52.       //玩家吃敌人
    5 M, K! K8 F$ z1 y5 |- I6 y
53.       if (player.r > Enemy[j].r)
    0 {  y5 n- t5 x6 X1 h, W
54.       {4 k\" N. Y3 R/ U6 y8 X
    
55.         player.r += Enemy[j].r / 10;
    : m: z4 I! {' X/ w2 ?3 z
56.         Enemy[j].x = rand() % Wide_map;$ s2 P4 J% D2 H  ]2 K1 f/ J9 G- h; W
    
57.         Enemy[j].y = rand() % Hight_map;
    - O. q) e  p) e0 [# D
58.         Enemy[j].r = 10;
    ( L) K, ^3 M( `6 K1 C
59.         Enemy[j].color = RGB(0, 255, 0);& d1 x' s% Q' s0 H
    
60.       }
    + O3 N* I' l( r! p; ~
61.       //敌人吃玩家
    * Q; T% U  c3 v: ~
62.       else\" W8 i/ u  w8 Q( x( p
    
63.       {# ~7 {% g! `; @. t
    
64.         if (invincibility == 0)
    ; f' O/ q+ s8 B; R% w% _/ H
65.         {' I, G, K7 ?# h3 ]& {\" T( J
    
66.           Enemy[j].r += player.r / 10;$ ~' B% m6 ]& e/ l- u
    
67.           player.x = Wide / 2;
    , W/ W) r6 G0 {- }
68.           player.y = Hight / 2;
    7 H+ V3 I' J. M' \6 H
69.           player.r = 10;
    . [6 F: ^4 N5 v3 H\" ]( @
70.           invincibility = 10;$ P3 b, y. z; }
    
71.         }
    / x5 |! D\" T2 J. F  j3 `# L0 c: N1 n
72.       }& `\" S- Y) n! ^) z% _# |' q. {
    
73.     }
    8 q/ Q! \. Z8 i. A2 b
74.   }
    ( P4 t5 ]% n$ ?- U2 |9 T
75. }

复制代码

完整代码见附件：


3 X" U5 o" t  y. r