球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
& x; }& j0 H0 p7 \" s
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

0 C* @" q; L& v% P) j8 D' K$ p玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

其他小球：其他小球又分为食物小球，和ai控制的小球
( w0 j5 T2 d5 ^% g+ U" C4 _
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
! L/ ~" @, O$ j% z. q" b" c, f% G% x
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

1 I' G" I8 g) I  _4 Q接下来，我们将通过以下几个步骤来实现这个游戏：

$ J2 V6 r+ ?  X" n+ f初始化游戏界面和小球的信息。
/ b% R9 b+ L* J0 M' v" T
处理键盘输入，实现玩家小球的移动和加速。
( j* Z; R+ Z3 p0 y. P/ e
, x) I* M" }$ H# x( D5 v! a生成足够数量的食物小球。

5 |( O( Z8 E; T生成ai小球，并控制其移动。
- _+ h$ I) x. C- T3 [
检测小球之间的吞噬关系，增加相应的体积。
' S* L, ]* ]) L4 j
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
8 m& L! p- }' Y) ~1 j4 {* e" \
1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

- B2 H: t/ X% m/ i) N5 K# I$ m8 Zstruct Ball
; g& M7 ~4 Y; ~9 e* z9 y" h7 I. f{
        int x;
3 ^$ J' E* Y$ p        int y;
9 i% Q: T5 m, j/ K8 ~        float r;
        DWORD color;
};
; M( h; e+ x6 h4 _8 m2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
' L7 h  ]3 J. c8 {' a" s. e& }
# U) @+ O% M6 FRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
1 j8 q  y& w0 c0 F: J/ U1 M; Z7 {. A
橙色可以通过RGB值（255, 128, 0）来表示。
" @. Y* [' ?  }黄色的RGB值为（255, 255, 0）。
6 B! a, d# m$ w绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
+ n! i% l/ M5 B0 b( C6 _+ D2 R紫色可以通过RGB值（170, 0, 255）来表示。
0 A& e. ]4 G7 T* _& P7 B# ?: q黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
! q% `' H/ Q$ N8 L0 S1 r& X+ x灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()5 `0 a7 n) g  `2 O: }# G
   
2. {1 [) ^- Z7 b! {$ O\" R7 y9 F
   
3.     //玩家小球
   ) M4 x  d+ z$ h* [) L: i: ]
4.   srand((unsigned)time(NULL));
   2 U7 f! [4 Q. Y% S  k
5.   player.x = Wide / 2;& u; q5 Y* }+ @$ P3 T) k# A
   
6.   player.y = Hight / 2;6 c0 b2 j0 N9 L
   
7.   player.r = 10;1 n# w& Y' [  |9 a) J) v
   
8.     //食物小球
   % Q6 G9 W2 V$ r6 g0 b+ \& f% p% a
9.   for (int i = 0; i < Food_num; i++)9 B% q( r. M# F5 s
   
10.   {
    3 |5 v7 c; N. ^' e; @' y5 [
11.     Food[i].x = rand() % Wide_map;
    + f) V1 t6 m+ |9 m1 j+ [# e9 ?
12.     Food[i].y = rand() % Hight_map;
    - E' W* z- h8 X) E) @9 T
13.     Food[i].r = rand() % 5 + 1;' F# g  o7 {- ?$ G% z2 T5 S
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);9 R7 V\" {; V# N
    
15.   }
    # o/ r! U  ?: L  _7 r
16.     //ai小球
    6 S, @, z7 B\" g- m1 ~0 q' G  ?9 O
17.   for (int i = 0; i < Enemy_num; i++)4 C4 Y8 m- Y  F/ w2 O- ~\" n
    
18.   {! h$ H9 m$ D2 E$ b  D
    
19.     Enemy[i].x = rand() % Wide_map;
    & u+ ?- h: H8 S4 Z' L1 i
20.     Enemy[i].y = rand() % Hight_map;
    - T- A- U* ^) F9 ]7 y% s  o
21.     Enemy[i].r = 10;
    0 A7 q% l' M, w5 X' c7 v0 i. [
22.     Enemy[i].color = RGB(0,255,0);& ?8 T4 W1 u* K
    
23.   }
    ' T4 X% B: p2 W! g  g+ J
24. 6 j3 Q- a6 N& l7 [% U! u4 b- W
    
25. }

复制代码

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

1. void Player_move()2 f# i. E7 J1 _* P
   
2. {\" D! c. W, @0 Q( K
   
3.   if (GetAsyncKeyState(VK_UP))5 W2 `9 e9 K7 m( g- |* X
   
4.   {
   2 ~( \( @) j7 h
5.     if (player.y > 0)* Z4 p+ v6 j4 }9 C
   
6.     {2 K4 ]- T, y1 T/ x
   
7.       player.y -= player_sleep;
   1 a! @/ d/ \$ Z' j) k
8.     }
   & c  Z\" ^+ k\" r\" ?2 J
9.   }- t9 j1 w1 k5 g7 \- x; w* B( g6 X6 \) B
   
10.   if (GetAsyncKeyState(VK_DOWN))9 c3 H6 c; V, w# O2 k% p* C, ^5 [
    
11.   {
    + m( y\" z, ?% y
12.     if (player.y < Hight_map)* l) h1 `. V1 T, l: g% m
    
13.     player.y += player_sleep;3 D+ _$ |: l\" z+ ]
    
14.   }* G% ^; T7 V; N) b( `
    
15.   if (GetAsyncKeyState(VK_LEFT))
    * F% E1 G, x/ O9 l8 N7 ^
16.   {
    1 U, r, c4 u# D# D8 A, R
17.     if (player.x > 0)
    ! I+ l+ G\" r3 J+ M2 t! T: W
18.     player.x -= player_sleep;
    ) A9 N% j+ s2 \9 J
19.   }9 @/ ^0 S$ ]2 b
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    $ Y# \5 w2 j- x6 ]5 M
21.   {& o# u( n7 X$ c+ {5 O- q
    
22.     if (player.x < Wide_map)
    . m6 \( U5 V/ r3 S0 |
23.     player.x += player_sleep;
    , R; Q$ d- L* y! `7 y
24.   }7 \7 s1 k$ \: g
    
25.   if (GetAsyncKeyState(0x20))
    & y+ Y- p# G4 ?5 k. Y# O) M
26.   {9 j6 s9 }3 M& ~  @
    
27.     player_sleep = l + 5;6 q9 O+ R6 ^' D; q: a+ E5 `0 H
    
28.   }1 m: ]* W# q& E# q
    
