球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
# ?$ U; [$ y7 u
- b! N% u' a" `4 Q在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
& u5 _# P3 h! H! s; Z% y" J+ s% Q
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
* U0 x# r6 G: [7 r( r
" J1 m8 E4 w; R2 m' V玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
/ m' H; ~5 |% J' E9 O( y
其他小球：其他小球又分为食物小球，和ai控制的小球
9 V1 y3 H6 f! M: J; ^! t4 a
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

6 t& R. a9 [+ O% u8 ?  t" G玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

% E1 Y( {3 _1 w0 L  yai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
$ i% B! m9 Q5 C! S2 i4 |/ N  b
7 g0 f. h% N1 G- r: ]接下来，我们将通过以下几个步骤来实现这个游戏：
+ k( q4 R8 Y6 u: F8 s
初始化游戏界面和小球的信息。
. \& ~7 h2 @" i5 W
处理键盘输入，实现玩家小球的移动和加速。

生成足够数量的食物小球。

生成ai小球，并控制其移动。
1 Z+ A  W% j6 d+ v, v8 L
! B' V8 q( r) t) O& d5 x检测小球之间的吞噬关系，增加相应的体积。

" b% P" r* e5 |通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
7 z/ L6 j8 R& v. U( _# L( R3 O
4 [! g! N1 F) ?% d" e/ V9 c  Y' v1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
2 `( D3 v* V$ d% g* V7 U# D4 }( U/ u
struct Ball
{
        int x;
7 i, ^# u; m+ K0 p% H        int y;
& ^7 a  W* l6 t, p        float r;
        DWORD color;
};
2. 初始化小球的信息
3 C2 D' ~0 K3 A1 A* T将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

. p7 e9 o& n4 \1 GRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
( U7 ?3 Y2 s( I
5 I: ]' i7 b! ]9 O/ S% L8 u橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
6 m2 I8 K, g2 W紫色可以通过RGB值（170, 0, 255）来表示。
& K& A3 D3 Q7 I黑色的RGB值为（0, 0, 0）。
: r+ `+ }6 W# T1 C. ?5 m. _白色的RGB值为（255, 255, 255）。
; ~% Q# ^) z# f" o+ J; a灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()8 O! C6 t% V! x1 ^/ t
   
2. {! M$ g) p7 T0 P1 b( ]: `
   
3.     //玩家小球
     H$ [& O# K! o) x\" T: K
4.   srand((unsigned)time(NULL));! }5 u* b& [5 N& ^& \5 Z; K
   
5.   player.x = Wide / 2;4 p  m6 f% O  g3 J1 q; c+ _
   
6.   player.y = Hight / 2;' B$ R7 v$ F9 T% k1 q
   
7.   player.r = 10;9 D6 e4 H; k9 P* i! t% G
   
8.     //食物小球
   7 i# X; B2 |' l% K0 z\" x5 p5 J
9.   for (int i = 0; i < Food_num; i++)* B! H% J2 s; J! T( i
   
10.   {7 K1 B' J/ Z4 B) k: a
    
11.     Food[i].x = rand() % Wide_map;. W- z& j& o+ @8 \2 \
    
12.     Food[i].y = rand() % Hight_map;: p% {& \0 I# h) T
    
13.     Food[i].r = rand() % 5 + 1;
    ! o: ?+ S- t5 K  O5 |+ k% K
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ! ^, p5 C) m8 C
15.   }; o& Q/ `  g' W. T: R
    
16.     //ai小球
    ( ~& s! y1 ?0 x8 ^3 [5 K+ k& J( W
17.   for (int i = 0; i < Enemy_num; i++)5 L5 a1 q. Y2 t/ G1 N
    
18.   {
    ! ~6 X! r% z. _- }$ h
19.     Enemy[i].x = rand() % Wide_map;
    + A5 W- k. }; U& Z2 {
20.     Enemy[i].y = rand() % Hight_map;8 Q+ @\" p2 p2 q  \
    
21.     Enemy[i].r = 10;
    8 A) q) v7 F9 b; B0 M( e. s% m; T
22.     Enemy[i].color = RGB(0,255,0);# B8 a0 T5 ~0 ~! |
    
23.   }5 u0 d7 z5 Z; r\" g
    
24. 1 \* y. n0 [4 ~$ L' v. q3 ?% u
    
25. }

复制代码

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

1. void Player_move()4 D+ u. u9 l+ l% S7 d
   
2. {
   ) U+ Y9 I7 e6 i+ J  ?% Q
3.   if (GetAsyncKeyState(VK_UP))
   4 m1 L- a4 e5 k  Z& K: Y) n4 s  h, @
4.   {
   6 O- q& W* g0 B5 o' @' W
5.     if (player.y > 0). \$ i2 T! ^/ C\" J) v& X* D1 y, e
   
6.     {8 C+ u( L8 n$ c# H0 w1 Q! K: j
   
7.       player.y -= player_sleep;. T2 b. z, s  J+ v6 `6 H0 K$ B+ [
   
8.     }
   8 K\" U% e/ F; G1 n
9.   }
   % }! X1 i2 _! f
10.   if (GetAsyncKeyState(VK_DOWN))
    2 t0 u* Y: y! h, y
11.   {2 j, _. c* |. r! D. o) d
    
12.     if (player.y < Hight_map)\" h1 }7 P7 D* ]- z3 p6 i+ C; [- n; h
    
13.     player.y += player_sleep;
    0 m\" ?7 F3 {, R- {2 L$ r
14.   }
    ! v( |: P: |( `; f! R2 g
15.   if (GetAsyncKeyState(VK_LEFT))' V4 l: M  P% O! S+ I% I! c
    
16.   {
    ' G( k2 l. T+ M# ], y
17.     if (player.x > 0)
    ! }4 [  Y, w) u; Q1 Q) e
18.     player.x -= player_sleep;! @  u' a. C\" k0 V- @4 U/ Z
    
19.   }\" i$ X0 F) m2 V
    
20.   if (GetAsyncKeyState(VK_RIGHT))1 M5 d0 ]+ P. J- Y! a5 \4 I1 K
    
21.   {9 `  d$ ?$ v9 y
    
22.     if (player.x < Wide_map)) M0 N\" q! R5 |7 Z# T$ P9 N1 i# D
    
23.     player.x += player_sleep;
    ; o/ w* g& t: z, v+ E4 R9 b+ a
24.   }
    ( _8 O* X& W3 Y: i1 Z
25.   if (GetAsyncKeyState(0x20))
    * Z. d! W2 q% |* f: p3 z
26.   {
    ' b! ]6 H$ V3 ]! L9 k\" ?
27.     player_sleep = l + 5;. w5 w+ D8 f+ x) @
    
28.   }- D4 m$ i4 H. f  j5 O+ I
    
29.   else
    - E6 X4 P/ i! x1 z& q2 z! F
30.   {
    : ^6 k* L( C8 ~
31.     player_sleep = l;
    $ w\" K8 _7 c7 _$ F& Y' J' x\" N
32.   }) u6 d( b' V6 }3 A
    
33. }

复制代码

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

1. void Show()
   8 r3 s0 b8 X' m1 A
2. {
   1 H+ D2 g$ V. I1 L\" ]
3.   , f' F\" L: i# X9 z
   
4.   //设置地图
   8 M% R& ~& R5 D- U& P9 K3 u  l
5.   SetWorkingImage(&map);
   / ^3 m7 p/ v9 E
6.   //清屏0 L& u, M! P; ?; X
   
7.   cleardevice();% x3 v2 ~+ I& ^
   
8.   //背景颜色: }5 K) R4 a* P8 G  K9 a
   
9.   setbkcolor(WHITE);/ l# {0 O9 p% d) A
   
10.   //划线颜色, |! U8 G- ]$ i3 t$ l/ x2 e9 g\" q
    
11.   setlinecolor(RGB(230,231,239));
    9 a1 v3 o  t. ^
12.   //划线
    * H7 Y6 b* Q* U# w
13.   for (int i = 0; i < Wide_map; i += 10)& m% i, D( A3 C
    
14.   {
    * ^6 v6 K5 `* p( C* u
15.     line(i, 0, i, Hight_map);
    , F2 `* `9 H/ H0 r, R! h\" N3 ~
16.   }\" w% Z% r# j; n& A
    
17.   for (int i = 0; i < Hight_map; i += 10)
    / Z/ B. G8 L  r  I& T
18.   {' O# }* j4 x* {6 P
    
19.     line(0, i, Wide_map, i);7 S( n: M0 N$ a7 ]( U
    
20.   }
    ' M% _\" s5 P% Q: V* d. S
21.   //食物
    ; _\" u0 w, B' `+ _4 B
22.   for (int i = 0; i < Food_num; i++)
    3 a1 e2 |) [, I& Z7 r% U1 G
23.   {
    0 ?) K: I8 a& G; X& L
24.     setfillcolor(Food[i].color);' c) y$ z/ m& y% c
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    6 y9 ?1 z  ]- G% b) P
26.   }
    ! t! d$ Q# [/ y( |1 V& ]
27.   //敌人+ b+ c5 {% o5 _* l; w+ j
    
28.   for (int i = 0; i < Enemy_num; i++)
    + i2 \7 I% a- f; U; p) D
29.   {+ J1 Y. I: S# P6 e. h
    
30.     setfillcolor(Enemy[i].color);7 _5 Y5 F5 {3 L1 ?0 X. N
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ) g9 J0 X2 p* q& F( A1 _
32.   }
      g6 t2 z: S9 y5 k7 @
33.   //玩家
    \" E* P6 ~( P4 [5 Z$ V
34.   setfillcolor(RED);
    0 O6 L* D- E2 T9 c- k
35.   solidcircle(player.x, player.y, player.r);' H# {. H1 U/ H& @- b! o
    
36.   SetWorkingImage();5 m4 O/ o5 X1 f2 J) ]
    
37. 
    : m- o. o* C; A; T
38.   int x = player.x - (Wide / 2);+ H3 M5 v4 R4 @- p
    
39.   int y = player.y - (Hight / 2);  O( j5 b; C% f) T0 R) y+ l
    
