1. 首页
  2. 文章中心
  3. # C语言游戏开发

Easyx项目小合集项目名称: 迷宫项目名称: 打雷风景项目名称: 烟花

71 阅读 0 评论
我是靠谱客的博主 拉长面包，最近开发中收集的这篇文章主要介绍Easyx项目小合集项目名称: 迷宫项目名称: 打雷风景项目名称: 烟花，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

这好像是很早之前，在官网找的项目

目录

  • 项目名称: 迷宫
  • 项目名称: 打雷风景
  • 项目名称: 烟花

项目名称: 迷宫

#include <graphics.h>
#include <time.h>



//
// 定义全局变量
//
BYTE**	g_aryMap = NULL;			// 迷宫地图
SIZE	g_szMap;					// 迷宫地图的尺寸
IMAGE	g_imgSight(360, 280);		// 游戏的视野
RECT	g_rtSight;					// 游戏的视野的范围
IMAGE	g_imgItem(180, 20);			// 地图元素
IMAGE	g_imgGPS;					// 迷你地图，用于显示游戏者在地图中的位置
POINT	g_ptGPS;					// 迷你地图的显示位置
SIZE	g_szGPS;					// 迷你地图的尺寸
POINT	g_ptPlayer;					// 游戏者的位置

// 枚举地图元素，兼做元素位置的 x 坐标
enum MAPITEM { MAP_WALL = 0, MAP_PLAYER = 20, MAP_GROUND = 40, MAP_MARKRED = 60, MAP_MARKGREEN = 80, MAP_MARKYELLOW = 100, MAP_ENTRANCE = 120, MAP_EXIT = 140, MAP_OUTSIDE = 160 };
// 枚举用户的控制命令
enum CMD { CMD_QUIT = 1, CMD_UP = 2, CMD_DOWN = 4, CMD_LEFT = 8, CMD_RIGHT = 16, CMD_MARKRED = 32, CMD_MARKGREEN = 64, CMD_MARKYELLOW = 128, CMD_CLEARMARK = 256 };



//
// 函数声明
//
void	Welcome();							// 绘制游戏界面
void	InitImage();						// 初始化游戏图片
void	InitGame();							// 初始化游戏数据
void	GetMazeSize();						// 提示用户输入迷宫大小
void	MakeMaze(int width, int height);	// 生成迷宫：初始化（注：宽高必须是奇数）
void	TravelMaze(int x, int y);			// 生成迷宫：遍历 (x, y) 四周
MAPITEM	GetMazeItem(int x, int y);			// 获取指定坐标的迷宫元素
void	Paint();							// 绘制视野范围内的迷宫
int		GetCmd();							// 获取用户输入的命令
void	DispatchCmd(int cmd);				// 处理用户输入的命令
void	OnUp();								// 向上移动
void	OnLeft();							// 向左移动
void	OnRight();							// 向右移动
void	OnDown();							// 向下移动
void	OnMark(MAPITEM value);				// 在地图中做标记
bool	CheckWin();							// 检查是否到出口
bool	Quit();								// 询问用户是否退出游戏



//
// 函数定义
//


// 主程序
void main()
{
	// 初始化
	initgraph(640, 480);			// 创建绘图窗口
	srand((unsigned)time(NULL));	// 设置随机种子

	// 显示主界面
	Welcome();

	// 初始化
	InitImage();
	InitGame();

	// 游戏过程
	int c;
	while( !(((c = GetCmd()) & CMD_QUIT) && Quit()) )
	{
		DispatchCmd(c);
		Paint();
		if (CheckWin())
			break;

		// 延时
		Sleep(100);
	}

	// 清理迷宫地图占用的内存
	for(int x = 0; x < g_szMap.cx + 2; x++)
		delete[] g_aryMap[x];
	delete [] g_aryMap;

	// 关闭图形模式
	closegraph();
}


// 绘制游戏界面
void Welcome()
{
	// 绘制渐变色外框
	for(int i=0; i<128; i++)
	{
		setlinecolor(RGB(0, 0, (127 - i) << 1));
		rectangle(149 - i, 109 - (i >> 1), 490 + i, 370 + (i >> 1));
	}

	// 设置字体样式
	settextcolor(WHITE);
	setbkmode(TRANSPARENT);

	// 绘制标题
	settextstyle(36, 0, _T("宋体"));
	outtextxy(248, 40, _T("迷　　宫"));

	// 绘制操作说明
	settextstyle(12, 0, _T("宋体"));
	outtextxy(50, 382, _T("控制说明："));
	outtextxy(74, 400, _T("方向键或 A/S/D/W：移动"));
	outtextxy(74, 418, _T("空格、Y、G：在地图上做红、黄、绿色 M 标记"));
	outtextxy(74, 436, _T("C：清除地图上的标记"));
	outtextxy(74, 454, _T("ESC：退出程序"));
}


