球球大作战

2744557306

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

, \4 w8 c( a" i" J在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

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

  ?! y5 n/ x$ f. e玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
; Y, L9 D/ @4 x. K( F# b
% C8 [2 L( I0 M# B# G2 i( g- S其他小球：其他小球又分为食物小球，和ai控制的小球

体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
4 z& I) j) |& Q  o- o% ^
玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
# ~% A  M( n) ^" G
ai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。

接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面和小球的信息。
6 }) P9 V0 O# ~
处理键盘输入，实现玩家小球的移动和加速。
' n  ~$ T2 A% n1 N
生成足够数量的食物小球。
+ Y& F- C) P( ]1 Z0 A
9 |! O  v3 P8 p0 A1 ?7 g生成ai小球，并控制其移动。
' n/ V+ r$ S5 X6 }9 M  I5 l0 Y
检测小球之间的吞噬关系，增加相应的体积。
- Q' y7 z6 F8 E; n$ ?) X
- W; ]' n2 M: J9 R0 P" G+ s通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
3 V0 R7 o8 g/ y6 L2 V& s
  ^- c" k4 j$ W6 N% q9 B. ^, ~1. 小球的要素
, F$ f$ Z; J8 m. Y, Z4 \在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。
; p1 B- }! U& K6 J3 X' T3 j
2 V6 G( I3 E& \$ lstruct Ball
# B" m( I( ~# f$ o- y1 s{
        int x;
        int y;
- A- G  W1 i1 C8 }7 n! i6 x( w        float r;
5 e' M9 g3 T+ @1 e3 _8 s( D        DWORD color;
& N+ k4 ^+ o3 C( Z; d};
% o$ N' g! N# s) ^' X, m2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：

橙色可以通过RGB值（255, 128, 0）来表示。
8 b" d- W1 |( V4 f黄色的RGB值为（255, 255, 0）。
# {% Q2 j9 h2 c3 Z+ V( q绿色的RGB值是（0, 255, 0）。
+ x2 I# q/ I/ M8 H" H- @: }% d& i蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
% |/ i7 |' u, y' q黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
. d* ^! f$ D7 p7 L2 K2 h( @灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   4 i7 V% A\" P' v8 c1 [
2. {
   / {- [, q: @9 |& {: v7 J5 u$ f* i6 P8 q
3.     //玩家小球
     m' `1 T' L. H: ?) n\" B
4.   srand((unsigned)time(NULL));
     @+ U. P2 v8 Q2 ?
5.   player.x = Wide / 2;
   1 E7 d/ o+ k' H+ A
6.   player.y = Hight / 2;7 W' v! d: y2 ^2 K! b\" ?
   
7.   player.r = 10;
   0 n3 j$ M8 o3 Y; N\" \
8.     //食物小球2 B5 o- _7 `- K# a' W  i
   
9.   for (int i = 0; i < Food_num; i++)
   # H1 k: @' g! A5 a& M2 _$ i- A& P) O
10.   {, Z* Y! Q0 Y2 j& ]
    
11.     Food[i].x = rand() % Wide_map;
    \" C  ^- ~, d, b
12.     Food[i].y = rand() % Hight_map;* ?2 K+ z/ r\" Y7 [1 P4 U2 K
    
13.     Food[i].r = rand() % 5 + 1;& d9 K+ c) D0 N% L+ I
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    - T5 D1 s) g$ n& h+ t
15.   }
    + Y4 ^0 U8 o. n
16.     //ai小球8 x2 s3 x9 g% ^1 P4 R5 ?) g
    
17.   for (int i = 0; i < Enemy_num; i++)& L; f- e* E0 G3 ^% n9 k
    
18.   {6 t8 r9 h/ }: ]
    
19.     Enemy[i].x = rand() % Wide_map;' P/ E% _2 T( v\" R- t& e\" t
    
20.     Enemy[i].y = rand() % Hight_map;
    $ D2 k5 x' p  H
21.     Enemy[i].r = 10;. I  {5 A5 ~$ v
    
22.     Enemy[i].color = RGB(0,255,0);
    ; Q' z  e, p9 M1 C- q
23.   }
    3 J\" n4 r' \: J  m
24. \" M9 U3 f( }5 h8 Y
    
25. }

