• C语言游戏实战（9）：球球大作战

      前言：

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

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

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

    玩家小球：玩家控制的小球可以在游戏界面内自由移动，按下空格键可以加速。

    其他小球：其他小球又分为食物小球，和ai控制的小球

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

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

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

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

    初始化游戏界面和小球的信息。

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

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

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

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

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

    1. 小球的要素

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

    1. struct Ball
    2. {
    3. 	int x;
    4. 	int y;
    5. 	float r;
    6. 	DWORD color;
    7. };

    2. 初始化小球的信息

    将玩家小球的初始位置设置在窗口的中间，半径大小为10。食物小球和ai小球的位置则通过rand函数、srand函数和time函数生成的随机数，随机分布在地图的各个位置，食物小球半径为1-5，ai小球的半径10.其中在这里使用了RGB随机生成一个颜色，使每个食物小球的颜色都不尽相同。

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

    • 橙色可以通过RGB值（255, 128, 0）来表示。
    • 黄色的RGB值为（255, 255, 0）。
    • 绿色的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()
    2. {
    3.     //玩家小球
    4. 	srand((unsigned)time(NULL));
    5. 	player.x = Wide / 2;
    6. 	player.y = Hight / 2;
    7. 	player.r = 10;
    8.     //食物小球
    9. 	for (int i = 0; i < Food_num; i++)
    10. 	{
    11. 		Food[i].x = rand() % Wide_map;
    12. 		Food[i].y = rand() % Hight_map;
    13. 		Food[i].r = rand() % 5 + 1;
    14. 		Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    15. 	}
    16.     //ai小球
    17. 	for (int i = 0; i < Enemy_num; i++)
    18. 	{
    19. 		Enemy[i].x = rand() % Wide_map;
    20. 		Enemy[i].y = rand() % Hight_map;
    21. 		Enemy[i].r = 10;
    22. 		Enemy[i].color = RGB(0,255,0);
    23. 	}
    24.  
    25. }

    3. 玩家操作小球

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

    1. void Player_move()
    2. {
    3. 	if (GetAsyncKeyState(VK_UP))
    4. 	{
    5. 		if (player.y > 0)
    6. 		{
    7. 			player.y -= player_sleep;
    8. 		}
    9. 	}
    10. 	if (GetAsyncKeyState(VK_DOWN))
    11. 	{
    12. 		if (player.y < Hight_map)
    13. 		player.y += player_sleep;
    14. 	}
    15. 	if (GetAsyncKeyState(VK_LEFT))
    16. 	{
    17. 		if (player.x > 0)
    18. 		player.x -= player_sleep;
    19. 	}
    20. 	if (GetAsyncKeyState(VK_RIGHT))
    21. 	{
    22. 		if (player.x < Wide_map)
    23. 		player.x += player_sleep;
    24. 	}
    25. 	if (GetAsyncKeyState(0x20))
    26. 	{
    27. 		player_sleep = l + 5;
    28. 	}
    29. 	else
    30. 	{
    31. 		player_sleep = l;
    32. 	}
    33. }

    4. 显示出小球

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

    1. void Show()
    2. {
    3. 	
    4. 	//设置地图
    5. 	SetWorkingImage(&map);
    6. 	//清屏
    7. 	cleardevice();
    8. 	//背景颜色
    9. 	setbkcolor(WHITE);
    10. 	//划线颜色
    11. 	setlinecolor(RGB(230,231,239));
    12. 	//划线
    13. 	for (int i = 0; i < Wide_map; i += 10)
    14. 	{
    15. 		line(i, 0, i, Hight_map);
    16. 	}
    17. 	for (int i = 0; i < Hight_map; i += 10)
    18. 	{
    19. 		line(0, i, Wide_map, i);
    20. 	}
    21. 	//食物
    22. 	for (int i = 0; i < Food_num; i++)
    23. 	{
    24. 		setfillcolor(Food[i].color);
    25. 		solidcircle(Food[i].x, Food[i].y, Food[i].r);
    26. 	}
    27. 	//敌人
    28. 	for (int i = 0; i < Enemy_num; i++)
    29. 	{
    30. 		setfillcolor(Enemy[i].color);
    31. 		solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    32. 	}
    33. 	//玩家
    34. 	setfillcolor(RED);
    35. 	solidcircle(player.x, player.y, player.r);
    36. 	SetWorkingImage();
    37.  
    38. 	int x = player.x - (Wide / 2);
    39. 	int y = player.y - (Hight / 2);
    40. 	//防止窗口越界
    41. 	if (x < 0)
    42. 	{
    43. 		x = 0;
    44. 	}
    45. 	if (y < 0)
    46. 	{
    47. 		y = 0;
    48. 	}
    49. 	if (x > Wide_map - Wide)
    50. 	{
    51. 		x = Wide_map - Wide;
    52. 	}
    53. 	if (y > Hight_map - Hight)
    54. 	{
    55. 		y = Hight_map - Hight;
    56. 	}
    57. 	//把map输出到窗口上
    58. 	putimage(0, 0, Wide, Hight, &map, x, y);
    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. //防止窗口越界
    2. if (x < 0)
    3. {
    4. 	x = 0;
    5. }
    6. if (y < 0)
    7. {
    8. 	y = 0;
    9. }
    10. if (x > Wide_map - Wide)
    11. {
    12. 	x = Wide_map - Wide;
    13. }
    14. if (y > Hight_map - Hight)
    15. {
    16. 	y = Hight_map - Hight;
    17. }

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

    1. (0, 0)：这是图像要绘制的目标位置的左上角坐标，即x=0和y=0，通常表示屏幕的左上角。

    2. Wide：这个参数指定了要绘制的图像的宽度。

    3. Hight：这个参数指定了要绘制的图像的高度。

    4. &map：这是一个指向图像内存地址的指针，该图像将被绘制到屏幕上。在这个上下文中，map可能是一个包含了图像数据的数据结构或数组。

    5. x：这个参数通常指定了要开始绘制图像的起始点的x坐标（在图像数据中）。

    6. y：这个参数通常指定了要开始绘制图像的起始点的y坐标（在图像数据中）。

    6. ai小球的移动

    随机生成0-3的数字分别代表ai小球上下左右的移动，这样小球就会自由移动了。当玩家小球与ai小球靠近时，ai小球会追击或者逃跑，这里我们需要先计算小球的之间的距离，小球之间的距离就是两小球的圆心坐标的x相减的平方加上y相减的平方再开根号。开根号的函数为sqrt，它的头文件是。

    1. //距离
    2. int Distance(int x, int y, int x1, int y1)
    3. {
    4. 	return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
    5. }

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

    1. void Enemy_move()
    2. {
    3. 	srand((unsigned)time(NULL));
    4. 	for (int i = 0; i < Enemy_num; i++)
    5. 	{
    6. 		int direction = rand() % 4;
    7.  
    8. 		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
    9. 		{
    10. 			if (direction == 0)
    11. 			{
    12. 				if (Enemy[i].y > 0)//防止小球越界的判断语句
    13. 				{
    14. 					Enemy[i].y -= enemy_sleep;
    15. 				}
    16. 			}
    17. 			if (direction == 1)
    18. 			{
    19. 				if (Enemy[i].y < Hight_map)
    20. 					Enemy[i].y += enemy_sleep;
    21. 			}
    22. 			if (direction == 2)
    23. 			{
    24. 				if (Enemy[i].x > 0)
    25. 					Enemy[i].x -= enemy_sleep;
    26. 			}
    27. 			if (direction == 3)
    28. 			{
    29. 				if (Enemy[i].x < Wide_map)
    30. 					Enemy[i].x += enemy_sleep;
    31. 			}
    32. 		}
    33. 		//敌人追击玩家
    34. 		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    35. 		{
    36. 			if (Enemy[i].r > player.r)
    37. 			{
    38. 				if (Enemy[i].x < player.x)
    39. 				{
    40. 					if (Enemy[i].x < Wide_map)
    41. 					{
    42. 						Enemy[i].x += enemy_sleep;
    43. 					}
    44. 				}
    45. 				if (Enemy[i].x > player.x)
    46. 				{
    47. 					if (Enemy[i].x > 0)
    48. 					{
    49. 						Enemy[i].x -= enemy_sleep;
    50. 					}
    51. 				}
    52. 				if (Enemy[i].y < player.y)
    53. 				{
    54. 					if (Enemy[i].y < Hight_map)
    55. 					{
    56. 						Enemy[i].y += enemy_sleep;
    57. 					}
    58. 				}
    59. 				if (Enemy[i].y > player.y)
    60. 				{
    61. 					if (Enemy[i].y > 0)
    62. 					{
    63. 						Enemy[i].y -= enemy_sleep;
    64. 					}
    65. 				}
    66. 			}
    67. 			//敌人逃跑
    68. 			else
    69. 			{
    70. 				if (Enemy[i].x < player.x)
    71. 				{
    72. 					if (Enemy[i].x > 0)
    73. 					{
    74. 						Enemy[i].x -= enemy_sleep;
    75. 					}
    76. 				}
    77. 				if (Enemy[i].x > player.x)
    78. 				{
    79. 					if (Enemy[i].x < Wide_map)
    80. 					{
    81. 						Enemy[i].x += enemy_sleep;
    82. 					}
    83. 				}
    84. 				if (Enemy[i].y < player.y)
    85. 				{
    86. 					if (Enemy[i].y > 0)
    87. 					{
    88. 						Enemy[i].y -= enemy_sleep;
    89. 					}
    90. 				}
    91. 				if (Enemy[i].y > player.y)
    92. 				{
    93. 					if (Enemy[i].y < Hight_map)
    94. 					{
    95. 						Enemy[i].y += enemy_sleep;
    96. 					}
    97. 				}
    98. 			}
    99. 		}
    100. 	}
    101. }

    7. 小球之间的吞噬关系

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

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

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

    1. void EatFood()
    2. {
    3. 	for (int i = 0; i < Food_num; i++)
    4. 	{
    5. 		//玩家吃食物
    6. 		if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
    7. 		{
    8. 			player.r += Food[i].r / 100;
    9. 			Food[i].x = rand() % Wide_map;
    10. 			Food[i].y = rand() % Hight_map;
    11. 			Food[i].r = rand() % 5 + 1;
    12. 			Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    13. 		}
    14. 		
    15. 	}
    16. 	for (int j = 0; j < Enemy_num; j++)
    17. 	{
    18. 		//敌人吃食物
    19. 		for (int i = 0; i < Food_num; i++)
    20. 		{
    21. 			if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    22. 			{
    23. 				Enemy[j].r += Food[i].r / 50;
    24. 				Food[i].x = rand() % Wide_map;
    25. 				Food[i].y = rand() % Hight_map;
    26. 				Food[i].r = rand() % 5 + 1;
    27. 				Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    28. 			}
    29. 		}
    30. 		//敌人吃敌人
    31. 		for (int i = 0; i < Enemy_num; i++)
    32. 		{
    33. 			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    34. 			{
    35. 				Enemy[j].r += Enemy[i].r / 10;
    36. 				Enemy[i].x = rand() % Wide_map;
    37. 				Enemy[i].y = rand() % Hight_map;
    38. 				Enemy[i].r = 10;
    39. 					Enemy[i].color = RGB(0, 255, 0);
    40. 			}
    41. 			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    42. 			{
    43. 				Enemy[i].r += Enemy[j].r / 10;
    44. 				Enemy[j].x = rand() % Wide_map;
    45. 				Enemy[j].y = rand() % Hight_map;
    46. 				Enemy[j].r = 10;
    47. 				Enemy[j].color = RGB(0, 255, 0);
    48. 			}
    49. 		}
    50. 		if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    51. 		{
    52. 			//玩家吃敌人
    53. 			if (player.r > Enemy[j].r)
    54. 			{
    55. 				player.r += Enemy[j].r / 10;
    56. 				Enemy[j].x = rand() % Wide_map;
    57. 				Enemy[j].y = rand() % Hight_map;
    58. 				Enemy[j].r = 10;
    59. 				Enemy[j].color = RGB(0, 255, 0);
    60. 			}
    61. 			//敌人吃玩家
    62. 			else
    63. 			{
    64. 				if (invincibility == 0)
    65. 				{
    66. 					Enemy[j].r += player.r / 10;
    67. 					player.x = Wide / 2;
    68. 					player.y = Hight / 2;
    69. 					player.r = 10;
    70. 					invincibility = 10;
    71. 				}
    72. 			}
    73. 		}
    74. 	}
    75. }

    最终效果：

    球球大作战

    源码：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #define Wide 1024
    6. #define Hight 640
    7. #define Wide_map (Wide*5)
    8. #define Hight_map (Hight*5)
    9. #define Food_num 1888
    10. #define Enemy_num 888
    11. //整个游戏地图
    12. IMAGE map(Wide_map, Hight_map);
    13. //复活时的无敌时间
    14. int invincibility = 10; 
    15. //玩家速度
    16. int player_sleep = 5;
    17. int l = 5;
    18. int enemy_sleep = 5;
    19. struct Ball
    20. {
    21. 	int x;
    22. 	int y;
    23. 	float r;
    24. 	DWORD color;
    25. };
    26. struct Ball player;
    27. struct Ball Food[Food_num];
    28. struct Ball Enemy[Enemy_num];
    29. //初始化球的数据
    30. void Inset()
    31. {
    32. 	srand((unsigned)time(NULL));
    33. 	player.x = Wide / 2;
    34. 	player.y = Hight / 2;
    35. 	player.r = 10;
    36. 	for (int i = 0; i < Food_num; i++)
    37. 	{
    38. 		Food[i].x = rand() % Wide_map;
    39. 		Food[i].y = rand() % Hight_map;
    40. 		Food[i].r = rand() % 5 + 1;
    41. 		Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    42. 	}
    43. 	for (int i = 0; i < Enemy_num; i++)
    44. 	{
    45. 		Enemy[i].x = rand() % Wide_map;
    46. 		Enemy[i].y = rand() % Hight_map;
    47. 		Enemy[i].r = 10;
    48. 		Enemy[i].color = RGB(0,255,0);
    49. 	}
    50.  
    51. }
    52. //玩家操作
    53. void Player_move()
    54. {
    55. 	if (GetAsyncKeyState(VK_UP))
    56. 	{
    57. 		if (player.y > 0)
    58. 		{
    59. 			player.y -= player_sleep;
    60. 		}
    61. 	}
    62. 	if (GetAsyncKeyState(VK_DOWN))
    63. 	{
    64. 		if (player.y < Hight_map)
    65. 		player.y += player_sleep;
    66. 	}
    67. 	if (GetAsyncKeyState(VK_LEFT))
    68. 	{
    69. 		if (player.x > 0)
    70. 		player.x -= player_sleep;
    71. 	}
    72. 	if (GetAsyncKeyState(VK_RIGHT))
    73. 	{
    74. 		if (player.x < Wide_map)
    75. 		player.x += player_sleep;
    76. 	}
    77. 	if (GetAsyncKeyState(0x20))
    78. 	{
    79. 		player_sleep = l + 5;
    80. 	}
    81. 	else
    82. 	{
    83. 		player_sleep = l;
    84. 	}
    85. }
    86. //距离
    87. int Distance(int x, int y, int x1, int y1)
    88. {
    89. 	return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
    90. }
    91. //敌人移动
    92. void Enemy_move()
    93. {
    94. 	srand((unsigned)time(NULL));
    95. 	for (int i = 0; i < Enemy_num; i++)
    96. 	{
    97. 		int direction = rand() % 400;
    98.  
    99. 		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
    100. 		{
    101. 			if (direction < 100)
    102. 			{
    103. 				if (Enemy[i].y > 0)
    104. 				{
    105. 					Enemy[i].y -= enemy_sleep;
    106. 				}
    107. 			}
    108. 			if (direction < 200 && direction >= 100)
    109. 			{
    110. 				if (Enemy[i].y < Hight_map)
    111. 					Enemy[i].y += enemy_sleep;
    112. 			}
    113. 			if (direction < 300 && direction >= 200)
    114. 			{
    115. 				if (Enemy[i].x > 0)
    116. 					Enemy[i].x -= enemy_sleep;
    117. 			}
    118. 			if (direction <400 && direction >= 300)
    119. 			{
    120. 				if (Enemy[i].x < Wide_map)
    121. 					Enemy[i].x += enemy_sleep;
    122. 			}
    123. 		}
    124. 		//敌人追击玩家
    125. 		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
    126. 		{
    127. 			if (Enemy[i].r > player.r)
    128. 			{
    129. 				if (Enemy[i].x < player.x)
    130. 				{
    131. 					if (Enemy[i].x < Wide_map)
    132. 					{
    133. 						Enemy[i].x += enemy_sleep;
    134. 					}
    135. 				}
    136. 				if (Enemy[i].x > player.x)
    137. 				{
    138. 					if (Enemy[i].x > 0)
    139. 					{
    140. 						Enemy[i].x -= enemy_sleep;
    141. 					}
    142. 				}
    143. 				if (Enemy[i].y < player.y)
    144. 				{
    145. 					if (Enemy[i].y < Hight_map)
    146. 					{
    147. 						Enemy[i].y += enemy_sleep;
    148. 					}
    149. 				}
    150. 				if (Enemy[i].y > player.y)
    151. 				{
    152. 					if (Enemy[i].y > 0)
    153. 					{
    154. 						Enemy[i].y -= enemy_sleep;
    155. 					}
    156. 				}
    157. 			}
    158. 			//敌人逃跑
    159. 			else
    160. 			{
    161. 				if (Enemy[i].x < player.x)
    162. 				{
    163. 					if (Enemy[i].x > 0)
    164. 					{
    165. 						Enemy[i].x -= enemy_sleep;
    166. 					}
    167. 				}
    168. 				if (Enemy[i].x > player.x)
    169. 				{
    170. 					if (Enemy[i].x < Wide_map)
    171. 					{
    172. 						Enemy[i].x += enemy_sleep;
    173. 					}
    174. 				}
    175. 				if (Enemy[i].y < player.y)
    176. 				{
    177. 					if (Enemy[i].y > 0)
    178. 					{
    179. 						Enemy[i].y -= enemy_sleep;
    180. 					}
    181. 				}
    182. 				if (Enemy[i].y > player.y)
    183. 				{
    184. 					if (Enemy[i].y < Hight_map)
    185. 					{
    186. 						Enemy[i].y += enemy_sleep;
    187. 					}
    188. 				}
    189. 			}
    190. 		}
    191. 		//for (int j = 0; j < Enemy_num; j++)
    192. 		//{
    193. 		//	if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r + Enemy[i].r + 30)
    194. 		//	{
    195. 		//		//敌人追敌人
    196. 		//		if (Enemy[i].r > Enemy[j].r)
    197. 		//		{
    198. 		//			int sleep = rand() % 6;
    199. 		//			int enemy_sleep1;
    200. 		//			if (sleep > 2)
    201. 		//			{
    202. 		//				enemy_sleep1 = enemy_sleep;
    203. 		//			}
    204. 		//			else
    205. 		//			{
    206. 		//				enemy_sleep1 = enemy_sleep + 5;
    207. 		//			}
    208. 		//			if (Enemy[i].x < Enemy[j].x)
    209. 		//			{
    210. 		//				if (Enemy[i].x < Wide_map)
    211. 		//				{
    212. 		//					Enemy[i].x += enemy_sleep1;
    213. 		//				}
    214. 		//			}
    215. 		//			if (Enemy[i].x > Enemy[j].x)
    216. 		//			{
    217. 		//				if (Enemy[i].x > 0)
    218. 		//				{
    219. 		//					Enemy[i].x -= enemy_sleep1;
    220. 		//				}
    221. 		//			}
    222. 		//			if (Enemy[i].y < Enemy[j].y)
    223. 		//			{
    224. 		//				if (Enemy[i].y < Hight_map)
    225. 		//				{
    226. 		//					Enemy[i].y += enemy_sleep1;
    227. 		//				}
    228. 		//			}
    229. 		//			if (Enemy[i].y > Enemy[j].y)
    230. 		//			{
    231. 		//				if (Enemy[i].y > 0)
    232. 		//				{
    233. 		//					Enemy[i].y -= enemy_sleep1;
    234. 		//				}
    235. 		//			}
    236. 		//		}
    237. 		//		//逃跑
    238. 		//		else
    239. 		//		{
    240. 		//			int sleep = rand() % 6;
    241. 		//			int enemy_sleep1;
    242. 		//			if (sleep > 2)
    243. 		//			{
    244. 		//				enemy_sleep1 = enemy_sleep;
    245. 		//			}
    246. 		//			else
    247. 		//			{
    248. 		//				enemy_sleep1 = enemy_sleep + 5;
    249. 		//			}
    250. 		//			if (Enemy[i].x < Enemy[j].x)
    251. 		//			{
    252. 		//				if (Enemy[i].x > 0)
    253. 		//				{
    254. 		//					Enemy[i].x -= enemy_sleep1;
    255. 		//				}
    256. 		//			}
    257. 		//			if (Enemy[i].x > Enemy[j].x)
    258. 		//			{
    259. 		//				if (Enemy[i].x < Wide_map)
    260. 		//				{
    261. 		//					Enemy[i].x += enemy_sleep1;
    262. 		//				}
    263. 		//			}
    264. 		//			if (Enemy[i].y < Enemy[j].y)
    265. 		//			{
    266. 		//				if (Enemy[i].y > 0)
    267. 		//				{
    268. 		//					Enemy[i].y -= enemy_sleep1;
    269. 		//				}
    270. 		//			}
    271. 		//			if (Enemy[i].y > Enemy[j].y)
    272. 		//			{
    273. 		//				if (Enemy[i].y < Hight_map)
    274. 		//				{
    275. 		//					Enemy[i].y += enemy_sleep1;
    276. 		//				}
    277. 		//			}
    278. 		//		}
    279. 		//	}
    280. 		//}
    281. 	}
    282. }
    283.  
    284. //吃食物
    285. void EatFood()
    286. {
    287. 	for (int i = 0; i < Food_num; i++)
    288. 	{
    289. 		//玩家吃食物
    290. 		if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
    291. 		{
    292. 			player.r += Food[i].r / 100;
    293. 			Food[i].x = rand() % Wide_map;
    294. 			Food[i].y = rand() % Hight_map;
    295. 			Food[i].r = rand() % 5 + 1;
    296. 			Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    297. 		}
    298. 		
    299. 	}
    300. 	for (int j = 0; j < Enemy_num; j++)
    301. 	{
    302. 		//敌人吃食物
    303. 		for (int i = 0; i < Food_num; i++)
    304. 		{
    305. 			if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
    306. 			{
    307. 				Enemy[j].r += Food[i].r / 50;
    308. 				Food[i].x = rand() % Wide_map;
    309. 				Food[i].y = rand() % Hight_map;
    310. 				Food[i].r = rand() % 5 + 1;
    311. 				Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
    312. 			}
    313. 		}
    314. 		//敌人吃敌人
    315. 		for (int i = 0; i < Enemy_num; i++)
    316. 		{
    317. 			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
    318. 			{
    319. 				Enemy[j].r += Enemy[i].r / 10;
    320. 				Enemy[i].x = rand() % Wide_map;
    321. 				Enemy[i].y = rand() % Hight_map;
    322. 				Enemy[i].r = 10;
    323. 					Enemy[i].color = RGB(0, 255, 0);
    324. 			}
    325. 			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
    326. 			{
    327. 				Enemy[i].r += Enemy[j].r / 10;
    328. 				Enemy[j].x = rand() % Wide_map;
    329. 				Enemy[j].y = rand() % Hight_map;
    330. 				Enemy[j].r = 10;
    331. 				Enemy[j].color = RGB(0, 255, 0);
    332. 			}
    333. 		}
    334. 		if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
    335. 		{
    336. 			//玩家吃敌人
    337. 			if (player.r > Enemy[j].r)
    338. 			{
    339. 				player.r += Enemy[j].r / 10;
    340. 				Enemy[j].x = rand() % Wide_map;
    341. 				Enemy[j].y = rand() % Hight_map;
    342. 				Enemy[j].r = 10;
    343. 				Enemy[j].color = RGB(0, 255, 0);
    344. 			}
    345. 			//敌人吃玩家
    346. 			else
    347. 			{
    348. 				if (invincibility == 0)
    349. 				{
    350. 					Enemy[j].r += player.r / 10;
    351. 					player.x = Wide / 2;
    352. 					player.y = Hight / 2;
    353. 					player.r = 10;
    354. 					invincibility = 10;
    355. 				}
    356. 			}
    357. 		}
    358. 	}
    359. }
    360. //显示
    361. void Show()
    362. {
    363. 	
    364. 	//设置地图
    365. 	SetWorkingImage(&map);
    366. 	//清屏
    367. 	cleardevice();
    368. 	//背景颜色
    369. 	setbkcolor(WHITE);
    370. 	//划线颜色
    371. 	setlinecolor(RGB(230,231,239));
    372. 	//划线
    373. 	for (int i = 0; i < Wide_map; i += 10)
    374. 	{
    375. 		line(i, 0, i, Hight_map);
    376. 	}
    377. 	for (int i = 0; i < Hight_map; i += 10)
    378. 	{
    379. 		line(0, i, Wide_map, i);
    380. 	}
    381. 	//食物
    382. 	for (int i = 0; i < Food_num; i++)
    383. 	{
    384. 		setfillcolor(Food[i].color);
    385. 		solidcircle(Food[i].x, Food[i].y, Food[i].r);
    386. 	}
    387. 	//敌人
    388. 	for (int i = 0; i < Enemy_num; i++)
    389. 	{
    390. 		setfillcolor(Enemy[i].color);
    391. 		solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
    392. 	}
    393. 	//玩家
    394. 	setfillcolor(RED);
    395. 	solidcircle(player.x, player.y, player.r);
    396. 	SetWorkingImage();
    397.  
    398. 	int x = player.x - (Wide / 2);
    399. 	int y = player.y - (Hight / 2);
    400. 	//防止窗口越界
    401. 	if (x < 0)
    402. 	{
    403. 		x = 0;
    404. 	}
    405. 	if (y < 0)
    406. 	{
    407. 		y = 0;
    408. 	}
    409. 	if (x > Wide_map - Wide)
    410. 	{
    411. 		x = Wide_map - Wide;
    412. 	}
    413. 	if (y > Hight_map - Hight)
    414. 	{
    415. 		y = Hight_map - Hight;
    416. 	}
    417. 	//把map输出到窗口上
    418. 	putimage(0, 0, Wide, Hight, &map, x, y);
    419. }
    420. int main()
    421. {
    422. 	
    423. 	initgraph(Wide, Hight);
    424. 	Inset();
    425. 	//缓冲
    426. 	BeginBatchDraw();
    427. 	while (1)
    428. 	{
    429. 		if (invincibility > 0)
    430. 			invincibility--;
    431. 		Show();
    432. 		//玩家操作
    433. 		Player_move();
    434. 		Enemy_move();
    435. 		EatFood();
    436. 		//刷新
    437. 		FlushBatchDraw();
    438. 	}
    439. 	closegraph();
    440. 	return 0;
    441. }

  • 相关阅读:
    封装composer包
    高等数学（第七版）同济大学 习题5-3 个人解答（前3题）
    [设计模式] 浅谈奇异递归模板模式
    Django笔记二十之手动编写migration文件
    手把手教你写一个图片预览组件
    Java字符串常量池
    java 阿里云上传照片
    C#往数据库上传文件
    ChatGPT提示词(prompt)资源汇总
    全局事件总线概述
  • 原文地址：https://blog.csdn.net/weixin_58252863/article/details/136639127