// 初始化游戏图片
void InitImage()
{
	// 预绘制游戏图片到 IMAGE 缓存（可以修改为加载图片以获得更好效果）
	SetWorkingImage(&g_imgItem);
	cleardevice();
	// 绘制 PLAYER
	setorigin(MAP_PLAYER, 0);
	setfillcolor(YELLOW);
	setlinecolor(YELLOW);
	fillellipse(2, 2, 17, 17);
	setlinecolor(BLACK);
	line(7, 7, 7, 8);
	line(12, 7, 12, 8);
	arc(5, 6, 14, 14, 3.34, 6.08);
	// 绘制墙壁
	setorigin(MAP_WALL, 0);
	settextcolor(BROWN);
	setfillstyle((BYTE*)"x20x20x20xffx04x04x04xff");
	setlinecolor(BROWN);
	solidrectangle(1, 1, 18, 18);
	rectangle(0, 0, 19, 19);
	// 绘制红色标记
	setorigin(MAP_MARKRED, 0);
	setlinecolor(RED);
	moveto(5, 15);
	linerel(0, -10);	linerel(5, 5);	linerel(5, -5);		linerel(0, 10);
	// 绘制绿色标记
	setorigin(MAP_MARKGREEN, 0);
	setlinecolor(GREEN);
	moveto(5, 15);
	linerel(0, -10);	linerel(5, 5);	linerel(5, -5);		linerel(0, 10);
	// 绘制黄色标记
	setorigin(MAP_MARKYELLOW, 0);
	setlinecolor(YELLOW);
	moveto(5, 15);
	linerel(0, -10);	linerel(5, 5);	linerel(5, -5);		linerel(0, 10);
	// 绘制入口
	setorigin(MAP_ENTRANCE, 0);
	setlinecolor(GREEN);
	settextstyle(12, 0, _T("宋体"));
	outtextxy(4, 4, _T("入"));
	// 绘制出口
	setorigin(MAP_EXIT, 0);
	outtextxy(4, 4, _T("出"));
	// 绘制迷宫外面的空地
	setorigin(MAP_OUTSIDE, 0);
	settextcolor(GREEN);
	setfillstyle((BYTE*)"x50x55x22x20x05x55x22x02");
	solidrectangle(0, 0, 19, 19);
	// 恢复坐标系
	setorigin(0, 0);

	// 显示作者
	SetWorkingImage();
	settextcolor(BLUE);
	TCHAR author[] = _T("Powered by zhaoh1987@qq.com");
	outtextxy(471, 4, author);
	settextcolor(LIGHTBLUE);
	outtextxy(470, 3, author);
}


// 初始化游戏数据
void InitGame()
{
	// 提示用户输入迷宫大小
	GetMazeSize();

	// 初始化参数
	if (g_aryMap != NULL)
	{	// 清理迷宫地图占用的内存
		for(int x = 0; x < g_szMap.cx + 2; x++)
			delete[] g_aryMap[x];
		delete [] g_aryMap;
	}
	MakeMaze(g_szMap.cx, g_szMap.cy);		// 创建迷宫
	g_ptPlayer.x	= 2;					// 设置游戏者的位置
	g_ptPlayer.y	= 2;
	g_rtSight.left	= 0;					// 设置视野范围
	g_rtSight.top	= 0;
	g_rtSight.right	= 17;
	g_rtSight.bottom= 13;

	// 设置 GPS 显示区
	setfillcolor(BLUE);
	solidrectangle(522, 368, 637, 471);
	if (g_szMap.cx > g_szMap.cy)	{	g_szGPS.cx = 100; g_szGPS.cy = (int)(100.0 * g_szMap.cy / g_szMap.cx + 0.5);	}
	else							{	g_szGPS.cy = 100; g_szGPS.cx = (int)(100.0 * g_szMap.cx / g_szMap.cy + 0.5);	}
	Resize(&g_imgGPS, g_szGPS.cx, g_szGPS.cy);
	g_ptGPS.x = 530 + 50 - g_szGPS.cx / 2;
	g_ptGPS.y = 370 + 50 - g_szGPS.cy / 2;
	// 画迷你地图外框
	setlinecolor(RED);
	rectangle(g_ptGPS.x - 1, g_ptGPS.y - 1, g_ptGPS.x + g_szGPS.cx, g_ptGPS.y + g_szGPS.cy);
	// 画迷你地图入口和出口
	setlinecolor(YELLOW);
	moveto(g_ptGPS.x - 8, g_ptGPS.y + g_szGPS.cy / g_szMap.cy);
	linerel(7, 0);	linerel(-3, -3);	moverel(3, 3);	linerel(-3, 3);
	moveto(g_ptGPS.x + g_szGPS.cx, g_ptGPS.y + g_szGPS.cy - g_szGPS.cy / g_szMap.cy);
	linerel(7, 0);	linerel(-3, -3);	moverel(3, 3);	linerel(-3, 3);

	// 绘制游戏区
	Paint();
}


