球球大作战

2744557306

这款简易版的球球大作战是一款单人游戏，玩家需要控制一个小球在地图上移动，吞噬其他小球来增大自己的体积。本游戏使用C语言和easyx图形库编写，旨在帮助初学者了解游戏开发的基本概念和技巧。
# l5 D* Z1 `3 x
在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：
( {3 ^; O8 G+ |( w
游戏界面：游戏界面是一个矩形区域，玩家可以在这个区域内控制球的移动。

玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
2 Q8 }/ y" l4 L. M- t- K4 B8 \
其他小球：其他小球又分为食物小球，和ai控制的小球

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

玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。

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

接下来，我们将通过以下几个步骤来实现这个游戏：
) W/ c: O7 m9 B3 ~3 D  M
初始化游戏界面和小球的信息。
6 i* ^0 n6 O, c$ [$ K  ~( E# a
. A. K6 I/ z$ K6 \3 S处理键盘输入，实现玩家小球的移动和加速。
6 J0 x" ?0 x$ Y/ L5 F9 K- ^. ~
5 N( w9 F9 S' k, S  q+ u2 P1 X生成足够数量的食物小球。

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

检测小球之间的吞噬关系，增加相应的体积。
: k- q& H2 ^) y7 n
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。

1. 小球的要素
/ l8 }- v/ J0 k3 T- v2 z在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

struct Ball
. n3 y+ C4 l' o1 f& T0 Y- A{
        int x;
        int y;
        float r;
        DWORD color;
7 o3 g  A7 u% A$ P% p};
2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

9 n- b0 ?3 T2 s6 k3 D! H2 B4 H4 U! nRGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
5 t  ^7 |* D7 v$ `# @$ m. }# K
橙色可以通过RGB值（255, 128, 0）来表示。
黄色的RGB值为（255, 255, 0）。
" F( c- J" A' T5 i绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()1 \4 f& Q! P9 G+ A5 A2 W9 g
   
2. {, x8 H! |  U, A/ E# r
   
3.     //玩家小球* X+ |9 F/ T; z0 L$ p* _5 O) r3 O  N1 v
   
4.   srand((unsigned)time(NULL));
   5 b4 q2 v, v+ P  d
5.   player.x = Wide / 2;
   ! x' O\" I' V/ }! W, ~& c* ?  a
6.   player.y = Hight / 2;: ]: S3 ?( o1 K+ g/ H
   
7.   player.r = 10;; j; k' i# T: |, J7 J% |/ S
   
8.     //食物小球
   . X8 \4 H, u3 Z/ {/ x6 q( H& c' L
9.   for (int i = 0; i < Food_num; i++)6 `9 l1 r5 ^: V$ ^, y. q. R( c+ W
   
10.   {* F6 j; G% J5 E# o- J& B
    
11.     Food[i].x = rand() % Wide_map;
    * m% Y  U6 h7 w% s/ ^  A
12.     Food[i].y = rand() % Hight_map;1 ]+ E/ z  a0 |  ^8 e
    
13.     Food[i].r = rand() % 5 + 1;
    % k/ q. e9 ^  c
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    1 h$ {2 G  d, x# s. L+ r3 ^
15.   }) w3 y* A0 o! B( \) }  N
    
16.     //ai小球
    5 N1 S$ k7 g7 u* o. U
17.   for (int i = 0; i < Enemy_num; i++); K9 G* F  Y  }
    
18.   {2 M5 ^$ @( X/ K8 _$ j
    
19.     Enemy[i].x = rand() % Wide_map;& I) g8 N& [) G
    
20.     Enemy[i].y = rand() % Hight_map;0 \* A1 E9 q' i
    
21.     Enemy[i].r = 10;$ L( J; r% c2 X) ~9 m% A
    
22.     Enemy[i].color = RGB(0,255,0);! j% G' U! m  z5 L
    
23.   }/ E\" G/ D\" C3 B) }: h9 e
    
24. 6 a. i9 p$ y+ y, }7 U
    
25. }

复制代码

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

1. void Player_move()
   8 a6 f; I% k; q; k+ a- E6 Z: t
