球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
+ w$ `: D: @6 L. q7 M; h
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
" e3 ], M$ ^( x- t, b
1 y- e3 G( K$ B8 B* \, t5 ^. B游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

1 E3 Z+ G" L( {' d1 v玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
$ [6 ]( `; q' X- R" O- ^3 P7 ^* b- d
其他小球：其他小球又分为食物小球，和ai控制的小球

1 z1 [0 X( ~" t( ?# d4 P2 }- {' a体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
7 Z; v# e/ \& I$ P+ i
! G  P6 }1 c- M7 m: L; l% `6 |% K3 B玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

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

8 T" H  L. \/ N$ C接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。

生成足够数量的食物小球。
- s0 V4 E/ n0 D' L8 e. {
生成ai小球，并控制其移动。

! j8 J# t+ S4 [: a% J5 ]检测小球之间的吞噬关系，增加相应的体积。
/ `- Z  T* z7 v6 B
" k1 t: l$ B9 R( J4 M: ]通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
% ~2 T- q. b7 C, Y; m4 z6 G
struct Ball
2 b# ^; h. K$ u- n' w. m+ K+ f8 M{
8 F  L3 S5 V; ]        int x;
! K, L$ p* I) D1 n        int y;
        float r;
. i/ W9 G+ G& p- X$ ]# K1 [9 _, T        DWORD color;
};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
; X3 C6 d0 B+ k6 W
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
, R2 a# L5 @3 E: k) x" l+ m9 ?
橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
: E7 a3 D+ v5 V2 p6 y0 V蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
9 ~4 I9 C0 x  a' Y; [: L6 D! [9 t黑色的RGB值为（0, 0, 0）。
) c" d6 j# @& O+ M0 o6 h白色的RGB值为（255, 255, 255）。
' {/ f# S% J# Z, c灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
     X  V; @- `; t. _\" i2 P9 J7 ~
2. {
   / V; f* P9 J$ y
3.     //玩家小球
     R* v5 s1 h/ R- Q; g
4.   srand((unsigned)time(NULL));* ?6 _+ N. m& A* ^
   
5.   player.x = Wide / 2;3 I; ?/ a\" q9 D9 `* n
   
6.   player.y = Hight / 2;7 e9 i' V% [2 P/ n$ p
   
7.   player.r = 10;9 @\" _; d! I6 F/ F# E+ O
   
8.     //食物小球
   ' x, u) x4 z  t; h5 n4 H
9.   for (int i = 0; i < Food_num; i++)
   , b\" n. F( j) z, b1 t- E\" a. v2 z
10.   {4 X; _5 b' c; J3 I+ L) P
    
11.     Food[i].x = rand() % Wide_map;+ `$ j7 n+ o; l3 k% n
    
12.     Food[i].y = rand() % Hight_map;
    : _8 M* F3 ?7 o\" C
13.     Food[i].r = rand() % 5 + 1;$ T/ a7 R0 X; F\" N  g$ W+ x
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);' y# }- v9 V: e5 ^% x
    
15.   }* j5 F, n1 f2 b
    
16.     //ai小球' b- d5 ], ]: F. m. y: V
    
17.   for (int i = 0; i < Enemy_num; i++)2 V+ @2 `: u9 [
    
18.   {9 }8 M& l8 m' y4 W
    
19.     Enemy[i].x = rand() % Wide_map;
    \" i) C( [1 S$ M) h
20.     Enemy[i].y = rand() % Hight_map;
    + \# ^. S: t6 t# p, y- S
21.     Enemy[i].r = 10;' v\" `1 h9 Q0 z- ?
    
22.     Enemy[i].color = RGB(0,255,0);
    1 E! C) c4 R! F9 ^6 j
23.   }
    7 o( c! g' c4 p! j4 }8 K( ~/ I
24. 
    , a; l3 G) O% I. H7 M* c* P- f5 W
25. }

复制代码

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

1. void Player_move()
   + k5 T% _0 D' a& k8 f7 Y\" G& c# f
