球球大作战

2744557306

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

8 i; ]: {0 G0 f. ?+ H, o7 F在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
. d: X% ~. f; @6 ^
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
! ^9 O; I. H: @& U, e% G; t
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
1 q5 ~3 b, _$ y& u# I, |
+ w9 R7 n1 V0 w( a其他小球：其他小球又分为食物小球，和ai控制的小球

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

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

% Z8 \$ [4 g0 h/ j/ z) gai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
- a; P) M& S, `. ~* q3 x5 E
接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。
, A0 `7 k$ W  g0 A; o" L. ~5 @' U/ J
处理键盘输入，实现玩家小球的移动和加速。
  X( G& @5 E5 l( R: a
! K' Q6 z, X, B3 A1 f) i生成足够数量的食物小球。
" c3 m6 y  V8 N9 t. h( K: n6 p
- G+ T, T) R: o) Q5 E生成ai小球，并控制其移动。
  V0 C0 ?) c; C4 ^; k% h
# |  i  I5 D/ X+ Q检测小球之间的吞噬关系，增加相应的体积。

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

: j" T+ c5 c* z/ C1. 小球的要素
! N% `. i1 V! c& H$ f8 O, e; I在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
; ^/ r! d! C5 `3 b- v% A
5 w, Y$ ?: S& z3 I" r" A& g) ?2 Gstruct Ball
; r2 l, W8 r  K! |$ @{
        int x;
        int y;
        float r;
        DWORD color;
};
2. 初始化小球的信息
+ n, V! K9 ~* s7 S9 ?0 V, p, D将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
! m- ], e5 g: o+ b/ X1 f' p8 H
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
* o6 M; g+ Y9 R6 _. R, t1 c& N
' g9 i5 L( ?2 n: Q5 A, A橙色可以通过RGB值（255, 128, 0）来表示。
# F7 s2 U) w2 q1 u: ?黄色的RGB值为（255, 255, 0）。
/ g7 f8 x7 w* N绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
* G8 C' T4 d$ g! i黑色的RGB值为（0, 0, 0）。
9 K9 N, N8 k; f: z0 U( l白色的RGB值为（255, 255, 255）。
! N7 m7 e6 G0 x7 C, f1 k' i7 R8 w灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()  R1 I* }5 Z) ^. }, d- @
   
2. {
   $ J3 s5 f, Z8 i! c
3.     //玩家小球
   : `- c( ^+ ~+ h& s3 d; S$ N3 \
4.   srand((unsigned)time(NULL));  W# @) C: b, [# u6 \
   
5.   player.x = Wide / 2;
   8 V1 Y* f\" |$ C' Z8 n1 O5 \
6.   player.y = Hight / 2;+ I/ q- n  o7 Q$ N; n
   
7.   player.r = 10;: y8 q$ o! V) Q3 Q3 M
   
8.     //食物小球( r% a/ d& X9 F  z0 \
   
9.   for (int i = 0; i < Food_num; i++)' [$ C7 \: Y$ u; q
   
10.   {
    % l  P; L5 F# o2 O5 s8 O
11.     Food[i].x = rand() % Wide_map;
      }! s/ c& W\" \\" Q  q3 @# ^
12.     Food[i].y = rand() % Hight_map;
      q9 d6 R) M/ j; ]& N' @: K' C  Y
13.     Food[i].r = rand() % 5 + 1;
    ' @9 C+ @0 O6 f* w' Y7 {' [) a/ [2 A
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ) |) L: Y& i6 ~4 p5 U7 v4 U: X  n5 I
15.   }0 t. j7 t2 T( l+ F
    
16.     //ai小球7 l. o\" w7 e7 b) Y# M0 P
    
17.   for (int i = 0; i < Enemy_num; i++)
    ' V: a/ w& w/ `3 l6 y. C1 O# n\" O- O
18.   {
    ; M; r! |& b. H: o  h+ }
19.     Enemy[i].x = rand() % Wide_map;4 t. Z6 @$ z! g( i2 l  f\" T7 o: p
    
20.     Enemy[i].y = rand() % Hight_map;
    # K* K8 L8 \: Z* _- y3 Q
21.     Enemy[i].r = 10;
    + Z, l  A3 l# t5 b/ \9 E% ~
22.     Enemy[i].color = RGB(0,255,0);
    - T8 C, ]+ \& }\" t, m
23.   }
    . e: r! @1 Y3 l3 C  ~