29.   else) j* z' i  e\" S5 }! C, h
    
30.   {8 F+ h' |2 @' t
    
31.     player_sleep = l;. @& M+ `  F1 C4 V9 @, m  W: q/ c
    
32.   }3 G+ m/ ^* R& p& r3 ^. }2 W
    
33. }

复制代码

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

1. void Show()\" a7 ?& e1 l* i3 r\" Y3 X8 v
   
2. {
   ( {  I. a  D2 E$ ?
3.   ; Y# W6 n* V+ U2 _
   
4.   //设置地图* `& q* e6 D$ |8 X, ?$ h- w' \/ C
   
5.   SetWorkingImage(&map);
   \" K* ~7 c( `1 f0 k8 b1 \
6.   //清屏) a' z8 y3 g$ y9 |, K2 D) g0 j
   
7.   cleardevice();0 U6 J* u2 N9 @5 p% z4 ]) \
   
8.   //背景颜色
   $ N, q( k* t3 h# t
9.   setbkcolor(WHITE);: D) }5 x+ j) P. V& V
   
10.   //划线颜色\" C2 W4 L& \% h6 t3 _
    
11.   setlinecolor(RGB(230,231,239));! j7 {8 @3 D8 a( \1 h
    
12.   //划线( Y  ^- L* H. O, F4 e\" W) ~
    
13.   for (int i = 0; i < Wide_map; i += 10)\" ]% d! M, J3 j8 L
    
14.   {: |  V' R2 o  C  r' m: X
    
15.     line(i, 0, i, Hight_map);
    9 D) ?: o: Y8 N2 D: i% L
16.   }3 b$ T8 Q\" _) C  f9 b9 D
    
17.   for (int i = 0; i < Hight_map; i += 10)& Z. N; L! B9 F8 \, v$ M
    
18.   {
    * H0 k) J7 O+ A1 s/ W: j
19.     line(0, i, Wide_map, i);5 \3 ~) e. X7 T5 E' W8 j# }6 h! X
    