40.   //防止窗口越界: A+ H! y+ Y! S$ R3 U0 J
    
41.   if (x < 0)1 F, u4 Y: y1 f
    
42.   {
      M0 t% r$ i  u& Q5 q
43.     x = 0;
    ( z& T/ b7 S: k$ y- S
44.   }! b0 I, ]8 b& `8 X
    
45.   if (y < 0)
    / w# C, U: f: [: f, i
46.   {7 \: T- i0 h8 A0 e
    
47.     y = 0;* y, ]& O; ], J
    
48.   }/ `3 `# f) A* u6 t( }
    
49.   if (x > Wide_map - Wide)
    . v! K# I* F* E: @+ D
50.   {
    : V; T5 j  ^6 \
51.     x = Wide_map - Wide;
    $ ~% s- D: `, g( O! G
52.   }* \( X' @- }. \! E9 l7 b! R% `  A
    
53.   if (y > Hight_map - Hight), L/ V- m% M. d5 b0 D2 F
    
54.   {\" _, u( ^2 s\" M# E2 [/ D
    
55.     y = Hight_map - Hight;; I: t/ j\" X( \% B
    
56.   }
    1 [3 l! O7 O. q* ]: T
57.   //把map输出到窗口上0 `6 U' g! W1 \: I; p: C6 T
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);' v7 p/ a& s3 K, o3 N( ^
    
