球球大作战

2744557306

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

" h+ C. W( ?) E9 ~3 ]2 V. ?在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

! P! b9 @, C6 ~- {游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
4 q3 h" M5 C& ]' S" u( t
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
8 c' l7 \8 ]% \) G! L- r3 J% ~
其他小球：其他小球又分为食物小球，和ai控制的小球

体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

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

ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

接下来，我们将通过以下几个步骤来实现这个游戏：

( t. G4 X; e1 l3 @. i初始化游戏界面和小球的信息。
: ]- `4 p$ N- q
处理键盘输入，实现玩家小球的移动和加速。
+ I* J& D! k3 P3 ?' t6 Z
7 Z6 |3 {" L" J1 W生成足够数量的食物小球。
- _2 a" k. O  ^/ p/ H
" Y9 ^+ U9 Y6 f: t生成ai小球，并控制其移动。

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

: Y+ t3 k+ a8 V/ J; m% C% d4 E5 m通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
& [$ G" a+ A$ L. o9 u; Q
" N' b0 ^3 Z* o- c6 ?1. 小球的要素
- P6 f' E/ e0 p* }. \( N在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

8 \; N, o' j% |0 w# _8 wstruct Ball
& a  t: ~" u4 I7 V& _9 Y{
        int x;
, O8 m$ ?3 C5 }: g$ H+ M        int y;
5 |1 G$ b" Q* b# H5 a        float r;
        DWORD color;
};
2. 初始化小球的信息
1 G( ]# C+ }0 @9 v+ M将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

橙色可以通过RGB值（255, 128, 0）来表示。
! b2 D$ `7 q, l黄色的RGB值为（255, 255, 0）。
0 \) \+ @/ O' f6 H. B绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
: ^1 y: A8 y  i. i0 Q6 m紫色可以通过RGB值（170, 0, 255）来表示。
/ K5 w8 F# c$ M5 l; W黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
: ?: I2 N; ]2 p% [) Q/ h灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   2 \9 Y$ v5 S! l
2. {' g) r0 F# W1 Z7 c& q. n/ {
   
3.     //玩家小球
   1 Y' Q. K5 f& z' j& s) k
4.   srand((unsigned)time(NULL));4 _0 E( o; J9 M9 ?- d) N2 l8 ?! |
   
5.   player.x = Wide / 2;. O\" ^2 n$ c1 X- h7 Y
   
6.   player.y = Hight / 2;# |$ L2 }) p5 N( k1 V  [
   
7.   player.r = 10;/ d/ J& t- e6 \\" G% r$ w
   
8.     //食物小球
   # R4 N! y7 ]\" Z+ K& o# Z
9.   for (int i = 0; i < Food_num; i++)
   ; `% m6 }+ S. Q% ]
10.   {- l) _4 S( x6 Y6 S$ |1 e; g
    
11.     Food[i].x = rand() % Wide_map;9 q* T/ h: O  @& @1 [
    
12.     Food[i].y = rand() % Hight_map;
    . z) {) h9 l4 p# S  z
13.     Food[i].r = rand() % 5 + 1;
    3 y$ Q( a8 A/ S, r5 U, ^+ t+ ?
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);; M7 Z* d. s4 R$ c! ^
    
15.   }$ F7 q6 P! Q9 d$ p+ N5 {, V' W
    
16.     //ai小球% r) D& A  i9 Q, t: g7 o
    
17.   for (int i = 0; i < Enemy_num; i++)
    3 G0 @9 L( T4 T- z* ?* t/ M
18.   {9 r. v3 n- K# ~! A
    
19.     Enemy[i].x = rand() % Wide_map;
    6 F& ~' G' j' f5 c6 O
20.     Enemy[i].y = rand() % Hight_map;/ Z$ n: Z! ~$ n0 Q- B* K0 o
    
21.     Enemy[i].r = 10;
    * N) N# h6 M' c- ^% [* ]
22.     Enemy[i].color = RGB(0,255,0);
    8 [  H/ b! ~: N8 {3 ~% n2 ^. [
23.   }
    4 F' J1 _1 I/ n5 L
24. 
    4 E1 W' F9 T& O7 Z( R
25. }

复制代码

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

1. void Player_move()' [\" b/ S1 E: y
   
2. {# b/ {* @# H\" d1 N
   
3.   if (GetAsyncKeyState(VK_UP))
   5 I2 D1 J/ }& w5 Q$ p  T6 G
4.   {
   $ ~) Y: a* n3 I* G& |& ^
5.     if (player.y > 0)
   ( Y1 ?# J* `: S
