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

最新推荐文章于 2024-04-24 23:59:14 发布
置顶 最新推荐文章于 2024-04-24 23:59:14 发布
阅读量10w+ 收藏 5.8k
点赞数 1.6k
分类专栏： c语言游戏实战篇 c语言 文章标签： c语言 游戏 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58252863/article/details/136639127
版权

  前言：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1. 小球的要素

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

struct Ball
{
	int x;
	int y;
	float r;
	DWORD color;
};

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，颜色就越接近白色，反之亦然。
void Inset()
{
    //玩家小球
	srand((unsigned)time(NULL));
	player.x = Wide / 2;
	player.y = Hight / 2;
	player.r = 10;
    //食物小球
	for (int i = 0; i < Food_num; i++)
	{
		Food[i].x = rand() % Wide_map;
		Food[i].y = rand() % Hight_map;
		Food[i].r = rand() % 5 + 1;
		Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
	}
    //ai小球
	for (int i = 0; i < Enemy_num; i++)
	{
		Enemy[i].x = rand() % Wide_map;
		Enemy[i].y = rand() % Hight_map;
		Enemy[i].r = 10;
		Enemy[i].color = RGB(0,255,0);
	}

}

3. 玩家操作小球

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

void Player_move()
{
	if (GetAsyncKeyState(VK_UP))
	{
		if (player.y > 0)
		{
			player.y -= player_sleep;
		}
	}
	if (GetAsyncKeyState(VK_DOWN))
	{
		if (player.y < Hight_map)
		player.y += player_sleep;
	}
	if (GetAsyncKeyState(VK_LEFT))
	{
		if (player.x > 0)
		player.x -= player_sleep;
	}
	if (GetAsyncKeyState(VK_RIGHT))
	{
		if (player.x < Wide_map)
		player.x += player_sleep;
	}
	if (GetAsyncKeyState(0x20))
	{
		player_sleep = l + 5;
	}
	else
	{
		player_sleep = l;
	}
}

4. 显示出小球

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

void Show()
{
	
	//设置地图
	SetWorkingImage(&map);
	//清屏
	cleardevice();
	//背景颜色
	setbkcolor(WHITE);
	//划线颜色
	setlinecolor(RGB(230,231,239));
	//划线
	for (int i = 0; i < Wide_map; i += 10)
	{
		line(i, 0, i, Hight_map);
	}
	for (int i = 0; i < Hight_map; i += 10)
	{
		line(0, i, Wide_map, i);
	}
	//食物
	for (int i = 0; i < Food_num; i++)
	{
		setfillcolor(Food[i].color);
		solidcircle(Food[i].x, Food[i].y, Food[i].r);
	}
	//敌人
	for (int i = 0; i < Enemy_num; i++)
	{
		setfillcolor(Enemy[i].color);
		solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
	}
	//玩家
	setfillcolor(RED);
	solidcircle(player.x, player.y, player.r);
	SetWorkingImage();

	int x = player.x - (Wide / 2);
	int y = player.y - (Hight / 2);
	//防止窗口越界
	if (x < 0)
	{
		x = 0;
	}
	if (y < 0)
	{
		y = 0;
	}
	if (x > Wide_map - Wide)
	{
		x = Wide_map - Wide;
	}
	if (y > Hight_map - Hight)
	{
		y = Hight_map - Hight;
	}
	//把map输出到窗口上
	putimage(0, 0, Wide, Hight, &map, x, y);
}

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的范围：

//防止窗口越界
if (x < 0)
{
	x = 0;
}
if (y < 0)
{
	y = 0;
}
if (x > Wide_map - Wide)
{
	x = Wide_map - Wide;
}
if (y > Hight_map - Hight)
{
	y = Hight_map - Hight;
}

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，它的头文件是<math.h>。

//距离
int Distance(int x, int y, int x1, int y1)
{
	return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}

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