2. {
     M7 v& i$ ^, s, g7 K& U
3.   if (GetAsyncKeyState(VK_UP))
   5 V  C5 {& W! Q7 q
4.   {2 r! r1 n\" Y* i. G2 P) g' c
   
5.     if (player.y > 0)
   ' c1 ^, y4 _8 v8 b
6.     {
   3 f1 v+ j2 a5 x. i0 j$ @) X1 R
7.       player.y -= player_sleep;
   & I+ k) ^! p\" |' l3 x0 B% Y
8.     }; W) N: j% `' g4 @. D
   
9.   }
   : v- ^% C; b* d* f4 F7 h$ n
10.   if (GetAsyncKeyState(VK_DOWN))1 c) u9 |0 l4 I8 J( B
    
11.   {8 R\" Q! D: b% t0 O, m/ m; b( X\" H
    
12.     if (player.y < Hight_map)
    ) x* j! q6 I, _  ?2 m# e
13.     player.y += player_sleep;
    ! A; G3 l1 D* v, @9 D
14.   }% s5 z$ h+ Z# o7 o6 o' W- g
    
15.   if (GetAsyncKeyState(VK_LEFT))
    / `* N0 K3 @) ]* b3 _1 Q\" t0 E
16.   {8 R5 h& m! {$ Y: J6 [5 p2 |2 m
    
17.     if (player.x > 0)- e) F0 `+ {. a# }7 R/ l9 B
    
18.     player.x -= player_sleep;4 ~! Z  v. S$ @, l+ w, h
    
19.   }# p  h4 t- n3 E8 Z- {0 z' D
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    , L6 K: C4 W8 z/ z- B
21.   {% C) f( c& U. U  I! W2 h; c6 k
    
22.     if (player.x < Wide_map)
    4 E! T\" I% l, W& H6 I- P
23.     player.x += player_sleep;
    # i9 v( ?! w+ {4 J' s/ x
24.   }* p9 _; z4 }/ ~8 |
    
25.   if (GetAsyncKeyState(0x20))9 x( @! V7 U8 ]$ Q' N4 U
    
26.   {
    ( X; n. q$ `; q* K' f
27.     player_sleep = l + 5;
    ) @/ J' c& O9 v6 O! Z% X' t5 S4 {
28.   }
    + D& h. T7 l! S\" _
29.   else
    ! T1 g- a9 D7 U
30.   {8 O% Q5 e- N# g$ L% b
    
31.     player_sleep = l;( v9 a6 }! M7 i3 V2 }% N4 j
    
32.   }0 v. P8 A! `& Q4 ]! s
    
33. }

复制代码

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

1. void Show()
   \" }: z% x9 P7 E8 _
2. {
   . k; s0 r1 @1 Q( l
3.   
   ) L# R* [5 Z- h- k3 E
4.   //设置地图' b9 B/ z5 i$ D
   
5.   SetWorkingImage(&map);
   3 w3 }6 N: M! m1 s\" v* o
6.   //清屏
   , B* b+ I6 a% ?
7.   cleardevice();
   - C' l. J4 P: M2 E
8.   //背景颜色+ \, V- X8 B8 ~* w0 Z
   
9.   setbkcolor(WHITE);
   , Q& B* _  y, A9 M4 m
10.   //划线颜色5 ?  `' J  W5 R7 \( V. U
    
11.   setlinecolor(RGB(230,231,239));
    % G* X% }% ^$ i2 C! O4 ?! T
12.   //划线8 F( G# S  M3 E* x\" o
    
13.   for (int i = 0; i < Wide_map; i += 10): `3 {  l  O' s4 ]. I; u$ o
    
14.   {( p  K8 G\" P# v; [
    
15.     line(i, 0, i, Hight_map);
    5 x/ f0 l) U\" M/ v  C\" Y
16.   }
    9 [\" n- p8 h$ }1 B4 t; b8 i
17.   for (int i = 0; i < Hight_map; i += 10)8 S: E. l) Y, _5 M
    
18.   {
    9 c% f( q1 Y' c: m* Z0 `+ n1 n
19.     line(0, i, Wide_map, i);
    ( z8 b0 d/ \# T
20.   }
    % W8 v; T( }, E6 @! Q