59. }

复制代码

5. 生成地图
8 u1 D( _( Z) J; A可以使用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. //防止窗口越界
   ( j3 p# G7 q2 D7 d8 d% Y, F  o& ?+ w
2. if (x < 0)
   4 V6 b# S; T& a( N
3. {, P\" y+ g0 o/ T8 d9 v1 \7 I
   
4.   x = 0;- T. U6 @! ?: [! V1 u/ C\" X
   
5. }
   9 U. q\" @+ G$ E0 H' X' ?
6. if (y < 0)4 U# t. v5 L% E: J+ a$ }# n5 T$ b
   
7. {6 u1 p1 ~4 S4 u: ^  b' V! `
   
8.   y = 0;
   & {0 q9 t5 ]8 y
9. }
   4 f0 S) h5 w0 {; n
10. if (x > Wide_map - Wide)' D' c( B4 J2 \1 {2 G1 z
    
11. {* D/ \) @% q5 \0 T2 S
    
12.   x = Wide_map - Wide;$ r* ?% h! z( D\" z' |- V+ K; V
    
13. }3 ]- G, T1 h9 \& @
    
14. if (y > Hight_map - Hight)
    4 [% o% \4 r7 L1 c( x  M
15. {
    : w- B\" i. Q- R# B! x3 s+ b( Z\" Y* V
16.   y = Hight_map - Hight;
    ) C3 ?* V8 {% e
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
- q( A3 _+ Z' C( Q3 z
. Y' Z# \. ^6 H( U4 j: p(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
. h( v% Q! U. ]5 N0 }
Wide：这个参数指定了要绘制的图像的宽度。
) S( w- @" m# i- b/ A( j% E
5 M! D  U* |& L8 {7 W7 `5 pHight：这个参数指定了要绘制的图像的高度。

8 o" \: d; E4 F  E! R) u* |, c" H  A9 \&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
4 u- C: V* t- F* s$ w5 D2 T
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
' C- ~4 ~( j' y1 R6 D. x7 H
3 T& G0 ~7 \+ [% H* E) S/ N& `5 Xy：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
! w* u: ]$ C* o7 Q6 y随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   + H+ [1 ^, d5 t
2. int Distance(int x, int y, int x1, int y1)
   / ?4 f& E. G% B* P) a
3. {
   $ F5 F. |- Z/ [, c
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   , Y, y$ L. N% c# `
5. }

复制代码

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

1. void Enemy_move()+ _- G0 d+ x8 @: a# K! a
   
2. {
   5 x: [. h- W) W4 b- Z* q
3.   srand((unsigned)time(NULL));2 Y  Y) `9 w' A/ Q& \. B4 y# w
   
4.   for (int i = 0; i < Enemy_num; i++)
   3 K0 I. o  t- A) F+ a! e
5.   {
   + X! S6 A. C1 Y- B* }2 B! L. L
6.     int direction = rand() % 4;
   7 z5 C2 J9 t3 v& z% u\" \% f
7. 
   / ]6 b% Z- p! Z; b
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)) C' Z6 e, L) T2 {7 C9 e( u
   
9.     {; K# R9 M# c% @* B+ [9 G5 R
   
10.       if (direction == 0)
    & z. x3 H5 W% a; W( E5 T
11.       {2 j1 K8 N1 f; O  q9 p. n
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    3 E% ~' |4 T6 j4 |, F1 }
13.         {: r) x% J* N' W5 W$ M
    
14.           Enemy[i].y -= enemy_sleep;$ [! V& d\" }# p5 w
    
15.         }
    0 }+ s\" l: U7 N
16.       }2 @7 I  L7 J- l6 o7 W+ b
    
17.       if (direction == 1)
      _' W3 y0 u( |
18.       {. I% E4 J! c! w- [& n- G
    
19.         if (Enemy[i].y < Hight_map)
    5 H8 b8 b7 X: c* l\" l- {0 E. o
20.           Enemy[i].y += enemy_sleep;
    5 ?* i5 J1 R6 j
21.       }
    4 R7 W+ L7 X5 n8 z8 p5 g
22.       if (direction == 2)4 s- l. P* v6 b- `- w* c$ j4 _; |
    
23.       {9 h! m+ U+ v1 x$ X1 j
    
24.         if (Enemy[i].x > 0)
    % I\" r7 Y6 T3 [2 s1 \3 w( X) }( G
25.           Enemy[i].x -= enemy_sleep;, m' k: W5 V% X( i' N2 G) r+ G
    
26.       }\" V2 K$ K4 C. i6 f& A- i9 M
    
27.       if (direction == 3)( g/ z% x3 c7 s7 J$ d
    
28.       {
    . W( d, c7 L+ M/ e9 A
29.         if (Enemy[i].x < Wide_map)2 a0 X, I4 T, ], x
    
30.           Enemy[i].x += enemy_sleep;
    7 P, w1 i9 [9 P- s) ]: f
31.       }
    * ~0 T- z* i' s- r1 j
32.     }& v! T- |! T* s, O+ Q1 S
    
33.     //敌人追击玩家
    4 f( R4 |\" W9 c9 i# K# Y) U* h, x
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50); d# F( g9 I2 {- b3 t$ D
    
35.     {
    ! ?+ P! M3 h$ ]% g5 K1 G
36.       if (Enemy[i].r > player.r)9 E2 |/ Q: z, h( _. o5 c0 a
    
37.       {
    - x! m# _0 Z4 `6 B7 V0 m
38.         if (Enemy[i].x < player.x), r. q$ h7 s, A1 Q8 c' |; k
    
39.         {( b, A& V9 u/ O) h. O' C4 T. p
    
40.           if (Enemy[i].x < Wide_map)
    , F  h9 w! \  h
41.           {
    2 w1 D: u$ g. y
42.             Enemy[i].x += enemy_sleep;
    # m/ f) g! Z6 G# Z\" x
43.           }
    5 f1 Z+ N+ b; \\" X2 z\" d
44.         }
    . _& ]9 \) G+ @, k) |/ X/ c% W7 ^
45.         if (Enemy[i].x > player.x)+ m4 q1 P7 g$ V* k6 E( m/ p  F- Q# K
    
46.         {/ x6 v( e8 }2 d: @
    
47.           if (Enemy[i].x > 0)
    ) [8 p( m: c$ l$ D7 B* d0 D
48.           {
    2 h4 S- ]; n+ a6 `# k. z2 G
49.             Enemy[i].x -= enemy_sleep;
    4 e6 ^* b4 g( a, D
50.           }\" ^\" A  k! i( q0 J
    
51.         }. ]& C9 X8 ^  s9 O
    
52.         if (Enemy[i].y < player.y)
    5 m; P, o. J8 Q
53.         {
    : Z  Q) {9 r8 t4 }! ?0 r
54.           if (Enemy[i].y < Hight_map)
    - D! j# a' t  s/ l3 E2 ]9 o6 q
55.           {
    . a' s/ x, {, f
56.             Enemy[i].y += enemy_sleep;2 b+ B& {. R# R
    
57.           }
    4 v) Q: L\" F( W
58.         }
    6 u; S9 t& p1 q) r% ]+ y! h( K
59.         if (Enemy[i].y > player.y)
    9 g9 Z, I* N0 i- z) l7 ]9 B& f( A
60.         {6 g3 v& r2 k0 J. c9 L
    
61.           if (Enemy[i].y > 0)) X+ A3 u3 u: q- P$ b9 e# b( Y
    
62.           {5 P8 f8 `  ?4 }7 {4 p
    
63.             Enemy[i].y -= enemy_sleep;$ M/ e$ I- b% c  a; m: E7 A
    
64.           }
    1 S4 f9 m- ~  [1 e# t# O) \2 u& f\" C
65.         }. Z3 L  u$ f3 h, T
    
66.       }) {. j3 ?1 ]- n1 v3 n
    
67.       //敌人逃跑2 J$ M' V2 _: R& v3 x' y0 \3 i% D
    
68.       else, D+ ^# u. w/ A$ i$ d6 f
    
69.       {8 T* y  n: ]1 |7 ?6 V! u3 y
    
70.         if (Enemy[i].x < player.x). u, P# k8 X0 I+ a3 M
    
71.         {6 x& V- G3 i5 l$ w3 C$ }
    
72.           if (Enemy[i].x > 0)
    - O' I! W3 j' f+ ~
73.           {
    & _, _) r' r* f7 b2 k# ^, k
74.             Enemy[i].x -= enemy_sleep;
    2 U0 p# ]( f* h; G5 \
75.           }; E7 i- `; D; w( m; n  ?
    
76.         }
    # x# t) o' h) }8 F
77.         if (Enemy[i].x > player.x)
    5 G4 F5 c! e6 k0 k' S+ x* S. N, I- }2 @
78.         {
    4 f1 q8 w, C. O\" p! R
79.           if (Enemy[i].x < Wide_map)
    0 w& l+ i2 W9 ]' p) _% A) R7 K9 T
80.           {
    & H9 S$ c- _) O$ I0 b+ ]
81.             Enemy[i].x += enemy_sleep;4 D( h! l6 p, Y0 h9 C
    
82.           }  M4 y4 h* j2 [6 K
    
83.         }
    9 m+ G$ @8 j4 b5 }4 ?  N( t. c4 j6 d
84.         if (Enemy[i].y < player.y)
    8 K5 m; F7 h2 N5 Z' t) V* L
85.         {
    / F$ O  O5 b3 [: w\" b7 S& _
86.           if (Enemy[i].y > 0)
    ! B+ C; J/ L1 R$ u$ N  e
87.           {4 i( r$ N9 w! F4 x3 @
    
88.             Enemy[i].y -= enemy_sleep;9 m& H5 l$ _! m
    
89.           }
    $ x! U7 U- d% w0 K* Z  L
90.         }
    * z3 Y: d4 v' ^; @% c* r
91.         if (Enemy[i].y > player.y)8 U0 g7 I/ t/ V, L! G5 X
    
92.         {
    . L( s+ `) I7 C
93.           if (Enemy[i].y < Hight_map)6 s' z) M7 n9 w# j* p: h0 `
    
94.           {
    # k3 u) }4 X- B
95.             Enemy[i].y += enemy_sleep;7 A) d4 f/ ~& X
    
96.           }
    + ~3 D. m/ U: |2 r/ S
97.         }
    - p5 R/ M0 b. E9 Q! H
98.       }
    . b0 m# }, T! u# ^+ a