2. {( G9 ~$ A) V* G7 L
   
3.   if (GetAsyncKeyState(VK_UP))/ W0 Z1 G6 ~% j6 X
   
4.   {* J$ Y* [\" V1 b) N: }
   
5.     if (player.y > 0)% W% H( F/ `/ V! l
   
6.     {* p3 U0 e# U  F9 \- f& Y
   
7.       player.y -= player_sleep;1 P' ?% o. |9 P+ N
   
8.     }' V/ d& N& O, A5 Z( w& V( a0 P
   
9.   }
   6 V: n) Z0 ^  j
10.   if (GetAsyncKeyState(VK_DOWN))5 i& U$ c: u$ t, m* A3 r3 p
    
11.   {
    1 V4 |: E& Z8 Z- J
12.     if (player.y < Hight_map)
    ! R* d5 y* t) s( W& y8 J! {
13.     player.y += player_sleep;
    9 p/ g# {1 v9 ~3 C# ?' V
14.   }
    ( k+ x, \1 x7 p: w) t
15.   if (GetAsyncKeyState(VK_LEFT))
    : \* m$ J, O0 e1 F
16.   {
    ; ]5 I- g9 U# W: }2 X
17.     if (player.x > 0)
    * C/ y9 L! F* U
18.     player.x -= player_sleep;\" h* @3 [9 a# i( v
    
19.   }
    ) b: N4 v, S. y6 x$ l  j2 O
20.   if (GetAsyncKeyState(VK_RIGHT))
    . A% b5 b$ G- ?- N& Y- o2 T5 h$ f
21.   {5 u- W& x. V6 y2 H$ s
    
22.     if (player.x < Wide_map)9 m' d! L' y& x# s  T4 c, r
    
23.     player.x += player_sleep;! P% F9 x6 U& b+ f\" r) r9 C$ M0 |0 T
    
24.   }
    ' @: R: G# U9 G9 \  w! i! Z
25.   if (GetAsyncKeyState(0x20))) H% F0 N+ k5 u5 {7 w
    
26.   {
    / f: I! N% v\" N
27.     player_sleep = l + 5;# ]% n' {) ~  w3 G
    
28.   }
    2 Y6 l( L% b4 J6 [% S! D' X
29.   else) ?9 Q' O  k1 e  ]7 i
    
30.   {* y% o* m9 c1 {. m
    
31.     player_sleep = l;
    * q5 E+ U% F9 m5 `3 ^) p\" Q2 q
32.   }
    & X$ l4 S) w& S1 S: \
33. }

复制代码

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

1. void Show(), ^0 V. _1 k5 \5 S+ a2 w5 A3 h
   
2. {
   4 C3 d- x$ p2 p6 S/ t4 }3 i# r\" g/ \
3.   9 v9 l* p$ Z3 o( T& a& Z\" g
   
4.   //设置地图
   / s$ O$ V( k5 {' C
5.   SetWorkingImage(&map);6 \4 g: d' B9 h( N* F0 o& `  n1 }6 C
   
6.   //清屏
   6 V9 c* m1 [) N* b* M  @$ r
7.   cleardevice();4 R% p% [\" T- D3 `
   
8.   //背景颜色. L  g* ~1 k1 r! s5 q
   
9.   setbkcolor(WHITE);
   ; t\" j3 @- ?0 w9 N5 f! q  P
10.   //划线颜色
    / F! _( B2 p8 m! ]- z% E# M  C
11.   setlinecolor(RGB(230,231,239));
    1 p) A% r$ D5 P% j
12.   //划线  E, H\" Q2 }( G/ ^+ H$ N  t: i, S
    
13.   for (int i = 0; i < Wide_map; i += 10)/ o* F, V/ J' v\" t  R
    
14.   {% o; ^$ l$ k, N+ X: E/ w
    
15.     line(i, 0, i, Hight_map);
    3 K7 C! k/ i' @' G6 F) U
16.   }
    9 V: z+ }  u6 u3 j$ k\" n
17.   for (int i = 0; i < Hight_map; i += 10)
    ( [- H0 z. E% t\" u7 G/ J% a  _
18.   {, v6 b$ U) h5 B) B' ?8 d  Y
    
19.     line(0, i, Wide_map, i);2 a  d/ d3 N\" ^/ Z( i8 m
    
20.   }4 Q5 A8 r. H+ G% Q7 y1 w
    
21.   //食物, T* f1 z) V0 f% A
    
22.   for (int i = 0; i < Food_num; i++)
    0 m- R5 ^8 v# w# c! S, Z! n8 s
23.   {; I5 N* S) A/ Z0 \3 Z7 t& c1 R
    
24.     setfillcolor(Food[i].color);6 S. _0 s% r9 K( t% ?* m. z: e: F
    
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    ; {- Q/ S8 t5 Z: C: L# r! g
26.   }
    % u3 W  P0 d# {$ S8 d4 n, J; j
27.   //敌人: p: f: m- [9 I; X: B* B$ ]( C
    
28.   for (int i = 0; i < Enemy_num; i++)& d- }% V\" b3 J4 t
    
29.   {* V* ?1 Z) P5 w
    
30.     setfillcolor(Enemy[i].color);4 h) ~! O# N' v! m5 y$ B
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);' e. x& e* b  I8 _
    
