球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
+ B( y2 b  @/ `8 U8 ?" l5 F
) {  |  A6 N8 o; k7 \+ D* ?在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

& j; x* M% H- D- r+ m游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。
; g) w" x- S2 r  v- p/ ?) v
玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
! ]/ ], \- Z# R; X5 b3 Y
其他小球：其他小球又分为食物小球，和ai控制的小球

$ G1 h: h0 N& T$ w体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。

1 i- _/ f: {0 F: @' }0 s7 z玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

/ Y& y+ c( X( x" |% ?' oai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
9 [! L6 O  T1 d1 A& u
接下来，我们将通过以下几个步骤来实现这个游戏：

& u0 r, b$ J( W* y+ F/ R初始化游戏界面和小球的信息。
8 v& A( g3 \% M9 G( l/ ~
5 v6 @) `+ k! t& G处理键盘输入，实现玩家小球的移动和加速。

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

& J4 K. a* V: |6 ?, L生成ai小球，并控制其移动。
# d( [2 M8 B7 P
检测小球之间的吞噬关系，增加相应的体积。

通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

5 g7 M2 {3 j$ Y- h5 y2 V1. 小球的要素
在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
+ |2 ]: N$ {6 j0 _
struct Ball
; |* t% H0 O) B) ^{
) e1 I9 @+ C0 \; O6 e        int x;
) D+ o6 G# ^* a        int y;
7 O& K3 O4 B. Q        float r;
! {) I7 O8 Z! b% [/ ~; N; i        DWORD color;
};
, o/ A; k0 H2 q2. 初始化小球的信息
$ ~# N8 S2 x; r+ {$ j将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

' v# G. ^' O7 u" t- x1 qRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
% p4 k* g, `7 S/ W9 x
橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
绿色的RGB值是（0, 255, 0）。
5 v! J# i" a" s6 S, O蓝色的RGB值为（0, 0, 255）。
- v# e5 y+ K/ R紫色可以通过RGB值（170, 0, 255）来表示。
  l% c5 h, r  V& R  D黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
/ `: H9 V# j6 x灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   + }, p/ z' V% @& g6 r
2. {) x2 ?* x' F% D
   
3.     //玩家小球4 c4 i) O9 x9 w0 n) X. O/ G* z0 M
   
4.   srand((unsigned)time(NULL));
   7 b6 Y2 {7 d# Q9 R/ N
5.   player.x = Wide / 2;
   7 |0 S' Q' m+ ]
6.   player.y = Hight / 2;; z- p) B0 i$ H4 c
   
7.   player.r = 10;) x7 N3 {3 |( g
   
8.     //食物小球
   1 Z# w  l) f4 t; i* b+ N, C
9.   for (int i = 0; i < Food_num; i++)
   + S; J. X# u& j& M
10.   {: I/ ~6 A\" U' X- ?\" e
    
11.     Food[i].x = rand() % Wide_map;
    + h* K0 f% ~+ \! |+ Y
12.     Food[i].y = rand() % Hight_map;
    8 r\" `# P3 m% z& {9 }$ o3 S) y
13.     Food[i].r = rand() % 5 + 1;( U! p% e/ b+ H( v5 D
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);/ w' L6 c+ R! d5 Q  }2 a8 w  z6 T1 L
    
15.   }
    ( T) j! J9 R; K2 x2 e, \$ F
16.     //ai小球- N& V, L8 i  a: Y0 q
    
17.   for (int i = 0; i < Enemy_num; i++)) @7 I0 j. Z0 }0 ?2 N2 s* F
    
18.   {
    5 {1 A4 E+ a5 H. a% U
19.     Enemy[i].x = rand() % Wide_map;& p$ ~0 w/ _\" |  \2 _% w- p# p
    
20.     Enemy[i].y = rand() % Hight_map;
      W8 v. e3 R* k: s7 J
21.     Enemy[i].r = 10;, A3 ^4 b7 D6 x+ F# b3 g
    
22.     Enemy[i].color = RGB(0,255,0);
    9 F5 b, \3 N8 n
23.   }
    8 \# g- {. u\" V4 i  {6 [
24. . `- t; x8 o; \. e4 b5 B- t
    
25. }

复制代码

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

1. void Player_move(); ?! e% Y; `& j+ j5 e! v\" s  Y7 `
   
2. {\" G0 Z2 {+ P5 }! V: J5 J& d. t
   
3.   if (GetAsyncKeyState(VK_UP))3 A& r) ]$ p) U4 ^! S/ K
   
