球球大作战

2744557306

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

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

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

玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。
6 t  H# B( w3 r) s* t: ^
其他小球：其他小球又分为食物小球，和ai控制的小球
. R, v! Y; Z+ u0 ^1 o- ]
$ w* }: p  _& V' V; Q9 i体积：玩家每吃一个其他小球体积就会增大一点，ai小球也可以通过吃食物和玩家小球增大体积。
; w' p$ g" h; F6 s8 H4 j
玩家被吃：当玩家小球被ai小球吃了，玩家小球就会回到初始点，体积也会变成初始大小。
3 [) C, B  a3 Z) e
  U8 u2 h  @! K" `+ U1 A% D, bai小球的追击和逃跑：当玩家小球与ai小球靠近时，ai小球会根据自身体积的大小选择追击玩家小球或者逃跑。
+ |6 A. [* x! D& M0 f) D2 v
接下来，我们将通过以下几个步骤来实现这个游戏：
; M/ u, p. p- n1 ~
初始化游戏界面和小球的信息。

处理键盘输入，实现玩家小球的移动和加速。

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

. g) j* Y8 u6 m& J9 H' {1 J生成ai小球，并控制其移动。

. a( {& q  \- W6 c2 W; Q6 }检测小球之间的吞噬关系，增加相应的体积。
7 z! n( _* U5 V( j, @, T
通过学习这个游戏的开发过程，初学者将能够掌握C语言编程和easyx图形库的基本技巧。
# S0 a( }; Y# _+ [
1. 小球的要素
- G0 L# O- w5 l: A( \) T  @在此游戏中一个小球的要素无非就是小球所在的位置（坐标）、小球的半径、以及小球的颜色，这里我们可以用一个结构体数组来存放这些要素，以方便初始化小球的信息。

% O& V8 z/ q  ustruct Ball
8 M* T8 S7 f6 H+ S{
        int x;
        int y;
( m# O) q' t  p% x2 U% p        float r;
9 r  |# j2 F& D3 D6 B        DWORD color;
1 o" `4 ~2 X' P' D; O};
2 j3 b5 |- _6 n6 r& b6 ^, O7 y% C- o. s2. 初始化小球的信息
将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

RGB色彩模式是一种工业标准，它通过红（R）、绿（G）、蓝（B）三个颜色通道的组合来表示不同的颜色。每个通道通常分配一个0到255之间的数值，其中0表示该颜色通道没有亮度，255表示该颜色通道的最大亮度。通过调整这三个通道的值，可以生成几乎所有人类视觉系统能够感知的颜色。例如：
- R  \5 V0 N: ^+ E! u# @
0 |/ p2 u0 n# k3 f7 \橙色可以通过RGB值（255, 128, 0）来表示。
: E1 Y# A0 g  ?0 \4 o黄色的RGB值为（255, 255, 0）。
$ m- z( P% {* e绿色的RGB值是（0, 255, 0）。
蓝色的RGB值为（0, 0, 255）。
紫色可以通过RGB值（170, 0, 255）来表示。
黑色的RGB值为（0, 0, 0）。
白色的RGB值为（255, 255, 255）。
5 d# ]& G9 ]6 Z) t) k灰色的RGB值可以是（128, 128, 128），其中三个值相等即可，值越接近255，颜色就越接近白色，反之亦然。

1. void Inset()
   + c7 B% G1 o3 ?: L8 }9 W
2. {0 E; m8 e0 o# J6 ~\" G9 ^
   
3.     //玩家小球
   ; ]( F( M, P7 w1 n
4.   srand((unsigned)time(NULL));/ d( q: [$ ^% M3 H( ?% Z
   
5.   player.x = Wide / 2;
   7 f  t. F2 z2 \\" E: n
6.   player.y = Hight / 2;\" L( S' w\" m$ l
   
7.   player.r = 10;, J, \& d0 x( ^! y* }
   
8.     //食物小球2 K\" K\" h: A3 ^\" x5 }. \& x! I+ f
   
9.   for (int i = 0; i < Food_num; i++)
   ( S( d: p$ ^$ s1 @
10.   {( \) s4 ]1 G  U1 W& J0 Z$ Y1 p
    
11.     Food[i].x = rand() % Wide_map;, j5 \/ n( L5 u7 B+ v( V% s
    
12.     Food[i].y = rand() % Hight_map;
    ! _7 {& |$ z% |- @7 {, i* w/ j
13.     Food[i].r = rand() % 5 + 1;6 R3 V6 C# {0 B: C1 J8 Y
    
14.     Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    8 b- C9 W2 a' P' e1 h6 m1 L2 g\" P
15.   }
    + N% B; d# I; [  ^7 F
16.     //ai小球
    ' m. i; g+ B; n% V$ I4 Q
17.   for (int i = 0; i < Enemy_num; i++)
    6 ]3 ?- t  m- ~
18.   {- _\" _* z3 b+ M$ V0 I- x- Z2 T
    
19.     Enemy[i].x = rand() % Wide_map;
    ! y$ d4 p7 m/ F; u2 _# E
20.     Enemy[i].y = rand() % Hight_map;4 o1 W' }7 I  n4 s
    
21.     Enemy[i].r = 10;
    7 t/ ]/ ?3 e# n- W. P# E
22.     Enemy[i].color = RGB(0,255,0);2 X( J$ I, e) l2 }  D
    
23.   }\" n7 |! k, y# f  c\" Q7 [) j
    
24. . V# G1 s9 K, W, k3 m. r
    
25. }

复制代码

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

1. void Player_move()
   % W  P7 j/ ?$ q+ ~  l
2. {
   , C& w& H+ h7 P1 v\" D0 {
3.   if (GetAsyncKeyState(VK_UP))
   7 k1 k% D) F% V$ i7 H) X
4.   {
   7 v( S# Z' L+ ]9 {& b8 Q* b
5.     if (player.y > 0)
   . ]0 b+ R' p# k+ @
6.     {
   4 Z\" X, H' ^8 h- T, X: |/ r; H
7.       player.y -= player_sleep;
   - O# t6 q2 s  q- g, |  M# O
8.     }9 R* J, m1 E: N5 Z
   
9.   }
   1 l- e, c9 O7 z7 F& }; {3 t
10.   if (GetAsyncKeyState(VK_DOWN))
    $ n/ r* ?, z  N7 u( T
11.   {% n, T# B. m! h( u1 ~
    
12.     if (player.y < Hight_map)
    * G# U* x& c# N
13.     player.y += player_sleep;3 R7 d1 p1 u7 ^# }5 ?
    
14.   }
    , N# X7 O# W; M4 t5 A
15.   if (GetAsyncKeyState(VK_LEFT))' [4 b: K/ E* D: L1 c2 x6 e% S
    
16.   {
    ; i4 ~) a6 b2 u+ M4 T, r
17.     if (player.x > 0)% U/ X/ ]$ Y0 }) }0 L& E
    
18.     player.x -= player_sleep;
    : C# v3 S1 C; @2 b. N: N
19.   }+ Q' I% X9 `0 @
    
20.   if (GetAsyncKeyState(VK_RIGHT))! R, o. X. b; {5 N) s; h2 q9 }
    
21.   {* a! Q) x\" I2 z- q$ u0 p8 M
    
22.     if (player.x < Wide_map)
      o  m3 B# P: F3 M1 P
23.     player.x += player_sleep;6 j- q# t' C7 ]
    
24.   }
    3 Y  k- X/ G! B
25.   if (GetAsyncKeyState(0x20))\" c. H  W) a$ x6 e1 J  }+ ~. a  f
    
26.   {\" m  f8 t5 y7 W8 n& Q
    
27.     player_sleep = l + 5;1 |2 C: d  ], w! }; G
    
28.   }: M  X; }- A# E\" k$ }& }, h
    
29.   else
    0 v6 v\" t4 t, a9 r
30.   {
    , k/ Y# g; b( g1 v9 D\" g
31.     player_sleep = l;8 C) }( ^7 B\" @. U- w4 p8 K, Z( i; X
    
32.   }  ]9 t5 O: U+ \# T
    