32.   }
    & l& s/ E9 n) N. \: k
33.   //玩家
    8 s4 B/ I6 x7 i9 t  |
34.   setfillcolor(RED);4 i9 G8 U- v5 N8 x! Q
    
35.   solidcircle(player.x, player.y, player.r);
    & ]0 A+ e% M5 @( W& s9 V5 l; g0 U
36.   SetWorkingImage();1 w; {2 z8 L6 m
    
37. 
    8 L/ q1 k1 d- C% t) G
38.   int x = player.x - (Wide / 2);
    0 L: g( X$ K% g: {* @) G1 e
39.   int y = player.y - (Hight / 2);
    9 E# z- N+ P/ r% G
40.   //防止窗口越界, x+ |. ?4 H8 M( I* O
    
41.   if (x < 0)# P+ M$ x! p\" b0 k
    
42.   {
      B$ `$ e8 \+ v/ s: l3 _$ U
43.     x = 0;
    0 g1 V) r  ^9 |\" \* c8 x; Q
44.   }5 b\" J- a# o% ], a  k, l\" Q4 r
    
45.   if (y < 0)
    3 |& v2 m6 m6 @\" x
46.   {
    # f7 x# k8 W9 K
47.     y = 0;- o# ^1 w; @3 f% j/ o
    
48.   }* x+ T\" B# z) ]/ o6 P
    
49.   if (x > Wide_map - Wide)\" D3 b/ z6 W8 e3 a7 |
    
50.   {
    4 D$ K; O5 \, V5 b; j
51.     x = Wide_map - Wide;' P! p3 N7 T+ s) \, j% u  ^4 u$ T
    
52.   }; K0 _\" b! A$ G5 N% n+ g1 R
    
53.   if (y > Hight_map - Hight)
    3 Y+ V2 k& u$ F  K* v
54.   {# e4 q9 l2 b8 ~) k8 K
    
55.     y = Hight_map - Hight;
    * l3 w# {  @\" v0 d2 f  a
56.   }6 b- J) Z\" m- T6 u
    
57.   //把map输出到窗口上! d/ _' O% l) T; e, t
    
58.   putimage(0, 0, Wide, Hight, &map, x, y);
    \" B/ s5 r# V* N- F. Y5 h
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. //防止窗口越界
   4 F* b4 B( L. y# S7 M! x
2. if (x < 0)
   8 ^3 I  Q2 E  O
3. {6 y; H# ^' N9 ]2 Z! X
   
4.   x = 0;4 K9 s$ S' m' c
   
5. }
   % E# D* d3 {4 D6 Y: r1 Y: L+ X! L
6. if (y < 0)
   ; @2 B8 i4 i5 I3 f, f* c
7. {
   : R3 Z) w6 u$ `7 i: z) V
8.   y = 0;
   8 p# r5 H$ y2 R. e7 [; ^, |' d) Y
9. }
   7 v1 p/ z% i2 L8 @) G
10. if (x > Wide_map - Wide)& s$ p  h\" _( {. L  h
    