4.   {5 Y3 D; P0 @# E4 h
   
5.     if (player.y > 0)
   ' H1 J3 t8 ~4 i) P: P
6.     {6 C+ D\" u6 e: N$ B  \- r4 R
   
7.       player.y -= player_sleep;
     Q% G+ H+ B- @. Q5 s, J9 s\" d% Y
8.     }+ k# L+ r6 |3 v  Q' w' w$ J
   
9.   }
   : Y0 q3 L$ l4 m8 a4 A* [
10.   if (GetAsyncKeyState(VK_DOWN))0 d$ \* z0 k- k2 G4 C
    
11.   {
    * O* f7 |  c6 A2 u\" D
12.     if (player.y < Hight_map)
    & k4 G, g6 G\" I; r$ \\" O* z
13.     player.y += player_sleep;
    # y* e5 _2 R) p7 T' I
14.   }
    . `7 w8 E, W8 U* f! E/ s
15.   if (GetAsyncKeyState(VK_LEFT))# q) U9 h4 Y4 V
    
16.   {
    ) P6 L1 e8 A0 H# s5 ~1 q, r
17.     if (player.x > 0)
    0 @$ ^; G: w' Q9 G\" O
18.     player.x -= player_sleep;1 X7 T; |5 |/ m) a; t$ w( j! r
    
19.   }, p8 ]  S1 z( E( _
    
20.   if (GetAsyncKeyState(VK_RIGHT))
    4 J# M2 l: y$ y! e
21.   {4 \0 M' v$ d. q( I( I; B1 M5 T\" ^# l
    
22.     if (player.x < Wide_map)
    $ ]8 z* d; g\" i, P
23.     player.x += player_sleep;
    7 c9 Y, D& y% {9 b
24.   }6 P) [- s! I$ {  C
    
25.   if (GetAsyncKeyState(0x20))
    8 N. E- Z+ |( r2 d\" I+ s
26.   {
    # A+ W7 g. }* c1 z2 i. s  ~
27.     player_sleep = l + 5;
    ( s: L/ A6 R7 L- k; s' ~8 _  M
28.   }& @  m+ I* Z) X5 i
    
29.   else7 X) I& u+ F\" W& f* x
    
30.   {
    ' P9 D3 \  L' o7 V; j
31.     player_sleep = l;
    $ ~\" H. c: P+ O1 b- x: z' N
32.   }
    \" ^) L6 z4 J: N  _. C+ J  b% u
33. }

复制代码

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

1. void Show(): d# @8 W6 P, T) J4 G% l
   
2. {
     }6 a3 }  @' _+ _
3.   
   ( i& o' i) A; x2 E  f
4.   //设置地图
   ) w9 Q- Y( R' `: a! e. O
5.   SetWorkingImage(&map);
   # {9 l0 U, Q& g7 G1 \
6.   //清屏
   \" Z% s. B8 O0 n4 d* A4 U; k
7.   cleardevice();
   2 X  K' _9 L8 l8 b0 H; ]
8.   //背景颜色4 T& s\" F# O) f) U& ^
   
9.   setbkcolor(WHITE);
   * n$ w' C+ o; K9 E  b) J6 t& V
10.   //划线颜色
    1 f- N1 Z1 K7 W! ^: Z9 S2 f
11.   setlinecolor(RGB(230,231,239));) |# Z9 `- k2 v) T! A' t7 `
    
12.   //划线
    ! n1 K, t' X. {7 q9 I
13.   for (int i = 0; i < Wide_map; i += 10)
    3 q5 ~. ^! Y' Z) A. ^( M