33. }

复制代码

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

1. void Show(). L+ W9 q2 W! r3 Y% L\" C\" J8 S
   
2. {
     J: W8 o) ~/ U6 v- p4 o
3.   
   . y, w; D8 N- Q
4.   //设置地图
   % K0 o# }% E3 J# h7 b- y- a: r, B8 d
5.   SetWorkingImage(&map);
   + y0 `3 t\" d3 T, f, s
6.   //清屏
   0 v  U+ @( H+ I% v
7.   cleardevice();
   , v0 Z- M9 d# I. x
8.   //背景颜色% L! l  j  a* i7 V' Q4 u& T! w
   
9.   setbkcolor(WHITE);\" l+ @8 X8 w5 A8 V' A\" G
   
10.   //划线颜色
      i4 y\" c0 O; ~  q, |0 R0 k
11.   setlinecolor(RGB(230,231,239));0 p4 S$ t# V2 O+ s
    
12.   //划线6 g) J1 J. ]- C6 S; Q: Y3 q
    
13.   for (int i = 0; i < Wide_map; i += 10)\" `1 L% c7 g5 }* A8 o: D
    
14.   {; b9 b9 m& H6 q7 g* s3 q) `
    
15.     line(i, 0, i, Hight_map);
    2 e4 j' E+ p4 l7 z
16.   }
    ' k. F$ S5 `. h4 z\" L% o; Q0 k