99.     }
      e0 y' i2 c& D8 ^4 _\" ?; ]# u+ @
100.   }
     4 i7 @+ A\" ?% Q% c' k  h
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()! ~$ `) m6 v2 S$ N# t; p4 g
   
2. {
   / o/ [& Y6 j. @8 a$ J! n
3.   for (int i = 0; i < Food_num; i++)
   $ n  T+ A' v9 H4 P; |8 I
4.   {
   7 |3 H# k7 c' O3 x, N
5.     //玩家吃食物
   ( Q% ^: o6 n( e& l7 G
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   % Q4 ~* M& l' `/ n! |6 |5 t
7.     {
   ( y5 O1 o$ k9 N8 o! B5 l
8.       player.r += Food[i].r / 100;3 [) y: s/ n5 v0 A/ ^, F
   
9.       Food[i].x = rand() % Wide_map;
   5 J8 w0 ]- l- m( H# ?* t. n; Z' ]( l
10.       Food[i].y = rand() % Hight_map;, t8 D+ m' [( {2 J
    
11.       Food[i].r = rand() % 5 + 1;2 b: x; Y- U6 y7 G. T. c
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);. }9 ?% E2 K- U8 a9 l0 [9 Y' V
    
13.     }& W; h) A. _6 Y* ~4 ~/ K1 J& K; u
    
