球球大作战

2744557306

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

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

* U8 z( b2 Q1 ^# G$ X玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
- H9 \" g; f( \( w) E
* Q8 p/ X) I- ?9 I$ C! x( C其他小球：其他小球又分为食物小球，和ai控制的小球

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

6 K$ |7 p: G* Z0 z' V玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

9 K* I! T# X8 G* ~ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

- m6 [0 C* V' s- B接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。
8 t' H' \: V- e0 w1 R2 T" M
( |2 r3 @/ {; K( Q/ o) t处理键盘输入，实现玩家小球的移动和加速。
7 _6 I- g) O2 m. N
# p: C" A; l0 l2 j" T9 k% M8 X生成足够数量的食物小球。

# D5 F( e! ?$ U' v2 X! J生成ai小球，并控制其移动。

检测小球之间的吞噬关系，增加相应的体积。

通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
9 N) K3 d' l8 `
1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
5 d" a* k( X2 {
; U" D4 Y2 e9 E. L4 J% Astruct Ball
{
        int x;
        int y;
        float r;
        DWORD color;
};
2. 初始化小球的信息
9 \4 F' y- C8 X& i: K) |将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。
8 `+ f! B2 F3 i  o( N4 L1 [4 r
RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
4 x0 B# ^) Q! @1 |% n
: W, V, B$ l( j- z* |$ X. _( f3 K: m橙色可以通过RGB值（255, 128, 0）来表示。
6 u+ @: v( K% z黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
5 r* `: Q: {7 g紫色可以通过RGB值（170, 0, 255）来表示。
3 Z) e" a; I6 A黑色的RGB值为（0, 0, 0）。
# @  U3 j+ T" R! `3 o) w白色的RGB值为（255, 255, 255）。
, |8 ?2 I( Z; E) p+ ~7 F6 Z灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   \" T4 D# Z* W6 h$ C$ g$ B- {$ ^\" }5 U
2. {0 v) a  n3 p! g
   
3.     //玩家小球6 z; ^( A3 ]. \( [
   
4.   srand((unsigned)time(NULL));
   2 \4 m9 T6 M4 u. W
5.   player.x = Wide / 2;6 ^3 T) N$ V' C' H( z
   
6.   player.y = Hight / 2;\" T6 Y( v3 p4 o' x
   
7.   player.r = 10;4 N: `6 P7 w' x) T; u2 M5 K7 I0 D! S
   
8.     //食物小球
   3 K/ B! o& p& J3 ?' B* `. o
9.   for (int i = 0; i < Food_num; i++)# u' a  B1 e) x0 S8 y5 b0 w
   
10.   {( q' M8 M! Q+ s6 `0 Z/ H% a
    
11.     Food[i].x = rand() % Wide_map;
    + J4 P1 {# p\" A& @3 o# z8 w* }' P
12.     Food[i].y = rand() % Hight_map;1 E6 F; A! f  [$ z3 G
    
13.     Food[i].r = rand() % 5 + 1;& ]$ B9 f$ X9 T. R9 b
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);& I\" K: L  Z' P# W
    
15.   }
    / L$ }! Q7 p  p% H
16.     //ai小球
    9 a& |' d6 }; A2 }. _\" T
17.   for (int i = 0; i < Enemy_num; i++)3 a& i6 {% E, e; u6 p6 _' M
    
18.   {2 J8 r\" K7 O8 v, _9 i1 q
    
19.     Enemy[i].x = rand() % Wide_map;. _3 ^# U# v+ \
    
20.     Enemy[i].y = rand() % Hight_map;
    6 k: m1 F# g2 [7 B8 p% v
21.     Enemy[i].r = 10;
      X/ z4 ~\" y$ m$ P0 }% {4 _  r; r
22.     Enemy[i].color = RGB(0,255,0);
    & H7 \- @6 @0 V1 Q+ P2 q1 b
23.   }
    ( C$ `$ x8 ]( R( t5 I6 k2 s1 Q
24. 
    ! u; y% ?\" m( k  |$ i  [2 k4 q6 ^
25. }

复制代码

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

1. void Player_move()7 |( w2 n5 l6 |1 I/ i# _
   
2. {5 ]4 P7 N2 T\" f* q. y5 r7 ~
   
3.   if (GetAsyncKeyState(VK_UP))4 N8 |2 M: k7 I/ Q: Y
   
4.   {
   9 r' C; V' {# y9 L$ C3 S! r7 A
5.     if (player.y > 0)# [! x. F5 P# H: x) V
   
6.     {
   7 a4 O3 F2 C* h\" l8 I5 g. [7 }% j9 U
7.       player.y -= player_sleep;
   - u$ S) M0 [# I2 `
8.     }# n1 C- W2 b9 f9 w
   
9.   }
   . P6 ]0 D3 n5 n) P6 s
