球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
% Y. i$ ], H& X, T& ?
; P: b3 m" H% V% P7 Y' v游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

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

$ ?7 |0 r4 u3 |% G1 z' R! g0 Q0 b& x其他小球：其他小球又分为食物小球，和ai控制的小球

3 o5 D* k) U: ^9 `体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
/ `- k5 M+ W; |$ f4 O; L
玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

/ }* S6 o: U* Y  U) x  E0 Cai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
5 d; M/ Z: R2 Q5 |' ~) {$ E
" u" N. t; B2 L# Z& I+ d* B接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。
  h% _5 l7 y( G; h' |' C
  X% p: z( t, R  A处理键盘输入，实现玩家小球的移动和加速。

生成足够数量的食物小球。
& P/ ~) `: M" v. H
% q# I6 U7 M& A3 f( K生成ai小球，并控制其移动。
% t6 D+ ]5 u& e! @6 U
) X- d9 C5 h. G7 Y检测小球之间的吞噬关系，增加相应的体积。

5 X+ F2 f5 l7 I: y! K3 f) t6 J通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
! P: n" T1 C) `7 P
1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

. e. I# `: g) Z, P: Xstruct Ball
  W/ J4 ^8 M9 G9 l9 U{
        int x;
        int y;
        float r;
8 L1 ?( v9 e5 P        DWORD color;
  M/ X$ c3 b1 G. n5 j3 i5 Z3 m. F};
! u  [" @. \4 `2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
9 X. y* }2 H3 f# r; }$ M8 f
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
  _2 N: G2 y1 e) x1 _
' L4 P4 N4 s. I  {橙色可以通过RGB值（255, 128, 0）来表示。
9 o# a6 n( \2 ?; p& c* v9 ^  J黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
. i+ |( j8 r8 P9 j$ {紫色可以通过RGB值（170, 0, 255）来表示。
5 P4 b& k4 w* `- r; `2 n黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   6 b/ s8 D7 c* @. M$ x
2. {\" o1 n1 W; W  W0 E4 e9 T
   
3.     //玩家小球
   % m. D2 u5 h/ L& b7 G/ Z
4.   srand((unsigned)time(NULL));
   6 ?* B9 `5 _3 H8 ?6 k* }
5.   player.x = Wide / 2;
   - n5 _% `) f2 B3 }; B+ d, Z
6.   player.y = Hight / 2;
   + `/ G2 j0 Z! r. N8 z
7.   player.r = 10;
   # _! I' v7 f$ F9 r1 v, }
8.     //食物小球4 T! l! O& |\" P
   
9.   for (int i = 0; i < Food_num; i++)
   ' s4 w4 p  I\" M/ q# b- M1 }
10.   {
    5 ~  l0 d) s! J' R5 Y3 u
11.     Food[i].x = rand() % Wide_map;8 U3 X) K6 d! F; P
    
12.     Food[i].y = rand() % Hight_map;
    ( y9 i/ x- i6 e9 K* \
13.     Food[i].r = rand() % 5 + 1;\" U0 k& M  ^8 z# X\" O+ i, Z
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);7 V\" v, E6 L1 g+ S% t
    
15.   }
    3 J6 j% {$ H+ m$ z$ @
16.     //ai小球1 I1 i  o\" B( Y4 \' ]8 b
    
17.   for (int i = 0; i < Enemy_num; i++)
    - h0 J% b7 D; T, K
18.   {
    2 ~' T# p% Q6 _$ E; N. R3 N\" m5 Z
19.     Enemy[i].x = rand() % Wide_map;/ r* L$ V+ E3 l4 N7 }/ ~4 O# @
    
20.     Enemy[i].y = rand() % Hight_map;! [! ]% E7 z* X
    
21.     Enemy[i].r = 10;
    & V' H3 l7 F- `
22.     Enemy[i].color = RGB(0,255,0);
    ' ?) W* n! T2 U' O8 J6 g3 S
23.   }
    : R; v\" h, V- I' h$ f
24. 
    4 x- h) o0 N+ B  e& o8 }, {
25. }