6.     {\" y$ c! X3 M8 X/ u! S( s0 u2 l\" s+ w
   
7.       player.y -= player_sleep;6 @  P* d1 X3 a/ a* J+ {/ ^; M
   
8.     }! f1 e4 ~( L# d- L. w
   
9.   }1 i9 v$ o/ c. m# ~\" N
   
10.   if (GetAsyncKeyState(VK_DOWN))
    $ [, ], W& P  X4 N
11.   {- O  P: ^, Q  f0 e3 x' \( c
    
12.     if (player.y < Hight_map)+ ~' b) a* l: L: E
    
13.     player.y += player_sleep;
    3 I& I1 @3 S! G; r
14.   }
    ) u* s8 Q+ n/ V4 U
15.   if (GetAsyncKeyState(VK_LEFT))/ A/ x4 I2 b8 H  H. ~
    
16.   {
    5 h/ f) J& X+ b' `9 D
17.     if (player.x > 0)- Z1 k% L# s' E' Z
    
18.     player.x -= player_sleep;
    6 F( T7 V' U; M
19.   }7 x# s+ z5 X\" }7 Z  o% _+ m8 o
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    ; E: z5 S! l3 c9 Y; h  c' D  Z
21.   {
    5 U0 f. J1 e8 h& ?
22.     if (player.x < Wide_map)# K$ }, K0 D/ c& E% D\" d- j
    
23.     player.x += player_sleep;
    + e& R; I# S' i9 n4 o
24.   }
    9 x, _5 ~0 O: z9 ~0 W
25.   if (GetAsyncKeyState(0x20))
    6 U2 S3 b- P% i+ ]! H- J\" q
26.   {\" t/ w$ v2 e. l& Z
    
27.     player_sleep = l + 5;, S5 U0 y$ u( ?7 A3 ]7 Y- H& U9 c
    
28.   }- I  O0 t4 n+ P$ J* A9 @
    
29.   else
    ! U) Z+ S( l: t% _7 j0 z& h
30.   {7 l* k& z( c/ r- `0 N/ J1 A
    
31.     player_sleep = l;1 L& h: n7 @) C! `
    
32.   }: f4 I& r9 _' }) M
    
33. }

复制代码

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

1. void Show()
   4 r, {$ W2 x# o; R5 T
2. {
   ) l. B! u9 s1 O! _- s3 e7 _  \4 ]
3.   $ V6 P# N, Q7 u( _$ g
   
4.   //设置地图6 e, A1 Y3 F0 n
   
5.   SetWorkingImage(&map);
   - B8 U8 T) _$ i. g: X* Q- i6 M2 k
6.   //清屏
   3 y\" z3 V- b4 W# t) ^: j/ w
7.   cleardevice();* p# Y+ P3 C, M+ u; d! u6 d% n
   
8.   //背景颜色
   + o  A$ d; M  |# C
9.   setbkcolor(WHITE);' X+ W+ _6 B& _$ {7 k
   
10.   //划线颜色
    3 s8 E3 `% r6 L0 r5 p$ a
11.   setlinecolor(RGB(230,231,239));
    ! d5 k# t! `$ Q* ~  n3 u/ s
12.   //划线
    0 F* d8 C0 t& b1 C$ i) }
13.   for (int i = 0; i < Wide_map; i += 10); X9 {% S% q! T  J) B
    