17.   for (int i = 0; i < Hight_map; i += 10)
    \" B- n. Z0 X$ n$ A# F4 S4 P+ p
18.   {, J) Q. I0 i# u+ i3 `4 ]
    
19.     line(0, i, Wide_map, i);
    / w, |* u9 ~: f* R\" F5 Q
20.   }( P  }7 h, {4 E- P- w
    
21.   //食物- {; ^- d) i! {
    
22.   for (int i = 0; i < Food_num; i++)/ p; N) u) E( j3 M. h3 _
    
23.   {
    : B) e) w' F; I# E  O
24.     setfillcolor(Food[i].color);
    4 @/ J- r6 z# E# x2 i
25.     solidcircle(Food[i].x, Food[i].y, Food[i].r);
    3 u. z; D1 ?0 C0 N, x
26.   }
    8 w( `4 \8 B  i8 k, V6 H
27.   //敌人
    # L$ h6 w6 {) \+ q- j. Y  W# d
28.   for (int i = 0; i < Enemy_num; i++)( ?0 x& W0 F8 U1 m7 N* l5 w+ q8 u8 o
    
29.   {* r% y\" }9 _\" }  C2 N5 z  u7 D
    
30.     setfillcolor(Enemy[i].color);, T0 H: b; {5 h\" U( h
    
31.     solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    / F( J9 C, W\" P3 @
32.   }6 M  c% Q2 b, j. |9 T/ @. {6 s
    
33.   //玩家1 I; e$ T\" N4 a. d% S
    
34.   setfillcolor(RED);
    $ h! _6 r\" L( k. v# j
35.   solidcircle(player.x, player.y, player.r);# p) m: I0 ~/ I3 h
    
36.   SetWorkingImage();+ F6 Q' i$ u\" q& H
    
37. 
    . R' D. f6 n9 r  n8 `
38.   int x = player.x - (Wide / 2);) O- {1 |, P5 _/ v7 Z7 t' B
    
39.   int y = player.y - (Hight / 2);; _3 i, U4 {4 K) C* l$ \
    
40.   //防止窗口越界7 e+ P* }2 |$ D8 X4 @! R1 Q
    
41.   if (x < 0)
    4 E9 Z/ O4 I, |: M9 ~4 ^
42.   {
    - V, e$ N  W\" ]3 u! ^2 F
43.     x = 0;
      t0 o7 _# \9 O$ |
44.   }
    . \+ K7 a% z$ j; ^. ?
45.   if (y < 0)6 H\" d' R5 @7 c
    
46.   {3 I4 ?\" e* M  ]; ~
    
47.     y = 0;
    0 }4 H) h1 m4 R; f: X( z& K
48.   }
    ) `5 _' a, @& D* E
49.   if (x > Wide_map - Wide)5 P+ {6 q& a\" u
    
50.   {3 Z; N) l( K( z' Q! M* P% `+ C
    
51.     x = Wide_map - Wide;0 l\" t8 g\" Z3 a9 N\" d* C* ^
    
52.   }
    \" w& ]8 v  W; A\" T1 v4 ?
53.   if (y > Hight_map - Hight)  X' x  u( R* |  L  W2 R( e
    
54.   {/ [0 n0 ~2 H, G4 ], [7 P\" f! e
    
55.     y = Hight_map - Hight;
    ) F6 f1 _$ ^$ Z5 q; D+ I3 U$ V
56.   }
    * ^9 l7 a5 p1 Y, o) K
57.   //把map输出到窗口上
    . g; ], i3 M9 E, N) i- r3 A
