球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
" o+ k* d; j& t2 ^
9 y2 v. |! y4 \! q7 q: L在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

( K& a, Y( F7 c1 l3 K' t5 z游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
( a4 }2 e9 Y0 W
0 _9 w1 ~2 K, Z* F& |! R! v玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
* T9 E5 R' G% K5 f& F4 x
0 t9 W9 v0 M1 e0 M' Q其他小球：其他小球又分为食物小球，和ai控制的小球
1 g' _3 {4 X* f- Z
体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
( i, s" j+ F, @6 \( H
1 R6 a: ]# X2 z9 J! f9 O玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
( D; ^1 _# T' z/ f  z, {7 H
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
, B! f. r0 i$ C" C# k
接下来，我们将通过以下几个步骤来实现这个游戏：

; g/ ]2 m2 a! Q! O/ S) e- r初始化游戏界面和小球的信息。
! L" L' w) s4 Q) x! f5 M$ y. ]
$ d% i3 o; S" o8 W/ S处理键盘输入，实现玩家小球的移动和加速。

- w, H, U+ P( K+ R" G生成足够数量的食物小球。

生成ai小球，并控制其移动。

检测小球之间的吞噬关系，增加相应的体积。
. ?2 D5 Y- i& O0 E
; K* I# D( n; \, P通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
$ v+ }1 s7 r& P& a" _
9 w8 q  j* o+ v  g- G) U9 S" g1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
% L$ K$ p( T* e3 {0 K' I
struct Ball
{
, a* _6 k- A5 _( c8 E. Q/ D        int x;
        int y;
        float r;
        DWORD color;
& C' g  B( H7 `0 ^% L  l};
+ ]: M% q* p7 X2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
$ V; i) n, c; h4 D: i
/ F- H6 s& D. |9 s; N% xRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

6 f. B3 S5 c( p: ^7 p9 w( ?) R5 O橙色可以通过RGB值（255, 128, 0）来表示。
$ `/ J( {% p: m! X黄色的RGB值为（255, 255, 0）。
2 Y+ h" ]- F/ ~: T$ v+ r绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
1 g9 o1 y' l: ~0 \' N黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
3 {# K% N2 ^+ E, H% J灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()! \6 J; h& t+ Z6 m/ E- E
   
2. {
   \" K$ ^2 C: L+ Z5 k' v/ ~0 m
3.     //玩家小球
   ; {8 j/ v2 v8 E, [7 d3 S. {2 M1 W
4.   srand((unsigned)time(NULL));
   ) U, \\" m! _  o& |4 z; p6 G2 W0 r
5.   player.x = Wide / 2;, t2 c3 k6 @$ u# t/ B) O* k, U
   
6.   player.y = Hight / 2;0 ~5 d$ Z2 d$ ]1 K6 ?% [$ Q
   
7.   player.r = 10;, a2 J; `\" P- M' w) W) s\" I( P
   
8.     //食物小球
   $ r3 t1 J' Q% g$ d* e) D: w
9.   for (int i = 0; i < Food_num; i++)
   ! w! o4 r6 a+ F% Z7 h) a& J2 r; k. j
10.   {. Z& i1 P' k' S. I
    
11.     Food[i].x = rand() % Wide_map;4 C' y0 i& P* h! w
    
12.     Food[i].y = rand() % Hight_map;/ }- D- Q( N# A% L! a
    
13.     Food[i].r = rand() % 5 + 1;: Q' @( z. B3 o\" B0 n3 Y4 B- g# {
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    0 b\" E6 K' g7 K\" J2 f+ h
15.   }
    2 q9 H% W) L) U; X& l
16.     //ai小球
    5 n/ b3 E$ k4 C# P