10.   if (GetAsyncKeyState(VK_DOWN))
    6 G: y/ F8 b& A% ]
11.   {6 u3 ]# t2 S' t) V0 r
    
12.     if (player.y < Hight_map); O7 K/ o8 \9 ~\" ]4 t
    
13.     player.y += player_sleep;/ l$ |4 R8 p  y' V\" x% S
    
14.   }
    : z8 H. y% E1 T- u% Z! q
15.   if (GetAsyncKeyState(VK_LEFT))
    : q5 d5 e) v& S4 x9 e4 q- F( F
16.   {
    9 |; l1 D0 u% P% N1 P: p
17.     if (player.x > 0)
    ' a+ H) t  z$ L: V! m4 }
18.     player.x -= player_sleep;
    / \( ?  \2 B) P1 O$ U5 d  n
19.   }
    & M8 K9 _1 `& e! S
20.   if (GetAsyncKeyState(VK_RIGHT))$ k- D) o3 c* `& N7 _% |
    
21.   {/ f, C8 E6 k5 |' w/ q  t8 v* {, y
    
22.     if (player.x < Wide_map)) ]+ X+ S9 y* O6 H( ]' f3 G2 ?
    
23.     player.x += player_sleep;3 ]3 d; I6 h+ B, M
    
24.   }. T2 j3 y4 K: C, l& t
    
25.   if (GetAsyncKeyState(0x20))
    ' |  @3 k! h- p( f4 c, X
26.   {
    ; u' Z: y. Y$ X
27.     player_sleep = l + 5;9 j1 s$ P- a! A  L
    
28.   }7 y6 t' e% {5 j
    
29.   else
    7 ~\" L; A+ t6 b. h. y' \8 ^
30.   {
    7 a  G- l3 |; C\" I+ u
31.     player_sleep = l;
    + X  @* }  A) ?# `& D
32.   }
    ! ~4 W2 E+ R# ~  p% x& M
33. }

复制代码

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

1. void Show()
   ! o' x2 O0 w1 F, Q+ r