void Enemy_move()
{
	srand((unsigned)time(NULL));
	for (int i = 0; i < Enemy_num; i++)
	{
		int direction = rand() % 4;

		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
		{
			if (direction == 0)
			{
				if (Enemy[i].y > 0)//防止小球越界的判断语句
				{
					Enemy[i].y -= enemy_sleep;
				}
			}
			if (direction == 1)
			{
				if (Enemy[i].y < Hight_map)
					Enemy[i].y += enemy_sleep;
			}
			if (direction == 2)
			{
				if (Enemy[i].x > 0)
					Enemy[i].x -= enemy_sleep;
			}
			if (direction == 3)
			{
				if (Enemy[i].x < Wide_map)
					Enemy[i].x += enemy_sleep;
			}
		}
		//敌人追击玩家
		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
		{
			if (Enemy[i].r > player.r)
			{
				if (Enemy[i].x < player.x)
				{
					if (Enemy[i].x < Wide_map)
					{
						Enemy[i].x += enemy_sleep;
					}
				}
				if (Enemy[i].x > player.x)
				{
					if (Enemy[i].x > 0)
					{
						Enemy[i].x -= enemy_sleep;
					}
				}
				if (Enemy[i].y < player.y)
				{
					if (Enemy[i].y < Hight_map)
					{
						Enemy[i].y += enemy_sleep;
					}
				}
				if (Enemy[i].y > player.y)
				{
					if (Enemy[i].y > 0)
					{
						Enemy[i].y -= enemy_sleep;
					}
				}
			}
			//敌人逃跑
			else
			{
				if (Enemy[i].x < player.x)
				{
					if (Enemy[i].x > 0)
					{
						Enemy[i].x -= enemy_sleep;
					}
				}
				if (Enemy[i].x > player.x)
				{
					if (Enemy[i].x < Wide_map)
					{
						Enemy[i].x += enemy_sleep;
					}
				}
				if (Enemy[i].y < player.y)
				{
					if (Enemy[i].y > 0)
					{
						Enemy[i].y -= enemy_sleep;
					}
				}
				if (Enemy[i].y > player.y)
				{
					if (Enemy[i].y < Hight_map)
					{
						Enemy[i].y += enemy_sleep;
					}
				}
			}
		}
	}
}

7. 小球之间的吞噬关系

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

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

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

void EatFood()
{
	for (int i = 0; i < Food_num; i++)
	{
		//玩家吃食物
		if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
		{
			player.r += Food[i].r / 100;
			Food[i].x = rand() % Wide_map;
			Food[i].y = rand() % Hight_map;
			Food[i].r = rand() % 5 + 1;
			Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
		}
		
	}
	for (int j = 0; j < Enemy_num; j++)
	{
		//敌人吃食物
		for (int i = 0; i < Food_num; i++)
		{
			if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
			{
				Enemy[j].r += Food[i].r / 50;
				Food[i].x = rand() % Wide_map;
				Food[i].y = rand() % Hight_map;
				Food[i].r = rand() % 5 + 1;
				Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
			}
		}
		//敌人吃敌人
		for (int i = 0; i < Enemy_num; i++)
		{
			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
			{
				Enemy[j].r += Enemy[i].r / 10;
				Enemy[i].x = rand() % Wide_map;
				Enemy[i].y = rand() % Hight_map;
				Enemy[i].r = 10;
					Enemy[i].color = RGB(0, 255, 0);
			}
			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
			{
				Enemy[i].r += Enemy[j].r / 10;
				Enemy[j].x = rand() % Wide_map;
				Enemy[j].y = rand() % Hight_map;
				Enemy[j].r = 10;
				Enemy[j].color = RGB(0, 255, 0);
			}
		}
		if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
		{
			//玩家吃敌人
			if (player.r > Enemy[j].r)
			{
				player.r += Enemy[j].r / 10;
				Enemy[j].x = rand() % Wide_map;
				Enemy[j].y = rand() % Hight_map;
				Enemy[j].r = 10;
				Enemy[j].color = RGB(0, 255, 0);
			}
			//敌人吃玩家
			else
			{
				if (invincibility == 0)
				{
					Enemy[j].r += player.r / 10;
					player.x = Wide / 2;
					player.y = Hight / 2;
					player.r = 10;
					invincibility = 10;
				}
			}
		}
	}
}

最终效果：

球球大作战

源码：