21.   //食物9 m- X3 ?( V+ A5 I8 F: A
    
22.   for (int i = 0; i < Food_num; i++)1 b' x, T# s. x, G& G9 s
    
23.   {
    , a, v/ v* Q% Z1 f6 y6 k  e
24.     setfillcolor(Food[i].color);
    , L9 p5 a! M0 o$ ^! f& |2 e- `
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    0 ]0 ?$ a$ x$ f1 N) n0 f9 ~
26.   }0 r4 {/ i/ N, t2 L( A1 }
    
27.   //敌人- T0 z/ f& W% j# s
    
28.   for (int i = 0; i < Enemy_num; i++)
    ( o6 a9 x; J4 d0 _
29.   {& D& S) d# N\" q; w( f
    
30.     setfillcolor(Enemy[i].color);
    6 Q# z% \) F8 V5 R
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    , r* l3 }/ ^2 ~% N\" f6 C+ _\" u
32.   }' i! ^% D; j5 `8 i
    
33.   //玩家
    & P1 o+ T% ~1 q
34.   setfillcolor(RED);) j9 K0 J3 V3 L- _
    
35.   solidcircle(player.x, player.y, player.r);0 H% V6 {& ]4 @\" j/ h9 Q0 M! X
    
36.   SetWorkingImage();
    : s# M5 b- ~2 [9 g; I3 |! m