复制代码

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

1. void Player_move()8 J! \0 O$ {8 G8 M0 \7 i
   
2. {  w7 m% c5 Q  \. S8 y. F1 ?! n
   
3.   if (GetAsyncKeyState(VK_UP))5 N& o' ?+ v) a# T+ N; @
   
4.   {
   : D5 }3 T% T+ `
5.     if (player.y > 0)
   & ~\" R) \9 S3 W# X9 E2 p1 b8 C
6.     {
   : c/ P+ _( v. u% |$ g+ \4 m
7.       player.y -= player_sleep;
     u, D( e9 _( k0 Z\" `
8.     }
   / ?% W* a* S9 X$ O9 m
9.   }  z! _+ Y: j% K  ~' X
   
10.   if (GetAsyncKeyState(VK_DOWN))
    5 N* y1 l% V8 X. e0 s& Z+ T
11.   {+ a) W, }7 r; {& U9 j
    
12.     if (player.y < Hight_map)\" x: a+ Z* w; K+ `) c. U
    
13.     player.y += player_sleep;6 f, I: E& l6 |0 n
    
14.   }
    + K- T7 T' ]8 p- v  Y  G
15.   if (GetAsyncKeyState(VK_LEFT)). @: |0 O0 J' A- G- x) u3 H# U; }
    
16.   {\" k\" y\" t, f9 m* o3 [, z  L) R
    
17.     if (player.x > 0)
    4 {' o\" l- j) m+ U/ V' V\" q/ p# F) C
18.     player.x -= player_sleep;
    6 k) ]0 {  O  W. }
19.   }
    5 F/ e8 h2 t7 Q4 s& I, N1 X, A
20.   if (GetAsyncKeyState(VK_RIGHT))
    \" \3 c( [) {# s: y7 L
21.   {9 g( j. l9 g3 r1 l7 Q. f+ ~; R
    
22.     if (player.x < Wide_map)
    ; H! j# y4 R\" \' K/ w. [9 Y
23.     player.x += player_sleep;2 {1 p7 k- A/ V9 P' F2 u$ j2 j) j
    
24.   }4 Y' P% R) }( C- a% t
    
25.   if (GetAsyncKeyState(0x20))3 @3 B8 x5 A; v
    
26.   {/ m, L9 E7 I3 d3 x
    
27.     player_sleep = l + 5;8 F9 w# I3 _  P; s
    
28.   }
    4 \( ^( M' I% U\" ~- v( O6 P* j& ]
29.   else, j; m; `# f) Y. M
    
30.   {
    9 P2 R1 J8 U: p+ q' L
31.     player_sleep = l;8 ~' l8 U& F, f3 p( S\" n: G, h
    
32.   }; F3 p' z/ k9 i2 }/ g$ ?
    
33. }

复制代码

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

1. void Show()6 F5 v, J) H: }. W5 I, b
   
2. {* ~# F0 e) I: z4 w\" B* i% [
   
3.   % @. s0 X8 W( {* W
   
4.   //设置地图
   # v9 i; J& o* o2 ]! a
5.   SetWorkingImage(&map);
   8 d# I/ z) K\" z$ v: W/ n+ _, p5 H1 _
6.   //清屏
   * Z- o: ?: P3 Z  K. c- _* }9 ^
7.   cleardevice();* S4 P. Z& ]# R! O# }$ r
   
8.   //背景颜色) q, i# Z+ j$ \! a0 C0 d! T
   
9.   setbkcolor(WHITE);4 ~1 s: z+ p  z% n! x. |
   
10.   //划线颜色& {, A9 H, Y, a% J) k8 t, ^
    
11.   setlinecolor(RGB(230,231,239));
    5 j% f1 ]2 `9 D7 E5 |
12.   //划线
    ) r: N- p( N! W  F) w) c. _
13.   for (int i = 0; i < Wide_map; i += 10)/ N/ S$ w! d1 ]
    
14.   {
    4 I5 t: v\" I7 x6 O2 S, ~# y\" y
15.     line(i, 0, i, Hight_map);% X6 I) D9 e9 f1 Z/ O
    
16.   }* J4 [, T0 b2 B
    
17.   for (int i = 0; i < Hight_map; i += 10)) S. j. Q9 k# p6 T
    