#include<stdio.h>
#include<easyx.h>
#include<time.h>
#include<math.h>
#define Wide 1024
#define Hight 640
#define Wide_map (Wide*5)
#define Hight_map (Hight*5)
#define Food_num 1888
#define Enemy_num 888
//整个游戏地图
IMAGE map(Wide_map, Hight_map);
//复活时的无敌时间
int invincibility = 10; 
//玩家速度
int player_sleep = 5;
int l = 5;
int enemy_sleep = 5;
struct Ball
{
	int x;
	int y;
	float r;
	DWORD color;
};
struct Ball player;
struct Ball Food[Food_num];
struct Ball Enemy[Enemy_num];
//初始化球的数据
void Inset()
{
	srand((unsigned)time(NULL));
	player.x = Wide / 2;
	player.y = Hight / 2;
	player.r = 10;
	for (int i = 0; i < Food_num; i++)
	{
		Food[i].x = rand() % Wide_map;
		Food[i].y = rand() % Hight_map;
		Food[i].r = rand() % 5 + 1;
		Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
	}
	for (int i = 0; i < Enemy_num; i++)
	{
		Enemy[i].x = rand() % Wide_map;
		Enemy[i].y = rand() % Hight_map;
		Enemy[i].r = 10;
		Enemy[i].color = RGB(0,255,0);
	}
 
}
//玩家操作
void Player_move()
{
	if (GetAsyncKeyState(VK_UP))
	{
		if (player.y > 0)
		{
			player.y -= player_sleep;
		}
	}
	if (GetAsyncKeyState(VK_DOWN))
	{
		if (player.y < Hight_map)
		player.y += player_sleep;
	}
	if (GetAsyncKeyState(VK_LEFT))
	{
		if (player.x > 0)
		player.x -= player_sleep;
	}
	if (GetAsyncKeyState(VK_RIGHT))
	{
		if (player.x < Wide_map)
		player.x += player_sleep;
	}
	if (GetAsyncKeyState(0x20))
	{
		player_sleep = l + 5;
	}
	else
	{
		player_sleep = l;
	}
}
//距离
int Distance(int x, int y, int x1, int y1)
{
	return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}
//敌人移动
void Enemy_move()
{
	srand((unsigned)time(NULL));
	for (int i = 0; i < Enemy_num; i++)
	{
		int direction = rand() % 400;
 
		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
		{
			if (direction < 100)
			{
				if (Enemy[i].y > 0)
				{
					Enemy[i].y -= enemy_sleep;
				}
			}
			if (direction < 200 && direction >= 100)
			{
				if (Enemy[i].y < Hight_map)
					Enemy[i].y += enemy_sleep;
			}
			if (direction < 300 && direction >= 200)
			{
				if (Enemy[i].x > 0)
					Enemy[i].x -= enemy_sleep;
			}
			if (direction <400 && direction >= 300)
			{
				if (Enemy[i].x < Wide_map)
					Enemy[i].x += enemy_sleep;
			}
		}
		//敌人追击玩家
		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) < player.r + Enemy[i].r + 50)
		{
			if (Enemy[i].r > player.r)
			{
				if (Enemy[i].x < player.x)
				{
					if (Enemy[i].x < Wide_map)
					{
						Enemy[i].x += enemy_sleep;
					}
				}
				if (Enemy[i].x > player.x)
				{
					if (Enemy[i].x > 0)
					{
						Enemy[i].x -= enemy_sleep;
					}
				}
				if (Enemy[i].y < player.y)
				{
					if (Enemy[i].y < Hight_map)
					{
						Enemy[i].y += enemy_sleep;
					}
				}
				if (Enemy[i].y > player.y)
				{
					if (Enemy[i].y > 0)
					{
						Enemy[i].y -= enemy_sleep;
					}
				}
			}
			//敌人逃跑
			else
			{
				if (Enemy[i].x < player.x)
				{
					if (Enemy[i].x > 0)
					{
						Enemy[i].x -= enemy_sleep;
					}
				}
				if (Enemy[i].x > player.x)
				{
					if (Enemy[i].x < Wide_map)
					{
						Enemy[i].x += enemy_sleep;
					}
				}
				if (Enemy[i].y < player.y)
				{
					if (Enemy[i].y > 0)
					{
						Enemy[i].y -= enemy_sleep;
					}
				}
				if (Enemy[i].y > player.y)
				{
					if (Enemy[i].y < Hight_map)
					{
						Enemy[i].y += enemy_sleep;
					}
				}
			}
		}
		//for (int j = 0; j < Enemy_num; j++)
		//{
		//	if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r + Enemy[i].r + 30)
		//	{
		//		//敌人追敌人
		//		if (Enemy[i].r > Enemy[j].r)
		//		{
		//			int sleep = rand() % 6;
		//			int enemy_sleep1;
		//			if (sleep > 2)
		//			{
		//				enemy_sleep1 = enemy_sleep;
		//			}
		//			else
		//			{
		//				enemy_sleep1 = enemy_sleep + 5;
		//			}
		//			if (Enemy[i].x < Enemy[j].x)
		//			{
		//				if (Enemy[i].x < Wide_map)
		//				{
		//					Enemy[i].x += enemy_sleep1;
		//				}
		//			}
		//			if (Enemy[i].x > Enemy[j].x)
		//			{
		//				if (Enemy[i].x > 0)
		//				{
		//					Enemy[i].x -= enemy_sleep1;
		//				}
		//			}
		//			if (Enemy[i].y < Enemy[j].y)
		//			{
		//				if (Enemy[i].y < Hight_map)
		//				{
		//					Enemy[i].y += enemy_sleep1;
		//				}
		//			}
		//			if (Enemy[i].y > Enemy[j].y)
		//			{
		//				if (Enemy[i].y > 0)
		//				{
		//					Enemy[i].y -= enemy_sleep1;
		//				}
		//			}
		//		}
		//		//逃跑
		//		else
		//		{
		//			int sleep = rand() % 6;
		//			int enemy_sleep1;
		//			if (sleep > 2)
		//			{
		//				enemy_sleep1 = enemy_sleep;
		//			}
		//			else
		//			{
		//				enemy_sleep1 = enemy_sleep + 5;
		//			}
		//			if (Enemy[i].x < Enemy[j].x)
		//			{
		//				if (Enemy[i].x > 0)
		//				{
		//					Enemy[i].x -= enemy_sleep1;
		//				}
		//			}
		//			if (Enemy[i].x > Enemy[j].x)
		//			{
		//				if (Enemy[i].x < Wide_map)
		//				{
		//					Enemy[i].x += enemy_sleep1;
		//				}
		//			}
		//			if (Enemy[i].y < Enemy[j].y)
		//			{
		//				if (Enemy[i].y > 0)
		//				{
		//					Enemy[i].y -= enemy_sleep1;
		//				}
		//			}
		//			if (Enemy[i].y > Enemy[j].y)
		//			{
		//				if (Enemy[i].y < Hight_map)
		//				{
		//					Enemy[i].y += enemy_sleep1;
		//				}
		//			}
		//		}
		//	}
		//}
	}
}
 