11. {. k: q; e  H9 T: t: w
    
12.   x = Wide_map - Wide;5 r* O4 k' D, E* P5 c& D3 ]( H
    
13. }
    ' Q# _% _- h# V8 T% W) J
14. if (y > Hight_map - Hight)
    2 `& V0 w; D7 y
15. {
    : k$ F4 [\" G9 k/ Y7 ]
16.   y = Hight_map - Hight;' v! S! T+ D, \* V  @3 g\" `& k6 L1 w
    
17. }

复制代码

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

(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。
4 Q; x% j+ _. _% C3 [
. W0 x! y1 J6 T# C0 {! BWide：这个参数指定了要绘制的图像的宽度。

Hight：这个参数指定了要绘制的图像的高度。
2 v, V( s% }" ^. \2 ?& U
3 g% Y  G1 d5 \+ J7 Z, T. r/ U&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。
0 G& o4 L1 ^4 T* j- l
( C0 Z* ?: E+ X6 |4 u' q. B* Zx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。
0 V& \0 H/ u9 I5 m& x+ l! F
y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。
6. ai小球的移动
随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是<math.h>。

1. //距离
   9 j: w- V* P8 ^$ N
2. int Distance(int x, int y, int x1, int y1)
   / M$ a5 ~  k1 R6 J) ?9 B
3. {  H4 i- Q% W: @' s6 N1 ?4 B
   
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));6 O5 D6 @# f5 L7 t8 J2 q
   
5. }

复制代码

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

1. void Enemy_move()
   % E) Y) d\" n# z2 z) a