18.   {
    & Y' q& F: ?6 X9 V
19.     line(0, i, Wide_map, i);
    . H, V% O3 c( W# W1 j/ i) z. t
20.   }
    5 @  C- w  c\" T& [
21.   //食物
    & H/ M\" y& k3 C+ M
22.   for (int i = 0; i < Food_num; i++): i  U5 K3 X  M1 o: u
    
23.   {
    , K& d; ~\" z. p+ A, y
24.     setfillcolor(Food[i].color);
    0 P7 s% K, u# \' y: j
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);% E: r# K7 M( s' H3 h! l5 T; d5 {5 `
    
26.   }2 i0 I1 n* B% d* {* V
    
27.   //敌人
    ) i$ `) F/ o6 e8 V
28.   for (int i = 0; i < Enemy_num; i++)( i/ s4 q: e2 F: s/ J9 {* A& r
    
29.   {
    & O. v! h0 d# d- `5 [7 v
30.     setfillcolor(Enemy[i].color);2 \2 q$ `  U+ q2 s
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    : x) A3 y) b( N. H8 Q
32.   }
    7 Z, G6 D9 A\" ?4 R
33.   //玩家+ U4 E$ Q* A% T
    
34.   setfillcolor(RED);
    \" c8 o\" z' ~/ V+ f# P, h3 a7 w
35.   solidcircle(player.x, player.y, player.r);
    0 U/ s! L: T/ p
36.   SetWorkingImage();
    \" b- m, P( Q5 k# U7 N\" e8 p\" |5 C
37. 
    : O. e/ n- p8 M6 t8 ]
38.   int x = player.x - (Wide / 2);* X: D% v, G5 h! v9 e: M
    
39.   int y = player.y - (Hight / 2);
    5 q7 K8 B! T1 D! R  J1 i
40.   //防止窗口越界% X6 O5 V4 W  p6 u4 b
    
41.   if (x < 0)& B: R; [6 U9 D8 r
    
42.   {6 R; T  I( ^! B! d0 l0 k8 M1 c
    
43.     x = 0;$ L3 K* q4 _6 A' }5 d
    
44.   }% d* @. g9 E) a; h6 o, e9 y+ V
    
45.   if (y < 0)
    ! q* F; i+ @) W# r9 z  {
46.   {
    # r$ |) d9 H/ ^. c1 ^, S, o
47.     y = 0;
    & C# ?0 ^\" R; a, n# }+ x
48.   }
    \" O: m/ n5 z5 i, e# r
49.   if (x > Wide_map - Wide)6 k* F# l\" R0 y% Z- Y* V
    
50.   {
    6 Z- Q, a$ O0 \. g: ^8 P; f! ?
51.     x = Wide_map - Wide;
      d( n9 {5 x! u
52.   }
    1 a* U% H3 ?\" E5 u& E
53.   if (y > Hight_map - Hight)
    8 m4 T! v' Q: u( p
54.   {1 l% }# [( r; w; x+ Y' C
    
55.     y = Hight_map - Hight;) }1 Q' d3 w' |/ y5 |
    
56.   }& P3 o  R2 u: P6 b; t/ B6 x* X
    
57.   //把map输出到窗口上
    ) f4 L& Z4 Z5 q  i
58.   putimage(0, 0, Wide, Hight, &map, x, y);$ w\" E9 k: @) B% i0 o
    
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. //防止窗口越界
   \" x) h3 L# |+ |
2. if (x < 0)! {1 I) a0 `5 T% P  g0 [- f
   
3. {
   . K\" @5 s% A; W* \) d0 w0 |
4.   x = 0;( H2 ]. i5 ]1 B5 O
   
5. }
   & Q  ]0 J  K7 T! ~7 v5 w6 Q