//吃食物
void EatFood()
{
	for (int i = 0; i < Food_num; i++)
	{
		//玩家吃食物
		if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
		{
			player.r += Food[i].r / 100;
			Food[i].x = rand() % Wide_map;
			Food[i].y = rand() % Hight_map;
			Food[i].r = rand() % 5 + 1;
			Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
		}
		
	}
	for (int j = 0; j < Enemy_num; j++)
	{
		//敌人吃食物
		for (int i = 0; i < Food_num; i++)
		{
			if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
			{
				Enemy[j].r += Food[i].r / 50;
				Food[i].x = rand() % Wide_map;
				Food[i].y = rand() % Hight_map;
				Food[i].r = rand() % 5 + 1;
				Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
			}
		}
		//敌人吃敌人
		for (int i = 0; i < Enemy_num; i++)
		{
			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
			{
				Enemy[j].r += Enemy[i].r / 10;
				Enemy[i].x = rand() % Wide_map;
				Enemy[i].y = rand() % Hight_map;
				Enemy[i].r = 10;
					Enemy[i].color = RGB(0, 255, 0);
			}
			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
			{
				Enemy[i].r += Enemy[j].r / 10;
				Enemy[j].x = rand() % Wide_map;
				Enemy[j].y = rand() % Hight_map;
				Enemy[j].r = 10;
				Enemy[j].color = RGB(0, 255, 0);
			}
		}
		if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
		{
			//玩家吃敌人
			if (player.r > Enemy[j].r)
			{
				player.r += Enemy[j].r / 10;
				Enemy[j].x = rand() % Wide_map;
				Enemy[j].y = rand() % Hight_map;
				Enemy[j].r = 10;
				Enemy[j].color = RGB(0, 255, 0);
			}
			//敌人吃玩家
			else
			{
				if (invincibility == 0)
				{
					Enemy[j].r += player.r / 10;
					player.x = Wide / 2;
					player.y = Hight / 2;
					player.r = 10;
					invincibility = 10;
				}
			}
		}
	}
}
//显示
void Show()
{
	
	//设置地图
	SetWorkingImage(&map);
	//清屏
	cleardevice();
	//背景颜色
	setbkcolor(WHITE);
	//划线颜色
	setlinecolor(RGB(230,231,239));
	//划线
	for (int i = 0; i < Wide_map; i += 10)
	{
		line(i, 0, i, Hight_map);
	}
	for (int i = 0; i < Hight_map; i += 10)
	{
		line(0, i, Wide_map, i);
	}
	//食物
	for (int i = 0; i < Food_num; i++)
	{
		setfillcolor(Food[i].color);
		solidcircle(Food[i].x, Food[i].y, Food[i].r);
	}
	//敌人
	for (int i = 0; i < Enemy_num; i++)
	{
		setfillcolor(Enemy[i].color);
		solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
	}
	//玩家
	setfillcolor(RED);
	solidcircle(player.x, player.y, player.r);
	SetWorkingImage();
 
	int x = player.x - (Wide / 2);
	int y = player.y - (Hight / 2);
	//防止窗口越界
	if (x < 0)
	{
		x = 0;
	}
	if (y < 0)
	{
		y = 0;
	}
	if (x > Wide_map - Wide)
	{
		x = Wide_map - Wide;
	}
	if (y > Hight_map - Hight)
	{
		y = Hight_map - Hight;
	}
	//把map输出到窗口上
	putimage(0, 0, Wide, Hight, &map, x, y);
}
int main()
{
	
	initgraph(Wide, Hight);
	Inset();
	//缓冲
	BeginBatchDraw();
	while (1)
	{
		if (invincibility > 0)
			invincibility--;
		Show();
		//玩家操作
		Player_move();
		Enemy_move();
		EatFood();
		//刷新
		FlushBatchDraw();
	}
	closegraph();
	return 0;
}