复制代码

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

1. void Player_move()
   % f& ^: x/ L9 A- O+ M
2. {\" V9 W6 h' ]5 }+ y; v4 I5 A/ g
   
3.   if (GetAsyncKeyState(VK_UP))( ~4 X% d5 q0 d$ U! w! R; f1 k
   
4.   {! w6 Z+ G2 x0 U
   
5.     if (player.y > 0)
   + b6 P1 ~  n7 O, p: ]& K
6.     {% r% C) Z% h\" I
   
7.       player.y -= player_sleep;
   ; e; q+ |  ^( I% O\" g7 q
8.     }- E* r$ _/ J+ V\" i0 e3 E
   
9.   }1 r+ L\" P7 b/ J
   
10.   if (GetAsyncKeyState(VK_DOWN))& z\" ^* u% o# O: N
    
11.   {
    ) S* g' I+ ^, W  |. ^- C+ `
12.     if (player.y < Hight_map)  N) E: g& P8 g: @, d! `/ ?) X\" W
    
13.     player.y += player_sleep;# O$ g. t2 P3 `& x
    
14.   }
    * a) n) [6 M& \0 S$ L5 J
15.   if (GetAsyncKeyState(VK_LEFT))
    : x/ ]2 N9 `) O, A( x7 n
16.   {: j1 S4 l$ @2 K5 Q. M: b\" I
    
17.     if (player.x > 0)
    / Z' l) m& y  F9 f2 ?5 I; A. A
18.     player.x -= player_sleep;) u( T3 J! H1 {
    
19.   }1 n' p5 g% \/ O3 l! z+ ~
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    5 P2 a3 G8 e$ I: ]; z2 J
21.   {8 s$ H, ?! D' U% a% a& U$ \
    
22.     if (player.x < Wide_map)8 p7 ^4 Y* T3 V! g: c
    
23.     player.x += player_sleep;8 T& |* [7 H$ e8 @' q
    
24.   }
      I' }* P6 `, D1 m: M
25.   if (GetAsyncKeyState(0x20))
    - g7 d4 v; [7 L6 k8 {
26.   {
      {# r2 E; ~4 E. g8 i' R1 h
27.     player_sleep = l + 5;
    3 \2 g, t6 M+ p8 {
28.   }
    & ~( P4 O$ K0 p- G6 F1 s/ C4 ^+ O
29.   else
    + I* `( ^  _( v( C
30.   {\" R; ^* Q0 y6 i& e3 e
    
31.     player_sleep = l;
    8 M# ?! @5 i  G: Q0 K7 V
32.   }) K/ e% L$ \  @8 h% b
    
33. }

复制代码

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

1. void Show()8 O7 g. c  U0 A3 T  q# {
   
2. {# N! t! G. F  b' J( k
   
3.   
   0 D0 W% s9 N, v0 \& o; F: C
4.   //设置地图0 U\" V  ?) B\" k8 d4 [+ [
   
5.   SetWorkingImage(&map);
   : c* {# ^6 t$ ?; w
6.   //清屏
   ; L8 Z* c0 E' g! C
7.   cleardevice();
   5 h$ J( j# j3 D# T5 E, V9 O
8.   //背景颜色9 M% S( a; |* _: A0 V
   
9.   setbkcolor(WHITE);
   ( h\" o, }. r5 p$ A' A
10.   //划线颜色
    6 f  L- z6 ^# E5 l# t; f% J
11.   setlinecolor(RGB(230,231,239));
    6 \5 ?, [) C% I$ `5 t# d
12.   //划线$ T, d, B- G* Y( C
    
13.   for (int i = 0; i < Wide_map; i += 10)
    . |0 o7 D$ F% w' U6 \4 Q4 c
14.   {! q3 q! e; A8 Q5 K* i  f
    
15.     line(i, 0, i, Hight_map);5 |\" o2 ^6 J! @: X\" W7 Q% Z$ S\" Y
    
16.   }
    9 ?5 m) E; L3 Y7 |& e! j! ^
17.   for (int i = 0; i < Hight_map; i += 10)' j6 n0 [* `8 F# C
    
18.   {
    ; T7 T* C, S5 Z5 h5 o
19.     line(0, i, Wide_map, i);
    $ y9 z0 O+ |. A
20.   }
    ! {$ Q8 }, T( t5 T) i+ x
21.   //食物
      f0 [9 e  B' [+ r$ m
22.   for (int i = 0; i < Food_num; i++)/ A9 }/ v6 W3 ?. J; v
    
23.   {% ]& A$ }+ W1 H9 h\" t8 N
    
24.     setfillcolor(Food[i].color);+ d' c6 i, M! }+ ^6 [% g+ L/ r
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
      J# R: o9 i( m3 q% U9 p. f0 x9 }
26.   }: q/ l& `; T$ K$ j\" z- w5 L# t& O
    
27.   //敌人
    * D; `' f% c' Z) J1 D! X# a
28.   for (int i = 0; i < Enemy_num; i++)
    2 Z( n/ n  V# v) Q% {- d
29.   {
    / E& c& g: }: G\" ?2 S
30.     setfillcolor(Enemy[i].color);
    2 m- W! {) X9 \- B. c$ K
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    / }0 D: K) f: ?
32.   }8 j/ W' y- f) ?) [
    