2. {6 m$ N+ z5 V9 w. S7 h' O
   
3.   ! Y\" d0 X: [* m( K6 }9 E% k  J
   
4.   //设置地图
   3 I% C\" N! m( r
5.   SetWorkingImage(&map);
   9 A! Q( Z: I6 L4 T9 `
6.   //清屏8 ~9 J/ w! x. M: A. v
   
7.   cleardevice();; e8 @3 C2 @2 w
   
8.   //背景颜色5 e& ?- p% L1 @6 n. F/ f
   
9.   setbkcolor(WHITE);
   * E4 \, b+ w! ~( K
10.   //划线颜色& F% o$ F' r+ j1 p
    
11.   setlinecolor(RGB(230,231,239));
    & c& A  y- w8 g: {2 H% L
12.   //划线6 h9 ^2 ?\" o1 a0 P
    
13.   for (int i = 0; i < Wide_map; i += 10); C' y& X# c7 A( P; P3 w) ^
    
14.   {, ]  I/ e+ t+ `- a% e3 ^0 d
    
15.     line(i, 0, i, Hight_map);
    9 G: t7 M% o5 S& V6 h& Y
16.   }
    7 i% [( d. N  A/ k
17.   for (int i = 0; i < Hight_map; i += 10)
    $ g$ M9 t# S$ U
18.   {
    ! D% Y$ w# ?. }4 D2 i8 T% n. r
19.     line(0, i, Wide_map, i);
    - k# b6 v) `2 P% b5 u6 L
20.   }
    2 U$ Q. o9 z) g; w: E  N& s
21.   //食物
    : @3 E. L, k/ O* q5 L
22.   for (int i = 0; i < Food_num; i++)& I% V% s/ i\" e% _7 u
    
23.   {
    8 `  n( `6 ^. ^8 K, b* I7 V, ~
24.     setfillcolor(Food[i].color);( i\" k\" z3 M/ a; m$ {/ j
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);. L7 d% q0 @6 p* d+ ]# w
    
26.   }
    5 F* o( O& _. d, u( r, B& b: r
27.   //敌人
    ! I+ K' W. _: Q! n5 f3 d
28.   for (int i = 0; i < Enemy_num; i++)' i* `. T3 _% R; y
    
29.   {2 e* g6 \2 n! o6 ]
    
30.     setfillcolor(Enemy[i].color);, v4 T7 S2 w0 N% Z& @\" f
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    1 p2 I0 G# T\" n6 W1 @! l
32.   }
    \" O4 S) Q$ y4 i8 H
33.   //玩家
    9 E\" w% o7 G$ s; P1 t1 I
34.   setfillcolor(RED);; {/ N1 t0 C% i+ _9 S/ M# o: W
    
35.   solidcircle(player.x, player.y, player.r);
    - S, T7 |! z, {, k5 t
36.   SetWorkingImage();
    % m1 V9 n4 g* O2 g$ Z% y
37. 2 M: p! W4 ]( m0 J6 L; A: Q
    
38.   int x = player.x - (Wide / 2);
    ) V/ K# E( ]3 m; s7 U
39.   int y = player.y - (Hight / 2);9 n6 a7 z2 M& L! G  `0 w
    
40.   //防止窗口越界\" |; t; c0 |5 L2 o) u2 F/ h
    
41.   if (x < 0)$ e, l4 Y9 ?$ ~) A' {
    
42.   {
    2 \$ a$ T' K3 v. Z! |, n+ h  E
43.     x = 0;
    9 n+ ^, V6 r8 ]# i0 p
44.   }
    . S  ?% E) W7 X! ^$ f4 f5 q; ?0 ]
45.   if (y < 0). d% H4 ^- |1 @* J1 b$ W: R( n9 r! P: X
    
46.   {0 {, l7 ^) L2 w6 N
    
47.     y = 0;
    / d! }. x; H% S8 l7 u
48.   }
    + |' x# S+ m& ?3 C+ v4 h
49.   if (x > Wide_map - Wide)
    6 R\" T4 d1 b6 {1 k! v
50.   {
    / J. l/ Q% D3 x8 ]0 X
51.     x = Wide_map - Wide;6 h  O% g1 ]4 s7 {* T
    
52.   }
    & H) n! x$ U7 T0 X
53.   if (y > Hight_map - Hight)
    4 x+ o. W7 p. x
54.   {6 R7 S% y( w7 G6 X( k
    
55.     y = Hight_map - Hight;
    7 b8 X( h7 |1 S7 A' A9 _
56.   }
    & q' n% Y' F1 r\" W7 y* |
57.   //把map输出到窗口上0 s( O7 ~$ V& Q\" y/ @6 r
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);3 y1 }/ _\" r! V& Y% v/ 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. //防止窗口越界
   ; H: u8 ]5 ~) k# m% d\" A7 |
2. if (x < 0)
   ; j7 N3 {* P% y\" ]% X  [( B
3. {3 E9 X6 Q% \\" f, u5 b
   
4.   x = 0;
   - Q  [* a2 f- B' e7 T5 b! h
5. }$ G# o- d\" V8 @- e6 Q% }
   
6. if (y < 0)
   - \9 M# z' `7 \: v0 N4 e) Z5 u
7. {. F2 ]0 A0 g2 Q3 e
   
8.   y = 0;
   & c% j2 M% ?4 m* W6 k( k( c
9. }! z. n& Z9 x  B6 r
   
10. if (x > Wide_map - Wide)2 X( ~* ]: N5 X& o
    
11. {- u' \\" {. h* i3 G+ t\" u8 Z6 g! X
    
12.   x = Wide_map - Wide;
    % n2 G5 R  `; @$ N% k5 d) R( I5 c
13. }
    # L# \# o7 t+ h3 s
14. if (y > Hight_map - Hight)5 n! j$ Q  A3 K' `) O$ ]( g
    
15. {
    3 ?; x2 ~% d* H\" K+ p# ^* o
16.   y = Hight_map - Hight;
    ) t+ P* z; S) G+ N6 K2 ^& D. l
17. }

复制代码

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

& ^0 l8 ~# C8 l8 h(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
- ^+ f1 |9 v* ?
) d7 f& ^$ t* s: e! nWide：这个参数指定了要绘制的图像的宽度。
  ]2 A3 F. w! x, L' p( ^7 m# H