37. ( X4 v& [' I/ N2 V7 ]! |
    
38.   int x = player.x - (Wide / 2);
    $ c& H: Z0 x8 S9 t1 R2 S
39.   int y = player.y - (Hight / 2);
    , a) s8 y5 S( `$ b; ^1 m4 g/ @
40.   //防止窗口越界, m! k4 Q+ O2 q7 K7 J$ q+ y/ p, r
    
41.   if (x < 0)
    ' K' z4 ~/ M8 J$ N
42.   {9 b\" h) D! V0 I. F+ u
    
43.     x = 0;! S3 _  O. J& i4 c! a
    
44.   }; g$ j# ~, _  ]9 G+ @& K) [
    
45.   if (y < 0)
    # y# Q$ S: |( z0 d4 j$ \2 |
46.   {
    / F. M0 ?) f1 u# G
47.     y = 0;
    ! b& S9 m: e: z1 Q' l- A; W2 E
48.   }, ~6 B# X8 k( h1 m9 }2 O2 s
    
49.   if (x > Wide_map - Wide)
    3 u  O5 g' ?, }
50.   {
    ( N/ x7 f, `2 N; B6 |6 O
51.     x = Wide_map - Wide;1 r% u8 l9 _  z  x/ p
    
52.   }
    + u$ o! ~' y- G- ]. w# l9 w' ~
53.   if (y > Hight_map - Hight)
    ( O\" N, s; i' \, ?7 C7 {
54.   {
    , c/ J( U\" c+ U0 g' `
55.     y = Hight_map - Hight;, w  n: W# P' T
    
56.   }
    4 O4 i3 t3 C1 z4 N7 X* ]$ o: `5 q* o
57.   //把map输出到窗口上; j4 @+ w, k# P7 _5 I1 X
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);$ Q8 t' Q5 @5 f/ W* Y. R$ `
    
59. }

复制代码

5. 生成地图
7 t" j8 `% Z$ |' M可以使用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. //防止窗口越界) K! R; T, c' s. F
   
2. if (x < 0)
   - k\" B# f. T\" i  H! T# J6 l\" H
3. {
   - a\" P  v! l2 U9 T; @8 f/ B
4.   x = 0;  R2 `8 K# l: i& q
   
5. }
   ) A4 f' J7 p9 D3 Z8 x+ P  `. V
6. if (y < 0)
   $ b2 c* X/ h% ?+ k& ^
7. {
   * p7 r% `3 P7 q
8.   y = 0;
   7 A4 S) d\" B# H
9. }
   ( X6 }# ~% _6 R9 q8 O4 \; r5 Y- I$ I$ w
10. if (x > Wide_map - Wide)+ i& N* _( i8 t6 s
    
11. {$ y( o. t2 {. z$ r# I0 B
    
12.   x = Wide_map - Wide;& O$ f: d, O4 Q7 {* H, W9 S: v) p
    
13. }
    , u# E, \9 M# \6 _' T
14. if (y > Hight_map - Hight)
    ' D, \  Y! ^0 H0 B
15. {. }' l' J( L& S. t
    
16.   y = Hight_map - Hight;
    . P/ A5 [) C& ]% J/ l$ F1 D. t1 [
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
* j/ q6 u1 K6 c  i: @) a
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

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

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

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
; G) y: G% J* s/ E: e# J: P2 i1 Y
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
' o+ |& T& f# i6 G% O) [' w: @  P5 r
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
* }9 O+ d( }( I6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   1 A9 a$ i7 I2 B: f1 c% {% @
2. int Distance(int x, int y, int x1, int y1)
   ' F$ g# \* y3 v' j\" U
3. {
   ) R2 u2 P  F& P5 O- q% G
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   7 Z9 r\" W- K6 C0 h$ P. Q6 w8 M
5. }

复制代码

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

1. void Enemy_move()
   ! l, A\" ?- Q+ ~% R$ }
2. {
   % F: E8 t+ O* Y  u+ J5 }8 K
3.   srand((unsigned)time(NULL));
   / {; ?; L+ M( i7 i* L: r
4.   for (int i = 0; i < Enemy_num; i++): k  ~5 o! p7 y0 `$ s. |$ v
   
5.   {
   2 ~& h$ R+ H7 T# a, w% G
6.     int direction = rand() % 4;4 o. ?8 A. o! R8 J. o+ p
   
7. 
   3 ]- l/ N: q. _- x, ]5 Z# E* y
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   1 z  o) i, `1 G6 H\" J/ I2 U( l
9.     {
   7 P( e! R1 z& R* a! J$ l
10.       if (direction == 0)) c1 z3 C' a  ]0 V
    
11.       {
    $ ^0 M) Z- w% l( D' d
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句0 f0 C! O7 Z; L6 K
    
13.         {
    ( i9 Q  I7 v( q4 A8 e  u8 I
14.           Enemy[i].y -= enemy_sleep;+ w1 L+ x! y' t0 U4 F$ s; D
    
15.         }4 w0 K- u5 [  B9 [
    
16.       }* M8 m9 S7 h' v! ]6 M& v
    
17.       if (direction == 1)
    , U4 C* t. i- ?
18.       {. A( I- T: E( `: w
    
19.         if (Enemy[i].y < Hight_map)8 j% D. G( s9 s( P8 E. T
    
20.           Enemy[i].y += enemy_sleep;
    ' p6 P\" G8 J* J
21.       }- M  a3 J% u0 X9 L$ z9 B
    
22.       if (direction == 2). W8 w/ H& h+ l2 V
    
23.       {
    & q) H# ]6 O% m/ t0 W
24.         if (Enemy[i].x > 0)
    ) l8 q& k, R& n+ y8 s
25.           Enemy[i].x -= enemy_sleep;7 ~/ p% O1 U& m! t$ E0 d3 m9 f
    
26.       }5 s6 C: g+ b% J& V\" w% F
    