17.   for (int i = 0; i < Enemy_num; i++), p& q, f6 o& F( G
    
18.   {. O5 I8 j. |- e% p; C
    
19.     Enemy[i].x = rand() % Wide_map;( N+ v* o/ P$ H7 m% z# o; u
    
20.     Enemy[i].y = rand() % Hight_map;
    ; i4 ?1 R& e- X7 Q
21.     Enemy[i].r = 10;; G; T+ H3 j* i( X\" P
    
22.     Enemy[i].color = RGB(0,255,0);
    7 n+ K& p4 m) _8 t2 @
23.   }
    , Y* l$ I/ S  ~( _/ \8 q( L6 j
24. 1 }8 K$ L\" [& e. W) Q2 X) z2 U
    
25. }

复制代码

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

1. void Player_move(): P: P! X& ~- A$ _0 {
   
2. {
   / \. X5 M4 g' F6 @
3.   if (GetAsyncKeyState(VK_UP))4 ~) Y) l* [) i( X, A& W/ k
   
4.   {
   / `! z* D! b9 Y3 U4 W2 P
5.     if (player.y > 0)( i0 e( Q+ H- R, Z3 S( G, Q
   
6.     {
   & e: \/ M- V# K
7.       player.y -= player_sleep;\" c* _\" T4 x$ @: r: P' c
   
8.     }
   ' _9 ~' B5 ~/ N3 N+ U5 p; A# g. [
9.   }
   ) t' I\" k6 C3 p4 E3 m- ^% h
10.   if (GetAsyncKeyState(VK_DOWN))
    ) C1 @! K* a$ q
11.   {
    & f) A! z- ]& Z  d\" y
12.     if (player.y < Hight_map)( c/ l' o. {: t# K% \! Y
    
13.     player.y += player_sleep;) y: o  P# B/ P0 I\" {+ u
    
14.   }* z7 f+ C9 q+ g: [; F2 p
    
15.   if (GetAsyncKeyState(VK_LEFT))) b$ l6 Y! Z% j' \8 `3 F. c, C1 i; S
    
16.   {, J  g) k- F& n\" W! b7 @# V
    
17.     if (player.x > 0)- m. K$ R* n. s$ i  Z
    
18.     player.x -= player_sleep;6 Q  u% Q' o2 g8 q4 G
    
19.   }+ b7 H7 O+ F\" N# q7 b) X. K
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    5 y7 C, i  N3 `% ~: V9 ~9 Z- A7 w
21.   {\" Y9 I; X8 X7 I! M: \/ l
    
22.     if (player.x < Wide_map)+ A3 i! q: o- n* Z% w+ I
    
23.     player.x += player_sleep;
    ; w4 K8 H$ Y1 G1 u! n9 h$ b
24.   }1 u) m  j/ t7 Q5 x4 q/ A  P( S9 ?
    
25.   if (GetAsyncKeyState(0x20))  g4 L) k0 L5 _* l: T6 I! x
    
26.   {
    + C8 s. a/ a1 n( t6 M0 [
27.     player_sleep = l + 5;  p6 ?$ L9 F  r! v1 k' J3 a+ o
    
28.   }
    - Q. R! [9 ]6 I+ P/ Q; @
29.   else' z  S, ], O6 z0 ]0 K
    
30.   {9 {6 v. J/ n1 Y  d2 ~' L
    
31.     player_sleep = l;
    8 t\" c7 S: p; n7 C6 |3 X* `2 ^
32.   }/ k5 H: [4 A\" A$ Z1 P* m! t
    
33. }

复制代码

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

1. void Show()
   5 K( ~' H+ S9 `1 `\" G$ n5 v
2. {
   4 |$ |* p3 V0 M3 @( b. A$ @
3.   
   6 w+ \6 F# C0 @+ K\" h0 v% Y
4.   //设置地图9 O2 [8 o4 d4 j( s5 x
   
5.   SetWorkingImage(&map);$ K+ `9 ^1 o7 j) g; ]& p
   
6.   //清屏) s+ ^( v: N5 M: |$ I* R, l
   
7.   cleardevice();# L  M7 ]# Q! v/ ~8 N\" U; F% F; X
   
8.   //背景颜色
   3 m, T2 S+ J, G
9.   setbkcolor(WHITE);
   4 n1 w& o- n# I. u8 \
10.   //划线颜色7 K6 w, x/ v4 a) ]4 d
    
11.   setlinecolor(RGB(230,231,239));
    ! w) I- k5 g. u- z3 n+ c- \+ X
12.   //划线( a  I' N5 E2 I& n' `% l' D
    
13.   for (int i = 0; i < Wide_map; i += 10)' i6 ~) J5 h  L4 T& f
    
14.   {+ g5 I2 ]- ?5 Z9 u1 _& B2 v: ?
    
15.     line(i, 0, i, Hight_map);
    & o6 z$ _3 K/ D5 I! N0 E\" b' T
16.   }
    2 W8 {& N' z2 c5 a1 A5 y
17.   for (int i = 0; i < Hight_map; i += 10)
      |6 I% s' b+ s  r: f4 |+ S# l7 A
18.   {
    ! V$ V+ f) p8 }, a! |
19.     line(0, i, Wide_map, i);
    : L3 R! h1 s' T\" j
20.   }4 |( o0 x: C. U) u; }9 v, s
    
21.   //食物2 G, q! D& K1 K6 v- [
    
22.   for (int i = 0; i < Food_num; i++)
    0 T% E; \! v6 Z0 b% O/ M1 G$ a
23.   {
    / h) O2 u, p8 n$ n( ?: E) z# ?
24.     setfillcolor(Food[i].color);7 S( S3 {5 U; j3 s6 U6 N, v6 f
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    2 @7 R, V, [. I, J
26.   }
    9 [- P! \, Y! k! V
27.   //敌人6 V  l2 k8 M9 t
    
28.   for (int i = 0; i < Enemy_num; i++)
    $ r& f\" o' C' ~* e; C  E1 I
29.   {# Y$ g* H  S2 v' ]' c
    
30.     setfillcolor(Enemy[i].color);
    2 o3 T! h+ f8 P, R5 x. Q
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    : }% w6 L7 h5 q8 A3 b
32.   }
    5 z. @1 W* i, n! Q. B9 k
33.   //玩家! C% W/ {5 n; x0 Q& W9 m* g/ N2 F
    
34.   setfillcolor(RED);
    \" p# a! K2 v; z4 c
35.   solidcircle(player.x, player.y, player.r);% E$ s  g: b9 C9 A8 ^) v+ C
    
36.   SetWorkingImage();
    9 g; }+ q6 D+ _$ Y+ K( R
37. # y& w3 |/ B4 t\" W; U) M2 ?
    
38.   int x = player.x - (Wide / 2);
    * _5 ~% w: u% M+ ^# C: c4 E9 U
39.   int y = player.y - (Hight / 2);
    7 g% T1 V; g' D
40.   //防止窗口越界1 j( `& f$ _+ S- o: O6 ?
    
41.   if (x < 0)\" k1 t* y! c. ~- ~# x; S, n
    
42.   {7 K: D2 _% d+ x) G! P
    
43.     x = 0;
    # `! b6 a' N) d8 ]
44.   }6 r& H# _* a& e\" H
    
45.   if (y < 0)
    5 z0 b. g\" N5 s
46.   {3 Z2 m2 U* G: E8 P: d! F0 l
    
47.     y = 0;
    % a+ N: E1 h; [
48.   }
    5 R  H( R( _\" L
49.   if (x > Wide_map - Wide)
    # c1 l% F0 t5 L% h0 c5 B# T
50.   {8 m5 C- L* _8 D6 h2 I: _! D
    
51.     x = Wide_map - Wide;
    8 R: Z- Z  \2 X7 d1 L\" s. ~# N
52.   }
    4 a# H7 R) o) z. a9 o# }1 ], l8 A, a
53.   if (y > Hight_map - Hight)3 c  Y; ~7 X8 [8 ~% l
    
54.   {
      Q9 k  D5 [1 k' C
55.     y = Hight_map - Hight;8 q4 p+ r. q% b
    
56.   }# Q- B6 ?# D$ A& O, n% g$ a- N5 ]
    
57.   //把map输出到窗口上# R- ?; M0 ^1 c0 E
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);) k) o! P7 n* s2 F
    
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. //防止窗口越界
   6 b6 d& G, ^( u6 p. Q; F/ X
2. if (x < 0). K2 ~5 \3 c1 A+ g$ h5 v
   
3. {
   6 G& n* d  T9 _& I\" a/ {- A8 q
4.   x = 0;9 v# W: w, L3 N% j
   
5. }
   1 D( H\" I2 v- z* M, }4 r' I
6. if (y < 0)9 u3 U1 p- n\" H3 w6 D, J% ?$ Z' F
   
7. {
   9 o; |3 t, u7 `* C! A  D
8.   y = 0;
   9 p+ v/ r# i. o3 k& h( G: R, Z
9. }4 J: ]3 P7 R7 i
   
10. if (x > Wide_map - Wide)
    * q9 Z  y8 @/ {
11. {
    # z2 ~: r/ U: N& ?- z1 j
12.   x = Wide_map - Wide;
    8 k5 n4 s( S: n8 W
13. }
    2 T+ F% A0 C4 \! h  D' }8 Y! J6 J
14. if (y > Hight_map - Hight). o8 ]5 E7 }\" F2 n7 }4 v: m6 ?
    
15. {+ P/ k+ n4 ^$ l0 K
    
16.   y = Hight_map - Hight;
    & s- W( M: F8 ?& g5 O5 ~0 E
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
$ i# e" @6 m% @; W( P
0 T. o: r' h2 s# H; B8 ^, L: w(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

- {- K# [: A2 }Wide：这个参数指定了要绘制的图像的宽度。
7 T2 e2 A0 f8 h& ~
! T9 P: m- |* l; }& ~4 aHight：这个参数指定了要绘制的图像的高度。

&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
$ z7 E" q) k* L# O: d% P: R6 y
x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
# P6 {4 x$ v8 t$ N0 B) _' F
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
7 ~2 |7 J4 N+ S5 N$ \6. ai小球的移动
  w* Y5 o; ~8 W7 e" L) b- J随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离. F$ t: g2 y+ W  \: v- a* @
   
2. int Distance(int x, int y, int x1, int y1); V% p: k. v& X$ w% W& G% \8 K; B
   
3. {
   , c! v$ m\" e9 _6 c5 d1 w1 n/ E
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   . t4 t! p5 P8 a0 q4 a' ]
5. }

复制代码

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

1. void Enemy_move(); O6 X9 |) k3 g: }* a
   
2. {! ]0 Z6 _. N' V0 E
   
3.   srand((unsigned)time(NULL));' v$ v  G! n- r+ u
   
4.   for (int i = 0; i < Enemy_num; i++)9 e1 X; _' j& y: c- M
   
5.   {
   4 d( F\" M; Y  z1 z' T
6.     int direction = rand() % 4;; W1 G1 i' J$ f8 Q
   
7. 
   ( l4 n0 T- r' D
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)8 m- D+ f/ z& N7 I
   
9.     {5 O7 p$ t; x  P0 {8 ~: H: k: E9 t
   
10.       if (direction == 0)
    # v! W5 g- ?\" G' _1 ]! |
11.       {
    9 X/ v$ n& Y- L- W9 ?  y7 A+ p
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句  l' z2 B3 p& H3 j: C% a+ q$ l# i
    
13.         {5 y( m/ O$ |- a  f$ n$ d
    
14.           Enemy[i].y -= enemy_sleep;
    0 g8 w& L. _: b% F0 U, X
15.         }
    9 K$ n  M& _! d% f0 A3 N. U
16.       }1 i6 K) ^( m8 V- G+ i
    
17.       if (direction == 1)8 t\" \\" r* V/ `3 I- e
    
18.       {
    ; s1 H4 u( A\" X1 |/ `
19.         if (Enemy[i].y < Hight_map)( ?% x: x- X. O( f3 F1 B\" T: v
    
20.           Enemy[i].y += enemy_sleep;# \1 l4 y0 y( g$ K9 q5 O2 S- g
    
21.       }
    % I+ U  M  P. P' r$ s
22.       if (direction == 2)/ l' `( y3 A% D: l* p
    
23.       {& h3 x1 j7 v) h6 g\" ^
    
24.         if (Enemy[i].x > 0)9 Q5 @7 x. _3 a
    
25.           Enemy[i].x -= enemy_sleep;( L& E# a. ~1 e
    
26.       }
    \" z/ L- W8 Q! F. g  i, p
27.       if (direction == 3)# O0 }: \% N7 W$ f4 b\" l
    
28.       {7 J( L( y$ L/ P  J: @* I
    
29.         if (Enemy[i].x < Wide_map)4 Q, {. e8 D6 A/ U7 |) h
    
30.           Enemy[i].x += enemy_sleep;
    2 s1 A' ]! p# M5 T( Y3 V. K8 F
31.       }# p, q& Z\" H5 Q8 g; P4 X\" i
    
32.     }
    ) k' O/ ^9 c  N/ c7 ]# k4 k1 x
33.     //敌人追击玩家
    ( |5 v- j  o7 X! c/ `/ f
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    5 o, I4 j. ?2 L8 z# }4 ~3 Q
35.     {+ b7 z1 e' \+ g8 S# t
    
36.       if (Enemy[i].r > player.r)# Q# X- R& @$ e  Z* V8 F
    
37.       {, P8 ?. e! S1 T\" p6 r& c9 G
    
38.         if (Enemy[i].x < player.x)
    ; @: _8 O3 @; e$ ?. B
39.         {5 H2 [% }4 p\" t% y! ~/ {/ y
    
40.           if (Enemy[i].x < Wide_map)+ t1 u; r% i0 D
    
41.           {
    4 l2 @# O) a) H
42.             Enemy[i].x += enemy_sleep;& r: b' ]4 F3 V
    
43.           }
    0 `( }$ F) h  d7 U  V/ H5 }
44.         }2 |$ k4 V, n- z- A6 H
    
45.         if (Enemy[i].x > player.x)
    8 K6 ?2 C3 [9 Q/ g! c! j) o7 M
46.         {
    3 r  g, o: z( F( M4 [, S
47.           if (Enemy[i].x > 0)1 N; [7 z! h\" L- H$ _
    
48.           {# i9 Q& u; V% |$ p& [1 D
    
49.             Enemy[i].x -= enemy_sleep;
    $ g6 n. w4 h& V% _6 `+ w
50.           }\" |0 ~1 f* r. b& O- Z5 R7 u# B; ]& l  V
    
51.         }
    $ ]& i7 W6 I2 h
52.         if (Enemy[i].y < player.y)
    ) A& u5 S5 p! V6 H! ?
53.         {
    ) k$ ^: N3 R# }) |
54.           if (Enemy[i].y < Hight_map)
    ' s2 N- R+ h9 f' h' j( ^0 H$ \
55.           {& {1 N( U9 S( X0 \7 F
    
56.             Enemy[i].y += enemy_sleep;8 }; _2 ^5 e& k  o( Z3 n
    
57.           }
    , a* r- i3 b6 j+ C
58.         }
    % c! }- ~\" ]* c5 h2 I5 j# T+ m
59.         if (Enemy[i].y > player.y)9 F# m# w% U0 D5 K. E; E
    
60.         {
    + Z' K  ^  K4 s; B: d
61.           if (Enemy[i].y > 0)
    % f- P1 c' @7 O
62.           {- u6 R* K\" ]. u9 c( u
    
63.             Enemy[i].y -= enemy_sleep;! u8 d+ x0 S2 p6 R
    
64.           }, T6 i3 ^- @. V, F
    
65.         }& f9 Q. A) U\" J
    
66.       }) D- w  D0 X4 C% e8 ?; \
    
67.       //敌人逃跑
    8 ~: m5 ~9 U8 w; i5 F' T% J# n
68.       else
    3 y7 N: @2 j' h- J4 B
69.       {5 I$ s% ^5 x7 L
    
70.         if (Enemy[i].x < player.x)2 Y6 B4 |, Q. h. S3 ^1 W+ U
    
71.         {, y' }0 g9 ^! S% a
    
72.           if (Enemy[i].x > 0)
    , T8 T  {, Y5 B# ], U$ ^1 R7 e) A
73.           {( V9 ~& J: S! ~# [* \
    
74.             Enemy[i].x -= enemy_sleep;0 L6 v5 x( Y  s# P! \. J4 m! o
    
75.           }2 d* |- n/ @& S9 v' |6 K
    
76.         }
    - ?' D; [5 Q- [1 G, I5 X
77.         if (Enemy[i].x > player.x)# g3 j, B' T. z$ f( t' S/ L
    
78.         {9 x1 d( y$ G: R. a( L. ^4 V0 y
    
79.           if (Enemy[i].x < Wide_map)% S: x1 G  Z, }% i+ u  w
    
80.           {9 A  n, S8 n# z. a
    
81.             Enemy[i].x += enemy_sleep;8 Z5 A( Y* E4 h9 o/ L8 p
    
82.           }% b% Y\" K; X% T+ ]5 B: T  I  Y4 v
    
83.         }: m. l  E! o# t; O$ ~# B0 m
    
84.         if (Enemy[i].y < player.y)
    : D- L0 {* r5 }) T' A\" I1 b
85.         {
    : N5 l. Z( u* M3 v2 ?. x3 D
86.           if (Enemy[i].y > 0)
    / e, F9 |3 ^( v  U* i7 E( {1 _: a, |+ q1 {
87.           {# j% @2 d* V6 P
    
88.             Enemy[i].y -= enemy_sleep;) K$ ^# e& o7 x/ u% H, Y+ H3 }' ?
    
89.           }
    7 X; u2 V  D* u  R# U0 b
90.         }* T5 |3 h8 n; A& e
    
91.         if (Enemy[i].y > player.y)- V' [. @4 j7 ~0 z- c( M# m
    
92.         {
    3 R3 |2 z% _3 w  H$ P! ~
93.           if (Enemy[i].y < Hight_map)9 K+ \* t3 w- s+ Q/ E
    
94.           {
    ; F\" {  c; ?6 @* a
95.             Enemy[i].y += enemy_sleep;6 w+ c$ c- V7 W& {: n* x$ S
    
96.           }4 F# Q; l- ?& q
    
97.         }6 ]  y7 ]- O' {! l6 m6 X# w) P' T
    
98.       }
    3 f3 P8 @  G8 q' E
99.     }
    % J, o0 w' w7 r6 x$ C3 C
100.   }
     % U6 x- j- i: c3 n4 r
101. }

复制代码

7. 小球之间的吞噬关系
7 J& k- |' R& T

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

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

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

1. void EatFood()
   ! N3 Y; G8 H4 x) c
2. {' h, b) E2 j4 r- L2 b, l
   
3.   for (int i = 0; i < Food_num; i++)
   % P- s! D6 s1 W  P\" y4 l+ I6 L' h
4.   {! S6 c4 @\" t- T$ v) o: I% y: W
   
5.     //玩家吃食物
   $ q- ~- u; |; \7 t$ j0 |/ N4 {
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   ' Q' _6 F5 u# n. Q
7.     {
   + [; g: U$ t$ y8 u
8.       player.r += Food[i].r / 100;
   ' x' p9 V9 ?, l) ^0 U
9.       Food[i].x = rand() % Wide_map;
   / N$ F6 I( e2 w
10.       Food[i].y = rand() % Hight_map;
    0 h! f/ Z4 ]# U  x
11.       Food[i].r = rand() % 5 + 1;8 K5 C5 o  J* L2 L  ?; S$ t! l
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    + Y0 n% y% [\" p8 H1 L7 o8 _4 Z
13.     }
    5 D2 f3 o$ l! `1 h% r, u* Z
14.    
    . `\" Y; _6 j( [! H* V  r
15.   }
    7 T) d* b7 F8 A5 g\" ?5 u- Q
16.   for (int j = 0; j < Enemy_num; j++)
    / J/ T$ V$ a& I( q
17.   {
    + m% q+ x4 [$ n) e# x
18.     //敌人吃食物4 F. T5 z6 j9 P% f; [8 t
    
19.     for (int i = 0; i < Food_num; i++)9 k/ Q! Z0 |\" u
    
20.     {
    1 q& ^) a; P1 @! z9 V
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)8 J' _0 f' I3 S. O1 b
    
22.       {% t# b' ^% P$ w# H+ X3 ?\" }
    
23.         Enemy[j].r += Food[i].r / 50;( y% V+ N0 }) c
    
24.         Food[i].x = rand() % Wide_map;1 a- I+ w# E. J3 K
    
25.         Food[i].y = rand() % Hight_map;- T' v3 X- K9 L\" f- L+ [
    
26.         Food[i].r = rand() % 5 + 1;
    ; F- E& k8 a3 K4 u
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);\" z8 ~  X6 E1 Y
    
28.       }* d& V* {( V. X
    
29.     }* n! v. B  g% j) D  t6 [/ z\" i# D) i$ v
    
30.     //敌人吃敌人9 q3 P. P1 }* p$ `& Z) x) g
    
31.     for (int i = 0; i < Enemy_num; i++)
    / P* g& d4 i! T; `
32.     {1 i4 c2 f- i2 j, d. 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)
    3 X9 y% i+ x( Y
34.       {
    ) ^; y2 x9 b' p
35.         Enemy[j].r += Enemy[i].r / 10;
    + `: _+ _; O* F( J3 |! G& U& g
36.         Enemy[i].x = rand() % Wide_map;, R6 q; F- q! m- N# ?9 M9 K
    
37.         Enemy[i].y = rand() % Hight_map;
    + a0 m\" o- i# K8 Q; V8 {; K
38.         Enemy[i].r = 10;
    # G$ X9 ?) Q1 l! U: E! M
39.           Enemy[i].color = RGB(0, 255, 0);
    ) z* h4 \5 @, _\" p) o
40.       }
    8 Q( h+ b2 B6 F/ M) S2 x
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)5 S1 U' M: o1 t+ M
    
42.       {
    : p! }4 T* c7 `- j1 S
43.         Enemy[i].r += Enemy[j].r / 10;8 \8 D/ d0 |. u
    
44.         Enemy[j].x = rand() % Wide_map;
    + w& W3 O: g; d
45.         Enemy[j].y = rand() % Hight_map;. _) U( ~- l% O/ }/ U# x: B! ^' J
    
46.         Enemy[j].r = 10;
    ; x/ E\" S7 N* S' g' I\" z6 w
47.         Enemy[j].color = RGB(0, 255, 0);* V$ F4 c) f- {+ ~) N# z
    
48.       }
    2 o# |: v$ d# ~' C: y2 S* i
49.     }2 Y! X) T' {% I6 e! \8 @4 c
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    , ~' ~. F' @/ ^7 q; L
51.     {
    # m# w1 `2 B\" s  ~* H5 P
52.       //玩家吃敌人9 i9 F9 F. T0 C' y( s$ r% J
    
53.       if (player.r > Enemy[j].r)
    ! h1 p9 J% m0 ]# l: Z# J9 Q. y
54.       {0 n) G+ u  S. u) {# ~3 U
    
55.         player.r += Enemy[j].r / 10;$ {. T  L* J\" f  c( K: q; S5 t
    
56.         Enemy[j].x = rand() % Wide_map;
    + q) H5 A) |4 V4 n+ P
57.         Enemy[j].y = rand() % Hight_map;
    / ~, H1 H8 h9 ?  K
58.         Enemy[j].r = 10;  p( v; t  |- H
    
59.         Enemy[j].color = RGB(0, 255, 0);
    5 E! l1 R6 j+ p2 }$ O  p: f
60.       }
    4 M* \. C: E2 w9 }6 |
61.       //敌人吃玩家
    # u# x+ u( a. J/ I4 E
62.       else
    / i8 K1 E; h; t9 A
63.       {\" V* y1 y# E3 x
    
64.         if (invincibility == 0)\" N6 n& J( V, k0 P2 N. F
    
65.         {$ n' n* p+ O\" w* N1 @% @- _
    
66.           Enemy[j].r += player.r / 10;/ e. z+ w2 B) ?% I2 X8 l% \
    
67.           player.x = Wide / 2;2 f1 a\" i( ?\" `9 N6 G
    
68.           player.y = Hight / 2;1 ^4 j\" y8 X4 V1 x: M$ B\" g' K
    
69.           player.r = 10;' ?% z1 g# m( ^$ _: l\" ^
    
70.           invincibility = 10;
    6 d. t) f8 p' K
71.         }) f; W% v) d0 S0 ~+ o8 f9 l
    
72.       }- r$ U: X* j2 t6 w, q8 [
    
73.     }- I. h* y$ D; w* e/ F. x7 R
    
74.   }  ^  t# ^% M$ H
    
75. }

复制代码

完整代码见附件：



" ^1 o9 j5 z4 X