58.   putimage(0, 0, Wide, Hight, &map, x, y);+ V2 u' m' b: R
    
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 T, A& g0 [1 i' J% ]! S
2. if (x < 0)
   ' D$ F\" \1 \! U
3. {6 W) {% s5 {( T# Y- e\" T
   
4.   x = 0;
   ( S( U, I% N9 c( N1 W% d# O
5. }
   / g8 e5 z/ b, x
6. if (y < 0)' m7 v5 \& O. l6 J' s
   
7. {
   + @8 W$ s; D\" e9 E
8.   y = 0;) V$ Z8 r; z: P# V
   
9. }
   + d* r3 V$ S3 L* g6 q
10. if (x > Wide_map - Wide): A! Q6 @9 {4 ?/ p
    
11. {
    4 g1 ^3 _' {\" w0 w! s( Q& Z7 B; i7 r
12.   x = Wide_map - Wide;
    5 D1 J4 }, a$ b! \5 H# X
13. }
    6 q; t6 b5 J9 l6 l\" B- P7 `- @
14. if (y > Hight_map - Hight)5 z5 g! t' U8 I) W' R5 \  s) B
    
15. {
    4 s5 A- k9 ^\" }5 w/ A2 y
16.   y = Hight_map - Hight;, ^. T# Y6 J$ Y8 s' j( C
    
17. }

复制代码

putimage(0, 0, Wide, Hight, &map, x, y) 这个函数调用是用于在屏幕上的特定位置绘制或显示一个图像。下面是对这个函数调用中各个参数的具体解释：
/ p2 _. n3 v% a- E' O. m
4 y- u7 P8 s$ e4 S(0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

, |0 Y% j3 M  r: g; YWide：这个参数指定了要绘制的图像的宽度。
. T+ Y8 Y- }+ q) b' E1 L6 e% ^
Hight：这个参数指定了要绘制的图像的高度。
; x6 o1 `! S" t6 A
&map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

. h( W% ^6 E4 S! m1 K5 c. Z  n. a$ lx：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

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

1. //距离
   % d2 Z3 r( e2 {/ T) I9 D
2. int Distance(int x, int y, int x1, int y1)4 ?$ ]; a- ?* S1 |4 U8 c- t
   
3. {
   # d  k# [9 _0 X* [! k
4.   return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
   1 \9 u  V- t, |9 ?/ M
5. }

复制代码

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

1. void Enemy_move()8 x7 t  [) f' }$ X' |$ ]
   
2. {6 W6 c% F( q, M! Q6 G- v# ^
   
3.   srand((unsigned)time(NULL));
   & S* b3 X! J' D8 k, k; f
4.   for (int i = 0; i < Enemy_num; i++)5 i9 R) c\" V1 N% o0 I/ T3 J
   
5.   {5 b, S$ m( H( O' w
   
6.     int direction = rand() % 4;
   2 Y3 X: f( r9 C( z+ _$ E
7. 
   5 }8 f. ~  _, z# }# n\" Z' v' k\" V
8.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
   ( b5 v4 T) P* i4 E5 M+ C
9.     {9 t. k8 A8 D# n% b- w
   
10.       if (direction == 0)' u8 m3 ^2 A5 ^& \0 R
    
11.       {3 G6 x& d. k9 b  `
    
12.         if (Enemy[i].y > 0)//防止小球越界的判断语句
    ( ?5 _, j# `& P' }
13.         {( T& _( U9 {4 t# _3 r& F
    
14.           Enemy[i].y -= enemy_sleep;
    ( u% F9 K& j+ V/ E( X
15.         }
      o( ]: d! m% R& R& t
16.       }
    / f7 n( i3 b& n' J. Z+ c9 S- b
17.       if (direction == 1)! T( J( T. o. J% [+ W
    
18.       {) N( ]4 t\" ~4 I
    
19.         if (Enemy[i].y < Hight_map)# U. b2 }4 H1 v+ b0 ~! F
    
20.           Enemy[i].y += enemy_sleep;4 Y  {4 @\" |* x* [3 X  f
    
21.       }
    & t# n7 n& i! L( \) N
22.       if (direction == 2)
    0 q! ^9 u\" Z2 J  x2 k7 @
23.       {3 f. R: ^# w; E
    
24.         if (Enemy[i].x > 0)
    % \\" k; D. k* K& c
25.           Enemy[i].x -= enemy_sleep;
    9 t* d% l7 m+ O\" u' F! o+ {2 G' j
26.       }
    - m3 E/ Y! i: i% F% I
27.       if (direction == 3)
    6 ^% m4 h1 S! v% M
28.       {
    # A\" R4 R) T1 p) Q2 b  J
29.         if (Enemy[i].x < Wide_map)$ |% V2 g5 J6 o3 {8 I3 J- o
    
30.           Enemy[i].x += enemy_sleep;1 [  m! u  z6 b4 R, S( ]
    
31.       }
    3 p$ }+ O  y( @7 ?) w# W: S
32.     }$ h# H5 \8 q' i0 o5 B8 F\" }8 p6 H# @- z
    
33.     //敌人追击玩家
    6 Y9 J4 s+ ~2 L  |! E# s  _
34.     if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)( ~- W3 T$ m) U2 g7 b' _' u; x
    
35.     {+ _1 ?) ?; P# @8 d
    
36.       if (Enemy[i].r > player.r): b1 F2 V# h: N) Q6 _
    
37.       {
    4 _% X* i# F1 M0 m5 m* h% G
38.         if (Enemy[i].x < player.x)
    5 u5 ?7 k# `4 E& G
39.         {
    ( l. P$ \) |* K: y. b! L
40.           if (Enemy[i].x < Wide_map)
    + d8 w# L  \. M' B$ K
41.           {
    8 R1 z  z8 a' ^8 I( c
42.             Enemy[i].x += enemy_sleep;
    6 T* H  ]/ _1 O% C6 x( i
43.           }7 d! r! W& r1 Q+ a' T
    
44.         }\" O& p/ f- ^\" J9 ^\" O8 ~) W
    
45.         if (Enemy[i].x > player.x)
    % R3 f6 T# a% N
46.         {. `1 u* H6 W+ T
    
47.           if (Enemy[i].x > 0)& \8 T6 @6 M4 s1 W, Q. Z7 ~# X
    
48.           {2 M0 n7 T, d# w
    
49.             Enemy[i].x -= enemy_sleep;
    6 S3 p1 M! w( T
50.           }
    2 W5 D) @0 u) R4 c. k
51.         }
    : O+ q3 R, _  ~# r: G
52.         if (Enemy[i].y < player.y)
    . B6 g: q: h& C: v7 f& S/ a
53.         {' f\" L5 m+ A1 ]- \* Y- f
    
54.           if (Enemy[i].y < Hight_map)! N- x% Y! q  ?* `3 D7 A. T2 ]7 h
    
55.           {
      H3 h: t8 n& |9 X3 J2 M
56.             Enemy[i].y += enemy_sleep;9 ^# A& x4 T1 N: V# |7 N# ?
    
57.           }- X; x3 C- {  t4 i
    
58.         }
    4 H: g4 v8 X) g' p0 K$ b2 l2 Y  v
59.         if (Enemy[i].y > player.y)9 d. \! z8 }5 t' h4 I# O
    
60.         {
    ! d6 c/ o: p/ E1 B8 I
61.           if (Enemy[i].y > 0)
    - @7 {' j1 k2 \' F1 r; @/ Y) D
62.           {3 W- u7 N5 t. C) w5 t6 l
    
63.             Enemy[i].y -= enemy_sleep;
    ; \. ]- p  r& w0 w* c0 I
64.           }2 [/ r* h\" e\" m+ a4 }7 W
    
65.         }
    - p4 T2 X- `' f! M, h\" A8 h9 _
66.       }0 ^% r7 I8 \: t  m& o
    
67.       //敌人逃跑
    8 `! i! S* I+ Y1 K& m  W! o' u
68.       else4 O' ~8 c, h3 t1 q5 A% e) R
    
69.       {
    , d' v* _% O& u
70.         if (Enemy[i].x < player.x)' J& `+ q5 d! C* p% |
    
71.         {
    $ I4 s' K5 l% T( ?$ o
72.           if (Enemy[i].x > 0)1 w' C2 S& K2 ~9 r( y, a
    
73.           {
    9 j* l, ^( N0 z7 c; l5 M
74.             Enemy[i].x -= enemy_sleep;
    . R* q* G* k\" A' Q5 e) D
75.           }/ U, y4 I& V8 F- r. |+ o\" d
    
76.         }: k( o! Y  z8 M0 l( w
    
77.         if (Enemy[i].x > player.x)
    5 w2 |( }0 _; M+ k2 E! [; M$ d
78.         {
    $ f) [/ @! y6 @\" a; i* O\" \9 j
79.           if (Enemy[i].x < Wide_map)* u9 c+ g& _4 o# F- {1 v7 N' s
    
80.           {( {6 _0 ~. n8 y1 O: i9 J# j$ w  Q
    
81.             Enemy[i].x += enemy_sleep;
    \" G3 X' t- n' ?' l
82.           }' T, T4 y& _- a- G' M$ i# B
    
83.         }0 _% r2 o3 ~) t/ T6 Z+ a; o
    
84.         if (Enemy[i].y < player.y)
    & U# E, o9 C( F9 g6 K. ~1 f+ w- r6 Y  n
85.         {& U$ ^0 m$ }3 v) n* b9 i
    
86.           if (Enemy[i].y > 0)
    ! W* F5 A1 |8 G  }9 u
87.           {
    7 g  j# I7 G, h$ _) ?0 T7 A2 W
88.             Enemy[i].y -= enemy_sleep;
    $ `9 Q- L2 J% P8 [! f
89.           }0 u$ @4 |7 f/ ^( @
    
90.         }. N6 e, z2 _  _: P( X7 ?2 W0 I
    
91.         if (Enemy[i].y > player.y)
    & R0 y: m7 D/ I( @. n
92.         {. R9 a2 C, ^. K) V$ m# s1 n
    
93.           if (Enemy[i].y < Hight_map)1 V2 ]4 N\" I6 |9 A2 N# k9 L1 i
    
94.           {
    3 a0 k9 M, {# p
95.             Enemy[i].y += enemy_sleep;/ X! F. _9 c  B# b
    
96.           }  d( m. @0 [  i% V3 [/ J
    
97.         }
    0 A# `- Q( i6 [( H! e# c# X& b
98.       }2 Q* f* U  V% N( j+ C
    
99.     }: g- P$ q/ o; h3 g$ w0 J
    
100.   }  t8 U. l1 }  V7 k  \2 w
     
101. }

复制代码

7. 小球之间的吞噬关系

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

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

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

1. void EatFood()' r$ D- x4 l! |2 d- a8 l
   
2. {
   / l% L0 }% n8 ]1 h  @' U
3.   for (int i = 0; i < Food_num; i++)0 [\" T5 V+ K\" O
   
4.   {+ J) y; G( \$ a9 Z/ d/ `
   
5.     //玩家吃食物
   $ m0 c6 d: @# t/ ^
6.     if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
   , X9 h4 S2 f4 s# _3 k8 w7 L* j8 [
7.     {
   , d\" ^- Y8 E+ ~2 ~5 I$ B- @
8.       player.r += Food[i].r / 100;* J( t4 i: f; [+ j' e
   
9.       Food[i].x = rand() % Wide_map;2 [, g) P7 X3 K. @! K
   
10.       Food[i].y = rand() % Hight_map;7 `\" g\" g2 Y6 J0 t( y
    
11.       Food[i].r = rand() % 5 + 1;+ X9 y6 ^& C4 ^# \9 y
    
12.       Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    / \) {* h6 S1 d- \
13.     }  M: S1 V0 I' X
    
14.     9 w5 k5 O* `3 }# x
    
15.   }- l+ w  T4 i% o. R, B& I
    
16.   for (int j = 0; j < Enemy_num; j++). A$ D8 g: P! X0 p7 B) s
    
17.   {
    & S( g% W8 W; s8 n% I! j
18.     //敌人吃食物6 {! V9 J8 B! q, s) e/ m# z
    
19.     for (int i = 0; i < Food_num; i++)  o. c6 ]5 J& P- j  s( Z0 k
    
20.     {4 X8 r3 L, ?  O
    
21.       if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)+ j% L6 k  }0 R! O0 c3 d5 u\" k
    
22.       {
    / ~  x+ Y% o8 z
23.         Enemy[j].r += Food[i].r / 50;
    ; {' W\" o+ ^0 W: \
24.         Food[i].x = rand() % Wide_map;
    / B  g/ n- a) ]
25.         Food[i].y = rand() % Hight_map;3 W* V: L3 k4 h\" j# F( n9 B2 J5 W
    
26.         Food[i].r = rand() % 5 + 1;
    ! [\" U$ [0 X3 h  U2 l4 t2 A
27.         Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);+ o7 G+ i! |( p) _4 k
    
28.       }( @4 Y7 v& h6 }
    
29.     }
    : _, s+ |+ L' n2 t4 u( [% R
30.     //敌人吃敌人
    1 l& T5 [& U3 b6 x: u) @
31.     for (int i = 0; i < Enemy_num; i++)
      U2 Y7 C5 Z* C3 D\" u
32.     {2 A; p8 Z; ?' 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)
    ' Y2 c) _1 ~  [8 B2 Q+ `
34.       {
    : R- K. K% x% o; z
35.         Enemy[j].r += Enemy[i].r / 10;
    * I. s\" }/ o, R- _; D; u/ \* \
36.         Enemy[i].x = rand() % Wide_map;/ y7 @# g- J/ V4 I
    
37.         Enemy[i].y = rand() % Hight_map;
    ) D% [  h$ E$ p- W! }- C$ `
38.         Enemy[i].r = 10;% V! s+ W! k- Z. r' {8 h
    
39.           Enemy[i].color = RGB(0, 255, 0);( U4 l3 |- j  e6 k- c$ L
    
40.       }
    ( N  n- O8 g$ S# J$ E( [5 H4 v
41.       if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    ' u4 n% c9 J+ g
42.       {; p3 s, W& G! j' T; }: h
    
43.         Enemy[i].r += Enemy[j].r / 10;
    & @9 P) d+ s6 I) Z; U
44.         Enemy[j].x = rand() % Wide_map;4 a& X/ y: u( _1 V6 {9 n  a# ]$ ~
    
45.         Enemy[j].y = rand() % Hight_map;4 a2 e0 K2 W) E/ |' W7 o
    
46.         Enemy[j].r = 10;
    ) Z9 i' S+ d, e& J7 [+ O
47.         Enemy[j].color = RGB(0, 255, 0);
    . v3 b5 M9 b3 n
48.       }0 i3 x$ |' a/ l9 ]+ ~
    
49.     }
    . _4 D9 Z7 o& c. t; j, E& S
50.     if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    . v/ ^- ^0 E+ U, P9 t; M, S
51.     {# e; o- v5 q- E# O# u0 {3 ^: ]* ]
    
52.       //玩家吃敌人
    - J, F, [7 E7 V. @' s
53.       if (player.r > Enemy[j].r)
    , c$ @' K( D) c  k& _( d. E
54.       {
    ' g+ \$ E( f\" a: p3 X0 x\" O
55.         player.r += Enemy[j].r / 10;
    \" @5 u3 e9 q' b. w  @* j6 m
56.         Enemy[j].x = rand() % Wide_map;2 }, \! w  o5 b7 H\" B
    
57.         Enemy[j].y = rand() % Hight_map;
    / Z) E- o+ x! R& i
58.         Enemy[j].r = 10;
    5 W/ ], e6 d\" W2 t5 x( Q! y  o/ v! V
59.         Enemy[j].color = RGB(0, 255, 0);. q$ x( V7 G3 {
    
60.       }0 S2 }+ f0 D8 V. _5 b; H
    
61.       //敌人吃玩家
    5 p$ G. Y- J7 @/ V8 i
62.       else
    & {- \4 o. `( f% z6 K+ N' z) z
63.       {5 Q2 r6 }- m  v% w2 ^4 e
    
64.         if (invincibility == 0)
    * m2 H2 R0 \  u- B
65.         {3 y* |# [* y% |! T4 Y
    
66.           Enemy[j].r += player.r / 10;; Q+ [% V, p: E9 ~6 s! |* t  y
    
67.           player.x = Wide / 2;
    ! `; H; y8 K( b4 h7 L
68.           player.y = Hight / 2;% W/ H; ~+ r4 P4 L
    
69.           player.r = 10;
    , L) w5 N2 F8 r: u, W
70.           invincibility = 10;
    - A3 y5 c/ m, @, l( n% t
71.         }
    * v1 _' q9 n9 c6 R' O( p6 f) Y% m
72.       }. y3 }9 Z% R) v6 a  {8 n
    
73.     }! K( j, i( B\" }: k! ^  z
    
74.   }& A0 G4 M# b# n
    
75. }

复制代码

完整代码见附件：
/ b# c. T9 E& y
5 G4 j: W# D; {! r
0 g; b8 c% ?+ ^* Q- W
4 Y1 w) T' Y, ?5 l