14.     - T; D# O7 Y; a) E2 ]8 y3 [
    
15.   }1 X/ p! ^, B7 S3 C
    
16.   for (int j = 0; j < Enemy_num; j++)
    ) J7 m6 A- Z/ d, _' J; R0 A  D
17.   {4 r7 _5 U( `5 W+ n6 L' F9 k! F) Q9 ]
    
18.     //敌人吃食物
    ! y5 Y2 u7 g1 ]; F5 Q
19.     for (int i = 0; i < Food_num; i++)
    - R2 P- [' S: ]' E6 q
20.     {2 O& L+ c: [5 e9 C
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    7 N  u$ p. q, M7 b( ^5 f# G
22.       {
    : E' |! }\" R$ N% \$ _* T
23.         Enemy[j].r += Food[i].r / 50;$ c3 E. M; m1 G' b+ v2 I
    
24.         Food[i].x = rand() % Wide_map;, S' E. D. V* @2 R$ V
    
25.         Food[i].y = rand() % Hight_map;
    % j. I7 {4 N' [7 t- `' j) I
26.         Food[i].r = rand() % 5 + 1;
    % E6 l' e\" Z4 x1 X7 Y1 G* w  W) V
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);' \2 Y1 c& [! ]2 q0 }. \- d7 Y
    
28.       }
    4 H# X0 o) z! i% t- {