6. if (y < 0), h3 N6 B2 l& c& @$ f$ {% [9 y
   
7. {, K7 v7 P8 o. o- Q6 ?4 c
   
8.   y = 0;1 ~0 Z0 [' P( S
   
9. }
   1 x2 C) m- K5 K/ o1 Y
10. if (x > Wide_map - Wide)
    ) X) `0 ?1 H' d' s
11. {7 ?, [& r* ^6 w4 m
    
12.   x = Wide_map - Wide;
    ! ]0 A( Z/ v; s  o
13. }
    3 Y2 U% q. i) V. y+ ?
14. if (y > Hight_map - Hight)# l& _2 P- @$ @. q. }4 y5 S
    
15. {
    \" v8 h0 g( Z; D2 u+ A- R' Y* g
16.   y = Hight_map - Hight;$ p% s7 U( l, g4 @
    
17. }

复制代码

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

. e% U& b( K( P( R, a5 b) q& ^(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

+ q" C  d( \* S5 iWide：这个参数指定了要绘制的图像的宽度。

8 z) m/ h8 A, O& [8 `) XHight：这个参数指定了要绘制的图像的高度。
; Q5 m$ G' X8 S1 u
* B: P" {. H, D' Z* R&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
9 T) V, P! L4 i" S4 [9 C0 {& W+ F, g. {
/ m$ f4 Z9 J4 F& M# Y. [$ Xy：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
( g4 R7 G5 l- K6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   ; @5 w% ^& [* U+ U\" b
2. int Distance(int x, int y, int x1, int y1)# s# M8 I( C' m* N' p! D; ~& ~
   
3. {
   $ p4 H7 }# F% `& \% |3 p; {1 H6 j
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   % D8 N% i7 s9 W
5. }

复制代码

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

1. void Enemy_move(), E, G) f  k4 T7 w( j; d6 z! V# j! ^
   
2. {
   3 t( k6 T, R! {
3.   srand((unsigned)time(NULL));
   : v) ~/ R' ]. Z1 y
4.   for (int i = 0; i < Enemy_num; i++)' [- k, T* @4 H; ^7 W
   
5.   {+ r! n# |& U\" f' |1 L
   
6.     int direction = rand() % 4;% j9 N6 r7 D* D& y' U2 g9 T6 ?
   
7. 
   3 U6 i+ p) P  I) g
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   ' m5 K  s* F. V1 ]  D8 c9 ?
9.     {
   / n4 n, {1 t4 i. U
10.       if (direction == 0)% p1 ~' }  m5 [* H
    
11.       {% {# ?3 j2 i, x  d! X  J6 y
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    ' K( H% M6 ]( T) L' e: z* N4 M
13.         {' T- G\" e\" h0 p, j& D( ^
    
14.           Enemy[i].y -= enemy_sleep;
      V+ R, H. r1 O: m1 J+ ]' p
15.         }
    - g3 i8 S5 Q: s7 e5 K
16.       }
    % g. D\" n+ g6 ?. _* Y/ d
17.       if (direction == 1)+ Y9 q/ @* x  J  S3 j
    
18.       {
    \" O\" d4 r- P8 o; K6 l+ Y; k& @3 E  l  G
19.         if (Enemy[i].y < Hight_map)# G2 ]  Q: B2 `7 g' U- k
    
20.           Enemy[i].y += enemy_sleep;
    ! }- `$ k7 V* d7 ]/ V( _- \) P
21.       }& `  U0 y: M) Z' J! x
    
22.       if (direction == 2)4 I) y. a! P: d; W* d
    
23.       {
    . J; G3 X7 D9 u1 G5 H/ A4 E
24.         if (Enemy[i].x > 0)# ?! u7 i/ \1 O  C2 G5 ]2 o
    
25.           Enemy[i].x -= enemy_sleep;
    4 X6 g$ e; ^7 {; U
26.       }
    ; I( I' y5 c. @( k\" r5 W
27.       if (direction == 3)7 C% p. x7 n% }( M7 N0 V\" u7 L, w
    
28.       {8 g3 f6 K* C0 m, s) d8 ]
    
29.         if (Enemy[i].x < Wide_map)
    ; ?5 E  o, n& u. }\" l
30.           Enemy[i].x += enemy_sleep;
      m7 u: p0 h/ \5 G- T4 b7 [
31.       }
    ; [# q7 \\" K8 d4 U
32.     }
      S# X1 O3 B6 y' k- _
33.     //敌人追击玩家
      m( }2 X% |, T7 j% }! v
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    , h8 a  C  z% _; e# {
35.     {
    - @! U% U# E, f) x  R( G; e
36.       if (Enemy[i].r > player.r)
    ( B. x+ v/ L& b7 y) l$ e
37.       {4 k% l( x! T1 P: Z7 }$ o+ F
    
38.         if (Enemy[i].x < player.x)/ i: |! b5 b* \7 {) M
    
39.         {
    ) b( Z; f1 z7 k  b
40.           if (Enemy[i].x < Wide_map): x/ K1 H! N1 T- K/ @1 s
    
41.           {
    6 p8 ~$ `) I* H  v
42.             Enemy[i].x += enemy_sleep;
    2 d# y! r7 V. E4 N
43.           }
    6 x/ f/ G- O0 }$ u3 P
44.         }
    ( @) p% N6 r% m( C& R
45.         if (Enemy[i].x > player.x)
    % ^6 K8 Q: Z* o/ G7 y. E0 o
46.         {& w7 d7 ~' m, V: F7 z% g# Y
    
47.           if (Enemy[i].x > 0)
    - Y! R1 l3 M1 y9 c2 q/ I# `/ I1 n5 ~0 M
48.           {
    $ Y1 Y+ p2 m* j) `# l0 k' |+ C
49.             Enemy[i].x -= enemy_sleep;
    ! P) j  {) o) \
50.           }
    * J+ h1 A+ v1 q) r. c  K2 k- W& \
51.         }, |$ w0 E  X- P2 q
    
52.         if (Enemy[i].y < player.y)
    * R5 `\" q2 \; U
53.         {
    ! {5 p5 [2 [# R! e) ~
54.           if (Enemy[i].y < Hight_map)) i. t* m* W; W. [, k
    
55.           {3 H# U( m# s8 i5 L# m. L
    
56.             Enemy[i].y += enemy_sleep;
    3 U0 Q& o3 ^6 j* f' e
57.           }
    # T  i: B( d4 \7 R$ {+ X4 \+ w# @
58.         }
    7 a; I' `\" S5 w/ t
59.         if (Enemy[i].y > player.y)
    \" Q7 j1 T8 G5 n* r; j9 {  P) M
60.         {
    9 m) _4 s# F, h\" J3 k8 i4 F: s\" W
61.           if (Enemy[i].y > 0)
    1 c4 ?3 v- s, ]( `8 \9 j3 @
62.           {
    ! C* l+ }+ t% y5 n: i\" v: x
63.             Enemy[i].y -= enemy_sleep;
    \" }; Y2 K: W' y0 p
64.           }, s$ ~0 W( I) j$ N
    
65.         }- P$ D+ o4 C; B* y4 x
    
66.       }
    % v& {3 Z2 x1 B
67.       //敌人逃跑& L# V( X2 J2 E+ {  W) l; N
    
68.       else
    5 D1 _3 V\" @% {5 i/ Y3 \8 n
69.       {: {  U4 w' m- [/ ?$ G
    
70.         if (Enemy[i].x < player.x)4 O  h0 Q. A+ D( d6 p9 ^# e
    
71.         {
    + j: ^+ C) Y6 D  b, U0 c
72.           if (Enemy[i].x > 0)/ v1 S! X8 ]$ c
    
73.           {
    : Y0 d  m, I) k# Y) B. {- o
74.             Enemy[i].x -= enemy_sleep;9 o' _2 N1 L\" |. V0 a5 l
    
75.           }
    2 ?# ~3 q  g1 I
76.         }
    9 ~0 y. t& S, Y
77.         if (Enemy[i].x > player.x)4 u3 R$ h. s- O7 J: t
    
78.         {
    3 ]# j3 g# n6 J- h: l2 ]+ Z+ h
79.           if (Enemy[i].x < Wide_map)
      R& N0 V# T! q\" e$ c9 s/ K
80.           {
    7 v* u\" S, w& J4 z# d
81.             Enemy[i].x += enemy_sleep;: u8 I\" s1 O\" x) v, P
    
82.           }+ J4 D' u: T' t  v( s
    
83.         }0 O9 ^0 F: d\" c* M9 K
    
84.         if (Enemy[i].y < player.y)4 g( B5 u4 B/ D. g6 e
    
85.         {' Q. ^- I7 {- W% a) k
    
86.           if (Enemy[i].y > 0)
    ; Q* L: x* p# V8 Z
87.           {/ ~\" m) Y' r4 s3 y
    
88.             Enemy[i].y -= enemy_sleep;
    / P, x\" b' O- l, [' J) q# S
89.           }4 O9 i6 i+ c) \, v8 u& Q
    
90.         }  }4 s  m+ e1 o\" Y$ {0 h9 h
    
91.         if (Enemy[i].y > player.y)7 y( U% ~* ]) X. t
    
92.         {/ t( Q5 Y6 s; b* Y
    
93.           if (Enemy[i].y < Hight_map)
    : I. }! s4 b/ p6 d$ }' F6 B; X
94.           {9 m2 _, j2 I( @, `: u! r
    
95.             Enemy[i].y += enemy_sleep;
    * h2 [3 p  |* T\" Q% \, `
96.           }
    # y- _5 v6 L4 E1 ]9 P
97.         }- Z% z& k8 ]% L  r( L8 O- X9 L8 D
    
98.       }
    6 i. C+ u7 X' ?; K6 V
99.     }* X/ C( G; e$ w9 i: T( H9 Z
    
100.   }/ j/ X3 _- p2 j) m\" P
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   , p  M\" t1 ~% Y$ c; w; _  Q7 S% ]3 ~
2. {
   * v5 Q* d; G0 T5 I( U5 e
3.   for (int i = 0; i < Food_num; i++)
   2 E( F1 u2 O& r- u( K; ^/ Q
4.   {- k- [\" c- H# k  m. B
   
5.     //玩家吃食物. o7 L) E- ^! p. O6 o' X' p
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   8 s4 @0 J+ Y' O' N
7.     {$ X3 W, f+ U& T% s6 _2 \* z\" w
   
8.       player.r += Food[i].r / 100;
   4 ^# G- L( A) N2 z$ C1 {4 ^: o; O
9.       Food[i].x = rand() % Wide_map;2 \9 A* ^% s7 s
   
10.       Food[i].y = rand() % Hight_map;- G  @( g/ m3 X
    
11.       Food[i].r = rand() % 5 + 1;
    7 }2 h- k7 e3 |/ g7 _
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);8 U5 d  v' @* h0 }! C* U( j
    
13.     }* u- J\" Q/ Q- h, T! @8 s# F1 r7 l
    
14.     $ s7 G3 g8 O3 \- |2 T) g( g, d
    
15.   }
    7 W9 f& L6 n3 r* T
16.   for (int j = 0; j < Enemy_num; j++)+ \8 q\" s; `5 L6 G1 F
    
17.   {
      q/ |1 x\" [' p. ?
18.     //敌人吃食物
    2 ?- W\" T: {# D7 y5 M- J8 U. f* |
19.     for (int i = 0; i < Food_num; i++)
    + Z\" r# M5 j\" o0 R3 `9 X
20.     {
    ( x6 x7 o! i* i/ A. x# o- v
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r). g9 H$ l/ Q; l5 w- c) N
    
22.       {. f, l& h7 @+ \# m
    
23.         Enemy[j].r += Food[i].r / 50;
    ) }' G! Y3 C) J3 K; i: V7 ?& Q+ N: u
24.         Food[i].x = rand() % Wide_map;. R  g4 ?$ w7 f  W
    
25.         Food[i].y = rand() % Hight_map;) V8 b0 ]6 }- z, E0 s
    
26.         Food[i].r = rand() % 5 + 1;
    * a, S/ B! {( G2 l: I3 s: [; h2 \! L
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    - k+ i9 D( @* x6 O2 k9 V6 s- k& a
28.       }
    , T\" s5 R9 b; \+ h; g. A
29.     }
    # c0 i3 U' {) n( e7 w
30.     //敌人吃敌人! S+ n( L+ r  y
    
31.     for (int i = 0; i < Enemy_num; i++)' Y$ E  l; J4 q; t\" m0 R/ _: T
    
32.     {
    . L/ u: v& g+ x1 v
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)6 Z9 J4 F1 f5 f  b
    
34.       {
    * c6 x2 i6 Q! o, p4 k% ~
35.         Enemy[j].r += Enemy[i].r / 10;
    , N. k4 W- k! F* g% r9 K
36.         Enemy[i].x = rand() % Wide_map;
    & v5 e4 T4 ]/ I7 g
37.         Enemy[i].y = rand() % Hight_map;* N( Z\" b  L6 ^5 y
    
38.         Enemy[i].r = 10;
    7 d+ m4 T( ]4 I2 {\" r7 X% F/ A
39.           Enemy[i].color = RGB(0, 255, 0);+ O$ Z( l8 }. |) ?
    
40.       }' u5 H9 g2 d% Y9 m4 p# j( v, f4 @\" F+ D
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)% W) W7 }# L8 P
    
42.       {
    . ]9 F1 o1 T1 H7 P, l
43.         Enemy[i].r += Enemy[j].r / 10;
    9 }, }! y\" Z# N0 D, C+ D$ o
44.         Enemy[j].x = rand() % Wide_map;1 S( p& C8 L4 X# x2 B- r% [
    
45.         Enemy[j].y = rand() % Hight_map;
    & F; l* l/ m3 q1 ~2 y
46.         Enemy[j].r = 10;' c* P- E' Q) P9 J6 ?' F, i4 E
    
47.         Enemy[j].color = RGB(0, 255, 0);3 D; {5 T% ]/ B) o0 p
    
48.       }
    / m  v, C  H( c+ P- d
49.     }
    8 R3 h1 V$ B4 O, V) j; E; q
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)\" i  v7 `: r$ Q/ E+ G# I- }7 D
    