2. {* V2 B+ G* Y+ U- _3 p$ b' \2 M
   
3.   srand((unsigned)time(NULL));
   ( ?2 Z, L; z% @+ _( K* t
4.   for (int i = 0; i < Enemy_num; i++)& j9 c  z2 h/ Z
   
5.   {) w! Q- T7 r& z- b( a  i2 V
   
6.     int direction = rand() % 4;% _2 N, N8 H6 T& x
   
7. 
   6 B( b; S9 S! f% _  Z( }
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   1 o- t) _4 {6 t; f& L
9.     {! v! M\" }1 u. B3 H6 ~* Q/ p
   
10.       if (direction == 0)
    & [& p4 G9 j3 B! t6 X( Y
11.       {
      @, F( E2 j! I$ b+ K9 B7 ?( M
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句) R8 j) u, O/ K, h3 K. H' a
    
13.         {, w4 S! f. d$ b+ I1 ?, f
    
14.           Enemy[i].y -= enemy_sleep;7 \$ F& w# X) L. f
    
15.         }
    2 O' \/ o3 X% c+ \( }9 A) W* n
16.       }& m8 b7 n4 a2 @& V
    
17.       if (direction == 1)! e  m% B$ r! n; l+ ^
    
18.       {
    9 I$ ^! V2 w. z
19.         if (Enemy[i].y < Hight_map): B; x\" V1 i  A' O4 A3 R  q) w+ D
    
20.           Enemy[i].y += enemy_sleep;
    - {1 D) W8 b5 o9 w
21.       }, E! s- O1 D$ `! m: A$ @
    
22.       if (direction == 2)
    6 b; a: \& U$ B& Q5 l8 n
23.       {
    . ?, [1 f5 E. P( r7 P4 M
24.         if (Enemy[i].x > 0)
    0 s. r. A6 B# h. m: d' g' f
25.           Enemy[i].x -= enemy_sleep;& \5 l\" V, c4 I' N1 Q
    
26.       }
    $ c+ Z3 p. N& g5 Q. M
27.       if (direction == 3)- C) {, B+ Q, E: M& r- A# w
    
28.       {
    % b, q1 G6 l2 N2 O
29.         if (Enemy[i].x < Wide_map)% [0 d) c0 ?& o2 d\" Q$ L: Q
    
30.           Enemy[i].x += enemy_sleep;( o$ G- h. C+ O; ~4 d
    
31.       }
    $ w) a( t% s9 I8 {8 r5 j3 a4 M3 ^
32.     }' d5 a2 {0 l3 p1 `0 D2 @, X
    
33.     //敌人追击玩家
    + E: C7 e7 L5 z4 p/ o0 q8 t7 r+ }
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    9 v* W, r5 U3 V% o+ e
35.     {
    \" c( f( K5 V, i) Q% T$ v& W& v( B
36.       if (Enemy[i].r > player.r)
      Q9 D! m. m. k5 A$ k
37.       {
    4 n( G- }6 L( C/ m
38.         if (Enemy[i].x < player.x)2 E9 B+ m, q' j
    
39.         {
    $ M+ Z0 s- i7 N; J$ r) ?- G
40.           if (Enemy[i].x < Wide_map)
    ( r; t7 F8 ?8 P9 D* i$ w
41.           {
    . ^2 m/ I2 U) N) x: g, U( O
42.             Enemy[i].x += enemy_sleep;
    - Q0 i) b, E# D5 v7 g* ?
43.           }
    \" Z8 C% Y2 z+ n$ p, ]
44.         }; `& S  r5 F. ~
    
45.         if (Enemy[i].x > player.x)4 F/ ^& M3 y% L& E! t$ X( Z2 Y
    
46.         {
    3 T2 c) h; z9 n5 b- }
47.           if (Enemy[i].x > 0)4 `# R8 y- X/ }+ _
    
48.           {
    2 v6 L7 R% C, O& w$ K$ l8 Q
49.             Enemy[i].x -= enemy_sleep;  w/ B; F( d$ K8 h2 |
    
50.           }  E: u+ \  p5 G0 g; j( ~
    
51.         }
    ( i, C\" N4 u; h1 H
52.         if (Enemy[i].y < player.y)
    0 t8 u1 ]* |2 f0 x6 y! C. V
53.         {% X1 @# x3 a  [9 N8 _& k: Y$ t
    
54.           if (Enemy[i].y < Hight_map)
    & h) D2 O; Z' ]0 E- C' |' g8 n& J
55.           {
    0 S0 h) R. D- q# h6 G4 Y
56.             Enemy[i].y += enemy_sleep;
    9 L, f; I4 p- j! A
57.           }3 [* K( ^) y; d( I  u$ Z* }0 C
    
58.         }
    ! K+ H, o8 Y, S! m7 {
59.         if (Enemy[i].y > player.y)
    7 {' q$ `% R( J# D6 ^- C$ @
60.         {1 {( J4 H7 u0 P& t2 R: ^( b7 Z& R
    
61.           if (Enemy[i].y > 0)2 s, Z, E/ }1 k7 y1 O
    
62.           {
    0 W9 z3 ^& l$ R/ W  J6 ~4 `
63.             Enemy[i].y -= enemy_sleep;
    \" G# L% N7 W& i) ^. q9 O3 ^. X
64.           }* H- F( `9 ?8 F2 E) r
    
65.         }/ w2 ?+ |9 s9 k- }
    
66.       }
    * g. ?- r+ b0 j. T
67.       //敌人逃跑
    ) j& w\" z& K7 e+ Y
68.       else
    , O: C3 F$ }& [) O
69.       {( c# p, K, L0 k6 O& ?0 Z
    
70.         if (Enemy[i].x < player.x)+ d/ A( ?) J; x
    
71.         {! v2 I5 {\" _2 b# z+ j4 S5 b/ s
    
72.           if (Enemy[i].x > 0)5 p: x; T) K% T
    
73.           {# J) n3 X; R\" P2 ^3 S7 Y/ U0 R
    
74.             Enemy[i].x -= enemy_sleep;$ w( i& E; N$ A' c\" N
    
75.           }  P  \- b, I4 `6 n1 ~- L* b
    
76.         }
    * z: G2 o. c. Y$ S
77.         if (Enemy[i].x > player.x)
    . \  W7 p- N7 l* c
78.         {9 `6 E6 }1 y& [8 W  ?5 |3 \5 e
    
79.           if (Enemy[i].x < Wide_map)
    * s\" `1 ~+ I% q0 K6 x0 B
80.           {
    % J4 C& \, j& X) c\" D/ ]\" ?, C
81.             Enemy[i].x += enemy_sleep;8 K) x. h; v* A5 k9 r0 h0 N
    
82.           }
    # h- E4 b% E2 k0 V; z$ Z
83.         }
    , f+ s% W) w% A; b: {# c\" G
84.         if (Enemy[i].y < player.y)
    ' t: m/ Q4 ]9 s) x
85.         {4 T2 G' P9 v\" E9 x) _1 _  r1 m0 `
    
86.           if (Enemy[i].y > 0)
    ) o/ p4 N8 ?2 G$ [& M6 E5 t
87.           {% v0 i; \; A, Q& w' g3 P
    
88.             Enemy[i].y -= enemy_sleep;! u! S/ R( K0 J  |7 J
    
89.           }
    7 f  u& S3 Y; K7 N  a3 k
90.         }
    / t0 l2 L: X' ~* n, G) }# h/ [
91.         if (Enemy[i].y > player.y)& R, a2 K  z  I% D: W1 L: }
    
92.         {6 E) t/ E, a- j% l
    
93.           if (Enemy[i].y < Hight_map)
    & t: p# e0 s. s8 a* b5 N& Y. f( Y
94.           {
    ( Y( n4 j1 k! g( |/ m+ _& M/ \: s; g
95.             Enemy[i].y += enemy_sleep;/ Q\" @( W) M: i  x
    
96.           }2 D, X+ j6 D1 c5 {
    
97.         }5 \9 d3 k5 L- B) \
    
98.       }
    ! y2 t% Q6 `3 Z1 p+ F$ R
99.     }
    ( t. x5 j4 b& E3 \0 `. z
100.   }
     * S  _2 |  o; M: W\" V0 N& |
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()
   , p- E& [, P$ Q7 L$ h- i
2. {  b6 W3 n+ A% {2 z$ e
   
3.   for (int i = 0; i < Food_num; i++)
   3 J5 V  Y  f+ N' Q9 T& ^+ R5 Q
4.   {
   2 J# P# ~6 |0 Y3 p0 g1 d4 r
5.     //玩家吃食物2 }& A, N' h; C6 t. @
   
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   ; J# w6 J# b! B3 x7 m8 A( Q
7.     {: Q# O: W. r1 F3 F! G) X0 E$ u% s
   
8.       player.r += Food[i].r / 100;
   6 B( [' N1 `, n# t* X. A+ _8 A
9.       Food[i].x = rand() % Wide_map;
   . v+ G8 [8 a7 u6 O; k
10.       Food[i].y = rand() % Hight_map;
    1 x4 ]9 S2 t' o/ l( g/ [
11.       Food[i].r = rand() % 5 + 1;
    2 H2 g6 u. k+ i6 E- T1 O
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);# M4 O5 o( v9 c$ E4 D' @
    
13.     }. g1 ?4 K+ V/ S9 m1 l3 x4 P
    
14.     $ e! I6 G. P8 _: I1 M6 E
    
15.   }
    6 E6 W0 A: K9 `' |$ u4 w
16.   for (int j = 0; j < Enemy_num; j++)
    & T' z) R, A' O2 W/ \
17.   {
    ( k5 U) x  r1 K* @) J. H4 U
18.     //敌人吃食物
    0 [/ p# B4 I5 i
19.     for (int i = 0; i < Food_num; i++)$ V6 j, O: l! H- g. r+ e. `
    
20.     {9 r# }% L0 v8 ]# W2 o/ |7 i
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r): \! A% L# M- S& T7 g
    
22.       {0 V7 o9 H7 I, ^
    
23.         Enemy[j].r += Food[i].r / 50;# |- I* ?* E# S4 r
    
24.         Food[i].x = rand() % Wide_map;# W\" v* {# e6 e3 k
    
25.         Food[i].y = rand() % Hight_map;
    $ T8 d& f, L0 {  b
26.         Food[i].r = rand() % 5 + 1;
    0 w\" q7 o, a( i3 n, t3 t
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);4 w9 Y# U# v7 z) k, O3 w\" I+ n
    
28.       }
    ) C9 o  T4 [# U0 T( Z8 X6 F
29.     }
    6 k$ |. n9 ^5 Z: }6 Q
30.     //敌人吃敌人% N  @4 u. g8 h3 G\" y1 [8 p
    
31.     for (int i = 0; i < Enemy_num; i++)- T4 g' Y9 B, j\" o, t  K
    
32.     {
    $ p: O* j, k8 L. [) \5 D
33.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    + ]- C0 ^5 z! j3 I3 T1 F/ b9 b
34.       {
    $ u* }: g+ X1 Q5 S: a% m& A8 Y
35.         Enemy[j].r += Enemy[i].r / 10;6 e7 g% [) ?, e6 L\" Z6 c
    
36.         Enemy[i].x = rand() % Wide_map;
    1 m; R* t0 z4 E* C* v
37.         Enemy[i].y = rand() % Hight_map;, x7 q( Q' b- o$ a
    
38.         Enemy[i].r = 10;9 o/ `: _( `5 E) n8 K- Y3 V& [
    
39.           Enemy[i].color = RGB(0, 255, 0);
    9 I  \\" J1 s\" G5 s5 `
40.       }6 J1 D/ F4 n( o- G' e( e
    
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    + Q% T8 z, _\" E
42.       {
    & Y) C7 W$ o1 D% U3 S1 }
43.         Enemy[i].r += Enemy[j].r / 10;3 b8 ]. e. H0 K/ i
    
44.         Enemy[j].x = rand() % Wide_map;
    9 G$ D; J. o2 H3 q% y2 P4 N* V
45.         Enemy[j].y = rand() % Hight_map;
    + d( F1 @* s4 x5 Y: V1 y$ z
46.         Enemy[j].r = 10;
    * v& i& ~\" o$ ]3 \' ^8 Y! I
47.         Enemy[j].color = RGB(0, 255, 0);
    ) Y0 K4 {( ^3 o. g
48.       }7 i. [: x8 R. H\" Y' c0 z; }
    
49.     }
      C( b9 x3 d% d7 g  G\" L+ [
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)* g/ \/ L0 X: V) h8 @
    
51.     {
    ! J  A8 Y\" t0 ~0 h* s0 u  v+ m
52.       //玩家吃敌人
    ' f$ @( }4 T1 V, |) i& Y\" c
53.       if (player.r > Enemy[j].r)9 Y* {  t9 O% W1 {  w
    
54.       {' R5 M( Q2 _# M3 \* Y7 L+ v5 U
    
55.         player.r += Enemy[j].r / 10;
    $ ~2 m0 v' I/ I4 p
56.         Enemy[j].x = rand() % Wide_map;
    - Y+ V8 x6 B& g; H# n# o* L
57.         Enemy[j].y = rand() % Hight_map;\" ]( `' m! c/ }+ f9 C
    
58.         Enemy[j].r = 10;9 P4 c1 f% x5 z+ v* j+ f
    
59.         Enemy[j].color = RGB(0, 255, 0);' p4 ?* g( D; f# o* ?' n
    
60.       }6 c) S) q% w3 u6 D: h
    
61.       //敌人吃玩家
    0 I) i& c- z& L/ ]; d
62.       else
    ' T/ v* w- }6 q( F' t0 _
63.       {7 ]\" g# D. _\" k4 Y5 P; Q3 r
    
64.         if (invincibility == 0). `3 t: m- M9 S5 W6 q
    
65.         {
    : z\" @8 ]- C2 d4 ^7 j, c$ e
66.           Enemy[j].r += player.r / 10;
    : A# l0 D7 R  l2 u( f- o* ^
67.           player.x = Wide / 2;
    8 @0 i( x$ e$ E- n9 G& r$ O+ S
68.           player.y = Hight / 2;+ L\" |8 t) P- `2 N( P4 R; e0 J
    
69.           player.r = 10;
    ( F3 I8 I& H! R& u* Q% \# I! f& A
70.           invincibility = 10;/ h1 C$ N& }; s: E8 A' f- H6 Q
    
71.         }4 B+ R1 g; h, m8 k  L, @\" j! z
    
72.       }
    8 o! F9 s- n. l; [( U! A\" @- R$ v
73.     }) O' B\" a( N- m+ a9 }
    
74.   }
    8 c+ o\" l' C9 F& j4 q
75. }

复制代码

完整代码见附件：


7 {9 ?; M; N# T& i- X4 y5 v+ z