33.   //玩家4 J( y0 u) f/ ~% N8 g9 L
    
34.   setfillcolor(RED);
    3 @% e& t$ ~8 o0 m) I& b
35.   solidcircle(player.x, player.y, player.r);
    , D; Q- o' z( t7 h! d! e  g
36.   SetWorkingImage();7 F# {& K; i# ^2 w6 H
    
37. 
    & p/ I3 Z+ ]+ ~  P* w; _\" C% y8 S2 l
38.   int x = player.x - (Wide / 2);, f. L0 f( I( h7 k/ D$ i
    
39.   int y = player.y - (Hight / 2);6 K, r1 N' f: H& o2 q  P5 J7 T/ f
    
40.   //防止窗口越界\" y8 D& {7 d0 d# W3 \
    
41.   if (x < 0)
    , x( m# @9 ^; m& _; D! M* `, k, H+ {
42.   {5 p% |' W+ A3 b% U0 T8 g
    
43.     x = 0;/ h3 K( |. F$ D4 b0 j9 l
    
44.   }5 W/ M* ]\" C# f
    
45.   if (y < 0)
    \" Q# Q# E' z: t. ~7 @  z
46.   {
    + s, p! Y/ d' Y! d6 i! b7 [+ [( a) A
47.     y = 0;0 A5 X- m0 W$ [6 r* {6 e( u$ ~# W
    
48.   }
    * R' n% V$ g- ?8 ?7 `
49.   if (x > Wide_map - Wide)
    7 b) w+ t2 Q' D$ m\" M\" m8 W
50.   {5 c# r) [2 ~5 a& p\" j6 S
    
51.     x = Wide_map - Wide;/ d( U& {5 y7 k# F8 n  _9 a
    
52.   }& A% m# W8 E+ }1 u( J8 p
    
53.   if (y > Hight_map - Hight)7 S4 k6 p6 K* \0 w( V% n1 L5 ~
    
54.   {& N6 O/ |# R9 J6 V: l
    
55.     y = Hight_map - Hight;
    7 ~& ], n! F- x, [
56.   }4 _: @& |7 ~7 M' Z0 i8 P! n+ }
    
57.   //把map输出到窗口上
    1 l\" X, V3 _- J; k
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    \" ~; b- _* N8 z8 G
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. //防止窗口越界
   & H- N\" G$ L\" U2 z) c
2. if (x < 0)
   ! h, ?) G* b6 p+ u7 z* l0 f: ]9 i) i
3. {
   ' J; p; H9 p$ Z+ i3 r; J
4.   x = 0;
   3 m/ E# U$ X. ?1 n+ y\" `8 E% K# x  w& ]
5. }
   2 O4 }4 i# ~3 N: f. i+ A
6. if (y < 0)
   # s3 v' o7 C) g8 l
7. {
   \" i' O: i, N3 \
8.   y = 0;- w: A( D* v1 _1 ^0 p
   
9. }: T( N0 d\" F+ d  m
   
10. if (x > Wide_map - Wide)
    / d$ j$ ^! R3 }: {: s. D5 s\" |
11. {
    $ v& B\" I) x8 w1 |' y
12.   x = Wide_map - Wide;
    7 j0 M  a! C8 J2 @
13. }& A1 l' X* l  Q* i\" o
    
14. if (y > Hight_map - Hight)
    3 d3 P- K$ [$ p1 Y7 e! L  _+ }4 S9 r
15. {$ O* y/ U- M; f1 c, _/ e
    
16.   y = Hight_map - Hight;
    1 e. X1 V. w' w: J& D! h/ Q
17. }

复制代码

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

, @! R6 }$ K, e/ E. o  p. u8 D(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

Wide：这个参数指定了要绘制的图像的宽度。

5 m$ C  ]7 x+ h! H% ~Hight：这个参数指定了要绘制的图像的高度。
! j6 h7 z( B& p/ r* C2 {
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
. G8 K, U% j- `* ?! }6 K  F, x
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
1 [3 D* t: i% c
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
: Z; ]& f6 p2 q! t$ |6. ai小球的移动
% j" {, U& F" x  E2 w: {& y0 d" B随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离! N3 d6 N7 u, J& H$ ]
   
2. int Distance(int x, int y, int x1, int y1)2 o) T; Y. h1 ~3 |* K
   
3. {
   $ J% b1 i0 ~) {\" n
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));' Q5 w  K1 h! p
   
5. }

复制代码

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

1. void Enemy_move()( q% o) i0 X* v/ S3 |
   
2. {
   $ z8 M* [! J0 T, _6 Q9 U' r\" \0 J
3.   srand((unsigned)time(NULL));/ l5 Z6 ^+ n; n6 u
   
4.   for (int i = 0; i < Enemy_num; i++)
   . e+ P6 Q1 c% g3 ?
5.   {
   3 X, U5 P& r4 G4 v8 l# K, |8 {
6.     int direction = rand() % 4;* j+ t7 ~8 S4 w, h3 h$ V
   
7. ! V$ H! c/ ~  M7 j  t. B
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   ( X# n+ k) z# @3 ]
9.     {$ L/ Z$ \7 ~! E- _8 g
   
10.       if (direction == 0)
    : T6 e( V+ U: h% }( p
11.       {
    / K& R3 r# V$ m! h
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句1 s3 L/ f' w\" g1 d! X  z
    
13.         {
    ; |) K; K* T% `. r( A4 V- k. P
14.           Enemy[i].y -= enemy_sleep;' s9 F% H8 a4 q* k( e4 U
    
15.         }4 G0 \8 |2 y. d+ F5 R
    
16.       }9 o: a$ b2 _/ M6 h0 O
    
17.       if (direction == 1)
    - z0 B, Y; p9 o
18.       {
    4 H3 t3 Q# r+ I& J$ I
19.         if (Enemy[i].y < Hight_map)$ n9 c! ?! x2 i8 Y+ Z( o) ?6 }
    
20.           Enemy[i].y += enemy_sleep;% Y! C. e& D1 _6 U
    
21.       }
    7 ]\" s' V$ j4 D+ u' K! o# I, |! P
22.       if (direction == 2)
    ( h\" h5 b: M8 `% @7 }3 K; M( W
23.       {* z5 @$ |: l7 d  y, M* z- H8 B
    
24.         if (Enemy[i].x > 0)7 |; A7 @/ A. s7 x% D
    
25.           Enemy[i].x -= enemy_sleep;5 p9 J8 `, ^+ N+ ?& H3 W
    
26.       }6 i6 H! l( \0 P% W
    
27.       if (direction == 3)- N& Y7 S* V# k. j* _
    
28.       {
    7 {+ c3 S* a$ k  D\" |
29.         if (Enemy[i].x < Wide_map)! ]5 O- }3 [% U/ m
    
30.           Enemy[i].x += enemy_sleep;( x/ @  V+ E# G1 G; w1 A: ]% N
    
31.       }' }& t# t. n\" @9 f4 o
    
32.     }! r+ i( b, G6 ~
    
33.     //敌人追击玩家
    ) M( h: c) z1 }. @& X
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50), }9 L- r( @( k5 b
    
35.     {% F, T5 x/ K5 M  m
    
36.       if (Enemy[i].r > player.r)& H\" t* L: ~1 `8 o: i
    
37.       {
    \" f1 h3 g. U9 ?, f1 q3 o. p
38.         if (Enemy[i].x < player.x)
    % @; G, U! r- W, B9 O2 p0 R
39.         {6 _6 `! l\" _6 F8 v* ~0 O( _
    
40.           if (Enemy[i].x < Wide_map)( g* _: _  O/ }& a0 g
    
41.           {
    ! K+ }* r+ ]7 f. [- }1 X
42.             Enemy[i].x += enemy_sleep;# e! u# F\" N  s* M# s8 e- G
    
43.           }4 d- g& a' \3 c2 Z! a) a) R\" r
    
44.         }
    2 s+ @0 k0 ]+ c
45.         if (Enemy[i].x > player.x)( q+ _) m3 |  A% }\" s
    
46.         {2 ?6 {- b1 H% W\" |0 ?: b8 {4 A' D2 P
    
47.           if (Enemy[i].x > 0). w8 m\" F1 l0 W6 F# T
    
48.           {1 z6 v& D) Y! w8 i5 Q0 a
    
49.             Enemy[i].x -= enemy_sleep;
    \" E* v3 W. h8 e! z
50.           }6 [5 p3 h0 r+ r* C
    
51.         }: L2 i1 D, x. p$ X
    
52.         if (Enemy[i].y < player.y)( n8 b7 d* e- F5 E/ @  ?
    
53.         {9 \/ E7 B! ~) r( t, q\" e( C
    
54.           if (Enemy[i].y < Hight_map)
    ( }0 Z8 k7 X. z
55.           {/ }\" K$ e4 i0 f. a
    
56.             Enemy[i].y += enemy_sleep;4 g$ O8 |8 Z: R
    
57.           }5 S$ U  l  v  }: h& O) T( N
    
58.         }* ^7 c4 L8 p' g2 K* D2 t
    
59.         if (Enemy[i].y > player.y)
    ! @: j- o* X' ^( ^9 P, Q. W. l) H4 Z
60.         {3 c+ d% |  q2 D+ r
    
61.           if (Enemy[i].y > 0)
    , F' x, t$ `1 d, n0 Q
62.           {5 r& F- F* i  [7 M
    
63.             Enemy[i].y -= enemy_sleep;
    * n* X. D7 T/ x- R3 R  E
64.           }3 m& I6 p$ _2 }: W1 b& z% \
    
65.         }
    + ?$ C- n* M1 a0 q3 z; P+ K: t
66.       }9 G, [+ E+ D4 ~
    
67.       //敌人逃跑$ L2 w8 K. G1 W! u/ D, x  t$ e
    
68.       else
    6 b( I0 K. x$ I
69.       {
      B( U; t0 {. f
70.         if (Enemy[i].x < player.x)! \\" V2 V  l  j* F7 N# V! v& e5 u' v
    
71.         {4 i. G; j+ Z. h
    
72.           if (Enemy[i].x > 0)6 a9 R' x\" o8 }4 j1 i* w
    
73.           {
      U- l2 d2 N2 |* N
74.             Enemy[i].x -= enemy_sleep;, g3 l+ Y- n( T! @6 c
    
75.           }
    + X! c0 g\" _4 s% M5 m
76.         }
    9 Y. R/ T* R6 a; K
77.         if (Enemy[i].x > player.x)
    , j  Z% ]\" o! X0 F% N! N
78.         {
    ! [+ r% x0 L1 n7 l) J
79.           if (Enemy[i].x < Wide_map)
    2 l\" z& z' y2 f) G6 c
80.           {\" K6 Y- M) }3 b. U
    
81.             Enemy[i].x += enemy_sleep;
    ' N9 F- d4 \5 F& E! o2 {
82.           }
    2 e; F) I2 I5 t9 C; P0 Y
83.         }
    \" K+ ]7 v- t- O8 c, d/ J6 B
84.         if (Enemy[i].y < player.y)
    $ `\" V( W% p/ m7 d/ l
85.         {
    7 ~8 A. U, O6 r; }4 C
86.           if (Enemy[i].y > 0)
    9 e- w1 X9 h/ Z% k* b/ G) d/ J0 N
87.           {
    . u1 ~9 Q# h' k$ C8 K% ~
88.             Enemy[i].y -= enemy_sleep;& x; |3 Q% r3 r$ h+ `
    
89.           }
    3 p& ~0 V2 o# Q9 A$ H9 d8 o
90.         }
    - n( M5 }: K. l
91.         if (Enemy[i].y > player.y)
    1 n% o8 p' J, y) E. C( V, h7 \7 G
92.         {
    $ Z/ y; u9 t$ h4 _. C
93.           if (Enemy[i].y < Hight_map)
    & u3 i' V+ D: [4 k8 P
94.           {
    % \# l9 j9 P\" \\" |$ w* O/ N
95.             Enemy[i].y += enemy_sleep;
    6 X4 {- y7 v3 D; W
96.           }. J; u) W3 i. F) H: _6 g% Z
    
97.         }
    5 f7 n5 |1 c$ p4 v8 S
98.       }
    # F6 j( y  i0 N/ P2 i3 a2 v
99.     }; _0 t+ x: f' D; Q1 P
    
100.   }\" y2 \: p, u, n. _* @& c, x
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood(); f' M6 I5 z5 e8 Y* o$ c8 F5 r1 D
   
2. {/ r- c; X! \6 M6 g$ B. _4 Q
   
3.   for (int i = 0; i < Food_num; i++)
   8 r7 F3 r) T. B* w9 s2 H
4.   {
   8 G1 o/ k$ L# j) u8 v
5.     //玩家吃食物
   6 l( W/ b2 ]\" U, ~' U; y\" x
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   \" a  v( \5 A6 D. F5 G
7.     {
   ) Q, g9 W, l8 V
8.       player.r += Food[i].r / 100;
   ) }8 q8 G2 u: n+ \
9.       Food[i].x = rand() % Wide_map;
   ( H  ?8 G2 m! T8 v\" O
10.       Food[i].y = rand() % Hight_map;6 G7 I0 I/ F\" w( _3 J! v9 g
    
11.       Food[i].r = rand() % 5 + 1;
    0 p* m+ r4 t, Y
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    - N9 q! O4 N5 M4 O7 n2 B. f( h
13.     }
    & R$ s+ R# o5 P+ x
14.     9 R' A- |1 Y& W, n
    
15.   }
    3 {# y\" B0 X% _
16.   for (int j = 0; j < Enemy_num; j++)
    , m# q' i1 B1 p) [  c; ~
17.   {
    \" v' Z3 v) Y; m8 [: w
18.     //敌人吃食物- Y) O! L( [\" e3 [$ K0 ?. x# ~, t
    
19.     for (int i = 0; i < Food_num; i++)7 j- e\" m$ p8 L7 f
    
20.     {3 x: d9 I% k$ d9 P% H
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    : n: Q3 C2 w$ b: o
22.       {$ ^- K\" M* ~. K6 p- U) y, s
    
23.         Enemy[j].r += Food[i].r / 50;
      h1 S3 U7 y6 Q/ D3 O: g+ N
24.         Food[i].x = rand() % Wide_map;$ G\" y* r; A  J4 `
    
25.         Food[i].y = rand() % Hight_map;* m: Z1 ^) z# l- y
    
26.         Food[i].r = rand() % 5 + 1;
    0 q& \3 f& w  k) x' m: d) z$ {0 w6 c6 r
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);6 }% W( w/ l! q& ?4 B
    
28.       }
    % `- x1 V# l/ l6 e
29.     }! h( \6 L( \) f' Y! u9 ]
    
30.     //敌人吃敌人
    7 _% {5 E; g& e# H, I5 v
31.     for (int i = 0; i < Enemy_num; i++)
    $ k& A& ~; _7 I) }  @5 h3 o
32.     {: k& S7 v9 h\" n
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
      m0 q, Y4 r- W
34.       {! o' |, f& R: Y( L8 l! x
    
35.         Enemy[j].r += Enemy[i].r / 10;+ F4 P3 p7 i: v1 Q. D
    
36.         Enemy[i].x = rand() % Wide_map;
    $ ~- E: i' J! C- g
37.         Enemy[i].y = rand() % Hight_map;' B, W- S, Q$ _\" w
    
38.         Enemy[i].r = 10;
    % M4 ?0 `5 q! [& t
39.           Enemy[i].color = RGB(0, 255, 0);7 x9 F  e* c/ c! v& L+ ]
    
40.       }
    ; i  D# Q: }& z
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    ) c  Q9 K5 n8 n5 A/ c- a. j( n
42.       {& D# D' I0 T) i7 Z* L! }
    
43.         Enemy[i].r += Enemy[j].r / 10;/ L5 {\" B/ l. M; w5 W- ~
    
44.         Enemy[j].x = rand() % Wide_map;
    % s3 P5 W1 s' ^
45.         Enemy[j].y = rand() % Hight_map;
    \" b$ q8 b9 \; o# v5 Z
46.         Enemy[j].r = 10;! Z: ?( P6 E8 w8 T\" }( j\" ^! K
    
47.         Enemy[j].color = RGB(0, 255, 0);6 s0 ~- u: Z4 ^. p* c; J, s& u/ ^
    
48.       }
    / B0 N9 t$ Y  g' a/ u( X8 D1 |5 A
49.     }
    + W' I3 O( P, Z4 U0 c2 I/ x
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)  }+ ?6 ~/ ~7 ^: j. l; h
    