// 提示用户输入迷宫大小
void GetMazeSize()
{
	g_szMap.cx = g_szMap.cy = 0;

	// 获取用户输入的宽高
	TCHAR s[4];
	while(g_szMap.cx < 20 || g_szMap.cx > 200)
	{
		InputBox(s, 4, _T("请输入迷宫的宽度n范围：20～200"), _T("输入"), _T("25"));
		g_szMap.cx = _ttoi(s);
	}
	while(g_szMap.cy < 20 || g_szMap.cx > 200)
	{
		InputBox(s, 4, _T("请输入迷宫的高度n范围：20～200"), _T("输入"), _T("25"));
		g_szMap.cy = _ttoi(s);
	}

	// 确保宽高为奇数
	if (g_szMap.cx % 2 != 1) g_szMap.cx++;
	if (g_szMap.cy % 2 != 1) g_szMap.cy++;
}


// 生成迷宫：初始化（注：宽高必须是奇数）
void MakeMaze(int width, int height)
{
	if (width % 2 != 1 || height % 2 != 1)
		return;

	int x, y;

	// 定义迷宫尺寸，并分配迷宫内存
	g_aryMap = new BYTE*[width + 2];
	for(x = 0; x < width + 2; x++)
	{
		g_aryMap[x] = new BYTE[height + 2];
		memset(g_aryMap[x], MAP_WALL, height + 2);
	}

	// 定义边界
	for (x = 0; x <= width + 1; x++)
		g_aryMap[x][0] = g_aryMap[x][height + 1] = MAP_GROUND;
	
	for (y = 1; y <= height; y++)
		g_aryMap[0][y] = g_aryMap[width + 1][y] = MAP_GROUND;
		
	// 定义入口和出口
	g_aryMap[1][2] = MAP_ENTRANCE;
	g_aryMap[width][height - 1] = MAP_EXIT;

	// 从任意点开始遍历生成迷宫
	TravelMaze(((rand() % (width - 1)) & 0xfffe) + 2, ((rand() % (height - 1)) & 0xfffe) + 2);

	// 将边界标记为迷宫外
	for (x = 0; x <= width + 1; x++)
		g_aryMap[x][0] = g_aryMap[x][height + 1] = MAP_OUTSIDE;
	
	for (y = 1; y <= height; y++)
		g_aryMap[0][y] = g_aryMap[width + 1][y] = MAP_OUTSIDE;
}