20.   }% z$ l6 [- n+ F# g% o8 q
    
21.   //食物
    % g% O7 s8 T6 R; J: P9 l$ z* n) X
22.   for (int i = 0; i < Food_num; i++)
    1 D1 [  f6 Y; @. i6 o
23.   {* H  L; ~4 k/ f7 y6 @5 _% D; y- l
    
24.     setfillcolor(Food[i].color);
    3 Y1 l. ~9 o; a5 n  i/ H; Y6 B
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    . I( a- l( }4 n6 b
26.   }+ d4 ?/ A! H) y, W+ \; c
    
27.   //敌人& {  `8 f4 ~, e1 i1 E
    
28.   for (int i = 0; i < Enemy_num; i++)
    5 W( c/ X8 R  M( A
29.   {
    1 `7 n\" c4 ^\" u6 F
30.     setfillcolor(Enemy[i].color);
    $ s+ H3 l2 b& N2 Q% G% n. _8 C
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    6 O\" w- c' }) G. f, k; I
32.   }* S& |. Q) K$ `! Z0 K# {
    
33.   //玩家
    4 Y4 x: \\" T( n6 k2 ^. l! G
34.   setfillcolor(RED);
    8 n/ s. g8 v, J4 t3 s
35.   solidcircle(player.x, player.y, player.r);+ T\" G* v0 r( O- `7 y$ n7 l
    
36.   SetWorkingImage();
    4 Q' F- _5 M( `; Z- O
37. 
    / v& v4 t) m1 q& I# h2 d
38.   int x = player.x - (Wide / 2);
    1 S! t: u8 g4 D
39.   int y = player.y - (Hight / 2);
    4 P2 F6 k- q  \  ?5 d) w
40.   //防止窗口越界; \# E& P: t( W! G% u
    
41.   if (x < 0)
    + r7 v2 j\" \5 P8 D1 }9 ?9 a
42.   {
    6 O3 N9 E. ~; g
43.     x = 0;1 D- ^1 Z8 s0 e& Z( w
    
44.   }
    ; Y( M5 j8 @2 y9 p
45.   if (y < 0)0 v+ ]  V3 D  F
    
46.   {
    : b# X) {8 ?$ W+ P) j5 Z
47.     y = 0;
    ! n3 [9 t6 {& p& |9 j7 ?7 b+ I
48.   }7 x: m: Z# _1 p5 |+ H6 }7 u
    
49.   if (x > Wide_map - Wide)3 t9 Y  o( n/ w
    
50.   {
    ! T6 f, _( p9 e
51.     x = Wide_map - Wide;* j0 j\" Y/ J7 P  c1 C! b0 k& ^) a' |
    
52.   }, @7 W; }% f& J4 j
    
53.   if (y > Hight_map - Hight)
    / d) q* H+ K7 ?  M
54.   {
    2 j% r! E, `9 S; \
55.     y = Hight_map - Hight;: V\" j4 v3 o$ ^) i8 g# P
    
56.   }
    $ v$ g' I8 L1 \* E! O
57.   //把map输出到窗口上
    9 V; g\" d1 w! X' j2 j- Y; v
58.   putimage(0, 0, Wide, Hight, &map, x, y);5 ?! ?. }- l* r' M  z
    
59. }

复制代码

5. 生成地图
; f+ J& k8 H) R/ b6 {5 j  Y$ D- Q可以使用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 \$ Y! P- E2 T) s
   
2. if (x < 0)
   . R, k2 A4 y  e  z
3. {
   % [2 ^9 W3 f! n0 L  v
4.   x = 0;
   3 n5 i5 h; F( @1 ~, R: c
5. }
   $ H$ x! j$ d5 c5 n. M( y' P. W
6. if (y < 0)' ^( X1 P# Z- D
   
7. {
   3 j+ B/ x' S' p9 r$ H
8.   y = 0;1 R1 C8 M1 Q# R5 N9 N4 `6 M8 a
   
9. }! z7 i( N) S\" T1 }9 G7 l3 O
   
10. if (x > Wide_map - Wide)
    : N6 h& \* a: {. o6 P4 y: d
11. {0 O1 s7 a8 e\" t6 E
    
12.   x = Wide_map - Wide;
    / |: y\" A$ _  M
13. }& R' y8 m! q, M% f9 X
    
14. if (y > Hight_map - Hight)
    4 w\" m4 H2 ^, w! E1 s
15. {
    # Y3 y, P\" H1 d) u
16.   y = Hight_map - Hight;
    ! ?9 w/ Y1 c\" A9 y6 R6 M
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
; [5 o6 ^9 N% K' b0 o* K; _
8 {; r) M9 V: V/ x! B2 Q& @(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
- P8 A4 R6 _8 k1 J9 d' o
Wide：这个参数指定了要绘制的图像的宽度。
: I6 k/ t! s+ @
- d* N! ^" ?2 c6 RHight：这个参数指定了要绘制的图像的高度。

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

! c" M. r2 k* O3 d6 {' Yx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
8 G. G8 \1 v7 G- Z3 [  _
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
3 X: S+ z- r' B% _9 w* u6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离) n/ B% {- l* H  D# q. b* e$ `5 \
   
2. int Distance(int x, int y, int x1, int y1)  w) [# c0 O! b4 x+ G: L' Y
   
3. {9 [# i4 x6 x, y( T
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));: q- U) D6 [8 J
   
5. }

复制代码

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

1. void Enemy_move()7 P\" q5 x* n\" T! j- ~/ f; N
   
2. {
   . X) O2 j% e4 l1 O( v$ s5 V. _3 A) M
3.   srand((unsigned)time(NULL));& i0 y% g( ^  u9 Z' C# _
   
4.   for (int i = 0; i < Enemy_num; i++)
   ) G# i* D3 j* F2 K5 h7 y
5.   {
   2 l2 ?# c9 a8 D
6.     int direction = rand() % 4;
   ; i0 @1 Z2 z. X+ h3 R( Y
7. ' q. }4 m( O- A2 b& Y. p5 Z
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
     {  ?* `, M* u0 u2 ]% U2 T
9.     {8 t7 d0 n( n; v' p# A. m8 q+ W0 _
   
10.       if (direction == 0)
    / d0 R+ [, S1 E
11.       {0 b* T& L7 @7 ~\" s
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句/ [$ |0 @8 j9 X# B2 ~- X+ ]5 L
    
13.         {6 I! c& g\" T+ W' w7 @- Q6 g& Z2 x2 B
    
14.           Enemy[i].y -= enemy_sleep;2 O% v. F. H% y# v
    
15.         }\" }# E( D\" X: [
    
16.       }
    . X# P: O. b3 ^7 F$ ^. Y4 f. [
17.       if (direction == 1)  I+ r3 z7 s6 x% `
    
18.       {4 Y% ]0 x8 W2 ^' m
    
19.         if (Enemy[i].y < Hight_map)/ |. g, P& k  O+ V
    
20.           Enemy[i].y += enemy_sleep;
    * X1 a% _- j5 G- o9 s, u# V0 h7 x/ e& k
21.       }
    + E. {\" ?( E; |
22.       if (direction == 2)2 P& \3 V% Y6 m% a0 W  p- L
    
23.       {
    0 ?9 Q0 Q  O) F\" v
24.         if (Enemy[i].x > 0)
    6 b. ~7 v) f0 v* |) C7 Y: \/ {/ N$ L
25.           Enemy[i].x -= enemy_sleep;
    - [0 w; r0 {) _2 d1 A) L+ q\" q
26.       }! H8 a6 L6 H4 o4 ?' J4 l- y
    
27.       if (direction == 3)6 k. N- P9 K' l: Y* Q1 l5 a
    
28.       {+ J3 l\" U! f- q* g: r3 s
    
29.         if (Enemy[i].x < Wide_map)8 ^9 r. o& B2 c0 m: t
    
30.           Enemy[i].x += enemy_sleep;
    2 V) y' N- `& n/ [8 v( V9 `
31.       }
      y6 Q# O! J1 d. }: z* j0 Q
32.     }1 k& G* Z7 W, X' S' T! O
    
33.     //敌人追击玩家( B\" O! \; `$ I* S( G
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    , Y1 ]2 j+ ^  p( A% V
35.     {
    ! |8 v, W8 G' Z  e4 E+ B) Z8 ^
36.       if (Enemy[i].r > player.r)
    : Y( z) X! j5 `. r, `8 i& o; ^
37.       {  M2 H/ b3 h0 N7 q
    
38.         if (Enemy[i].x < player.x)
    ; ]# v! @1 u5 K; o8 Z3 @! [, _0 P  s7 L
39.         {/ @' a6 `0 B( u/ Q/ v
    
40.           if (Enemy[i].x < Wide_map)
    1 i0 U0 A6 V# y( \2 V; E: i
41.           {5 E, Z- Q3 k0 H4 Z
    
42.             Enemy[i].x += enemy_sleep;
    & K\" w' h9 p  W
43.           }\" U# F- J1 S7 P5 p* d- Y8 _
    
44.         }6 |5 t& L+ ?: K+ p& _# a
    
45.         if (Enemy[i].x > player.x). S4 M/ @, Y; ?4 I2 g* S4 O
    
46.         {, i3 p4 B' [+ R1 X! l1 Q7 m
    
47.           if (Enemy[i].x > 0)6 a- n6 h9 w/ V2 `
    
48.           {
    / d( u1 o/ g$ V
49.             Enemy[i].x -= enemy_sleep;! S$ z+ M- i. l, ^7 r
    
50.           }$ B2 _1 v* P& e& E  J' \6 M4 i
    
51.         }
    4 q) v% L+ C8 M6 N
52.         if (Enemy[i].y < player.y)
    7 j: r' g2 k% \. l
53.         {
    6 K& W( A/ M. n/ n% T
54.           if (Enemy[i].y < Hight_map)& g. v  x2 K9 _. P7 o3 c
    
55.           {
    $ k2 l* D\" J\" Z. @4 `
56.             Enemy[i].y += enemy_sleep;
    2 c, t7 i  d% D$ x8 y( D, I% P
57.           }
    ) p\" U0 T) ~( p6 o
58.         }& t- h. f& r# x3 |6 h
    
59.         if (Enemy[i].y > player.y)
    - H9 j$ q3 n8 N/ A
60.         {
    / u: T- m- A- S0 F+ _* L' |
61.           if (Enemy[i].y > 0)
    7 _8 \1 k3 c4 o
62.           {1 }\" ~) |0 K+ T
    
63.             Enemy[i].y -= enemy_sleep;
    0 ^# {3 e\" ~/ X7 f/ i5 f( t; [6 W
64.           }
    $ |0 R- m' |( ?/ Q% I
65.         }3 m) x7 q6 f6 q( C
    
66.       }. |, k% L8 _1 H- e& C* h# N5 ~$ E
    
67.       //敌人逃跑6 ?: P- j; V) |1 x\" `
    
68.       else5 i5 k2 f, p0 u, F8 E& U8 U
    
69.       {\" O  S. `  G0 n8 {% b
    
70.         if (Enemy[i].x < player.x)
    7 X0 u8 `3 W' D+ G
71.         {2 `\" Z4 }' {& Q7 q2 z
    
72.           if (Enemy[i].x > 0)
    / o- t1 S. z9 J7 T
73.           {
    * X# O$ }\" f# m  r9 l9 Q, U, B\" e
74.             Enemy[i].x -= enemy_sleep;, I( r! }! W5 s7 V2 r
    
75.           }
    - P8 q, h1 Q& R/ h
76.         }- |* g% d8 K1 m- {: E7 |$ v
    
77.         if (Enemy[i].x > player.x)
    \" {& e3 Z8 O) Z\" u
78.         {  Z1 V. ~8 }5 f
    
79.           if (Enemy[i].x < Wide_map)
    1 J6 E7 q/ I* j- W1 {& `7 X, A9 @) w
80.           {
    ' J) Q, s) |/ J+ P
81.             Enemy[i].x += enemy_sleep;
    + M, p% }\" D8 B
82.           }7 c0 H/ ~\" B2 \\" S4 d8 U2 @\" X/ C
    
83.         }
    + C( i' A6 b4 C/ G- ?
84.         if (Enemy[i].y < player.y)
    + M5 M0 r0 J+ \, |
85.         {
    : e  t* r7 p  t; F! |
86.           if (Enemy[i].y > 0)) R2 M\" A7 I- L. z& G1 w
    
87.           {/ K2 O3 d$ \\" m/ q2 Z. v# C
    
88.             Enemy[i].y -= enemy_sleep;
      o: r# r\" N* g* I2 T2 u  o7 D\" }; }: Z
89.           }) Q9 D7 x  T4 j5 W1 W
    
90.         }% b2 @$ y1 b3 F7 h% B
    
91.         if (Enemy[i].y > player.y)6 c7 z\" F% ~! k\" P+ e7 h. t: {
    
92.         {
    # q+ D/ d' h: f; a4 l* I
93.           if (Enemy[i].y < Hight_map)! M0 \0 k: N3 c6 Y& g! B) d
    
94.           {3 m5 @- y# f& i5 K1 N
    
95.             Enemy[i].y += enemy_sleep;
    6 F* U$ r6 F, z- X/ q* J, h$ r
96.           }0 ^9 q. G5 o/ E$ E
    
97.         }2 t' P5 l& Z: ]  [7 S1 w5 G
    
98.       }1 i. Q& J* O+ W
    
99.     }* ?: @7 P$ Y$ ^3 ]/ A0 ^
    
100.   }
     ! M9 V9 f9 w' v* z! I
101. }

复制代码

7. 小球之间的吞噬关系
! p. y% ~- Q& e0 j' O

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

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

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

1. void EatFood()
   ; {+ {1 Q8 s, b$ G/ |* u# q
2. {
   8 ?' g4 e/ q' x5 g8 Y. T3 m2 j
3.   for (int i = 0; i < Food_num; i++)
   - ~, r0 L, d* ?  h2 H
4.   {
   6 H; ^3 Q9 m6 ^# V
5.     //玩家吃食物/ ?# h. l, |' N* v\" q5 P* u# Q
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   5 u) y5 ^6 i* ?& C
7.     {1 W\" N3 G# \* a8 B* @; u8 Y5 c' ]
   
8.       player.r += Food[i].r / 100;
   6 y; V, j3 w$ q! k6 r
9.       Food[i].x = rand() % Wide_map;' E! B* C8 M( I6 |( \/ @4 p. `  W
   
10.       Food[i].y = rand() % Hight_map;; n. i1 m; r' I; z2 I- r8 E! S
    
11.       Food[i].r = rand() % 5 + 1;  e; I\" t& p% i8 H  j\" z3 d( J
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ! b/ ^8 {+ ]: j+ |
13.     }
    ) c\" Y. l* `& h0 q6 b$ J
14.    
    ! n7 K, h/ C' M
15.   }
    ) t5 b5 r, O- ]\" h% D. e
16.   for (int j = 0; j < Enemy_num; j++)
    & {6 p& I- o2 W% J
17.   {! E\" s5 }- D9 T+ b, q  E0 Q
    
18.     //敌人吃食物) C, k/ Y6 U9 Z  p; [$ ~) |
    
19.     for (int i = 0; i < Food_num; i++)
    6 I+ ?; j. ~2 A/ `! c6 h4 y; [
20.     {: V! L3 u6 ~8 \) h2 [
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    6 Y6 @3 Q5 Z\" v* U# t
22.       {- K. R# F. ]$ _1 {' Y# c
    
23.         Enemy[j].r += Food[i].r / 50;
    \" O7 y! w5 G- A- t7 d; r4 L' Y
24.         Food[i].x = rand() % Wide_map;
    . O+ b: ?8 U\" P/ X/ M# [7 W8 i
25.         Food[i].y = rand() % Hight_map;
    9 r5 j& b- C4 Z
26.         Food[i].r = rand() % 5 + 1;2 ?! D- v/ {; d. d0 Q% M4 ?' R9 s
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    8 Z4 @' d3 L% y) P% H+ F
28.       }
    7 k% K& Q& t8 }2 p# Z5 R
29.     }. c8 i0 g7 M: R6 e
    
30.     //敌人吃敌人& z& F# ]# e: u# z: @
    
31.     for (int i = 0; i < Enemy_num; i++)3 M8 a7 Q& J, y
    
32.     {
    * b* Y! C% W2 M1 E. B: m
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)% ?0 y6 s2 |4 k
    
34.       {
    ) s9 B, h+ ~: m# T8 E) z
35.         Enemy[j].r += Enemy[i].r / 10;8 d, g6 K7 m) N2 y/ {, k- D1 b\" {
    
36.         Enemy[i].x = rand() % Wide_map;+ p) A8 y+ W: G/ p8 F1 O6 G, T4 V
    
37.         Enemy[i].y = rand() % Hight_map;
    # _\" ]$ I1 D- j4 v
38.         Enemy[i].r = 10;9 J- g7 y& K' b2 R' U+ t: x. l
    
39.           Enemy[i].color = RGB(0, 255, 0);9 F& n. \# H7 o% `# x- }
    
40.       }6 c+ o2 m( n& M
    
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 R1 y1 c' f( G. l' Q
42.       {
    * ?8 I8 z  }1 k+ H) X
43.         Enemy[i].r += Enemy[j].r / 10;
    ) C# {% X' z  G% c8 Q4 c( i
44.         Enemy[j].x = rand() % Wide_map;+ K# ~\" _- G\" T2 D  m
    
45.         Enemy[j].y = rand() % Hight_map;5 v, B% r; R/ A0 M6 S0 C! ?1 o
    
46.         Enemy[j].r = 10;
    $ _  D( J' ~; W0 W0 `) L& Q2 I
47.         Enemy[j].color = RGB(0, 255, 0);7 l& J) @\" P5 C+ y
    
48.       }4 `4 C# [2 N) T. s  V* A
    
49.     }
    - Y4 p* ?% o# W4 J\" g* P
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r), B+ K2 t! w9 u! l3 Z
    
51.     {
    , }4 `9 O3 ?3 J7 C' W
52.       //玩家吃敌人+ q4 o, r  B\" g  V: X0 l7 g2 D3 {: g) U
    
53.       if (player.r > Enemy[j].r)) A4 |6 J) i  p. \$ l9 m# R
    