Hight：这个参数指定了要绘制的图像的高度。
0 r* y. F6 |2 P1 c5 A
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

5 M& p6 `/ M6 f3 Ox：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
  G/ F4 f/ f; ~4 B4 m
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
' b6 c3 D1 f3 e6 c! d随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   ) S8 s  ]2 K2 `. Y, N: m
2. int Distance(int x, int y, int x1, int y1)5 L4 I& ~  p1 }0 Q! w
   
3. {1 N7 }4 m5 P0 l2 F* a
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));9 V' E( s# h3 }& d\" }1 e+ Q( m, {  B
   
5. }

复制代码

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

1. void Enemy_move()! f) L0 v) x$ z* w
   
2. {7 v  n: l& ]* T0 \# m& a
   
3.   srand((unsigned)time(NULL));
   / j7 U4 B9 J  [2 `
4.   for (int i = 0; i < Enemy_num; i++)\" s/ f5 W9 Q4 N* @- {9 f9 o( {0 c$ l
   
5.   {
   + |- b\" ]! o4 J- ^: T9 s
6.     int direction = rand() % 4;/ W5 G+ k9 M. n0 Y8 K. D\" C
   
7. 9 _9 t4 }$ |% W* l; X
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   . k: A- k7 P% d# Y9 h# S
9.     {0 ]4 \6 u* ~' X! c8 h: ~! Z
   
10.       if (direction == 0)7 M/ p+ B+ r$ m! \. i# `! S
    
11.       {
    , T\" |0 y) e* V/ E7 e6 c( k& M
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    6 t; z; [$ }( i8 A$ u9 M
13.         {% H9 s5 `/ c$ W: |/ E6 x
    
14.           Enemy[i].y -= enemy_sleep;/ n' E  {2 n* X- Y
    
15.         }
      z2 g2 D! ]: C% W, D( X& [1 t; Y
16.       }, u6 p8 B) O9 \. G) v
    
17.       if (direction == 1): O' j1 @5 K& M) A\" ~
    
18.       {
    9 v  C. \& `9 k. M
19.         if (Enemy[i].y < Hight_map)! c7 O1 D8 j# I! {/ t2 u
    
20.           Enemy[i].y += enemy_sleep;
    ' b/ u, f! l7 M  s+ Z3 o- n
21.       }
    : ^6 H( y. q9 \( J3 J4 N
22.       if (direction == 2)
    7 H\" m  F6 @$ J% S7 _+ F+ K
23.       {
    2 S6 ]\" N7 A/ E\" o6 Z* s, C* o2 f+ g
24.         if (Enemy[i].x > 0)
    / O1 n3 q! B, v; `
25.           Enemy[i].x -= enemy_sleep;
    ) y- X% a4 Y2 q
26.       }
    ' n* d( L6 _- B5 [% P
27.       if (direction == 3)3 p3 h' i: M/ [, t! e/ z- _
    
28.       {0 i: t. V- G! a- c
    
29.         if (Enemy[i].x < Wide_map)
    : r) K$ ]2 m! @' E0 |0 g
30.           Enemy[i].x += enemy_sleep;# U\" O% K2 I' ?5 G( k  v5 N4 k8 S
    
31.       }  h, ~. F; L\" `\" m8 w) n
    
32.     }
    ! j, r( T4 a\" G1 A! M& a
33.     //敌人追击玩家% r2 n) T$ a& `( n
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    ) i5 s/ u: n* \7 O; E) T
35.     {6 r6 Q! d- ?4 M* c  g5 p* N
    
36.       if (Enemy[i].r > player.r)
    , W: ~$ D5 {0 i7 L* I
37.       {5 c) i- E+ T' j9 i9 M% i( y
    
38.         if (Enemy[i].x < player.x)
    & k9 E\" ~4 S5 I+ c! b4 N/ n( x
39.         {( }  u$ n  n1 h) M
    
40.           if (Enemy[i].x < Wide_map)( E4 |7 b9 b\" o# I4 L\" L
    
41.           {
    # i+ ~- `4 I\" D3 a1 I
42.             Enemy[i].x += enemy_sleep;
    3 C: Y) m7 }0 M3 i\" Y' G! u* T
43.           }
    2 A  N  f; G: B
44.         }
    / S# @\" Y4 E5 L
45.         if (Enemy[i].x > player.x)
    9 Q% `1 P3 V5 j& y1 Y
46.         {. J( v) W8 G0 Q; o+ v
    
47.           if (Enemy[i].x > 0)
    5 G' X* ?' I8 T
48.           {; N2 }0 F! O4 X
    
49.             Enemy[i].x -= enemy_sleep;
    0 k\" _: f8 v: Q2 ?% ]1 u. g+ Y
50.           }, m  }; M0 X$ w% r7 S
    
51.         }1 a% ~3 j5 X# C' c0 e* P) c6 [
    
52.         if (Enemy[i].y < player.y)
    + ]5 M6 M9 {' [\" F, ~; M' `1 l
53.         {
    : u9 W8 H( t\" {\" v# q6 U0 _
54.           if (Enemy[i].y < Hight_map)
    , D& ?, R3 q$ _; @( Q
55.           {# _3 p1 K& Y# f! d- Q
    
56.             Enemy[i].y += enemy_sleep;
    2 a) ]' S; x\" p& q9 |( z5 y
57.           }
      z; x( v9 o1 [4 v
58.         }! N/ m7 Z& y! n; M. q! O( z
    
59.         if (Enemy[i].y > player.y)1 j* N- w; B$ D: V$ B
    
60.         {
    $ Z; B8 B2 P. o$ P\" X8 k
61.           if (Enemy[i].y > 0)  n) e  K# I% k+ V3 m( [+ o
    
62.           {
    9 L  j2 p6 C  Z1 c$ h$ S/ K: [
63.             Enemy[i].y -= enemy_sleep;0 a: I5 a5 p\" W. Q' _* S# Z  k
    
64.           }
    8 a( f  z\" Z. ~. x/ D# x8 M) p
65.         }
    ! q* u% H& P4 |; y
66.       }
    : |' i/ p7 Y8 F+ R' X5 o* ]) o
67.       //敌人逃跑
    ' W- z' E- {- s. |2 m7 \: u+ _  v
68.       else
    * _4 k3 B1 l( }7 n& H
69.       {# {+ H\" i. ~2 p9 C& G4 U\" t
    
70.         if (Enemy[i].x < player.x)9 R4 P- E5 X# o' b& C\" v% J' I- O, F
    
71.         {
    6 `$ p* D) L; Q  y
72.           if (Enemy[i].x > 0)
    ; @! U8 l+ u6 [
73.           {9 q\" Y7 G8 f& |  ?/ g: i
    
74.             Enemy[i].x -= enemy_sleep;2 A. j0 k, q9 L- B
    
75.           }
    8 c- p6 W! c1 H! y
76.         }9 S9 y. \4 |\" _& Q/ U! e$ x
    
77.         if (Enemy[i].x > player.x)
    0 ^\" W6 N. R% E
78.         {
    & a8 Z8 N* ~, c
79.           if (Enemy[i].x < Wide_map)
    4 h: u\" g, [7 }
80.           {
    \" _: j  M- \' V: J9 I/ B
81.             Enemy[i].x += enemy_sleep;\" R/ X9 f, R5 D. a
    
82.           }
    9 q5 \( S; B; G3 _4 Q
83.         }
    ; L  S8 l9 T! y& B
84.         if (Enemy[i].y < player.y)2 l; l, d% s! i% j- }6 b& q
    
85.         {
    ! `' @' x9 N/ `8 R
86.           if (Enemy[i].y > 0)7 O) D& k# ?9 C( K* X
    
87.           {, T: X( @% J* Y- }3 N\" G# ?
    
88.             Enemy[i].y -= enemy_sleep;/ F\" j. a/ k\" ~. M3 V
    
89.           }5 l8 B/ ~  M! E, D$ j- ~
    
90.         }, l6 {- I\" s  f8 A/ n( z6 o
    
91.         if (Enemy[i].y > player.y)2 L6 C6 N: j- C% n7 P
    
92.         {
    5 G* R- s) D7 I7 S; @
93.           if (Enemy[i].y < Hight_map)8 t$ h. f+ F1 n& G8 B\" _; M
    
94.           {7 A: T* `; G/ N' `4 p5 I  Z, j: n
    
95.             Enemy[i].y += enemy_sleep;
    0 w. e\" _2 i2 f+ y! ?
96.           }! M: W/ l$ T3 F6 ~6 z( `5 H
    
97.         }
    9 ]# B+ g& G0 Z' h2 g2 ~6 v
98.       }
    \" `  e* ]2 H  C3 q* G- \- O
99.     }
    , p* C7 `. O; F( m' p9 c3 h4 _
100.   }2 K  S& D1 \2 }- Q$ o) H
     
101. }

复制代码

7. 小球之间的吞噬关系
" z4 T+ n  t* w) j

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

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

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

1. void EatFood()
   5 D: H& v8 @2 h7 [+ {5 O) i: K. W+ J
2. {5 z7 j) k) @4 D4 b% n: K1 [
   
3.   for (int i = 0; i < Food_num; i++)1 V: ^: p0 a\" ?' X) M
   
4.   {, N& B2 K) C: G% u) d
   
5.     //玩家吃食物
   2 w1 l* z/ o0 D- q
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   : j$ Y% m7 J# r' e
7.     {
   6 ?+ [6 L9 F2 w$ P
8.       player.r += Food[i].r / 100;8 z8 \6 D* `. x( I\" N
   
9.       Food[i].x = rand() % Wide_map;8 k- R, @7 e8 _, k# ^
   
10.       Food[i].y = rand() % Hight_map;( R6 I8 J8 q: Q9 y- C+ _# j
    
11.       Food[i].r = rand() % 5 + 1;; @1 t4 c  q! A
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    7 y' S) ~2 g$ {! x! ?; B: U. P3 c6 e* Q
13.     }
    ) ^# w: ]( H9 ~4 h$ M* o8 E
14.    
    . @! B+ M/ ^8 j6 o1 ]
15.   }
    9 Y& ?  D- H$ s% j4 p6 I3 L
16.   for (int j = 0; j < Enemy_num; j++)# _  Q% I8 G3 N/ M1 Q
    
17.   {
    6 r( @/ Z2 _+ I0 r7 Z0 H
18.     //敌人吃食物: V. s0 S\" g$ V
    
19.     for (int i = 0; i < Food_num; i++)
    * G' v3 [& A& V% y$ ?5 Q, i, N8 f
20.     {
    9 m  S( O8 P# I- G/ C  [+ x
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r), {0 \) g5 d, J. v7 m$ P
    
22.       {
    & B  d! Y) N4 T' A+ u& A
23.         Enemy[j].r += Food[i].r / 50;
    5 v. p9 }+ d' B+ u
24.         Food[i].x = rand() % Wide_map;
    # K- K( H, s% y4 |* v6 g& ^; O: h
25.         Food[i].y = rand() % Hight_map;
    . N7 K7 K- G& a
26.         Food[i].r = rand() % 5 + 1;
    6 y# y, `) d0 ]7 B6 H\" Z( w( T0 e
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);5 p) {/ m% y\" ^8 A& \1 G- p* S7 D
    
28.       }# Z6 M; Z& N) a( C% b
    
29.     }
    8 k7 \1 O\" M1 V# s6 b# m
30.     //敌人吃敌人
    + m; e% @& C, Z& `/ t/ j* @( _7 a
31.     for (int i = 0; i < Enemy_num; i++)+ K# d9 _% m' G# s
    
32.     {, Y( M1 h( ^$ {4 d5 J+ 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)
    7 m+ q1 D6 c- f. K- S
34.       {
    $ A& Q' }\" A/ o3 N
35.         Enemy[j].r += Enemy[i].r / 10;
    1 A; w; x, E3 j- l  @# k1 [
36.         Enemy[i].x = rand() % Wide_map;. K! L2 L' b1 r9 m5 [
    
37.         Enemy[i].y = rand() % Hight_map;- L& g5 b0 `4 |5 L9 q. K
    
38.         Enemy[i].r = 10;& j3 u+ d7 V6 y4 B
    
39.           Enemy[i].color = RGB(0, 255, 0);
    * w6 p8 u: j7 r( O; c% R
40.       }
    8 ^, J9 S6 ^* k, O% t- K/ 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)9 o( v\" e; R+ |6 l7 l( O
    
42.       {, E5 u9 W! T- ^3 G5 C/ K, x9 h
    
43.         Enemy[i].r += Enemy[j].r / 10;
    . n1 N# r) n+ Q& P; G
44.         Enemy[j].x = rand() % Wide_map;
    1 V$ r+ T* S' @. \8 h
45.         Enemy[j].y = rand() % Hight_map;
    4 w6 E. b( u; I1 B! ~4 `& E
46.         Enemy[j].r = 10;! N2 ~3 U. @: t% X% L\" i! x
    
47.         Enemy[j].color = RGB(0, 255, 0);' t( V. D( D\" S/ ~! u. I! A' Y1 t
    
48.       }7 |8 x1 p2 O* U' F- \
    
49.     }& g; j* U9 R2 P- c( B5 c
    
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r), ^7 f) p$ `; ?+ b$ T4 B9 w
    
51.     {
    2 l% K0 z6 z2 j9 R5 m& M5 Y
52.       //玩家吃敌人
    $ |3 F2 _# n6 b2 x3 _$ R
53.       if (player.r > Enemy[j].r); F3 K9 B* @1 F# G6 ^0 R0 Q
    
54.       {7 [/ @! W5 p+ _
    
55.         player.r += Enemy[j].r / 10;
    + W\" l( u; F) z, Y0 s\" j8 W
56.         Enemy[j].x = rand() % Wide_map;
    - \3 c. k. G$ _3 I% X: i6 d
57.         Enemy[j].y = rand() % Hight_map;7 f2 a2 v\" N\" x7 x
    
58.         Enemy[j].r = 10;
    6 c; T) x; ~7 s( C+ x9 m* W8 }\" s' |
59.         Enemy[j].color = RGB(0, 255, 0);
    - u2 a, w8 p! N8 z% l  S
60.       }7 c\" f4 t5 Y  F0 ]0 b3 a
    
61.       //敌人吃玩家3 p1 P% p: g2 o* h2 O2 d; w3 c
    
62.       else
      s5 {( L) g; e' d# E8 L
63.       {
    8 F4 E$ W1 b7 E* j2 P5 y: e
64.         if (invincibility == 0)0 X) D, I: v; Y: ^; |; e
    
65.         {
    + q/ k4 j  ?% Z6 L8 w4 ]- j
66.           Enemy[j].r += player.r / 10;4 y4 m5 M% H* A* ^- l\" y% M
    
67.           player.x = Wide / 2;1 J+ _( H( U1 E
    
68.           player.y = Hight / 2;
    # i) u, k\" G* q4 W+ q# m8 Z5 b: g3 B
69.           player.r = 10;3 H2 `  W* y& |: L0 C
    
70.           invincibility = 10;( }9 v$ M/ _! o, b1 e2 o
    
71.         }
    : k9 L# s9 X( |5 Y2 Z. Z3 ?
72.       }$ {; l8 O7 f( n  c3 p$ I% f
    
73.     }% x7 C/ ~4 b4 a
    
74.   }/ J1 C1 a, z2 I2 A# Y! Q
    
75. }

复制代码

完整代码见附件：
6 H$ m. |) t8 f" O$ H5 X


4 g' O, y% K* t; D* h* w: N