14.   {7 X' C2 M1 |: F0 ~* J
    
15.     line(i, 0, i, Hight_map);; I; [# e- q2 O! U! V
    
16.   }
    2 `8 l& m3 L7 n) i
17.   for (int i = 0; i < Hight_map; i += 10)4 y) f- M6 V7 `3 z  w% o
    
18.   {# T1 b# M- u3 V2 ]
    
19.     line(0, i, Wide_map, i);# W& w. V: A% S( L9 h
    
20.   }
    5 T( ]' q& Y+ m) t4 a1 ?
21.   //食物
    8 v+ I6 l4 |7 |% w- k2 c
22.   for (int i = 0; i < Food_num; i++)( D1 a4 P; a# r. p/ {\" `) k+ ^
    
23.   {6 _& r2 h5 v\" {( {, C8 E
    
24.     setfillcolor(Food[i].color);% n; O5 e0 [) K  u/ B9 {
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);! u( p! Q\" b7 y8 ]/ n$ V+ p
    
26.   }
    / {, d% h& U' r9 I% ?# [% j
27.   //敌人
    # x& m: P+ J; m
28.   for (int i = 0; i < Enemy_num; i++)
    # H. u: G6 y; z& u7 I) m\" L
29.   {
    $ D$ ^/ Q! x7 \\" l
30.     setfillcolor(Enemy[i].color);4 A0 G0 ~( }/ l; N* x! ]
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ; x$ J- N  Y% }+ ?: I) n' _2 Q- u
32.   }) `- Z5 t* _\" ^  e8 u. M
    
33.   //玩家1 b3 I5 u$ O# j# D8 E9 l+ e
    
34.   setfillcolor(RED);  V: k1 I9 t0 A  {, P\" Q/ O* I
    
35.   solidcircle(player.x, player.y, player.r);
    8 Y0 P3 x/ H, M
36.   SetWorkingImage();4 u9 d, d% o$ ^& j
    
37. 4 w: l1 |) k# ^( b# }& N
    
38.   int x = player.x - (Wide / 2);: M# V' K3 y/ w$ F
    
39.   int y = player.y - (Hight / 2);
    \" l+ y8 @# _\" B
40.   //防止窗口越界
    9 y! f\" I/ ~0 X; K5 H; U\" I
41.   if (x < 0)6 W. ~1 p9 i\" S' `
    
42.   {
    ( H. w0 f; Q5 @# z8 T: ~# _; ]5 H
43.     x = 0;. p3 L1 |$ x$ ]
    
44.   }
    * t' |* J7 a+ I
45.   if (y < 0)
    4 J) e5 |1 ?2 R6 N! |( s
46.   {( C  t4 f+ Q& V0 q7 p
    
47.     y = 0;
    . {8 N$ ]# n# J) E+ a4 z, i; b& T
48.   }2 l8 f; u2 l$ q5 {4 D& b2 e9 S9 O; ]
    
49.   if (x > Wide_map - Wide)
    / }2 b. u  q0 g+ N' \( z- F7 M
50.   {
    ; d- k  ?\" L5 `* w7 `
51.     x = Wide_map - Wide;  o\" h) \  [% o% k
    
52.   }
    : d5 Q' C. W2 l- D
53.   if (y > Hight_map - Hight). b3 v! c/ i, f- D+ G
    
54.   {
    \" B% L( i- {' d
55.     y = Hight_map - Hight;0 c) G% W$ `- }4 x
    
56.   }9 M+ C1 ~2 D; z4 q
    
57.   //把map输出到窗口上$ N. j$ M8 R- X
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    : E\" q, B/ r* w; n$ X2 W; 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. //防止窗口越界
   : C' J- g( ]( z: h' O
2. if (x < 0)
   ) y\" [5 \4 C! i
3. {
   . Y. C4 j. P8 f6 f9 t
4.   x = 0;
   ) j& u/ v( M+ k. x% {1 N2 a4 P( A
5. }
   4 L: F# r7 [7 }+ D. l
6. if (y < 0)
   : u5 D9 a. q# E& B& P( N) L; q  r( o5 [
7. {
   ! e7 l) ]8 W: I- d+ ]- c, U* k
8.   y = 0;) i$ v- ^$ O3 v; k. m
   
9. }: h* E& w7 I$ f/ P, b* M& y% [
   
10. if (x > Wide_map - Wide)/ L! s: ?8 E0 T7 y0 d
    
11. {2 H3 h9 {- g( r5 P
    
12.   x = Wide_map - Wide;( ~\" C/ ~9 i8 ?# R
    
13. }
    0 X6 A3 t6 S6 J3 ?0 m2 k- t
14. if (y > Hight_map - Hight)
    ' E\" \; o7 a2 b
15. {
    : _& T- C; U- j: n
16.   y = Hight_map - Hight;
    ' S3 E  d9 D. {0 ~/ t
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
5 {+ [) j4 n5 U: a( G0 O1 |
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
0 P% S' ~! J1 D- i
Wide：这个参数指定了要绘制的图像的宽度。
, ~3 \+ J* G% Q" D9 s
Hight：这个参数指定了要绘制的图像的高度。
, O. ?/ D. S6 B1 r) p
$ K" P1 c8 ?7 R) B3 N( R. }&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

* @4 R) {* s, j0 n8 G8 X7 |+ sx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
; c  l8 j( i) j2 P  s8 i
' ]+ h& i9 C5 b1 p3 s8 K( c& ^; ?y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离7 j  G% w5 d6 ?
   
2. int Distance(int x, int y, int x1, int y1)
   : ]$ z. J- y, i$ i
3. {5 ]4 ?- `4 d\" q9 }. J& n/ m
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   7 V+ V; z6 K7 l6 N
5. }