54.       {
    , {6 D  j1 ]6 }$ C+ H\" Q
55.         player.r += Enemy[j].r / 10;
    # C! \$ j\" {: }& N+ ?# h
56.         Enemy[j].x = rand() % Wide_map;4 a2 Q4 y. \% ~: a& t$ m$ X
    
57.         Enemy[j].y = rand() % Hight_map;( |; \  z3 ?\" q( Z) G: M+ S
    
58.         Enemy[j].r = 10;6 ]; e\" A3 X8 K+ n) A
    
59.         Enemy[j].color = RGB(0, 255, 0);
    ; R4 k9 o2 [9 `& x& o8 U* |4 Q( v
60.       }
    & @- W7 I& x3 L& z8 \
61.       //敌人吃玩家0 L  X\" W6 J' _) a$ m
    
62.       else
    / i/ Q1 h1 ~5 L6 ~3 u; G
63.       {
    5 F9 ^6 N\" r+ w0 ~\" O8 a
64.         if (invincibility == 0)3 m: H$ h4 C5 o7 W\" T# }7 _
    
65.         {* v. v# N; _8 j6 k1 @+ h\" g! v
    
66.           Enemy[j].r += player.r / 10;
    9 m  W8 J& S# s
67.           player.x = Wide / 2;
    ( A- y- J5 {6 O9 j' {\" S& L
68.           player.y = Hight / 2;$ ?1 q/ W0 N# g6 b& U
    
69.           player.r = 10;5 }9 j$ G/ ]8 S\" M/ s9 D% P$ g; L
    
70.           invincibility = 10;, y  D+ {5 @# `2 c' ?( ?2 J+ Y# B2 v% ?
    
71.         }# X& y/ X* _8 I$ j
    
72.       }
    # x9 d  X0 J/ i$ ^/ w% b. h
73.     }
    3 S, E+ [* q0 W
74.   }
    + ~& i8 L* n& I3 E
75. }

复制代码

完整代码见附件：
! A4 w8 _, b% I6 `) ~: p
% ?* D; S1 Q+ v- l6 `7 @