51.     {
    3 {% J& n4 X! }# H5 j4 @
52.       //玩家吃敌人
    8 s0 f- v- o3 {. f, R7 s
53.       if (player.r > Enemy[j].r)3 v1 X' Y5 A2 c4 c2 D
    
54.       {
    6 o0 ]# X& l2 M7 P* I: O
55.         player.r += Enemy[j].r / 10;
    9 H- ]) Y& V. B0 e4 f
56.         Enemy[j].x = rand() % Wide_map;
    , E# i, b\" `5 A+ K
57.         Enemy[j].y = rand() % Hight_map;3 u8 N$ }9 F5 x/ g0 P4 Y
    
58.         Enemy[j].r = 10;6 d3 ~. E7 l! s
    
59.         Enemy[j].color = RGB(0, 255, 0);
    , a( j& m7 ~* d. f4 {) i
60.       }
    7 q. E$ q% A  r! t( @8 B
61.       //敌人吃玩家
    3 M5 q! x- ?, s\" G6 T
62.       else8 N9 m9 R& {! O9 W0 Q7 `4 R; P3 R
    
63.       {
    - O, ~$ \5 g# n% ^+ J
64.         if (invincibility == 0)
    1 h! z! l/ j5 U, j
65.         {# K. y8 F9 `, L9 K
    
66.           Enemy[j].r += player.r / 10;; y& |6 s# m9 K5 R. H7 I
    
67.           player.x = Wide / 2;6 I3 w3 A) f5 |! v
    
68.           player.y = Hight / 2;
    % H& H( ?4 A2 g1 Y  @! S. W
69.           player.r = 10;/ O0 |! ~; C4 x2 H
    
70.           invincibility = 10;
    9 @$ A, e8 I( Q/ M4 L8 ~
71.         }
    1 Q6 ~0 H( G5 w) ]8 p1 h
72.       }* r# ~, x  S, N3 [% N) {
    
73.     }- I& V, _( y; I2 x
    
74.   }7 C( O6 ~\" {3 U, P2 g
    
75. }

复制代码

完整代码见附件：