27.       if (direction == 3)
    1 V- L' I# j3 L5 {: }$ `& x' {
28.       {
    * R4 R) `+ |4 Q- C- S
29.         if (Enemy[i].x < Wide_map)
    , N. e0 y. Y! n- H2 w8 v
30.           Enemy[i].x += enemy_sleep;
    + P% H6 P  Q# w
31.       }
    - h& ^9 A  n9 p: p* S- R! V7 ?
32.     }
    * O0 h3 D9 o; o3 y2 j
33.     //敌人追击玩家& Y1 K  [9 {+ A7 }! [7 j9 d4 h' W
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    . p, a8 `0 J* q
35.     {
    , {- v6 d4 x\" x) d; p
36.       if (Enemy[i].r > player.r)
    0 K9 U& ]7 ?4 [. V7 I  j
37.       {
    : k/ u* b$ A9 T\" g
38.         if (Enemy[i].x < player.x), O/ c7 t$ w* k6 D$ p  \5 h
    
39.         {3 h4 b1 A- {  d. B  m) s, Q
    
40.           if (Enemy[i].x < Wide_map)
    , v8 v& J# ~' Q3 ~) t0 ?0 Q
41.           {
    * V9 B1 E\" ]7 B  J7 P
42.             Enemy[i].x += enemy_sleep;* g$ m6 O1 s/ [% T
    
43.           }\" F* |0 a) t, h5 F* r6 K! i
    
44.         }
    8 a( x. {+ j# u( m: y4 r
45.         if (Enemy[i].x > player.x)  x- v7 z; o' U9 c3 D( v
    
46.         {
    3 I( |: l/ G) u  o
47.           if (Enemy[i].x > 0)
    \" O' D1 U% ^( ^# a7 Z6 p7 x
48.           {
    + C3 _8 }5 `0 M1 z\" k+ r1 u
49.             Enemy[i].x -= enemy_sleep;& ^: Y+ S2 {\" c! C- Y8 n, _
    
50.           }
    ; w* Z6 o; q% g5 f1 E6 S* _# E' a% O
51.         }- W3 P+ Y4 A$ C* z
    
52.         if (Enemy[i].y < player.y)
    & ^\" |+ W( S  X4 m( j; l
53.         {
    5 ~. E' x9 K  c9 [& o8 H& z
54.           if (Enemy[i].y < Hight_map)
    ! M/ X* T; q. K. c
55.           {
    6 D. n- Z- M7 k( K1 ?- y\" z5 Z
56.             Enemy[i].y += enemy_sleep;, q: N9 ^. C0 `# R
    
57.           }% s& c2 S) J' F+ |: l/ ?, U
    
58.         }
    + ]# [/ t' _% S' J1 q, ?( M
59.         if (Enemy[i].y > player.y)
    5 o& i2 R% A2 m. O* m9 n
60.         {
    ( _, x4 b  i$ t! I4 r, c! K( W
61.           if (Enemy[i].y > 0)
    7 \  q5 t8 Q- b2 t' T4 b) _\" i( |* L
62.           {
    & X& m, G( g+ ?( D, z5 ]
63.             Enemy[i].y -= enemy_sleep;# _! r- c/ L& O) z& f
    
64.           }
    # F9 ?) E+ o+ F. l  z2 b( P
65.         }
    6 z0 R+ B\" z2 n, q+ {. `$ l
66.       }
    + [+ ^1 m( b- a0 x7 U
67.       //敌人逃跑, Z: X0 q5 ~7 o$ Y# t  X* I
    
68.       else) \8 y  ~' a9 }' b* E\" @; o
    
69.       {3 p; K, n: C$ ~% V: u
    
70.         if (Enemy[i].x < player.x): |$ U  K, Y6 `' {. E% f  [
    
71.         {
    1 r8 c1 X7 ]8 g: U2 m- v
72.           if (Enemy[i].x > 0)
    + e7 o! `% }. E: [3 L! ]
73.           {' O, r6 g) f, W$ x9 u
    
74.             Enemy[i].x -= enemy_sleep;0 G7 r* q2 H5 o# {) `. U$ r
    
75.           }
    & }% V' X7 d& G& t6 a8 o
76.         }& s6 Z) j5 i& E9 v. l9 L
    
77.         if (Enemy[i].x > player.x). s6 M8 ]. Z& ?0 R( q. t- e
    
78.         {
    3 Q0 `8 ~- l0 S( w, f5 H1 P
79.           if (Enemy[i].x < Wide_map)
    . _5 B/ S. u1 ?  n  @5 b
80.           {
    % i: f$ M1 }2 {$ _& Q' ?
81.             Enemy[i].x += enemy_sleep;, L- ?( I4 {% `2 f/ q
    
82.           }
    ! Q\" s0 r& Q' d* Y+ b+ M) C
83.         }7 m! i1 F$ e( D0 a
    
84.         if (Enemy[i].y < player.y)
    & b% R+ i8 c% q- \3 ^
85.         {\" i  s) G# j$ t4 I1 b( N3 G, _( R
    
86.           if (Enemy[i].y > 0)3 v/ }& N; I4 M6 d4 h
    
87.           {
    3 y( o( z( Y& b9 c, k
88.             Enemy[i].y -= enemy_sleep;
    5 N) G+ R& {( O; s1 W7 C/ i
89.           }
    ; c* V, I& h\" i\" @- k- ?
90.         }
    ' Y\" m; Y. g& x! `+ h$ E, R  C+ U0 Q
91.         if (Enemy[i].y > player.y)8 `( M\" B- L2 k4 U' m4 x\" I
    
92.         {\" u  z7 }- q% {) \: \1 m5 H
    
93.           if (Enemy[i].y < Hight_map)5 q6 H& v2 {9 l  y( A5 p8 k
    
94.           {
    \" j  \2 W5 ?& [2 C7 D- G0 _
95.             Enemy[i].y += enemy_sleep;( V4 x* |; H, \
    
96.           }
    ( l6 d0 L0 b# |- M( G* W% x8 o) F
97.         }
    # q  I$ L7 C3 T5 r8 R% Z
98.       }
    & V' f0 o6 l4 E\" A$ `: F
99.     }: d( c& \+ x! U* ?3 w5 v% X& ^
    
100.   }# Q# ^. m  ^$ R
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   ' P& J% w/ ?8 N$ [2 o2 X
2. {
   ! R  W* [7 I( w4 r, Q; @
3.   for (int i = 0; i < Food_num; i++), i; {& I) j3 T# E, u\" p; X
   
4.   {
   1 V- H- c  _* S3 e
5.     //玩家吃食物8 b8 |, }* c7 y7 e
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)& l$ h* P4 B& O0 t
   
7.     {
   5 |# u4 o. Q- t# I2 N3 _$ T
8.       player.r += Food[i].r / 100;6 V7 k2 G( f! u* d0 D& T7 I4 f
   
9.       Food[i].x = rand() % Wide_map;
     }+ S6 {, w& F/ n) a
10.       Food[i].y = rand() % Hight_map;
    + |4 v( B0 Z, p' Z; f
11.       Food[i].r = rand() % 5 + 1;  A9 y  E& a1 V. Z: Q' Q
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    ( P! j# U# U0 @0 c  n% r% Q
13.     }
    : }' r1 K8 f$ V* ]4 c$ K; _
14.     7 Z+ |3 }1 h  G  e\" S( b* G7 j
    
15.   }8 A% H2 v0 V: f6 z& i) `5 R
    
16.   for (int j = 0; j < Enemy_num; j++)
    2 q' L3 @) C: J' h  J9 }, B
17.   {
    2 g/ Z( S: t' m7 s9 h' S' [- }4 Y/ B
18.     //敌人吃食物
      ~7 i! B3 p+ x. m5 ?- G. J2 d# |
19.     for (int i = 0; i < Food_num; i++)
    4 H; U! e/ T/ H
20.     {  Z- e/ o2 V- _8 p* S2 u/ ~- t, g
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)( ^) _7 q, d8 }7 B
    
22.       {
    2 R* X1 W# b, X8 N' L
23.         Enemy[j].r += Food[i].r / 50;! C1 {- {8 D8 Y9 o
    
24.         Food[i].x = rand() % Wide_map;8 D7 }* Z0 L8 I& w
    
25.         Food[i].y = rand() % Hight_map;
    & L; t; q6 m' ^
26.         Food[i].r = rand() % 5 + 1;# q& |5 B8 E. `' A8 J' m  q8 k
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);- F# V5 I& ~: p& {$ l* W0 S# n
    
28.       }
    + _) A8 ?3 ]7 j) L
29.     }1 m# A4 E: [  l: U) e$ X\" D( w1 ]
    
30.     //敌人吃敌人
    ( R9 f  D( S\" a
31.     for (int i = 0; i < Enemy_num; i++)' b9 u& [' V- c0 x\" x
    
32.     {
    9 l\" ~/ V* \. j  _& Q
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 f) M6 A5 M8 {$ U
34.       {* s& I\" j5 V; w3 s4 ]! a
    
35.         Enemy[j].r += Enemy[i].r / 10;
    4 j1 Y3 o% s+ _9 ?\" O1 P5 u- t$ O$ V0 L
36.         Enemy[i].x = rand() % Wide_map;\" K& w: f# S3 e1 x- m- R/ ~- q
    
37.         Enemy[i].y = rand() % Hight_map;
    $ j* j, ]6 h) E# E, s/ C
38.         Enemy[i].r = 10;! b  I, @  u$ n! X2 J% j( O
    
39.           Enemy[i].color = RGB(0, 255, 0);
    2 o; V  v* K( U6 O' O  i
40.       }
    3 D) _\" n$ `, L& M8 s* V/ y
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    4 S  p  c+ d; p! y' `0 G
42.       {
    , p/ @$ }: l\" M3 F& ]3 ^7 t0 C
43.         Enemy[i].r += Enemy[j].r / 10;
    + |9 B* h: V& v/ X
44.         Enemy[j].x = rand() % Wide_map;; R& h; N0 l; E7 p8 @/ t' d* j. \( E
    
45.         Enemy[j].y = rand() % Hight_map;
    , X8 n' z! n. a3 U3 ?- @$ A0 r# o3 d
46.         Enemy[j].r = 10;7 g6 d/ ^' s6 [- q
    
47.         Enemy[j].color = RGB(0, 255, 0);
    5 W, Y  D5 K5 \5 o. X- p/ i
48.       }5 f\" p3 F+ J' x1 B/ e- h
    
49.     }$ G4 g5 _+ _6 K\" j/ ?$ R
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    ; G\" b8 Z0 r\" L9 d8 S3 Y7 P
51.     {! J6 l) T* B. M+ w7 I# H
    
52.       //玩家吃敌人- r/ E: |8 f6 G8 A; T
    
53.       if (player.r > Enemy[j].r)
    . g0 ^% v4 w1 _, o: `' O
54.       {4 @. R5 z1 M2 {1 S) E
    
55.         player.r += Enemy[j].r / 10;
    ! `( h& h# z. W  r6 ?
56.         Enemy[j].x = rand() % Wide_map;
    \" E\" j* ^' }+ I4 n% D' g$ Z
57.         Enemy[j].y = rand() % Hight_map;
    ( ~( g' M7 T9 n1 C: X  o
58.         Enemy[j].r = 10;
    0 S( |( A8 F- q' k
59.         Enemy[j].color = RGB(0, 255, 0);6 i6 u\" @8 W. Y. ?) x! L0 a
    
60.       }
    # `7 y* _4 N( e( Y/ D+ B\" W: @
61.       //敌人吃玩家
    8 R' m& ^! q* \: I
62.       else1 }2 R& g+ \6 p7 v. P
    
63.       {
    - g: P' @% v% O; M
64.         if (invincibility == 0)
    2 H0 P2 b  u5 [( e6 a
65.         {
    2 D) g( D# H; ~+ s5 c\" ?
66.           Enemy[j].r += player.r / 10;1 W, u( x2 [5 m$ X# A) O
    
67.           player.x = Wide / 2;
    2 i, t. l7 y9 R$ n
68.           player.y = Hight / 2;( i: v8 W5 s; K2 h' W
    
69.           player.r = 10;0 J' ?7 i7 n$ s9 r
    
70.           invincibility = 10;/ N  P( \3 n5 Q# n9 p. f* E4 `' q
    
71.         }! h; O* q: ]2 v
    
72.       }. u- P5 ]6 ?7 x+ c/ s
    
73.     }# e* _\" M% @2 j( M
    
74.   }\" q6 E$ H\" L7 c3 j) p+ L, P2 ^
    
75. }

复制代码

完整代码见附件：
. v! [# C9 [+ o% y
1 j3 ]! Q/ u1 J4 b" ?
2 g0 R/ B/ ?6 e  E8 Q