14.   {( `5 J: i% D: M% z' i6 [
    
15.     line(i, 0, i, Hight_map);; U8 @/ ^0 ^  S( M
    
16.   }( O\" J' L) C+ w3 E- h/ s0 Q
    
17.   for (int i = 0; i < Hight_map; i += 10)
    % z- _* w8 s* Q9 Z% ~# w\" n
18.   {
    7 a, q; h$ B/ p' \  v& A
19.     line(0, i, Wide_map, i);! l\" I% h5 o- c\" V! L9 _3 Q1 n
    
20.   }
    ) O) b6 B3 w# I
21.   //食物
    + A( [  g% ~; d2 A6 ~
22.   for (int i = 0; i < Food_num; i++), C% P+ _1 U: L$ r6 ?' G+ {8 Q
    
23.   {7 J) J! `: D; |
    
24.     setfillcolor(Food[i].color);7 s9 H9 b6 J/ S* A
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    + c  [, a+ O( l9 T' R- n
26.   }1 x6 ?9 L7 W: |% \
    
27.   //敌人: [\" s$ T+ |- T- T. e! |
    
28.   for (int i = 0; i < Enemy_num; i++)! H- }6 `: k0 G; S
    
29.   {! W$ P- N/ O' C  h& @
    
30.     setfillcolor(Enemy[i].color);
    9 G9 G; @6 d6 Z$ q9 P2 t' I. U8 F
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    ) h  \7 b4 D% P, }) ]- V
32.   }
    2 ^; Y- Y7 ]7 z$ p0 O
33.   //玩家
    % M& o/ p, {4 H9 C) ^9 y
34.   setfillcolor(RED);/ B  M; N' K5 o+ y
    
35.   solidcircle(player.x, player.y, player.r);
    4 h& E9 S) t$ U9 m
36.   SetWorkingImage();- Y6 u2 s) i$ [
    
37. 
    4 r* s& o/ T+ C
38.   int x = player.x - (Wide / 2);& U7 J4 j) ]8 D2 @
    
39.   int y = player.y - (Hight / 2);
    / Y; U8 o8 e1 i: x1 ^5 y* {$ S% M
40.   //防止窗口越界
    # w7 r: d  V4 t; r/ T
41.   if (x < 0)
    ) o# r! I. j0 [: J* y, c; y7 r/ D
42.   {, c1 \% E* N5 {: ~' B( S
    
43.     x = 0;
    ! w$ D: Q- ^- ~( e1 `6 U
44.   }
    7 }+ p5 a; [& {: n$ s/ R: L
45.   if (y < 0)
    ( k& D8 o8 A\" a8 F& @  L
46.   {
    6 }* B& q5 w# Q+ T: R+ h
47.     y = 0;9 e! M% V. a/ N$ g. w
    
48.   }) F. G  H; v+ B& F- A' {  m* _  g
    
49.   if (x > Wide_map - Wide)8 S( {% L  n+ B  l& M
    
50.   {
    \" U$ _3 {4 Y, @4 b; v
51.     x = Wide_map - Wide;5 A0 G) q* a, L8 w8 G
    
52.   }6 q$ D* s+ i4 ^\" ]; Y
    
53.   if (y > Hight_map - Hight)
    9 D$ L) {0 L9 ]# W/ G
54.   {2 s* P/ i! y\" G! Y2 {. P% Z2 ^/ C
    
55.     y = Hight_map - Hight;5 t7 ^) H2 F/ z4 N- t5 d: l7 V
    
56.   }' U$ o; C  c% Q8 x; q: g
    
57.   //把map输出到窗口上
    ) L9 U8 `8 Z& p8 v% B
58.   putimage(0, 0, Wide, Hight, &map, x, y);$ Z6 w  j7 O/ D# @/ Z. n
    
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. //防止窗口越界: P/ j, {. ~5 q0 S! c, a+ n- {+ z
   
2. if (x < 0)
   1 q- P; _/ T8 {5 X6 N
3. {
   9 l0 ]/ f. d4 z5 S6 V1 o. Q
4.   x = 0;
   . l\" ^7 T8 d+ R# `( \0 C& w\" K9 `
5. }
   & m3 N, v. v# b  K- f