24. 
    ' l9 W, T( f\" x; k\" S3 p$ u3 v' z1 O
25. }

复制代码

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

1. void Player_move()
   ! V' l0 F' x; y- L: R# |7 ]% g9 h
2. {# ^' Q3 W9 ^5 c0 i0 L* J0 J
   
3.   if (GetAsyncKeyState(VK_UP))
   4 c3 ]* J7 N2 c# v& l
4.   {. ]% s+ e\" `. r0 I6 Z
   
5.     if (player.y > 0)% m/ m\" m. x. G6 r1 p8 v
   
6.     {$ E6 m  _) j2 r  I0 v
   
7.       player.y -= player_sleep;
   : T+ L' Z3 d- E( H
8.     }
   8 y/ |4 y) p% u0 q6 j- q# X# a8 J
9.   }
   ( Z\" j( M$ Z$ o# G- I
10.   if (GetAsyncKeyState(VK_DOWN))
    4 L$ A4 _2 b- l9 R
11.   {
    , F: g; H0 k: z8 ]4 x4 D4 P! F) b9 a6 k5 e
12.     if (player.y < Hight_map)0 g5 @0 D- Z( f- ~$ v2 K
    
13.     player.y += player_sleep;
    7 ~3 v9 o; W' X
14.   }
    5 Y/ p/ o$ j: [# ^7 E; G% i
15.   if (GetAsyncKeyState(VK_LEFT))9 z2 Q- k5 s7 |2 a; h2 j
    
16.   {
    * L1 p  P5 Y, z8 z7 t+ n5 g
17.     if (player.x > 0)
    5 ]& y4 @( m5 C0 L
18.     player.x -= player_sleep;
    9 e6 m0 \* x& w3 S  L
19.   }
    - R6 S! g/ I8 S7 d0 m% ?; L
20.   if (GetAsyncKeyState(VK_RIGHT))
    & r( t2 \0 }2 r0 [- _2 ^
21.   {
    : g+ _' y; Q5 [0 L4 S
22.     if (player.x < Wide_map)0 p2 w: @  [& V' f  I) f
    
23.     player.x += player_sleep;
    $ V/ ?. J. p+ z, o9 }
24.   }, c! v5 A4 ~3 C3 k
    
25.   if (GetAsyncKeyState(0x20))
      J$ k\" |9 Z; _
26.   {
    \" G) b# l; }, r7 {1 _9 w* z2 B5 a
27.     player_sleep = l + 5;
    ; y8 l2 a! r* G/ v
28.   }
    ( X; w- ^  }( `. _
29.   else: Q. v5 J- r2 n% v  V
    
30.   {
    5 @* M. D/ |( z2 Q3 h
31.     player_sleep = l;
    , j* u. k( X8 \
32.   }3 e' G; x, s1 b
    
33. }

复制代码

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

1. void Show()6 `\" _6 j. t* \% }2 h
   
2. {
   4 \! s/ _1 `: \  e* B! t( G
3.   
   ' t# Y  r5 r* ^% R
4.   //设置地图
   6 |( ?3 G' w0 s, f3 ^
5.   SetWorkingImage(&map);' z( {; y/ Q0 F6 A. Q
   
6.   //清屏/ A! k8 y3 _3 P. P) N- |, ?! c
   
7.   cleardevice();
   , B# `7 V0 A: z8 D% v6 p
8.   //背景颜色
   + I% ?0 z7 J* c
9.   setbkcolor(WHITE);
   % ?5 Q, X6 ]' p- G3 j
10.   //划线颜色$ P* i8 p2 `/ Z4 u, b) H
    
11.   setlinecolor(RGB(230,231,239));9 F' c5 b0 g3 E
    
12.   //划线0 ^0 j. E, ?6 A# u+ G  A
    
13.   for (int i = 0; i < Wide_map; i += 10)
    + ~: t\" p) q2 k$ T
14.   {8 ]' k% S' q( w; f0 k/ ~
    
15.     line(i, 0, i, Hight_map);; Q, v2 ^( i+ c* x
    
16.   }
    ) g6 |. b& g( c( f2 u6 o
17.   for (int i = 0; i < Hight_map; i += 10)2 m$ w0 O5 a# }! f8 O
    
18.   {
    8 N  V4 e* e) `. Q
19.     line(0, i, Wide_map, i);
    & j) B1 b- x8 y% v/ ^
20.   }! k\" L* _\" Y0 O8 y$ V0 F! S
    
21.   //食物4 q9 ^7 r4 Z- `; R; ~
    
22.   for (int i = 0; i < Food_num; i++)
    8 k) O! d) n6 ?* S
23.   {( o- b: r; ?6 M9 V2 @4 r7 C! h/ o
    
24.     setfillcolor(Food[i].color);
    0 J& C# x$ I0 h1 b2 K
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);, T9 [. L& e& e/ X- ]
    
26.   }
    + f- V) a4 A2 F9 \* P  f
27.   //敌人
    2 \) P' Z5 h7 e. T: S. ]6 f
28.   for (int i = 0; i < Enemy_num; i++)$ Y' C- i$ M! [5 {3 @
    
29.   {
    , T. l7 r) _* P
30.     setfillcolor(Enemy[i].color);5 ~0 P# Z8 r; `1 P
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);1 q8 Q9 g# I2 {: @, Z' j9 B: W
    