51.     {
    7 E# ~( L* z7 p# t7 ~! K
52.       //玩家吃敌人
    ) u( O3 l7 W* X; B2 n7 N$ d; |
53.       if (player.r > Enemy[j].r)3 `$ N, c\" N& z; c
    
54.       {( k/ \7 w8 B. y  u0 C8 k1 T
    
55.         player.r += Enemy[j].r / 10;! R% u3 r3 |' g
    
56.         Enemy[j].x = rand() % Wide_map;; m\" \3 {. P1 i5 U. x0 p, ~* H
    
57.         Enemy[j].y = rand() % Hight_map;6 G/ U! ?( a; y: f% N* d0 p7 |
    
58.         Enemy[j].r = 10;: T: h  v7 r7 C: r& O
    
59.         Enemy[j].color = RGB(0, 255, 0);
    + Z* ~( H) z1 |' f$ T1 @  Q4 i
60.       }- v5 s. |6 @( }. }/ ]: b/ V) d: ^
    
61.       //敌人吃玩家! K8 c. H- E3 A) p8 o
    
62.       else  G( [' Q+ y0 J5 H7 @
    
63.       {
    1 m  B# _3 m$ n- e6 e\" ^
64.         if (invincibility == 0)
    / j\" p! Y; b6 s$ Z) l- O) ^
65.         {\" j. G9 T3 r$ G+ t- @6 j! l
    
66.           Enemy[j].r += player.r / 10;
    ; ]1 q' u  I$ }! S# W; l2 T# [4 K
67.           player.x = Wide / 2;! }) Z8 ]: v, p) i7 Q. V1 P& B
    
68.           player.y = Hight / 2;2 m+ b- N. V* W  Q: t
    
69.           player.r = 10;
    , p4 D* G+ u& ~/ \7 W4 ?8 j' G
70.           invincibility = 10;* y! b6 _& r! G- ~
    
71.         }* d& H' {) L9 g% g
    
72.       }2 ?' Z& Z* k& R* Z  K
    
73.     }0 N1 o) V( n+ K+ ], B9 ^2 f
    
74.   }4 a& h2 N0 o& q$ j. `1 l- B
    
75. }

复制代码

完整代码见附件：


7 t3 q. |% E1 ]$ @8 c/ D