//修改版
#include<stdio.h>
#include<easyx.h>
#include<time.h>
#include<math.h>
#define Wide 1139
#define Hight 640
#define Wide_map (Wide*5)
#define Hight_map (Hight*5)
#define Food_num 2888
#define Enemy_num 388
#define Invincibility 50
//整个游戏地图
IMAGE map(Wide_map, Hight_map);
//复活时的无敌时间
int invincibility = Invincibility;
//玩家速度
int player_sleep = 2;
int l = 2;
int enemy_sleep = 2;
struct Ball
{
	int x;
	int y;
	float r;
	DWORD color;
};
struct Ball player;
struct Ball Food[Food_num];
struct Ball Enemy[Enemy_num];
//初始化球的数据
void Inset()
{
	srand((unsigned)time(NULL));
	player.x = Wide / 2;
	player.y = Hight / 2;
	player.r = 15;
	for (int i = 0; i < Food_num; i++)
	{
		Food[i].x = rand() % Wide_map;
		Food[i].y = rand() % Hight_map;
		Food[i].r = rand() % 5 + 1;
		Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
	}
	for (int i = 0; i < Enemy_num; i++)
	{
		Enemy[i].x = rand() % Wide_map;
		Enemy[i].y = rand() % Hight_map;
		Enemy[i].r = rand() % 15 + 15;
		Enemy[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
	}

}
//玩家操作
void Player_move()
{
	if (GetAsyncKeyState(VK_UP)|| GetAsyncKeyState(0x57))
	{
		if (player.y > 0)
		{
			player.y -= player_sleep;
		}
	}
	if (GetAsyncKeyState(VK_DOWN)||GetAsyncKeyState(83))
	{
		if (player.y < Hight_map)
		player.y += player_sleep;
	}
	if (GetAsyncKeyState(VK_LEFT)|| GetAsyncKeyState(65))
	{
		if (player.x > 0)
		player.x -= player_sleep;
	}
	if (GetAsyncKeyState(VK_RIGHT)|| GetAsyncKeyState(68))
	{
		if (player.x < Wide_map)
		player.x += player_sleep;
	}
	if (GetAsyncKeyState(0x20))
	{
		player_sleep = l + 2;
	}
	else
	{
		player_sleep = l;
	}
}
//距离
int Distance(int x, int y, int x1, int y1)
{
	return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}
//敌人移动
void Enemy_move()
{
	srand((unsigned)time(NULL));
	for (int i = 0; i < Enemy_num; i++)
	{
		int direction = rand() % 400;

		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) > player.r + Enemy[i].r + 50)
		{
			if (direction < 100)
			{
				if (Enemy[i].y > 0)
				{
					Enemy[i].y -= enemy_sleep;
				}
			}
			if (direction < 200 && direction >= 100)
			{
				if (Enemy[i].y < Hight_map)
					Enemy[i].y += enemy_sleep;
			}
			if (direction < 300 && direction >= 200)
			{
				if (Enemy[i].x > 0)
					Enemy[i].x -= enemy_sleep;
			}
			if (direction <400 && direction >= 300)
			{
				if (Enemy[i].x < Wide_map)
					Enemy[i].x += enemy_sleep;
			}
		}
		//敌人追击玩家
		if (Distance(player.x, player.y, Enemy[i].x, Enemy[i].y) <= player.r + Enemy[i].r + 50)
		{
			if (Enemy[i].r > player.r)
			{
				if (Enemy[i].x < player.x)
				{
					if (Enemy[i].x < Wide_map)
					{
						Enemy[i].x += enemy_sleep;
					}
				}
				if (Enemy[i].x > player.x)
				{
					if (Enemy[i].x > 0)
					{
						Enemy[i].x -= enemy_sleep;
					}
				}
				if (Enemy[i].y < player.y)
				{
					if (Enemy[i].y < Hight_map)
					{
						Enemy[i].y += enemy_sleep;
					}
				}
				if (Enemy[i].y > player.y)
				{
					if (Enemy[i].y > 0)
					{
						Enemy[i].y -= enemy_sleep;
					}
				}
			}
			//敌人逃跑
			else
			{
				if (Enemy[i].x < player.x)
				{
					if (Enemy[i].x > 0)
					{
						Enemy[i].x -= enemy_sleep;
					}
				}
				if (Enemy[i].x > player.x)
				{
					if (Enemy[i].x < Wide_map)
					{
						Enemy[i].x += enemy_sleep;
					}
				}
				if (Enemy[i].y < player.y)
				{
					if (Enemy[i].y > 0)
					{
						Enemy[i].y -= enemy_sleep;
					}
				}
				if (Enemy[i].y > player.y)
				{
					if (Enemy[i].y < Hight_map)
					{
						Enemy[i].y += enemy_sleep;
					}
				}
			}
		}
		
	}
}