复制代码

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

1. void Enemy_move()7 J  k- [- u; l' C$ Y5 w6 }
   
2. {
   : h! L3 K% k8 a$ o
3.   srand((unsigned)time(NULL));
     m# B2 _( a0 i% v& L
4.   for (int i = 0; i < Enemy_num; i++)
   9 n& \/ u  A6 z
5.   {
   ! c, ]# P( l+ D( K# D' u# A
6.     int direction = rand() % 4;) N% Z: Y( [\" C
   
7. 7 u# `, G+ k$ g$ u2 k
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)& C& {- }% X1 S# y+ f4 M' u
   
9.     {) \2 Y8 N( y% r9 t0 ?: j' ^' M
   
10.       if (direction == 0)
    7 Y, c5 R9 ^& [# U3 `+ V# K% W
11.       {
    9 d& I) Y6 T, p. ^. k
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    + t  ~# f7 c\" f' t6 C0 J$ S
13.         {
    ! V' S: n) ?  z( \
14.           Enemy[i].y -= enemy_sleep;
    4 M; P/ o' Y  U! T6 j5 J* p
15.         }# E+ I' @, P5 E) e
    
16.       }+ k3 r* w\" r* |: U
    
17.       if (direction == 1)8 d\" J: U; v$ Z2 d
    
18.       {4 `# F5 J7 G' h6 m' y0 x\" N
    
19.         if (Enemy[i].y < Hight_map)
    ! L# S+ v1 ?3 q& ]3 C9 Q, Q8 p
20.           Enemy[i].y += enemy_sleep;
    $ P5 ^. l7 e$ N  X8 \\" C. t5 Z6 O9 o
21.       }
    ! S0 `+ s1 [3 b+ `& ?
22.       if (direction == 2)
    \" U/ k0 X4 w0 L; a\" B
23.       {3 x; e3 Q6 h& I) N
    
24.         if (Enemy[i].x > 0)
    $ ~# q5 L) ^) @: Y, w
25.           Enemy[i].x -= enemy_sleep;
    % L  B\" [/ W\" j: S, D1 V9 u+ F4 r$ ?
26.       }/ A  h- b: Q7 y# E; x
    
27.       if (direction == 3)8 y! g1 G7 v. |' h2 o9 J3 L
    
28.       {& w3 H/ t# n$ S
    
29.         if (Enemy[i].x < Wide_map)# a) H1 c/ `5 m; Q
    
30.           Enemy[i].x += enemy_sleep;0 S3 M* k4 v0 {( K
    
31.       }
    6 J% h6 N) r) E( J- n. d5 C5 Z
32.     }; [8 o' K4 N# ?! p5 c& J1 h4 T
    
33.     //敌人追击玩家0 g2 e4 B  R% D, ]
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)2 \: ?\" o- A7 e' e
    
35.     {
    : m# F1 B0 R1 t( H6 H7 I
36.       if (Enemy[i].r > player.r)0 g+ b& U  _% M5 h. D+ k' R
    
37.       {
    & x) H, b( H4 C5 b. e
38.         if (Enemy[i].x < player.x)
    $ @  Q) P! T' g\" E. ?, s: C
39.         {
    & s. ^' L4 W+ o4 o! M, C( A. |/ d
40.           if (Enemy[i].x < Wide_map)
    6 C# o* F6 |! x/ l7 V1 x) `
41.           {* b# K+ @\" r2 O
    
42.             Enemy[i].x += enemy_sleep;6 e9 g4 |; X( D7 L( N- B; O
    
43.           }) \8 o0 L3 g0 w$ P  ]: q3 K, E
    
44.         }$ n6 Y. L) t6 `
    
45.         if (Enemy[i].x > player.x)0 K  Z+ N( d3 g  @% Q4 d( ]
    
46.         {  A1 M4 E8 L/ k5 V; J
    
47.           if (Enemy[i].x > 0)
    0 Z7 l  O2 ?1 D) m3 x$ s
48.           {
    ' g1 c1 o/ |% T5 k! G
49.             Enemy[i].x -= enemy_sleep;4 }/ ^5 u! \7 {' q. H/ e0 v, s
    
50.           }
    0 z2 ?$ f; r2 h, H) n# A0 f
51.         }
    / h' c0 r2 u! p9 k9 Q, ~1 {& Z
52.         if (Enemy[i].y < player.y)
    \" G* O  q\" E! A' B1 ^  I7 `
53.         {. n& P$ r- H+ F, H. h3 Y6 C
    
54.           if (Enemy[i].y < Hight_map)8 \% E, ^! ^  K+ b
    
55.           {
    , L. X1 I, d6 t4 h% D\" Y
56.             Enemy[i].y += enemy_sleep;
    \" f0 Y. r. Y$ |4 H1 y
57.           }
    - u: y  l0 p\" z5 }$ r' t
58.         }- k2 ?4 v! g. n0 r6 i
    
59.         if (Enemy[i].y > player.y)
    9 B6 z8 X( {, B( {# m
60.         {
    ! u2 [- \: |9 J0 i- o. A
61.           if (Enemy[i].y > 0)4 x; G+ S\" K$ {
    
62.           {9 v* s, u$ U. s
    
63.             Enemy[i].y -= enemy_sleep;6 y3 s7 z! ]8 H' V
    
64.           }/ U. Z' D1 e5 B7 j( Y
    
65.         }
    1 T$ H% I, `8 A- U- {8 m\" O
66.       }
    9 h4 ^# P' N  F
67.       //敌人逃跑
    + J# ]$ G* D8 G# x
68.       else; n: A) p\" p5 M) g2 Q0 f
    
69.       {  G2 b: X% a) ~* |) J
    
70.         if (Enemy[i].x < player.x)
    0 R2 W. E9 f. H/ x# C$ p
71.         {
    . h! Y. }/ Z9 o; _' l$ f0 j& f
72.           if (Enemy[i].x > 0)% m. t; S8 C6 V- R9 j
    
73.           {
    4 @+ o% w1 Q$ ]' ~- w7 j
74.             Enemy[i].x -= enemy_sleep;
    + ?; i4 q! @. P! O! h
75.           }
    * W5 q5 V# W) G
76.         }
    ( u$ h0 x& N! \5 r' D
77.         if (Enemy[i].x > player.x)) V2 x$ y+ E5 E2 g3 ^# }
    
78.         {
    % c7 t! P7 S1 T9 A
79.           if (Enemy[i].x < Wide_map)
    ! L7 z0 I& L8 h2 P6 D
80.           {# T, E$ a' J  f: S% H  H1 A6 c9 L1 j
    
81.             Enemy[i].x += enemy_sleep;
    * v3 i+ B8 j  q6 T: }( k
82.           }. o: _, P5 C, I! s' }/ c
    
83.         }
    ) V- E1 ]3 o' s# p+ ^
84.         if (Enemy[i].y < player.y)
    : q3 o: R& O5 z7 v8 C5 u3 y$ y
85.         {
    3 g+ H% c5 Y( \% n8 w& B$ r\" P
86.           if (Enemy[i].y > 0)% ~+ t7 E# N, b
    
87.           {9 @, ~- z- F/ ]; z
    
88.             Enemy[i].y -= enemy_sleep;
    5 t4 j( f* k3 m, q
89.           }: v0 R/ `9 O: h4 N& P0 |& L0 |
    
90.         }8 R* a) M9 J: x9 S, |0 {6 f& L7 \* d3 Y
    
91.         if (Enemy[i].y > player.y). ~5 D3 V0 r) m
    
92.         {
    ) f; f* }3 z! ^* I0 C4 t$ y3 d
93.           if (Enemy[i].y < Hight_map)8 h8 T- R, ^3 N% h  A
    
94.           {7 |% T/ L0 l7 z( B* ?* b% x6 m! u
    
95.             Enemy[i].y += enemy_sleep;
    ' [! D+ O\" C3 P  f+ h: j: t
96.           }
    + J# I) d6 B\" Z\" @7 P
97.         }; k* f  V+ B' O& E# a0 j
    
98.       }$ }: w8 J4 M6 l2 D3 e
    
99.     }( l8 z5 B6 G+ S
    
100.   }
     : C; A1 R9 C2 a
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   $ A+ @9 V1 {$ B- i% C/ \; t
2. {\" i( `\" f& D) V! w) {: {
   
3.   for (int i = 0; i < Food_num; i++)\" t( d3 R3 j& K( ~# R
   
4.   {
   ( r! c! S' W/ b8 C  I0 N
5.     //玩家吃食物
     Z+ I! T9 k9 w
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   0 y% g- R# |3 N: @# W
7.     {: \( p/ O$ G- h4 g/ w. e- P
   
8.       player.r += Food[i].r / 100;4 `; p4 |9 |2 j3 L% j# t
   
9.       Food[i].x = rand() % Wide_map;
   ) R7 N, Z1 B( k  y' W* _& P
10.       Food[i].y = rand() % Hight_map;! W/ W9 ^% D# t7 h! q
    
11.       Food[i].r = rand() % 5 + 1;* Y5 L3 c' @: K4 j! U
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    2 V- }0 w& {  E8 V  m
13.     }6 Q) R. u$ B# c3 j6 L1 T
    
14.    
    $ {$ P* G\" \1 v4 m1 {( |
15.   }
    \" M; A, {/ q, z! I8 }) v
16.   for (int j = 0; j < Enemy_num; j++)
    1 ~0 _: v6 d) A0 Y. F* S) C; d
17.   {* ~* J- x' i/ k/ q( G
    
18.     //敌人吃食物
    & l! e4 G; q' S, o' v/ w7 u
19.     for (int i = 0; i < Food_num; i++)# `# d) R1 B% o# j! ~
    
20.     {0 a: h# `5 P0 q% }' |2 V+ X9 m\" E
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)6 J1 x\" w0 y, G4 A\" a* P- V# @
    
22.       {  e$ T  a7 O  G- g
    
23.         Enemy[j].r += Food[i].r / 50;# D3 R$ X3 N. W' c1 o( N% A
    
24.         Food[i].x = rand() % Wide_map;! I2 K# x: V; x% z* ]8 d7 a' g7 {4 m
    
25.         Food[i].y = rand() % Hight_map;* Q2 B# J2 V. T3 R
    
26.         Food[i].r = rand() % 5 + 1;7 c. c) e. Y* c% N/ t
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);* f4 B2 @5 Q7 [3 Z( l! O: ]2 n
    
28.       }, Z9 B1 H4 i% ~9 J4 [+ u* P( l
    
29.     }
    ) K' Y) `. V% c) Z
30.     //敌人吃敌人
    0 I3 `8 K6 d$ f; P8 H
31.     for (int i = 0; i < Enemy_num; i++)( n; n+ ?! o3 p\" o. z
    
32.     {
    # H* O0 A* c- S+ o1 M& p, [8 h
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    8 [% w. d. m8 ~9 ?  C
34.       {! W! p$ B) b3 T' C. Q* x
    
35.         Enemy[j].r += Enemy[i].r / 10;
    / N8 Q/ O9 a8 y. m/ T+ a+ w5 y
36.         Enemy[i].x = rand() % Wide_map;% y( ~! |  A\" _+ m5 F4 w
    
37.         Enemy[i].y = rand() % Hight_map;) ]  f! N- Y! L: r3 \
    
38.         Enemy[i].r = 10;
    + m( _9 ?; x7 f$ B
39.           Enemy[i].color = RGB(0, 255, 0);
    7 A# a2 G8 }2 c# J8 |( F
40.       }* P& T7 P7 G9 N( {! F+ ?2 A! d& p
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    2 G4 |' W- d+ E
42.       {
    ) U' F. g- Z: Z' e. y
43.         Enemy[i].r += Enemy[j].r / 10;) L& M4 ~1 x; x& L& G% G
    
44.         Enemy[j].x = rand() % Wide_map;' i% q, z* h# F5 {. v7 v/ f8 |
    
45.         Enemy[j].y = rand() % Hight_map;
    9 w# l5 N% K\" I% ]
46.         Enemy[j].r = 10;
    8 ]5 i- Q\" @. T2 c4 A6 @. y
47.         Enemy[j].color = RGB(0, 255, 0);$ L  a; K0 \6 C8 e) k, j
    
48.       }
    7 K& J. @( l9 C2 s, W! M
49.     }
    4 |8 ^/ B+ q3 d4 d; m
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    1 o# S$ F3 d+ l8 \6 M
51.     {
      w4 a* x' X& r+ \0 u# `
52.       //玩家吃敌人2 W7 {: h9 }2 A1 b( h3 {! D/ f
    
53.       if (player.r > Enemy[j].r)0 ]& {. x* q: E, D8 M+ R0 o8 O. ^
    
54.       {
      c- v1 e\" \: @4 [1 j# {2 P
55.         player.r += Enemy[j].r / 10;
    6 l5 x: @* b' r( p6 n2 ]  ]+ {
56.         Enemy[j].x = rand() % Wide_map;
    \" n0 }7 A- h; V: n2 j& i
57.         Enemy[j].y = rand() % Hight_map;
    6 Q+ h0 I\" b; R/ F* }5 F
58.         Enemy[j].r = 10;
    8 i, J8 K+ o6 J& E4 O
59.         Enemy[j].color = RGB(0, 255, 0);7 |% {; C7 M0 i! S. |
    
60.       }
    - F: n; }/ @3 m' ~6 C0 D
61.       //敌人吃玩家
    / N. U3 |2 ^+ [  v, K- X
62.       else
    $ u\" ~: e2 Y( l; x
63.       {  U' s\" D, t6 `, e' C6 [
    
64.         if (invincibility == 0)/ ?5 x\" ~8 N. W' ~+ K; }
    
65.         {8 E4 E! D9 v0 u/ G/ B( o
    
66.           Enemy[j].r += player.r / 10;5 X/ @! e+ v' p+ L& W* R
    
67.           player.x = Wide / 2;' T9 [  l$ a4 C+ R8 o. s' l
    
68.           player.y = Hight / 2;
    & f& W4 I% C2 k$ _8 ]) P$ e5 m
69.           player.r = 10;
    - U, ^* ]( A7 M- R
70.           invincibility = 10;: S* u  m7 v( k- S2 t
    
71.         }
    $ x: x3 r' x# q
72.       }
      ]: {1 w$ f6 b6 Y, N! e  ~* |
73.     }
    9 [& V8 E; J7 g4 S\" [
74.   }3 U9 q) e7 H6 n
    
75. }

复制代码

完整代码见附件：

0 g& d* f  H+ R5 i0 L0 v
; h3 a8 Z7 h% d- ~' R0 O