29.     }1 l5 ?# b+ C5 r8 m1 {
    
30.     //敌人吃敌人% c& u* L8 t\" ]! ?3 D# ^
    
31.     for (int i = 0; i < Enemy_num; i++)* H+ p6 c& |& C3 a  f0 X$ T
    
32.     {\" s4 L0 r, k. e) W
    
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)7 K- K8 p9 I- e
    
34.       {) f- m8 }; i) w$ l3 A
    
35.         Enemy[j].r += Enemy[i].r / 10;
    ! e2 I9 L7 @9 P* ^0 P1 O
36.         Enemy[i].x = rand() % Wide_map;, L. _( Z, E$ t
    
37.         Enemy[i].y = rand() % Hight_map;
      Y. \# N4 s( e, \) W) v
38.         Enemy[i].r = 10;5 ?1 h9 _/ |7 s- r4 z1 W+ q2 ^
    
39.           Enemy[i].color = RGB(0, 255, 0);, N4 H0 Z! M8 a) u* ]\" @
    
40.       }# K: e) E) @; g6 g% |4 z9 G+ E
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)) T- `+ d, P4 J: F; ~
    
42.       {+ c/ j4 w* l* i1 o, o\" `
    
43.         Enemy[i].r += Enemy[j].r / 10;- ]7 c; j- G6 L4 `& Z
    
44.         Enemy[j].x = rand() % Wide_map;
    \" P. @1 `; T: e\" I