6. if (y < 0)
   5 g8 b) s9 E/ P1 X8 A\" H
7. {1 A1 {* L, G- f/ j% `% o* t\" `
   
8.   y = 0;
     t* r  Y/ E9 r3 ^$ n
9. }\" V) Q3 F9 P+ a, [- L
   
10. if (x > Wide_map - Wide)& j, I: x+ G' Z
    
11. {
    7 u) |6 j& b6 G\" `' L\" l6 M$ P
12.   x = Wide_map - Wide;- l4 H* J% a- ]; g
    
13. }
    8 L. }* `\" I6 P' x; i; g, e
14. if (y > Hight_map - Hight)
    : m. w( ^# p/ ?1 N* |: H
15. {: y6 l3 H( C2 w- E6 h% L
    
16.   y = Hight_map - Hight;
    - S1 r2 U0 m5 m; x8 z
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
- G, R3 a/ J7 g: X8 J  L. L
(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

Wide：这个参数指定了要绘制的图像的宽度。
3 ]2 {5 }; g. t. W5 x) y2 A
Hight：这个参数指定了要绘制的图像的高度。

# u/ u6 o! q3 ~% m* \% J/ a0 S2 p&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

) u9 k7 L/ C7 b0 E& `9 d: W' Ix：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

/ i& c5 \: r; Z6 i- [& uy：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
. t( m+ P/ H" k9 Y( m6. ai小球的移动
2 P& i3 e, A: T' @随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   + i7 X/ `/ F. y$ h) Y  U
2. int Distance(int x, int y, int x1, int y1)
   , f7 @; X0 z& p% \
3. {( q. H\" p0 \: i1 Z
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   8 ?6 [- H2 E. d\" [7 b) H; ]% K
5. }

复制代码

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

1. void Enemy_move()\" p9 }) A6 Z# w
   
2. {/ q( Z$ r3 o- o
   
3.   srand((unsigned)time(NULL));
   ) E( R( ^& o& u$ p3 ]8 ]& y/ J
4.   for (int i = 0; i < Enemy_num; i++)
   8 c\" N* R4 U- B7 G7 V
5.   {
   4 [( j\" Q' i\" [% k% O
6.     int direction = rand() % 4;5 c( i( Z7 ?& J
   
7. 3 ?1 }$ _' Z% h. C( s/ N+ Q
   
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   * Y, `0 ~7 Q6 ~$ h0 ~
9.     {) d6 Z5 h! [; Y% f3 T3 p
   
10.       if (direction == 0)
    ' \; Z; B: i: Q) D( A+ @
11.       {
    ) H( [, c/ W. ~. Q& r5 R
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句( \' `$ w- Q* Q0 ?( _; y
    
13.         {* |& m- b$ @% u$ O5 [
    
14.           Enemy[i].y -= enemy_sleep;) q7 d9 S6 `) j
    
15.         }
    4 D& {4 x  k! [2 P; y
16.       }1 M( i/ u6 v% w
    
17.       if (direction == 1)
    - P0 R* G8 ^5 S; c! k\" P
18.       {/ q7 n5 ~1 [5 k9 C
    
19.         if (Enemy[i].y < Hight_map)
    * n. l! M2 P5 p( t; ~9 g+ x
20.           Enemy[i].y += enemy_sleep;
      a: s* }7 q1 N  c' x! d* d
21.       }, {; c8 G+ ^& H\" t  X
    
22.       if (direction == 2)# Z$ ]& @: e& i
    
23.       {  r8 ?3 `) U0 D. C7 N: G  ?
    
24.         if (Enemy[i].x > 0)
    / g3 Z4 \$ T0 [4 T; \$ `2 C
25.           Enemy[i].x -= enemy_sleep;2 {: S; x. f! ]5 ?- M  N5 n$ p5 d
    
26.       }. r0 H) N) e: `. p3 p
    
27.       if (direction == 3)4 |! o7 l0 a, `7 v\" e
    
28.       {' k9 I7 t6 ]& G/ x& u
    
29.         if (Enemy[i].x < Wide_map)
    ' g2 w\" h8 I/ i: b0 l; U
30.           Enemy[i].x += enemy_sleep;+ e* q3 h! L2 K, l! L0 B
    
31.       }1 E& |! H, f! {4 K; u
    
32.     }$ B7 z, o  J: v! i
    
33.     //敌人追击玩家: R7 [+ F7 D  x4 x( i! u
    
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50): `- X8 k- g0 |8 \
    
35.     {
    ( F- g. Q. E) m% s( P7 K( A
36.       if (Enemy[i].r > player.r)
    + B, g4 `: D* \3 i) G8 S9 a% U
37.       {
    # ~, P3 X( \1 p8 X- Q\" S, B1 E
38.         if (Enemy[i].x < player.x)
    2 G+ z! E2 D\" l* N. B( _; Q
39.         {7 g& I/ q/ o8 u3 J! F1 a8 Z
    
40.           if (Enemy[i].x < Wide_map)
    ; U9 `* N' ?' W; |\" Y
41.           {
    + Z  r\" K8 A( ^/ J( D* N
42.             Enemy[i].x += enemy_sleep;- [& B% j2 _4 ^4 Y# l8 V8 a9 D
    
43.           }
    % l( A) u9 L- h: P) E+ b9 y
44.         }
    . L% [! [) e- |5 O! x8 m
45.         if (Enemy[i].x > player.x)
    2 i: N/ v$ B$ \6 D) P% J. n
46.         {
    - A  }& y  ^% c3 b6 D4 ]) ]/ F
47.           if (Enemy[i].x > 0)- i8 G- F4 a- F
    
48.           {& {0 S2 R1 G( |\" z\" N* C9 ]( t% ~. X
    
49.             Enemy[i].x -= enemy_sleep;8 s- X& n! E& F+ @. r
    
50.           }
    ( V8 R3 I  j; B& `
51.         }5 n# _: p( |) H. z9 x7 K- v
    
52.         if (Enemy[i].y < player.y)\" [7 x4 z! j$ D3 \\" L- R& \
    
53.         {- L+ }' M0 A: F. I+ H
    
54.           if (Enemy[i].y < Hight_map)
    3 F9 n, d& m  z
55.           {
    ) ?! r3 c: T6 W& N+ D% ^
56.             Enemy[i].y += enemy_sleep;, g, S2 k$ p5 y\" C* f
    
57.           }& o2 U6 T, A' j5 E5 J
    
58.         }
    / H) G' i/ F! U) L+ ~: K1 u* Y) U
59.         if (Enemy[i].y > player.y)
    8 d' X7 g/ o. y% m( ?) r6 }7 O, h
60.         {0 P. \8 n9 g% O5 a( B% k
    
61.           if (Enemy[i].y > 0)8 A+ B+ w. r% g4 g1 i
    
62.           {
    # Z6 o6 j; {7 X# U
63.             Enemy[i].y -= enemy_sleep;& N; c, b. m/ f
    
64.           }
    # A( G$ s$ M/ i6 H* y/ k4 I
65.         }9 h& @- g* D8 A/ d
    
66.       }6 r  q1 ^7 |/ J; H$ m
    
67.       //敌人逃跑
    ; [0 |/ Z  }/ j3 d
68.       else
    , N8 u\" @' J\" R7 I8 |
69.       {
    ' U& G8 {' @% U: p$ d6 E- r
70.         if (Enemy[i].x < player.x)
    0 Y: F2 W6 H. b( I
71.         {
      e. J: h$ q5 O' c+ D
72.           if (Enemy[i].x > 0)+ e2 j/ @/ o/ N( B
    
73.           {+ i3 x& t7 P; v7 n) `2 p
    
74.             Enemy[i].x -= enemy_sleep;
    ! @0 u8 X3 \. @  T' c
75.           }- I+ B% _2 y* k4 U0 C- F
    
76.         }, D( t\" E. ~/ @3 K) s
    
77.         if (Enemy[i].x > player.x)
    ' B/ g( _. R5 ?  k
78.         {) C3 ~) h- n! }\" |% W
    
79.           if (Enemy[i].x < Wide_map)% k0 r& X8 @' w
    
80.           {2 x$ w! ^8 q0 E9 C. ]% n/ U, w8 z
    
81.             Enemy[i].x += enemy_sleep;  H' K/ s' ?. o; [! c
    
82.           }
    : N. R  I/ ^- f2 ?  v# l$ {, F7 t
83.         }3 k( v% Q4 a& q2 D; U1 J
    
84.         if (Enemy[i].y < player.y)& h+ R7 \$ R% b; k4 e
    
85.         {
    $ L- X+ ~  J: }\" G2 W8 U
86.           if (Enemy[i].y > 0), `* P) W1 @) x9 p, i; f
    
87.           {* j6 d8 L$ \; ]4 A; G
    
88.             Enemy[i].y -= enemy_sleep;. q7 J) z0 L  T8 r  O8 }) i
    
89.           }
    , u/ }* y& C/ y3 E1 `2 q6 H4 f
90.         }
    # E- n# g5 p. X; I( c
91.         if (Enemy[i].y > player.y)# Z7 I% |1 T\" Z- o) F: O
    
92.         {
    . I; D. H/ _0 m  ^* v
93.           if (Enemy[i].y < Hight_map)
    0 F8 Q7 k' D3 F
94.           {2 d& v\" I! \1 ~( P, A+ x
    
95.             Enemy[i].y += enemy_sleep;1 g1 p* C& w4 V- v4 M1 A/ L
    
96.           }/ m, P/ R\" r' E: F0 f5 [; h4 w: o
    
97.         }) u/ B3 w' _0 o: G
    
98.       }
    ! }% t\" ~# a! m' P5 N
99.     }
    7 G! \6 f0 V- X7 q6 y' i$ ~9 ~
100.   }6 o3 \) r! E3 O/ J( ?( q
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   % Z; h4 B$ `5 G0 v
2. {
   ; R\" a  {; Y0 \
3.   for (int i = 0; i < Food_num; i++)
   + A3 N0 u; R7 B# K2 Y
4.   {9 t4 ?/ E% y9 ]' A; P- Y1 t0 `
   
5.     //玩家吃食物
   & q+ ?% j) O$ L% z5 P
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)$ ?( F9 w- P- x- b3 X, j; q1 P
   
7.     {
   8 W* [7 f4 v7 V6 _: s
8.       player.r += Food[i].r / 100;1 @) |( b+ ?4 v! V
   
9.       Food[i].x = rand() % Wide_map;# l% H7 c3 K2 C+ X$ U9 F
   
10.       Food[i].y = rand() % Hight_map;) @; R! X& B; B2 x+ N
    
11.       Food[i].r = rand() % 5 + 1;# t0 m4 x' \: t$ K) C
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    $ y/ _5 ?* ^4 O. D
13.     }$ ~1 I& d0 b& z7 Z7 G
    
14.    
    1 [# }) Q8 o$ \$ D9 a\" D
15.   }: N( }- z- e$ S* ^! T* t6 L3 n
    
16.   for (int j = 0; j < Enemy_num; j++), B9 }6 u' l& T% `, ?
    
17.   {
    5 D3 K3 ~$ |7 r8 z$ W
18.     //敌人吃食物
    0 a2 j2 D1 M' x# t& n. P
19.     for (int i = 0; i < Food_num; i++)
    : x: E( M7 A  D\" U
20.     {
    1 `5 e: C7 D: T; L
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    8 Q8 B1 X& ~6 c
22.       {- {/ v' t  U2 O( [
    
23.         Enemy[j].r += Food[i].r / 50;4 ^3 m+ ]; b4 ~+ u
    
24.         Food[i].x = rand() % Wide_map;
    7 [+ F, t$ n! M: G
25.         Food[i].y = rand() % Hight_map;
    ; Z  h/ d! A! W- A
26.         Food[i].r = rand() % 5 + 1;( H! s  X; {% `, C7 b
    
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    % b9 r8 g) ~9 q\" X' V, S
28.       }% \0 D8 X( p. \8 \- k
    
29.     }+ `3 G4 u) I/ \' }) |* F# T
    
30.     //敌人吃敌人
    : V$ p8 b3 w+ u, n+ p
31.     for (int i = 0; i < Enemy_num; i++)
    6 |+ p7 E$ b) O9 ~6 v
32.     {
      W8 C/ T/ T( `5 Y# |6 I
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)1 F/ G  C* W. o6 t& i
    
34.       {
    6 J: s) b/ {: r+ |
35.         Enemy[j].r += Enemy[i].r / 10;
    8 ~6 [# V  X) `9 f( W: E) i  s
36.         Enemy[i].x = rand() % Wide_map;4 D# K5 E) k6 ~7 |\" p( H& [  p6 F, K
    
37.         Enemy[i].y = rand() % Hight_map;3 b  P& Z0 `0 O& ^( i
    
38.         Enemy[i].r = 10;
    9 ?8 Y* V- R- t
39.           Enemy[i].color = RGB(0, 255, 0);( X, ^' d' J9 h
    
40.       }
    % M* D  z7 x2 x3 n7 a
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)( R5 D( z( N! B' d! l3 J( Z
    
42.       {
    * \\" p% r& q. F) j
43.         Enemy[i].r += Enemy[j].r / 10;
    + B\" U  r/ z3 D, N
44.         Enemy[j].x = rand() % Wide_map;
    - o% r2 a/ Z/ F- h
45.         Enemy[j].y = rand() % Hight_map;
    & W) K& C$ n% {
46.         Enemy[j].r = 10;0 x6 K5 V8 ~4 n2 C, F
    
47.         Enemy[j].color = RGB(0, 255, 0);: j( S/ [  c6 I/ |- z1 B/ u
    
48.       }
    ; L$ I  g1 J$ ^. R. I% O
49.     }
    - n# t\" ~' T$ `0 y9 w# d* ^
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)- l* _  G- N1 }4 N
    
51.     {
    , K# o5 {+ f; B5 g$ r0 S
52.       //玩家吃敌人
    * k, G$ ]) S! ?+ j5 s9 v
53.       if (player.r > Enemy[j].r)6 ^3 U3 F! A  `& q* j3 I
    
54.       {
    ( D$ G9 J( C& @' L' S
55.         player.r += Enemy[j].r / 10;8 f4 X  v6 K2 ^' Q
    
56.         Enemy[j].x = rand() % Wide_map;
    3 j+ C, A/ o$ E# |- I$ v
57.         Enemy[j].y = rand() % Hight_map;
    6 }8 g( n# x& a7 d/ }8 X
58.         Enemy[j].r = 10;
    6 @2 T. h7 n9 a. @; G# r$ W1 N# G
59.         Enemy[j].color = RGB(0, 255, 0);  q  _, r9 d; k) C0 r% I1 \( A
    
60.       }
    ' s9 `$ @+ r9 ^\" {) w
61.       //敌人吃玩家/ K# W- X. h4 R7 r
    
62.       else
    4 z# t5 C/ a  a( ^3 @
63.       {3 X* f2 S9 M& N! O  c; c+ i) p
    
64.         if (invincibility == 0)* L! i9 d$ c$ W' G
    
65.         {
    ( Q* p* w2 i$ ]/ }2 G
66.           Enemy[j].r += player.r / 10;9 Q# t3 @! G& K! n# D' i4 m& ~
    
67.           player.x = Wide / 2;
    7 l4 `/ K; y$ B9 p: `9 T% G
68.           player.y = Hight / 2;
    ! u% L$ H2 ^4 ]; K; g' H6 V. O
69.           player.r = 10;
    ! l) w2 \6 n; B. g$ e4 I
70.           invincibility = 10;
    + D3 o+ R) k2 g% L9 {5 t( H) r
71.         }
    5 b' l6 q1 y# h
72.       }! Z/ w  }6 P( ^0 @
    
73.     }
    + u\" W& t\" ]9 N3 G& R9 n
74.   }( z% i( A: {/ K5 S
    
75. }

复制代码

完整代码见附件：
1 C4 |5 Y7 a+ K0 g: T( k


! H% z: Y7 t. r4 N3 d1 G* G