//吃食物
void EatFood()
{
	for (int i = 0; i < Food_num; i++)
	{
		//玩家吃食物
		if (Distance(player.x, player.y, Food[i].x, Food[i].y) < player.r)
		{
			player.r += Food[i].r / 50;
			Food[i].x = rand() % Wide_map;
			Food[i].y = rand() % Hight_map;
			Food[i].r = rand() % 5 + 1;
			Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
		}
		
	}
	for (int j = 0; j < Enemy_num; j++)
	{
		//敌人吃食物
		for (int i = 0; i < Food_num; i++)
		{
			if (Distance(Enemy[j].x, Enemy[j].y, Food[i].x, Food[i].y) < Enemy[j].r)
			{
				Enemy[j].r += Food[i].r / 50;
				Food[i].x = rand() % Wide_map;
				Food[i].y = rand() % Hight_map;
				Food[i].r = rand() % 5 + 1;
				Food[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
			}
		}
		//敌人吃敌人
		for (int i = 0; i < Enemy_num; i++)
		{
			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[j].r&& Enemy[j].r > Enemy[i].r)
			{
				Enemy[j].r += Enemy[i].r / 10;
				Enemy[i].x = rand() % Wide_map;
				Enemy[i].y = rand() % Hight_map;
				Enemy[i].r = rand() % 10 + 15;
				Enemy[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
			}
			if (Distance(Enemy[j].x, Enemy[j].y, Enemy[i].x, Enemy[i].y) < Enemy[i].r && Enemy[j].r < Enemy[i].r)
			{
				Enemy[i].r += Enemy[j].r / 10;
				Enemy[j].x = rand() % Wide_map;
				Enemy[j].y = rand() % Hight_map;
				Enemy[j].r = rand() % 10 + 15;
				Enemy[j].color = RGB(rand() % 256, rand() % 256, rand() % 256);
			}
		}
		if (Distance(player.x, player.y, Enemy[j].x, Enemy[j].y) < player.r)
		{
			//玩家吃敌人
			if (player.r > Enemy[j].r)
			{
				player.r += Enemy[j].r / 10;
				Enemy[j].x = rand() % Wide_map;
				Enemy[j].y = rand() % Hight_map;
				Enemy[j].r = rand() % 10 + 15;
				Enemy[j].color = RGB(rand() % 256, rand() % 256, rand() % 256);
			}
			//敌人吃玩家
			else
			{
				if (invincibility == 0)
				{
					Enemy[j].r += player.r / 10;
					player.x = Wide / 2;
					player.y = Hight / 2;
					player.r = 15;
					invincibility = Invincibility;
				}
			}
		}
	}
}
//显示
void Show()
{
	
	//设置地图
	SetWorkingImage(&map);
	//清屏
	cleardevice();
	//背景颜色
	setbkcolor(RGB(46, 47, 68));
	//划线颜色
	//setlinecolor(RGB(230,231,239));
	划线
	//for (int i = 0; i < Wide_map; i += 10)
	//{
	//	line(i, 0, i, Hight_map);
	//}
	//for (int i = 0; i < Hight_map; i += 10)
	//{
	//	line(0, i, Wide_map, i);
	//}
	//食物
	for (int i = 0; i < Food_num; i++)
	{
		setfillcolor(Food[i].color);
		solidcircle(Food[i].x, Food[i].y, Food[i].r);
	}
	//敌人
	for (int i = 0; i < Enemy_num; i++)
	{
		setfillcolor(Enemy[i].color);
		solidcircle(Enemy[i].x, Enemy[i].y, Enemy[i].r);
	}
	//玩家
	setfillcolor(RED);
	solidcircle(player.x, player.y, player.r);
	SetWorkingImage();

	int x = player.x - (Wide / 2);
	int y = player.y - (Hight / 2);
	//防止窗口越界
	if (x < 0)
	{
		x = 0;
	}
	if (y < 0)
	{
		y = 0;
	}
	if (x > Wide_map - Wide)
	{
		x = Wide_map - Wide;
	}
	if (y > Hight_map - Hight)
	{
		y = Hight_map - Hight;
	}
	//把map输出到窗口上
	putimage(0, 0, Wide, Hight, &map, x, y);
}
int main()
{
	
	initgraph(Wide, Hight);
	Inset();
	//缓冲
	BeginBatchDraw();
	while (1)
	{
		if (invincibility > 0)
			invincibility--;
		Show();
		//玩家操作
		Player_move();
		Enemy_move();
		EatFood();
		//刷新
		FlushBatchDraw();
	}
	closegraph();
	return 0;
}

Code Warrior
关注
  • 1616
    点赞
  • 踩
  • 5891
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 130
    评论
专栏目录
C语言制作的球球大作战带视频亲测游戏.rar
08-14
C语言制作的球球大作战带视频亲测游戏.rar
精美的球球大作战游戏
02-28
一款c语言小游戏，球球大作战。以玩家间的实时互动PK产生游戏乐趣为设计宗旨，通过简单的规则将玩家操作直接转化为游戏策略，体验智谋碰撞的战斗乐趣。《球球大作战》是一款好玩，萌酷，有挑战性，可与全球玩家实时对战的休闲游戏。在这个球球的世界里，每个人都化身为一颗独特的球球，大球吃小球，努力生存下来就是唯一目标。
c语言-球球大作战软件
03-03
本次分享的资源是我个人开发的简易版单人球球大作战游戏软件。这款游戏灵感来源于流行的在线多人游戏“球球大作战”，但我的版本专为单人体验设计，旨在提供一个简单易上手、休闲而又具有挑战性的游戏体验。 软件功能： 单人游戏体验：玩家与计算机控制的对手进行对战，无需联网等待，随时享受游戏乐趣。 简洁直观的操作界面：清晰易懂的界面设计，帮助玩家快速入门。 吞噬成长机制：通过吞噬地图中的小颗粒使球球不断变大，以达成更高分数。 ai小球设置：地图内设有多个ai小球，它们可以根据自身的大小和与玩家的距离来选择追击玩家或者逃跑，增加游戏的趣味性。 积分系统：设立积分系统，玩家可挑战自我，刷新最高记录。 注意事项： 本软件仅供个人学习和娱乐使用，请勿用于商业目的。 请遵守相关的法律法规，并尊重知识产权。 遇到问题或有改进建议时，欢迎提出，以便持续完善游戏。 结语： 这款单人版的简易球球大作战游戏旨在带给玩家轻松愉快的单机体验。希望它能在您空闲时提供一些简单的快乐，并期待您的反馈和支持！
c语言游戏实战（10）：坤坤的篮球回避秀的图片资源
03-05
这里面包含博文： 《c语言游戏实战（10）：坤坤的篮球回避秀》https://blog.csdn.net/weixin_58252863/article/details/136474286 的所有图片资源，需要的朋友可以自行下载。
c语言球球大作战
06-20
自己独立完成的球球大作战游戏，当做课程设计了，不会与其他人的重复
C 语言游戏实战：球球大作战
最新发布
weixin_44361445的博客
04-24 160
在本篇文章中，我们将探讨如何使用 C 语言创建一个简单但有趣的游戏——球球大作战。球球大作战是一款流行的在线多人游戏，玩家控制一个球体，吞食其他球体以增长自己的体积，并尽可能生存更长时间。我们将使用 C 语言和简单的控制台图形界面来实现这个游戏的基本功能。希望这篇文章能帮助你了解如何使用 C 语言制作简单的游戏，并激发你对游戏开发的兴趣！接下来，让我们开始编写代码。我们将使用 C 语言的基本语法和控制台输入输出函数来实现游戏的功能。首先，我们需要创建一个游戏地图，并在地图上绘制玩家控制的球体以及其他球体。
【源码+文档】C语言实战期末项目：球球大作战
yuxibdd的博客
08-21 292
大球吃小球，若a.r>b.r且a和b 圆心距d<a.r+b.r，则a.r = sqrt(a.r。初始化AI，生成指定数量的AI，每个AI随机坐标，生命值均为1，颜色随机，大小固定与玩家相同，形状为圆形。随机位置生成指定数量的食物，颜色随机，大小在一定范围内随机，形状为圆形、椭圆形、圆角矩形等随机。b.r)，b.r=0，b的生命变为0。所有AI的生命都变为0时，游戏结束，获得胜利。8）玩家如果被AI吃，玩家生命变为0，游戏结束，游戏失败，显示游戏累 计时间。1）性能：程序总体占用空间较小，响应时间较块。
C语言项目实战：《球球大作战》零基础项目 + 源码示例
致力于C语言C++知识分享！
11-18 1532
这篇文章主要为大家详细介绍了C语言实现——《球球大作战项目》，文中示例代码介绍的非常详细，具有一定的参考价值,感兴趣的小伙伴们可以参考一下！在室友面前秀一下岂不是美滋滋！ 游戏介绍： 这是一个大球吃小球的世界，玩家的目标是要努力吃成最大的球球。在游戏一开始，玩家出现在地图上随机位置，地图里洒满了小彩豆，玩家吃掉小彩豆体积就会增大，当增大到比别人的球大时，就可以吃别人的球啦，当然也得躲避更大的球。小球速度快，大球速度慢。球球到达一定重量后，可以分身，一个球变成等大的两个球，可以再次分身，但是最多可以拥
C语言项目实战：《球球大作战》零基础项目，185 行源代码示例
yx5666的博客
04-14 3105
这篇文章主要为大家详细介绍了C语言实现——《球球大作战项目》，文中示例代码介绍的非常详细，具有一定的参考价值,感兴趣的小伙伴们可以参考一下，在室友面前秀一下岂不是美滋滋 游戏介绍： 这是一个大球吃小球的世界，玩家的目标是要努力吃成最大的球球。在游戏一开始，玩家出现在地图上随机位置，地图里洒满了小彩豆，玩家吃掉小彩豆体积就会增大，当增大到比别人的球大时，就可以吃别人的球啦，当然也得躲避更大的球。小球速度快，大球速度慢。球球到达一定重量后，可以分身，一个球变成等大的两个球，可以再次分身，但是最多可以拥有
球球大作战
10-04
贪婪球.cpp 自己写的小游戏.
C语言指针应用实战：字符串解析
08-28
曾经从朋友那见过一道题，解析以下字符串"abc=b\\n;c=\\x61d;d=234;t=\\n;d=\"test;yes\";m=1023456;h=123dfr;"。出于强化自己C语言指针应用能力的目的，写了如下代码。运行结果也已经打包进资源中。如有需求可在评论中回复，看到后回抽时间讲解回复。
球球大作战C语言实战.zip
12-26
球球大作战C语言实战.zip
C语言程序设计课件：9 文件.ppt
05-07
C语言程序设计课件：9 文件.ppt
C语言学习路线图：C语言开发入门及项目实战
07-22
资源名称：C语言学习路线图：C语言开发入门及项目实战资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
基于C语言实现球球大作战游戏【100012443】
05-25
本项目是基于C语言开发，开发平台我们选择Visual Studio 2017 Community，此版本为免费版，由Microsoft公司免费提供给开发者使用；主流的开发环境有Windows和Linux，我们选择使用Windows进行开发，因为Windows我们...
C语言案例-球球大作战.zip
12-21
完整C语言案例。
球球大作战源代码
10-05
球球大作战源代码2号,实现小地图和毒圈..功能完善,视野变化
C语言大作业：贪吃蛇游戏
12-09
使用easyx库和VS开发，总代码量300多行，无实验报告，内含已打包的setup文件（安装包），只有一个源文件，无头文件，适合C语言新手应付大作业。
贪吃蛇大作战c语言代码
05-13
很抱歉，我无法提供完整的代码，但我可以提供一些指导和思路。 "贪吃蛇大作战"游戏的基本逻辑是蛇在地图上移动，吃掉食物，长大，并避免撞到边界或自己的身体。要实现这个游戏，您需要使用编程语言，如C语言，编写代码实现以下几个部分: 1. 地图初始化：您需要定义游戏地图的大小和边界。 2. 蛇的初始化：您需要定义蛇的初始长度和位置。 3. 食物生成：您需要随机生成食物的位置。 4. 蛇的移动：您需要编写代码使蛇能够移动，并更新蛇的位置和长度。 5. 碰撞检测：您需要编写代码检测蛇是否撞到了边界或自己的身体。 6. 循环游戏：您需要编写代码使游戏能够不断循环直到结束。 这些是贪吃蛇游戏的基本部分，您可以在此基础上进行更多的扩展和改进。希望以上内容对您有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 130
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Code Warrior

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值