45.         Enemy[j].y = rand() % Hight_map;6 P1 G# a4 ^7 x+ |/ [' N
    
46.         Enemy[j].r = 10;
    6 ?9 \* s8 ]/ w$ i
47.         Enemy[j].color = RGB(0, 255, 0);
    & X% K0 \5 R\" l! f7 |( c
48.       }1 `6 k4 [4 z, T$ l
    
49.     }- d; i5 C: f8 |- Z8 e, o! H
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)$ e4 W1 c' C' j: L* E
    
51.     {
    * M( y/ [\" j- `5 q
52.       //玩家吃敌人$ ^% I0 R\" d: L: l2 k6 U0 `3 W
    
53.       if (player.r > Enemy[j].r)
    3 G\" L  H4 Q# p% U8 g. D! N
54.       {6 U\" T$ k% U, t! y+ s# }8 F
    
55.         player.r += Enemy[j].r / 10;
    ) O% y9 A1 F0 ]' ?* T* U
56.         Enemy[j].x = rand() % Wide_map;/ _; Z3 j$ n$ j
    
57.         Enemy[j].y = rand() % Hight_map;
    ' K2 J& R, o: u, m! M7 j
58.         Enemy[j].r = 10;
    5 D- q2 F; Q0 {+ @! R% k9 a  k
59.         Enemy[j].color = RGB(0, 255, 0);# [, q' t  T! b0 \
    
60.       }/ T/ r, A% p. c8 w: e) Z
    
61.       //敌人吃玩家5 V% m' u# T, V# I1 [6 @9 C  j6 ?
    
62.       else
    6 A# i, {2 W4 u. ~
63.       {( |; @, _, [6 |4 i+ A0 m$ a
    
64.         if (invincibility == 0)
    3 A8 C/ O* y) W* p
65.         {7 @5 Z( k2 f- k; ^$ w1 a5 o\" _
    
66.           Enemy[j].r += player.r / 10;
    ; L, \; [! g; k1 w+ J' U
67.           player.x = Wide / 2;
    . @; I, \\" ^7 W& c/ G/ ?- D9 o
68.           player.y = Hight / 2;
    0 m/ @7 x0 f. _+ v7 e6 `! f- j0 Q
69.           player.r = 10;
    ' t3 S  B6 n% f, p( ?# H# n  D
70.           invincibility = 10;
    6 y+ ~/ Z0 R' |+ Z9 t1 }
71.         }; m$ {# I1 y\" j1 q9 u3 X- C7 U8 x
    
72.       }
      P# L. l( m2 {( I5 O% @0 F7 Y
73.     }$ ?5 q: k4 e- \( t: D3 ?$ w& }
    
74.   }
    - t6 d- s7 b+ ]) b. B
75. }

复制代码

完整代码见附件：



; u: e& Y! U) ?$ I, Q) }