// 生成迷宫：遍历 (x, y) 四周
void TravelMaze(int x, int y)
{
	// 定义遍历方向
	int d[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
	
	// 将遍历方向乱序
	int n, t, i;
	for(i = 0; i < 4; i++)
	{
		n = rand() % 4;
		t = d[i][0], d[i][0] = d[n][0], d[n][0] = t;
		t = d[i][1], d[i][1] = d[n][1], d[n][1] = t;
	}
	
	// 尝试周围四个方向
	g_aryMap[x][y] = MAP_GROUND;
	for(i = 0; i < 4; i++)
		if (g_aryMap[x + 2 * d[i][0]][y + 2 * d[i][1]] == MAP_WALL)
		{
			g_aryMap[x + d[i][0]][y + d[i][1]] = MAP_GROUND;
			TravelMaze(x + d[i][0] * 2, y + d[i][1] * 2);		// 递归
		}
}


// 获取指定坐标的迷宫元素
MAPITEM GetMazeItem(int x, int y)
{
	return (MAPITEM)g_aryMap[x][y];
}


// 绘制视野范围内的迷宫
void Paint()
{
	int x1, y1;

	// 绘制视野内的迷宫
	SetWorkingImage(&g_imgSight);
	for(int x = g_rtSight.left; x <= g_rtSight.right; x++)
		for(int y = g_rtSight.top; y <= g_rtSight.bottom; y++)
		{
			x1 = (x - g_rtSight.left) * 20;
			y1 = (y - g_rtSight.top) * 20;
			putimage(x1, y1, 20, 20, &g_imgItem, GetMazeItem(x, y), 0);
		}

	// 绘制游戏者
	x1 = (g_ptPlayer.x - g_rtSight.left) * 20;
	y1 = (g_ptPlayer.y - g_rtSight.top) * 20;
	putimage(x1, y1, 20, 20, &g_imgItem, MAP_PLAYER, 0);

	// 绘制迷你地图
	SetWorkingImage(&g_imgGPS);
	cleardevice();
	int tx = (int)((g_ptPlayer.x - 1) * g_szGPS.cx / (double)(g_szMap.cx - 1) + 0.5);
	int ty = (int)((g_ptPlayer.y - 1) * g_szGPS.cy / (double)(g_szMap.cy - 1) + 0.5);
	setlinecolor(YELLOW);
	circle(tx, ty, 1);

	// 更新到绘图窗口
	SetWorkingImage();
	putimage(150, 110, 340, 260, &g_imgSight, 10, 10);
	putimage(g_ptGPS.x, g_ptGPS.y, &g_imgGPS);
}


// 获取用户输入的命令
int GetCmd()
{
	int c = 0;

	if (GetAsyncKeyState(VK_LEFT)	& 0x8000)		c |= CMD_LEFT;
	if (GetAsyncKeyState(VK_RIGHT)	& 0x8000)		c |= CMD_RIGHT;
	if (GetAsyncKeyState(VK_UP)		& 0x8000)		c |= CMD_UP;
	if (GetAsyncKeyState(VK_DOWN)	& 0x8000)		c |= CMD_DOWN;
	if (GetAsyncKeyState('A')		& 0x8000)		c |= CMD_LEFT;
	if (GetAsyncKeyState('D')		& 0x8000)		c |= CMD_RIGHT;
	if (GetAsyncKeyState('W')		& 0x8000)		c |= CMD_UP;
	if (GetAsyncKeyState('S')		& 0x8000)		c |= CMD_DOWN;
	if (GetAsyncKeyState(' ')		& 0x8000)		c |= CMD_MARKRED;
	if (GetAsyncKeyState('G')		& 0x8000)		c |= CMD_MARKGREEN;
	if (GetAsyncKeyState('Y')		& 0x8000)		c |= CMD_MARKYELLOW;
	if (GetAsyncKeyState('C')		& 0x8000)		c |= CMD_CLEARMARK;
	if (GetAsyncKeyState(VK_ESCAPE)	& 0x8000)		c |= CMD_QUIT;

	return c;
}


// 处理用户输入的命令
void DispatchCmd(int cmd)
{
	if (cmd & CMD_UP)			OnUp();
	if (cmd & CMD_DOWN)			OnDown();
	if (cmd & CMD_LEFT)			OnLeft();
	if (cmd & CMD_RIGHT)		OnRight();
	if (cmd & CMD_MARKRED)		OnMark(MAP_MARKRED);
	if (cmd & CMD_MARKGREEN)	OnMark(MAP_MARKGREEN);
	if (cmd & CMD_MARKYELLOW)	OnMark(MAP_MARKYELLOW);
	if (cmd & CMD_CLEARMARK)	OnMark(MAP_GROUND);
}


// 向上移动
void OnUp()
{
	if (g_ptPlayer.y > 1 && GetMazeItem(g_ptPlayer.x, g_ptPlayer.y - 1) != MAP_WALL)
	{
		g_ptPlayer.y--;

		if (g_ptPlayer.y - g_rtSight.top < 4 && g_rtSight.top > 0)
		{
			g_rtSight.top--;
			g_rtSight.bottom--;
		}
	}
}


// 向左移动
void OnLeft()
{
	if (g_ptPlayer.x > 1 && GetMazeItem(g_ptPlayer.x - 1, g_ptPlayer.y) != MAP_WALL && GetMazeItem(g_ptPlayer.x - 1, g_ptPlayer.y) != MAP_ENTRANCE)
	{
		g_ptPlayer.x--;

		if (g_ptPlayer.x - g_rtSight.left < 5 && g_rtSight.left > 0)
		{
			g_rtSight.left--;
			g_rtSight.right--;
		}
	}
}


// 向右移动
void OnRight()
{
	if (g_ptPlayer.x < g_szMap.cx && GetMazeItem(g_ptPlayer.x + 1, g_ptPlayer.y) != MAP_WALL)
	{
		g_ptPlayer.x++;

		if (g_rtSight.right - g_ptPlayer.x < 5 && g_rtSight.right <= g_szMap.cx)
		{
			g_rtSight.left++;
			g_rtSight.right++;
		}
	}
}


// 向下移动
void OnDown()
{
	if (g_ptPlayer.y < g_szMap.cy && GetMazeItem(g_ptPlayer.x, g_ptPlayer.y + 1) != MAP_WALL)
	{
		g_ptPlayer.y++;

		if (g_rtSight.bottom - g_ptPlayer.y < 4 && g_rtSight.bottom <= g_szMap.cy)
		{
			g_rtSight.top++;
			g_rtSight.bottom++;
		}
	}
}


// 在地图中做标记
void OnMark(MAPITEM value)
{
	g_aryMap[g_ptPlayer.x][g_ptPlayer.y] = value;
}


// 检查是否到出口
bool CheckWin()
{
	if (g_ptPlayer.x == g_szMap.cx && g_ptPlayer.y == g_szMap.cy - 1)
	{
		HWND hwnd = GetHWnd();
		if (MessageBox(hwnd, _T("恭喜你走出来了！n您想再来一局吗？"), _T("恭喜"), MB_YESNO | MB_ICONQUESTION) == IDYES)
		{
			InitGame();
			return false;
		}
		else
			return true;
	}

	return false;
}


// 询问用户是否退出游戏
bool Quit()
{
	HWND hwnd = GetHWnd();
	return (MessageBox(hwnd, _T("您确定要退出游戏吗？"), _T("询问"), MB_OKCANCEL | MB_ICONQUESTION) == IDOK);
}

项目名称: 打雷风景

#include <stdio.h>
#include <graphics.h>
#include <time.h>
#include <math.h>

#define PI		3.1415926															// 定义圆周率
#define BRIGHT	5																	// 闪电颜色亮度(可以随意调节)

// 街道建筑物的结构体
struct Window
{
	int length;																		// 窗户的长
	int width;																		// 窗户的宽
};
// 房子类型1
struct House1
{
	int length;																		// 房子的长
	int width;																		// 房子的宽
	Window win;																		// 房子上的窗户
};
// 房子类型2
struct House2
{
	int length;																		// 房子的长
	int width;																		// 房子墙壁的高度
	int top;																		// 房子顶部尖锥的高
};

IMAGE temp;																			// 用于保存闪电前的街道图像

// 函数声明
int CirJudgeZero(int index1, int index2);											// 得到一个非零的随机数，index1、index2表示随机范围的指数
void Light(int x);																	// 绘制闪电
void Building();																	// 绘制街道(部分随机)
int DrawHou1(int Sumbor);															// 画房子类型1
int DrawHou2(int Sumbor);															// 画房子类型2
void LightChange();																	// 绘制高亮街道

// 入口函数
int main()
{
	srand((unsigned)time(NULL));													// 设置随机种子
	initgraph(640, 480);

	setorigin(0, 480);																// 设置坐标原点在左下角
	setaspectratio(1, -1);															// 设置坐标y轴反向
	setbkcolor(RGB(20, 20, 20));													// 重置背景色
	cleardevice();

	Building();																		// 先绘制街道并保存image
	
	int seedtime,time,Xpoint;

	while (true)																	// 鼠标右键退出程序
	{
		do {
			seedtime = rand() % 500;
		} while (seedtime <= 150);
		
		time = rand() % 3000 + seedtime;
		Xpoint = rand() % 590 + 50;													// 随机闪电出现的横坐标
		Sleep(time);																// 等待一段随机时间，出现闪电
		Light(Xpoint);																// 画闪电
		LightChange();																// 高光图像算法以及恢复
	}

	closegraph();
}

// 得到一个非零的随机数，index1、index2表示随机范围的指数
int CirJudgeZero(int index1,int index2)												// 循环随机数，得到一个非零的随机数，index1、index2表示随机范围的指数
{
	int rec = 0;																	// 用于传递的非零参数，初始化为0
	while (rec == 0)
	{
		rec = rand() % index1 + index2;
	}
	return rec;
}

// 绘制闪电
void Light(int x)
{
	int RanTimes = CirJudgeZero(3, 0);												// 随机是否出现双重闪电
	int EndPoi;																		// 用于记录闪电的终点
	for (int i = 0; i < RanTimes; i++)
	{
		int Xpoint = x, Ypoint = 480;
		EndPoi = Ypoint - rand() % 120 - 120;										// 随机闪电的终点
		while (Ypoint >= EndPoi)													// 判断是否到达终点 && 绘制每个小线段
		{
			int Dis = rand() % 20;													// 随机闪电每段的长度
			int Ang1 = rand() % 120 - 60;											// 随机闪电的角度(x轴)
			int Ang2 = rand() % 120 - 60;											// 随机闪电的角度(y轴)
			int NextX = Xpoint + (int)(Dis * sin(Ang1 * PI / 180));					// 计算闪电短点的下一点(x轴)
			int NextY = Ypoint - (int)(Dis * cos(Ang2 * PI / 180));					// 计算闪电短点的下一点(y轴)
			setlinecolor(RGB(125, 250, 255));										// 设置闪电颜色
			setlinestyle(PS_ENDCAP_ROUND | PS_SOLID, 2);							// 设置闪电样式(线段断点为平、实线、宽度)
			line(Xpoint, Ypoint, NextX, NextY);										// 绘制闪电
			Xpoint = NextX;															// 将端点赋值给初始点(x轴)
			Ypoint = NextY;															// 将端点赋值给初始点(y轴)
			Sleep((rand() % 100) > 66 ? 1 : 0);										// 设置停滞时间
		}
	}
}

// 画房子类型1
int DrawHou1(int Sumbor)															
{
	House1 hou1;
	hou1.length = CirJudgeZero(40, 60);												// 随机房子的长
	hou1.width = CirJudgeZero(160, 80);												// 随机房子的宽
	hou1.win.length = 10;															// 窗户的长
	hou1.win.width = 8;																// 窗户的宽
	int point1[8] = { Sumbor,0,
						Sumbor + hou1.length,0,
						Sumbor + hou1.length,hou1.width,
						Sumbor,hou1.width };										// 定义房子的轮廓坐标
	setfillcolor(RGB(30, 30, 60));													// 设置房子的填充色
	solidpolygon((POINT*)point1, 4);												// 绘制填充房子(四边形)

	// 绘制房子上的窗户
	int WinLefDis = CirJudgeZero(10, 18);											// 随机窗户离左边的距离
	int WinTopDis = CirJudgeZero(10, 10);											// 随机窗户离顶部的距离
	int WinInvDis = CirJudgeZero(10, 10);											// 随机窗户与窗户之间的间隔(上下与左右都是这个值)
	for (int Ypoint = hou1.width - WinTopDis; Ypoint > hou1.width / 3;)				// 控制窗户的行数
	{
		for (int Xpoint = Sumbor + WinLefDis; Xpoint < Sumbor + hou1.length - 19;)	//  控制每行画几个窗户
		{
			int WinPoint[8] = { Xpoint ,Ypoint ,
				Xpoint + hou1.win.length ,Ypoint ,
				Xpoint + hou1.win.length ,Ypoint - hou1.win.width,
				Xpoint ,Ypoint - hou1.win.width };									// 定义窗户坐标数组
			int ran = CirJudgeZero(3, 0);											// 随机值用于判断颜色(亮着的和暗着的)
			if (ran == 1)
				setfillcolor(RGB(240, 240, 150));									// 设置窗户亮着
			else if (ran == 2)
				setfillcolor(RGB(30, 44, 40));										// 设置窗户暗着

			solidpolygon((POINT*)WinPoint, 4);										// 画无边框的填充窗(四边形)
			Xpoint += (hou1.win.length + WinInvDis);								// 窗左上角的x值每次画完都增加，方便画下一个窗户
		}
		Ypoint -= (hou1.win.width + WinInvDis);										// 窗左上角的y值每次画完都增加，方便画下一个窗户
	}
	Sumbor += hou1.length;															// x坐标加上整个房子的长，用于判断是否画出屏幕范围
	return Sumbor;																	// 返回x坐标
}

// 画房子类型2
int DrawHou2(int Sumbor)															
{
	House2 hou2;
	hou2.length = CirJudgeZero(20, 80);												// 随机房子的长
	hou2.width = CirJudgeZero(40, 60);												// 随机房子的宽
	hou2.top = CirJudgeZero(10, 100);												// 随机房子的顶部的y坐标
	int point2[10] = { Sumbor,0,
						Sumbor ,hou2.width ,
						Sumbor + (hou2.length / 2),hou2.top ,
						hou2.length + Sumbor,hou2.width,
						hou2.length + Sumbor,0 };									// 定义房子的坐标
	setfillcolor(RGB(30, 44, 83));													// 设置房子的填充色
	solidpolygon((POINT*)point2, 5);												// 画填充的房子(5边形)

	// 画房子2的装饰
	int ran = CirJudgeZero(3, 0);													// 定义一个随机数，用于判断画什么样的窗户
	if (ran == 1)																	// 画圆形窗户
	{
		int ranlight = CirJudgeZero(3, 0);											// 定义一个随机数，用于判断窗户是否亮着
		if (ranlight == 1)															// 暗着的窗户
			setfillcolor(RGB(30, 44, 50));
		else if(ranlight == 2)														// 亮着的窗户
			setfillcolor(RGB(150, 200, 130));
		int radius = rand() % 10 + (hou2.width / 6);								// 定义半径
		solidcircle(Sumbor + (hou2.length / 2), hou2.width * 2 / 3, radius);		// 画填充无边框圆形窗户
	}
	else if (ran == 2)																// 画拱形窗户
	{
		int ranlight = CirJudgeZero(3, 0);											// 定义一个随机数，用于判断窗户是否亮着
		if (ranlight == 1)															// 暗着的窗户
			setfillcolor(RGB(30, 44, 50));
		else if (ranlight == 2)														// 亮着的窗户
			setfillcolor(RGB(150, 200, 130));
		int radius = rand() % 10 + (hou2.width / 6);								// 定义半径
		solidcircle(Sumbor + (hou2.length / 2), hou2.width * 3 / 5, radius);		// 拱形是由圆形和四边形嵌合组成
		solidrectangle(Sumbor + (hou2.length / 2) - radius, hou2.width * 3 / 5, Sumbor + (hou2.length / 2) + radius, hou2.width * 3 / 5 - radius);
	}
	Sumbor += hou2.length;															// x坐标加上整个房子的长，用于判断是否画出屏幕范围
	return Sumbor;
}

// 画建筑物
void Building()																		
{
	int index = 0;																	// 随机值，来判断绘制什么房子
	// 随机房子类型
	for (int Sumbor = 0; Sumbor < 640; )											// 记录建筑物的右边界，别让程序停不下来了
	{
		index = CirJudgeZero(3, 0);
		switch (index)
		{
		case 1:																		// 画房子类型1
			Sumbor = DrawHou1(Sumbor);
			break;
		case 2:																		// 画房子类型2
			Sumbor = DrawHou2(Sumbor);
			break;
		}
	}
	getimage(&temp, 0, 0, 640, 480);												// 记录此时的图像，为了闪电后恢复图像
}

// 闪电出现时的???光
void LightChange()																
{
	// 随机闪电(屏幕)的亮度
	float Lightness = (float)CirJudgeZero(10,(CirJudgeZero(15, 10) / 10));

	IMAGE image;																	// 定义一个图像对象，用于绘制高亮的图像
	getimage(&image, 0, 0, 640, 480);												// 获取图像范围
	DWORD *pMem = GetImageBuffer(&image);											// 获取指向显存的指针
	int r, g, b;																	// 定义分别获取点的RGB颜色值
	for (int i = 0; i < (640 * 480); i++)											// 循环获取每个点的RGB值并判断是否大于255
	{
		r = min((int)(GetRValue(pMem[i])*Lightness), 255);							// 这里所有像素点都乘以一个大于1的数值，点的颜色就变亮了
		b = min((int)(GetBValue(pMem[i])*Lightness), 255);
		g = min((int)(GetGValue(pMem[i])*Lightness), 255);
		pMem[i] = RGB(r, g, b);
	}
	putimage(0, 0, &image);															// 输出高光图像
	Sleep(100);																		// 停滞时间
	cleardevice();																	// 清除屏幕图像(好像putimage输出图像在顶部是有一段空隙的,因此直接清屏,就看不到空隙了)
	putimage(0, 0, &temp);															// 重新输出原来街道的图像
}

项目名称: 烟花

#include<graphics.h>
#include<cmath>
#include<conio.h>
#define PI 3.1415926
void star(int x,int y); //画星星
void drawmoon(); //画月亮
void drawstar(); //画星空
void starflower1(); //烟花绽放1
void starflower2(); //烟花绽放2


int main()
{
int i;
initgraph(640, 480);// 初始化绘图窗口
line(100, 421, 540, 421);// 画地平线
drawstar(); //画星空
while(!kbhit())
{
starflower1();//烟花绽放函数1
starflower2();//烟花绽放函数2
Sleep(10);
}
getch();
closegraph(); // 关闭绘图窗口
return 0;
}


void star(int x,int y) //画星星函数
{
int i,a;
int n=5;
int x1[5],y1[5],x2[5],y2[5];
setcolor(YELLOW);
for(i=0;i<5;i++)
{
x1[i]=(int)(x+n*cos(i*72*PI/180) + 1);
y1[i]=(int)(y+n*sin(i*72*PI/180) + 1);
x2[i]=(int)(x+n/2*cos(i*72*PI/180+PI/5) + 1);
y2[i]=(int)(y+n/2*sin(i*72*PI/180+PI/5) + 1);
}
for(i=0;i<5;i++)
{
a=i+1;
if(a>4) a=0;
line(x1[i],y1[i],x2[i],y2[i]);//两点间画直线
line(x2[i],y2[i],x1[a],y1[a]);
}
}


void drawmoon() //画月亮
{
setfillcolor(WHITE);
//fillcircle(550,80,40);//画圆(有边框)
solidcircle(550,80,40);//画圆（无边框）
}


void drawstar() //画星空
{
int a[]={40,250,140,140,90,350,300};
int b[]={40,25,99,100,98,60,78},i;
//setfillstyle(1,14);
for(i=0;i<10;i++)
{
star(a[i],b[i]);
floodfill(a[i],b[i],YELLOW);
}
drawmoon();
}


void starflower1() //烟花绽放函数1
{
 double h,v,dv; // 高度, 速度（方向向下）,加速度（每 1/50 秒）
{
h=470,v= 54,dv= 9.8 / 10;
while(h>=200)
{
h-=(v - dv / 2);
v = v * 0.9; 
setcolor(GREEN);
setfillcolor(RED);//填充颜色为蓝色
fillcircle(300,int(h), 5);
 Sleep(20);// 延时
// 擦掉球?
 setcolor(BLACK);
 setfillcolor(BLACK);//填充颜色为黑色
 fillcircle(300,int(h), 5);
Sleep(10);
}
}
}


void starflower2() //烟花绽放函数2
{
int i=0,j,n=60, x=300,y=200, px,py;
while(1)
{
if(i<100)
{
for(j=0;j<n;j++)
{
px=(int)(x+i*cos(j*360/n*PI/180) + 1);
py=(int)(y+i*sin(j*360/n*PI/180) + 1);
putpixel(px-1,py,BLUE);
putpixel(px,py+1,BLUE);
putpixel(px+1,py-1,YELLOW);
putpixel(px,py-1,YELLOW);
putpixel(px+1,py,RED);
putpixel(px+1,py+1,RED);
}
//画圆擦掉
Sleep(10);
setfillcolor(BLACK);
solidcircle(300,200,101);
}
i+=2;
if(i>=100) break;
}
}

最后

以上就是拉长面包为你收集整理的Easyx项目小合集项目名称: 迷宫项目名称: 打雷风景项目名称: 烟花的全部内容，希望文章能够帮你解决Easyx项目小合集项目名称: 迷宫项目名称: 打雷风景项目名称: 烟花所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(47)

相关文章

（EasyX入门与实战）第五章 添加音乐        1、将 .mp3 文件复制粘贴到程序文件夹中。         2、音乐播放、循环播放、停止播放语法及步骤
（EasyX入门与实战）第五章 添加音乐        1、将 .mp3 文件复制粘贴到程序文件夹中。         2、音乐播放、循环播放、停止播放语法及步骤
用C++实现打砖块游戏
用C++实现打砖块游戏
easyx的背景音乐处理
easyx的背景音乐处理
自带easyx的c语言编译器,采用easyX插件进行C语言编写的贪吃蛇，自带播放音乐
自带easyx的c语言编译器,采用easyX插件进行C语言编写的贪吃蛇，自带播放音乐
Easyx项目小合集项目名称: 迷宫项目名称: 打雷风景项目名称: 烟花
Easyx项目小合集项目名称: 迷宫项目名称: 打雷风景项目名称: 烟花
基于easyx 下用C播放音乐
基于easyx 下用C播放音乐
关于位图背景色透明化的实现
关于位图背景色透明化的实现
【Visual C++】游戏开发笔记之六——游戏画面绘图（三）透明特效的制作方法
【Visual C++】游戏开发笔记之六——游戏画面绘图（三）透明特效的制作方法

评论列表共有 0 条评论

立即
投稿
返回
顶部