32.   }' c+ V, M, \3 @& m  E# E5 [
    
33.   //玩家
    - B\" r4 s- t/ c
34.   setfillcolor(RED);1 q9 X$ D; e4 @
    
35.   solidcircle(player.x, player.y, player.r);
    0 v- Z3 F: e( e7 o9 G# U2 x- X
36.   SetWorkingImage();1 m1 d4 A1 D- D- p5 t
    
37. / a) r; l1 @\" l- o: u; v
    
38.   int x = player.x - (Wide / 2);7 k1 d* t- J1 `- ^% V: N
    
39.   int y = player.y - (Hight / 2);$ W! w7 P4 L; Z7 u* J& G) m/ T\" W* a
    
40.   //防止窗口越界
    2 R- y( F. n0 o6 `7 r+ Z6 d/ S; G
41.   if (x < 0)/ P3 a8 a, V7 G. M) s# i+ Q
    
42.   {$ h6 E# g\" F8 h* T4 |
    
43.     x = 0;1 i' D7 s( W2 n# M/ ?- p' G
    
44.   }4 a, Q0 \- [7 K7 c9 q! B
    
45.   if (y < 0)7 D: p$ R: s9 Z6 ?. z
    
46.   {
    \" D. {  D. u( p% J+ i4 D1 V
47.     y = 0;$ S; K& u* V6 A\" r8 u
    
48.   }1 o; _6 T( G9 o. W; S
    
49.   if (x > Wide_map - Wide)
    3 g\" o. I3 Y2 T) X2 ]
50.   {
    3 |9 C\" `8 ]5 e% R, a' F- f
51.     x = Wide_map - Wide;9 Z( b1 r# y9 n  w1 p8 \0 q, ^% L
    
52.   }4 p: A, |9 U, Y3 ~9 k
    
53.   if (y > Hight_map - Hight)/ d- U6 R8 J5 \+ E( N6 Y: M' C  q
    
54.   {1 t4 n! m- o3 i  ?0 A3 s5 x1 O
    
55.     y = Hight_map - Hight;! ^& w$ K  H3 y; l; l' \
    
56.   }  e; [5 E, V1 ~6 r. r0 O$ T2 j4 ]
    
57.   //把map输出到窗口上
    1 _: C% ^) k+ [; d! r
58.   putimage(0, 0, Wide, Hight, &map, x, y);8 c1 E1 a7 d5 @% J; R
    
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. //防止窗口越界: v5 T2 |6 k  ]3 W6 i# B, u
   
2. if (x < 0)
   ! q: {/ L; D! ^4 D( ]$ n! Q* t
3. {( k4 i! ~' A- m& K3 C
   
4.   x = 0;
   : L5 ~0 f\" g0 q# R9 b6 ^7 x
5. }
   7 Z4 w, N. O% Z1 |4 i  s
6. if (y < 0)
   0 D* D2 ?& L2 x7 s; M# z
7. {
   & j* e0 ?' s6 q; R4 }* W' R# i1 h  Y% e
8.   y = 0;
   3 C5 j5 Q) T8 O) {2 {
9. }; S4 i0 y2 r\" X0 p+ Q; N9 i
   
10. if (x > Wide_map - Wide)9 t7 b: \  Q/ W! f& x8 F! I
    
11. {' ]0 w4 X1 y% c* J
    
12.   x = Wide_map - Wide;
    ( h9 V: A9 S6 t/ i2 n
13. }) X6 Y. c( j\" s5 e: `& P4 M8 l
    
14. if (y > Hight_map - Hight)- L& H( N  B  f* \\" q$ Z4 R
    
15. {
    9 ?% o, r\" q( D
16.   y = Hight_map - Hight;
    \" C( d4 H, z8 S' r: ?
17. }

复制代码

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

( E# l( w5 a7 I, D& U' H(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

Wide：这个参数指定了要绘制的图像的宽度。
" e: R8 @0 s9 \# O+ O' d- T
  T  t2 m4 v& |/ _Hight：这个参数指定了要绘制的图像的高度。

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
9 b) r! n( Q) x. ?. W
7 t; S. j5 n6 x4 lx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离
   ; X2 s0 c. b8 q+ U3 Q: C
2. int Distance(int x, int y, int x1, int y1)
     f, O0 F7 z: x4 _
3. {2 u$ d9 N9 z9 Y\" M
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   + w. W  ~: x$ {9 H& }- e\" d: L3 U
5. }

复制代码

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

1. void Enemy_move()) E6 c& k0 X+ r# g\" h; O. b
   
2. {
   ; \6 v- A2 T8 r
3.   srand((unsigned)time(NULL));
   3 \% o\" W, x8 L$ b9 E
4.   for (int i = 0; i < Enemy_num; i++)7 C  {( _0 s7 O0 Q
   
5.   {. r( X! \, ^( B\" u/ k
   
6.     int direction = rand() % 4;
   ! o' R) g0 I3 `! W& l8 y
7. 6 v' ]% \! O; J5 b
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   ; B0 j6 i6 B& f2 D( J
9.     {: z8 j' j9 c  f8 M7 @
   
10.       if (direction == 0), _% J# J\" h; d: {
    
11.       {) [$ \: `* e2 T
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句4 y1 E+ j5 y0 R( S- a9 s) F% k
    
13.         {
    : a% L3 Q' j3 v/ a
14.           Enemy[i].y -= enemy_sleep;
    7 v) q5 v0 P6 j$ h  b* ~
15.         }' v* p! r5 l7 Q' G0 D+ l  l
    
16.       }
    ; Y' W, @' X8 l, s
17.       if (direction == 1)
    / v0 G' n2 w# r4 q# j1 {
18.       {4 W, d* E& w: }\" u! I# t6 x2 M
    
19.         if (Enemy[i].y < Hight_map)
    ( a% k. U) F0 i! h\" X
20.           Enemy[i].y += enemy_sleep;4 ?* I9 Z0 ?6 r, S9 [5 u* [\" ?/ y2 W\" g
    
21.       }
    \" Q$ H4 V) u' W) a
22.       if (direction == 2)% j0 v* L) ^) m' _* e9 c+ N
    
23.       {0 G5 a1 }0 ~* X7 K0 s1 `2 k
    
24.         if (Enemy[i].x > 0)
    + I& f5 C3 ]; _4 n5 ?5 n# U
25.           Enemy[i].x -= enemy_sleep;. n0 B1 {4 O% D2 L; {0 h
    
26.       }: n1 V. g& Z, n1 Y5 z2 N6 W
    
27.       if (direction == 3)7 p  j) v3 T! Y0 ^
    
28.       {
    9 Z9 j& e) v5 P7 x9 _& X$ G9 ^  u
29.         if (Enemy[i].x < Wide_map)
    0 ~1 S, z  }. ?
30.           Enemy[i].x += enemy_sleep;0 Z# C% j4 O* O6 }% D2 J2 X
    
31.       }
    5 e7 X  {  r& D6 e
32.     }0 j7 M) f! u' F+ l1 }  O9 [4 P: W
    
33.     //敌人追击玩家) p6 B3 o# j2 Q  p, g. e
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)8 X  [& u% m# y/ @% e1 H
    
35.     {
    % X+ _1 D5 }; z8 \\" B& k+ T/ K* u
36.       if (Enemy[i].r > player.r)
    . J  Q6 G3 ~  V6 |+ y8 u3 ]0 t2 Q4 ^
37.       {2 _$ z5 m! M/ r( K2 I& J
    
38.         if (Enemy[i].x < player.x)
    3 \, w* e/ _; b- O/ P
39.         {
    $ W) I9 w7 B  v7 H. G/ h  s
40.           if (Enemy[i].x < Wide_map): q' e; m* J4 \
    
41.           {
    4 g' q! U2 X* u3 s( s9 b& D
42.             Enemy[i].x += enemy_sleep;# |: L$ U! v# e$ h7 K  ?
    
43.           }
    , E3 l7 o. z2 N! ^0 i* y
44.         }
    + e' `; a, [3 G+ f. B\" l
45.         if (Enemy[i].x > player.x). l) J* q8 a7 }1 C. W) X
    
46.         {
    / \$ h# k+ b+ k
47.           if (Enemy[i].x > 0)
    8 F/ U0 [8 D2 U( o9 Q\" L
48.           {
    & x+ J! h; |8 W0 ~
49.             Enemy[i].x -= enemy_sleep;
    . W9 Y6 h$ c. j; ^% h
50.           }+ \* p3 t7 |5 B
    
51.         }
    & d1 l6 ^2 h: N+ U+ X
52.         if (Enemy[i].y < player.y)+ m: w$ }8 O( I- E  I# v
    
53.         {
    . `  M1 ^6 L& ~
54.           if (Enemy[i].y < Hight_map)
    * ~- G: o# {. U8 W* w
55.           {  R: n; o8 a& k2 c6 U
    
56.             Enemy[i].y += enemy_sleep;
    * @- G7 _# E7 f
57.           }
    . N9 g5 F, Q& X' x3 a' F
58.         }
    + a8 W# S$ j% H( x
59.         if (Enemy[i].y > player.y). V9 ?% G5 p0 X/ k
    
60.         {
    5 Y) k* }! k4 j2 A  ]
61.           if (Enemy[i].y > 0)\" ?3 E3 u5 F/ p. y; C* F
    
62.           {
    + p6 y2 a\" H1 e- @# k
63.             Enemy[i].y -= enemy_sleep;
    / N+ n- R# c2 _8 l6 [$ `' A
64.           }9 V0 O3 R: O- D' U$ R
    
65.         }4 Q4 ]$ B6 m9 U\" w+ O( W' W5 W  ?$ g
    
66.       }
      `. _1 Z\" q2 @. e* J  B' u
67.       //敌人逃跑( P- ?0 n+ B1 _1 F
    
68.       else
    # {4 G7 ?\" \& |/ l8 _! D% O
69.       {: `6 f1 B: j6 R7 T; u
    
70.         if (Enemy[i].x < player.x)* l3 L2 O& C  K1 h: C
    
71.         {! ]2 l8 p2 u3 u7 ~5 k1 T. V
    
72.           if (Enemy[i].x > 0)
    7 G1 A# E. B2 ^
73.           {
    : J$ P2 a. e# `2 f# e
74.             Enemy[i].x -= enemy_sleep;
    ) K, {- P. a* A$ U\" J3 J
75.           }* J/ x0 J- w& `- ]3 v
    
76.         }/ G7 c& I; R4 N- e
    
77.         if (Enemy[i].x > player.x)
    . ?6 T- }: V2 r
78.         {
    3 c, w+ y$ A1 t
79.           if (Enemy[i].x < Wide_map)
    4 ^, p! ^: S, S/ W4 H
80.           {8 d6 d3 q4 P; {0 R5 Z
    
81.             Enemy[i].x += enemy_sleep;; J1 U# d2 }* a6 c  u# ]
    
82.           }\" C# L- j, d/ o9 t, Y
    
83.         }
    * j; A$ v: Y$ g  Y9 [
84.         if (Enemy[i].y < player.y)& d6 h, Y: V# Q
    
85.         {8 \6 ^: [\" N8 L0 s
    
86.           if (Enemy[i].y > 0)
    + [3 P$ l0 o$ X3 Q
87.           {( \# z: s- e$ ]( o
    
88.             Enemy[i].y -= enemy_sleep;4 x5 K$ r* q  T) ]5 _' c2 y  m
    
89.           }
    6 u' ?  P7 e: d, E& Z
90.         }* a* i6 A, m+ j  @- q% D) g6 \
    
91.         if (Enemy[i].y > player.y)
    \" d8 G& ^/ j  B  w) S
92.         {- T& p) J8 I% o' e
    
93.           if (Enemy[i].y < Hight_map)
    % W\" B\" u) P9 }
94.           {
    * d& P8 v) P* X# L5 a/ n# b/ I/ r
95.             Enemy[i].y += enemy_sleep;  T( [5 y\" M9 K7 S
    
96.           }7 z# w2 Y9 ~3 V% b
    
97.         }* K- Y8 ]: J4 l9 p8 E$ v8 t
    
98.       }
    8 D/ q0 V# k8 I8 K0 u+ p3 R
99.     }
    0 e2 X3 v7 x8 J( A( [7 }
100.   }
     & M0 ^2 r4 m: `. ]/ c  Q. Z
101. }

复制代码

7. 小球之间的吞噬关系
0 C& x, n; ?+ g9 Y% \. E! x

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

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

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

1. void EatFood()
   - b( J) C1 x' y- S8 Z  a
2. {, |+ J% W% E% ^/ \8 h
   
3.   for (int i = 0; i < Food_num; i++)
     Y2 o2 f- ~  F3 t: u
4.   {' ^+ E  u- `! K# B
   
5.     //玩家吃食物2 i+ a* L$ F% N) u$ e
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)' @9 W. Y8 t1 k& V
   
7.     {. e, U! o, g+ O+ F* c
   
8.       player.r += Food[i].r / 100;
   8 W8 l8 Z\" I1 `7 j' B# P
9.       Food[i].x = rand() % Wide_map;2 Z  l; ^( n\" G
   
10.       Food[i].y = rand() % Hight_map;
    : q% |# w  ~* p2 l( y
11.       Food[i].r = rand() % 5 + 1;1 s2 d& j7 B' _! O. l% d7 M* Z7 Y% z
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);7 ]3 d6 ?$ U3 e1 R
    
13.     }( m+ ]- m( N) C. ~
    
14.    
    * \7 k; ~5 F  B- A
15.   }4 Z. c3 X7 G# ]/ L0 j
    
16.   for (int j = 0; j < Enemy_num; j++)
    . J# n  Q/ z+ B! C/ a/ R
17.   {# t) U( x5 R8 M2 H9 v\" V! Q' Z
    
18.     //敌人吃食物
    9 @, J; |4 Z! c3 E$ O\" r
19.     for (int i = 0; i < Food_num; i++)3 C+ e2 L# A0 P: B% R, ^5 Z
    
20.     {
    2 C! A- ^6 S9 Q6 F# T
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    , c. Z  l4 C4 S\" Q0 q2 Q
22.       {2 c( e. a9 P' ^: e
    
23.         Enemy[j].r += Food[i].r / 50;
    9 z. i( b# Y8 l0 i. v& V
24.         Food[i].x = rand() % Wide_map;& g5 B. z) r0 z' p4 A
    
25.         Food[i].y = rand() % Hight_map;1 c( M' _) O4 T/ f0 |$ D6 G
    
26.         Food[i].r = rand() % 5 + 1;/ ]) K+ K' x* }7 T
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    8 u' z# p5 k4 d+ X  f
28.       }
    % o7 T8 L1 }3 \/ N7 \
29.     }
    % E6 e5 U& J$ Q* ^8 X
30.     //敌人吃敌人* @6 i4 _! ], X4 T* l- A
    
31.     for (int i = 0; i < Enemy_num; i++)' _) G! L  Z, A) u1 X7 G* |( j
    
32.     {) Q9 `- r- o/ Y
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    , E( Q: h8 M; ]4 ]+ a+ e7 l* Q
34.       {+ f% u+ t0 M2 F, ~% |
    
35.         Enemy[j].r += Enemy[i].r / 10;+ F- h+ _  r5 K
    
36.         Enemy[i].x = rand() % Wide_map;
    ) Z- b$ _: U: ]' t  w& l4 n- K8 E
37.         Enemy[i].y = rand() % Hight_map;
    - N* ~  U9 G4 |\" [0 \
38.         Enemy[i].r = 10;
    0 X5 {5 d8 o. f
39.           Enemy[i].color = RGB(0, 255, 0);
    # ]9 y  ^! W. X4 b- ~3 \! {
40.       }
    ! g. F+ ?* z. s. R% o
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    , W9 e( t$ l3 u3 U5 Y- f
42.       {\" e\" v5 |, ^7 U9 h
    
43.         Enemy[i].r += Enemy[j].r / 10;/ G! P( ^% \# t* x& ]
    
44.         Enemy[j].x = rand() % Wide_map;! y7 T; K: Y# \
    
45.         Enemy[j].y = rand() % Hight_map;4 o\" ^  p. k% P6 o
    
46.         Enemy[j].r = 10;
    2 i0 H0 ^# g0 F9 E! O1 y; D
47.         Enemy[j].color = RGB(0, 255, 0);7 P1 V\" ^8 {! Q; ]2 h
    
48.       }4 N0 S* S  b7 n' v
    
49.     }
    $ P0 Q! u4 x$ U' Z( y
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)$ ]; M* b4 b9 j, p' F& q% Q/ M% S
    
51.     {
    : \5 t0 _1 y! @
52.       //玩家吃敌人$ E/ C- x/ P- c+ W( V9 k+ a
    
53.       if (player.r > Enemy[j].r)
    5 S2 k- p, w\" G, j\" k7 I; Z2 y
54.       {
    % u8 F3 _6 g* i8 N
55.         player.r += Enemy[j].r / 10;/ Y1 h0 f4 I2 P) v# o0 V
    
56.         Enemy[j].x = rand() % Wide_map;
    ' j* A# |1 ~) x7 T1 `
57.         Enemy[j].y = rand() % Hight_map;
    ( a; G& Y- U/ f, Q' c2 @* W3 ~; A1 H
58.         Enemy[j].r = 10;9 |) _7 n8 c& p1 \0 q
    
59.         Enemy[j].color = RGB(0, 255, 0);) g. ]0 c7 Y3 z4 O0 J! a) J
    
60.       }$ ^\" d0 G1 i2 Y) x7 R' e8 P
    
61.       //敌人吃玩家! D2 y: j! u  ?! L
    
62.       else0 u( h& G: \- [
    
63.       {9 H$ S/ Z! j- a& }
    
64.         if (invincibility == 0)2 [4 p% i7 i0 O6 g4 I
    
65.         {
    # f& s6 e1 E  F/ v
66.           Enemy[j].r += player.r / 10;
    4 g) }- j4 R% F3 \/ s' s! r4 q
67.           player.x = Wide / 2;
    2 ^: T1 {4 D6 Q' Y8 {( s1 }
68.           player.y = Hight / 2;5 W0 ~, H8 G2 D' Y& s8 P! u( f) [
    
69.           player.r = 10;/ b9 Y, p( v7 L. B3 O
    
70.           invincibility = 10;
    * a! Z$ x& D+ V! a: e. Y. }6 }
71.         }, I0 E- T7 W- n4 x4 B
    
72.       }* w. `5 T! @3 Q. R: \& ^$ r- m( V
    
73.     }\" f% n- @! r- O1 A( L; O& T
    
74.   }0 Q5 V8 r# F; P3 P' g' ~6 D
    
75. }

复制代码

完整代码见附件：



6 z$ _3 r0 W3 V  g% k