• 分析网上的一篇“浪漫烟花“程序＜VS-C++＞

     结果:多个烟花弹同时上升,然后进行爆炸,并进行了花样设计,采取心型设计方案,背景音乐设置为"小幸运",除此在最初,窗口设置有文本.

    接下来,就让我们来分析代码:

    1. // 烟花结构
    2. struct FIRE
    3. {
    4. 	int r;					// 当前爆炸半径
    5. 	int max_r;				// 爆炸中心距离边缘最大半径
    6. 	int x, y;				// 爆炸中心在窗口的坐标
    7. 	int cen_x, cen_y;		// 爆炸中心相对图片左上角的坐标
    8. 	int width, height;		// 图片的宽高
    9. 	int xy[240][240];		// 储存图片像素点
    10.  
    11. 	bool show;				// 是否绽放
    12. 	bool draw;				// 开始输出像素点
    13. 	DWORD t1, t2, dt;		// 绽放速度
    14. }Fire[NUM];
    15.  
    16. // 烟花弹结构
    17. struct JET
    18. {
    19. 	int x, y;				// 喷射点坐标
    20. 	int hx, hy;				// 最高点坐标------将赋值给 FIRE 里面的 x, y
    21. 	int height;				// 烟花高度
    22. 	bool shoot;				// 是否可以发射
    23.  
    24. 	DWORD t1, t2, dt;		// 发射速度
    25. 	IMAGE img[2];			// 储存花弹一亮一暗图片
    26. 	byte n : 1;				// 图片下标
    27. }Jet[NUM];

    首先把烟花和烟花弹都设定为一个结构.

    烟花弹的基本理解:设定一个喷射点的坐标,然后垂直向上进行运动,一直运行到最高点截至

    此时要设定一个布尔类型,用以判断烟花弹是否可以发射.在这过程当中,发射的速度是匀速的,可以直接定义速度,当然这里采用定义时间的方式去进行,定义三个时间,分别为t1,t2和dt用来控制速度的变化.存储每一个位置的图片采用IMAGE函数

    这里byte n:1;的基本信息我并不是很了解,我们先看下面的,然后在返回来看此处.

    其次分析烟花的基本参数:

    对于烟花的理解,烟花是要进行爆炸的,所以是从一个点慢慢想外进行拓展的,而这个点在窗口中的位置则是在烟花弹的最高点,所以我们要设定烟花的中心点坐标和爆炸半径以及最大半径.其次我们要设定一个爆炸中心相对于图片左上角的坐标,这个坐标是用于确定每一个像素图片在这一整个图片当中的坐标,接下来限定好图片的宽和高,以此来确定图片中每一个像素图的坐标范围.接下来定义两个布尔参数,判断烟花是否要绽放和是否要输出每一个像素图.最后定义三个时间以此来控制烟花爆炸的速度:

    烟花从内向外爆炸,速度是越来越慢的,所以这里后面可以单独定义一个关于dt的时间数组,时间越来越长,代表的就是速度越来越慢.

    烟花和烟花弹每一个结构的尾部都新建一个数组结构,那么下面就可以直接运用了.

    接下来,我们来回想一下上面程序的流程:

    第一步:一个回形的文本弹出,并显示几行文字

    第二步:背景音乐播放

    第三步:烟花弹上升并爆炸烟花

    第四步:花样烟花,也就是心型烟花弹的上升和爆炸

    那接下来,每一步我们都设定一个单独函数来表示.

    首先:文本输出

    1. void welcome()
    2. {
    3. 	//setfillstyle(0);
    4. 	setcolor(YELLOW);
    5.  
    6. 	for (int i = 0; i < 50; i++)
    7. 	{
    8. 		int x = 600 + int(180 * sin(PI * 2 * i / 60));
    9. 		int y = 200 + int(180 * cos(PI * 2 * i / 60));
    10. 		cleardevice();
    11. 		settextstyle(i, 0, "楷体");
    12. 		outtextxy(x - 80, y, "浪漫表白日");
    13. 		outtextxy(x - 10, y + 100, "献给挚爱的你");
    14. 		Sleep(30);
    15. 	}
    16. 	Sleep(5000);
    17. 	getchar();
    18. 	cleardevice();
    19. 	settextstyle(25, 0, "楷体");
    20. 	outtextxy(400, 200, "原来你是我最想留住的幸运");
    21. 	outtextxy(400, 250, "原来我们和爱情曾经靠得那么近");
    22. 	outtextxy(400, 300, "那为我对抗世界的决定");
    23. 	outtextxy(400, 350, "那陪我淋的雨");
    24. 	outtextxy(400, 400, "一幕幕都是你");
    25. 	outtextxy(400, 450, "一尘不染的真心。");
    26. 	outtextxy(600, 500, "----《小幸运》");
    27. 	Sleep(10000);
    28. 	getchar();
    29. }

    setcolor()函数用以编辑字体颜色,程序中设置成yellow

    接下来的一个for循环,就是我们看到的类似于回型的一个文字输入,此处要注意

    cleardevice()这个函数使用当前背景色清空绘图设备,如果去除掉这个函数,则会出现下面图片的显示.

    1. 	// 播放背景音乐
    2. 	mciSendString("open D:/program/yanhua/小幸运.mp3 alias bk", 0, 0, 0);
    3. 	mciSendString("play bk repeat", 0, 0, 0);

     Sleep(5000);延时5s后,getchar();按下回车继续

    cleardevice();再次使用当前背景色清空绘图设备,然后编辑字体为楷体,字号为25,采用settextstyle()函数,接下来,就是在不同的位置依次输出你想输入的文本.采用outtextxy()函数

    最后在延时10s,按回车继续.

    第二步背景音乐播放

    1. 	// 播放背景音乐
    2. 	mciSendString("open D:/program/yanhua/小幸运.mp3 alias bk", 0, 0, 0);
    3. 	mciSendString("play bk repeat", 0, 0, 0);

    直接放在了主函数里面

    mci---send--string也就是说发送音乐字符串,open就是打开对应的文件,而play就是播放对应的文件.

    第三步:烟花弹上升并爆炸烟花

    在进行这一步之前,要先初始化烟花弹和烟花的数值

    1. // 初始化烟花参数
    2. void Init(int i)
    3. {
    4. 	// 分别为：烟花中心到图片边缘的最远距离、烟花中心到图片左上角的距离 (x、y) 两个分量
    5. 	int r[13] = { 120, 120, 155, 123, 130, 147, 138, 138, 130, 135, 140, 132, 155 };
    6. 	int x[13] = { 120, 120, 110, 117, 110, 93, 102, 102, 110, 105, 100, 108, 110 };
    7. 	int y[13] = { 120, 120, 85, 118, 120, 103, 105, 110, 110, 120, 120, 104, 85 };
    8.  
    9. 	/**** 初始化烟花 *****/
    10.  
    11. 	Fire[i].x = 0;				// 烟花中心坐标
    12. 	Fire[i].y = 0;
    13. 	Fire[i].width = 240;				// 图片宽
    14. 	Fire[i].height = 240;				// 图片高
    15. 	Fire[i].max_r = r[i];				// 最大半径
    16. 	Fire[i].cen_x = x[i];				// 中心距左上角距离
    17. 	Fire[i].cen_y = y[i];
    18. 	Fire[i].show = false;			// 是否绽放
    19. 	Fire[i].dt = 5;				// 绽放时间间隔
    20. 	Fire[i].t1 = timeGetTime();
    21. 	Fire[i].r = 0;				// 从 0 开始绽放
    22.  
    23. 	/**** 初始化烟花弹 *****/
    24.  
    25. 	Jet[i].x = -240;				// 烟花弹左上角坐标
    26. 	Jet[i].y = -240;
    27. 	Jet[i].hx = -240;				// 烟花弹发射最高点坐标
    28. 	Jet[i].hy = -240;
    29. 	Jet[i].height = 0;				// 发射高度
    30. 	Jet[i].t1 = timeGetTime();
    31. 	Jet[i].dt = rand() % 10;		// 发射速度时间间隔
    32. 	Jet[i].n = 0;				// 烟花弹闪烁图片下标
    33. 	Jet[i].shoot = false;			// 是否发射
    34. }

     r[],x[],y[]三个数组代表的分别是烟花集里面每一个烟花图的基本像素

    烟花集如下,一共有13个烟花,所以这里定义为13

     其他的参数初始化就直接理解就可以了.

    烟花和烟花弹加载函数

    1.  
    2. // 加载图片
    3. void Load()
    4. {
    5. 	/**** 储存烟花的像素点颜色 ****/
    6. 	IMAGE fm, gm;
    7. 	loadimage(&fm, "D:/program/yanhua/yanhua.jpg", 3120, 240);
    8.  
    9. 	for (int i = 0; i < 13; i++)
    10. 	{
    11. 		SetWorkingImage(&fm);
    12. 		getimage(&gm, i * 240, 0, 240, 240);
    13. 		SetWorkingImage(&gm);
    14.  
    15. 		for (int a = 0; a < 240; a++)
    16. 			for (int b = 0; b < 240; b++)
    17. 				Fire[i].xy[a][b] = getpixel(a, b);
    18. 	}
    19.  
    20. 	/**** 加载烟花弹 ************/
    21. 	IMAGE sm;
    22. 	loadimage(&sm, "D:/program/yanhua/dan.jpg", 200, 50);
    23.  
    24. 	for (int i = 0; i < 13; i++)
    25. 	{
    26. 		SetWorkingImage(&sm);
    27. 		int n = rand() % 5;
    28.  
    29. 		getimage(&Jet[i].img[0], n * 20, 0, 20, 50);			// 暗
    30. 		getimage(&Jet[i].img[1], (n + 5) * 20, 0, 20, 50);		// 亮
    31. 	}
    32.  
    33.  
    34. 	SetWorkingImage();		// 设置回绘图窗口
    35. }

            getimage(&gm, i * 240, 0, 240, 240);    烟花集依次每一个烟花从左到右执行

    选出可以发射的烟花

    1. // 在一定范围内筛选可发射的烟花，并初始化发射参数，输出烟花弹到屏幕，播放声音
    2. void Chose(DWORD& t1)
    3. {
    4. 	DWORD t2 = timeGetTime();
    5.  
    6. 	if (t2 - t1 > 100)
    7. 	{
    8. 		int n = rand() % 20;
    9.  
    10. 		if (n < 13 && Jet[n].shoot == false && Fire[n].show == false)
    11. 		{
    12. 			/**** 重置烟花弹，预备发射 *****/
    13. 			Jet[n].x = rand() % 1200;
    14. 			Jet[n].y = rand() % 100 + 600;
    15. 			Jet[n].hx = Jet[n].x;
    16. 			Jet[n].hy = rand() % 400;
    17. 			Jet[n].height = Jet[n].y - Jet[n].hy;
    18. 			Jet[n].shoot = true;
    19. 			putimage(Jet[n].x, Jet[n].y, &Jet[n].img[Jet[n].n], SRCINVERT);
    20.  
    21. 			/**** 播放每个烟花弹的声音 *****/
    22. 			/*char c1[50], c2[30], c3[30];
    23. 			sprintf(c1, "open ./fire/shoot.mp3 alias s%d", n);
    24. 			sprintf(c2, "play s%d", n);
    25. 			sprintf(c3, "close n%d", n);
    26.  
    27. 			mciSendString(c3, 0, 0, 0);
    28. 			mciSendString(c1, 0, 0, 0);
    29. 			mciSendString(c2, 0, 0, 0);*/
    30. 		}
    31. 		t1 = t2;
    32. 	}
    33. }

    发射烟花

    1. // 扫描烟花弹并发射
    2. void Shoot()
    3. {
    4. 	for (int i = 0; i < 13; i++)
    5. 	{
    6. 		Jet[i].t2 = timeGetTime();
    7.  
    8. 		if (Jet[i].t2 - Jet[i].t1 > Jet[i].dt && Jet[i].shoot == true)
    9. 		{
    10. 			/**** 烟花弹的上升 *****/
    11. 			putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);
    12.  
    13. 			if (Jet[i].y > Jet[i].hy)
    14. 			{
    15. 				Jet[i].n++;
    16. 				Jet[i].y -= 5;
    17. 			}
    18.  
    19. 			putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);
    20.  
    21. 			/**** 上升到高度的 3 / 4，减速 *****/
    22. 			if ((Jet[i].y - Jet[i].hy) * 4 < Jet[i].height)
    23. 				Jet[i].dt = rand() % 4 + 10;
    24.  
    25. 			/**** 上升到最大高度 *****/
    26. 			if (Jet[i].y <= Jet[i].hy)
    27. 			{
    28. 				// 播放爆炸声
    29. 				/*char c1[50], c2[30], c3[30];
    30. 				sprintf(c1, "open ./fire/bomb.wav alias n%d", i);
    31. 				sprintf(c2, "play n%d", i);
    32. 				sprintf(c3, "close s%d", i);
    33.  
    34. 				mciSendString(c3, 0, 0, 0);
    35. 				mciSendString(c1, 0, 0, 0);
    36. 				mciSendString(c2, 0, 0, 0);*/
    37.  
    38. 				putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);	// 擦掉烟花弹
    39. 				Fire[i].x = Jet[i].hx + 10;											// 在烟花弹中间爆炸
    40. 				Fire[i].y = Jet[i].hy;												// 在最高点绽放
    41. 				Fire[i].show = true;					// 开始绽放
    42. 				Jet[i].shoot = false;					// 停止发射
    43.  
    44. 			}
    45. 			Jet[i].t1 = Jet[i].t2;
    46. 		}
    47. 	}
    48. }

    这里注意的一个点,要记录烟花弹到最高点的坐标,就是烟花爆炸的中心点坐标,同时设置烟花为开始绽放

    绽放烟花函数

    1. void Show(DWORD* pMem)
    2. {
    3. 	// 烟花个阶段绽放时间间隔，制作变速绽放效果
    4. 	int drt[16] = { 5, 5, 5, 5, 5, 6, 25, 25, 25, 25, 55, 55, 55, 55, 55 };
    5.  
    6. 	for (int i = 0; i < NUM; i++)
    7. 	{
    8. 		Fire[i].t2 = timeGetTime();
    9.  
    10. 		// 增加爆炸半径，绽放烟花，增加时间间隔做变速效果
    11. 		if (Fire[i].t2 - Fire[i].t1 > Fire[i].dt && Fire[i].show == true)
    12. 		{
    13. 			if (Fire[i].r < Fire[i].max_r)
    14. 			{
    15. 				Fire[i].r++;
    16. 				Fire[i].dt = drt[Fire[i].r / 10];
    17. 				Fire[i].draw = true;
    18. 			}
    19.  
    20. 			if (Fire[i].r >= Fire[i].max_r - 1)
    21. 			{
    22. 				Fire[i].draw = false;
    23. 				Init(i);
    24. 			}
    25. 			Fire[i].t1 = Fire[i].t2;
    26. 		}
    27.  
    28. 		// 如果该号炮花可爆炸，根据当前爆炸半径画烟花，颜色值接近黑色的不输出。
    29. 		if (Fire[i].draw)
    30. 		{
    31. 			for (double a = 0; a <= 6.28; a += 0.01)
    32. 			{
    33. 				int x1 = (int)(Fire[i].cen_x + Fire[i].r * cos(a));				// 相对于图片左上角的坐标
    34. 				int y1 = (int)(Fire[i].cen_y - Fire[i].r * sin(a));
    35.  
    36. 				if (x1 > 0 && x1 < Fire[i].width && y1 > 0 && y1 < Fire[i].height)	// 只输出图片内的像素点
    37. 				{
    38. 					int b = Fire[i].xy[x1][y1] & 0xff;
    39. 					int g = (Fire[i].xy[x1][y1] >> 8) & 0xff;
    40. 					int r = (Fire[i].xy[x1][y1] >> 16);
    42. 					// 烟花像素点在窗口上的坐标
    43. 					int xx = (int)(Fire[i].x + Fire[i].r * cos(a));
    44. 					int yy = (int)(Fire[i].y - Fire[i].r * sin(a));
    45.  
    46. 					// 较暗的像素点不输出、防止越界
    47. 					if (r > 0x20 && g > 0x20 && b > 0x20 && xx > 0 && xx < 1200 && yy > 0 && yy < 800)
    48. 						pMem[yy * 1200 + xx] = BGR(Fire[i].xy[x1][y1]);	// 显存操作绘制烟花
    49. 				}
    50. 			}
    51. 			Fire[i].draw = false;
    52. 		}
    53. 	}
    54. }

    BGR()的像素点,都显示地赋值给pMem();

    第四个则是花样烟花

    1. // 显示花样
    2. void Style(DWORD& st1)
    3. {
    4. 	DWORD st2 = timeGetTime();
    5.  
    6. 	if (st2 - st1 > 20000)		// 一首歌的时间
    7. 	{
    8. 		// 心形坐标
    9. 		int x[13] = { 60, 75, 91, 100, 95, 75, 60, 45, 25, 15, 25, 41, 60 };
    10. 		int y[13] = { 65, 53, 40, 22, 5, 4, 20, 4, 5, 22, 40, 53, 65 };
    11. 		for (int i = 0; i < NUM; i++)
    12. 		{
    13. 			//cleardevice();
    14. 			/**** 规律分布烟花弹 ***/
    15. 			Jet[i].x = x[i] * 10;
    16. 			Jet[i].y = (y[i] + 75) * 10;
    17. 			Jet[i].hx = Jet[i].x;
    18. 			Jet[i].hy = y[i] * 10;
    19. 			Jet[i].height = Jet[i].y - Jet[i].hy;
    20. 			Jet[i].shoot = true;
    21. 			Jet[i].dt = 7;
    22. 			putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);	// 显示烟花弹
    23.  
    24. 			/**** 设置烟花参数 ***/
    25. 			Fire[i].x = Jet[i].x + 10;
    26. 			Fire[i].y = Jet[i].hy;
    27. 			Fire[i].show = false;
    28. 			Fire[i].r = 0;
    29.  
    30. 			/**** 播放发射声音 ***/
    31. 			/*char c1[50], c2[30], c3[30];
    32. 			sprintf(c1, "open ./fire/shoot.mp3 alias s%d", i);
    33. 			sprintf(c2, "play s%d", i);
    34. 			sprintf(c3, "close n%d", i);
    35.  
    36. 			mciSendString(c3, 0, 0, 0);
    37. 			mciSendString(c1, 0, 0, 0);
    38. 			mciSendString(c2, 0, 0, 0);*/
    39. 		}
    40. 		st1 = st2;
    41. 	}
    42. }

    其实就是结合发射烟花弹函数,将发射的坐标修改成了心形的坐标

    最后就是主函数

    1. // 主函数
    2. int main()
    3. {
    4. 	initgraph(1200, 800);
    5. 	srand(time(0));
    6.  
    7. 	// 播放背景音乐
    8. 	mciSendString("open D:/program/yanhua/小幸运.mp3 alias bk", 0, 0, 0);
    9.  
    10. 	mciSendString("play bk repeat", 0, 0, 0);
    11.  
    12. 	welcome();
    13.  
    14. 	DWORD t1 = timeGetTime();			// 筛选烟花计时
    15. 	DWORD st1 = timeGetTime();			// 播放花样计时
    16. 	DWORD* pMem = GetImageBuffer();		// 获取窗口显存指针
    17.  
    18. 	for (int i = 0; i < NUM; i++)		// 初始化烟花
    19. 	{
    20. 		Init(i);
    21. 	}
    22. 	Load();								// 将烟花图片信息加载进相应结构中
    23. 	BeginBatchDraw();					// 开始批量绘图
    24.  
    25. 	while (!kbhit())
    26. 	{
    27. 		Sleep(1);
    28.  
    29. 		// 随机选择 4000 个像素点擦除
    30. 		for (int clr = 0; clr < 1000; clr++)
    31. 		{
    32. 			for (int j = 0; j < 2; j++)
    33. 			{
    34. 				int px1 = rand() % 1200;
    35. 				int py1 = rand() % 800;
    36.  
    37. 				if (py1 < 799)				// 防止越界
    38. 					pMem[py1 * 1200 + px1] = pMem[py1 * 1200 + px1 + 1] = BLACK;	// 对显存赋值擦出像素点
    39. 			}
    40. 		}
    41. 		Chose(t1);			// 筛选烟花
    42. 		Shoot();			// 发射烟花
    43. 		Show(pMem);			// 绽放烟花
    44. 		Style(st1);			// 花样发射
    45. 		FlushBatchDraw();	// 显示前面的所有绘图操作
    46. 	}
    47.  
    48. }

    执行上面的顺序就可以了

    最后总代码如下:

    1. #pragma warning(disable:4996)//忽略4996错误提示
    2. #pragma comment(linker,"/entry:mainCRTStartup /subsystem:windows")
    3. #include <graphics.h>
    4. #include <conio.h>
    5. #include <math.h>
    6. #include <time.h>
    7. #include <stdio.h>
    8. #include <Mmsystem.h>		
    9. #pragma comment ( lib, "Winmm.lib" )
    10.  
    11. /***** 宏定义区 ******/
    12.  
    13. #define NUM		13			// 烟花种类数量宏定义
    14. #define PI      3.1415926548
    15.  
    16. /***** 结构定义区 **********/
    17.  
    18. // 烟花结构
    19. struct FIRE
    20. {
    21. 	int r;					// 当前爆炸半径
    22. 	int max_r;				// 爆炸中心距离边缘最大半径
    23. 	int x, y;				// 爆炸中心在窗口的坐标
    24. 	int cen_x, cen_y;		// 爆炸中心相对图片左上角的坐标
    25. 	int width, height;		// 图片的宽高
    26. 	int xy[240][240];		// 储存图片像素点
    27.  
    28. 	bool show;				// 是否绽放
    29. 	bool draw;				// 开始输出像素点
    30. 	DWORD t1, t2, dt;		// 绽放速度
    31. }Fire[NUM];
    32.  
    33. // 烟花弹结构
    34. struct JET
    35. {
    36. 	int x, y;				// 喷射点坐标
    37. 	int hx, hy;				// 最高点坐标------将赋值给 FIRE 里面的 x, y
    38. 	int height;				// 烟花高度
    39. 	bool shoot;				// 是否可以发射
    40.  
    41. 	DWORD t1, t2, dt;		// 发射速度
    42. 	IMAGE img[2];			// 储存花弹一亮一暗图片
    43. 	byte n : 1;				// 图片下标
    44. }Jet[NUM];
    45.  
    46.  
    47. /**** 函数申明区 ****/
    48.  
    49. void welcome();
    50. void Init(int);		// 初始化烟花
    51. void Load();		// 加载烟花图片
    52. void Shoot();		// 发射烟花
    53. void Chose(DWORD&);		// 筛选烟花
    54. void Style(DWORD&);		// 发射样式
    55. void Show(DWORD*);		// 绽放烟花
    56.  
    57.  
    58. // 主函数
    59. int main()
    60. {
    61. 	initgraph(1200, 800);
    62. 	srand(time(0));
    63.  
    64. 	// 播放背景音乐
    65. 	mciSendString("open D:/program/yanhua/小幸运.mp3 alias bk", 0, 0, 0);
    66.  
    67. 	mciSendString("play bk repeat", 0, 0, 0);
    68.  
    69. 	welcome();
    70.  
    71. 	DWORD t1 = timeGetTime();			// 筛选烟花计时
    72. 	DWORD st1 = timeGetTime();			// 播放花样计时
    73. 	DWORD* pMem = GetImageBuffer();		// 获取窗口显存指针
    74.  
    75. 	for (int i = 0; i < NUM; i++)		// 初始化烟花
    76. 	{
    77. 		Init(i);
    78. 	}
    79. 	Load();								// 将烟花图片信息加载进相应结构中
    80. 	BeginBatchDraw();					// 开始批量绘图
    81.  
    82. 	while (!kbhit())
    83. 	{
    84. 		Sleep(1);
    85.  
    86. 		// 随机选择 4000 个像素点擦除
    87. 		for (int clr = 0; clr < 1000; clr++)
    88. 		{
    89. 			for (int j = 0; j < 2; j++)
    90. 			{
    91. 				int px1 = rand() % 1200;
    92. 				int py1 = rand() % 800;
    93.  
    94. 				if (py1 < 799)				// 防止越界
    95. 					pMem[py1 * 1200 + px1] = pMem[py1 * 1200 + px1 + 1] = BLACK;	// 对显存赋值擦出像素点
    96. 			}
    97. 		}
    98. 		Chose(t1);			// 筛选烟花
    99. 		Shoot();			// 发射烟花
    100. 		Show(pMem);			// 绽放烟花
    101. 		Style(st1);			// 花样发射
    102. 		FlushBatchDraw();	// 显示前面的所有绘图操作
    103. 	}
    104.  
    105. }
    106.  
    107.  
    108. void welcome()
    109. {
    110. 	//setfillstyle(0);
    111. 	setcolor(YELLOW);
    112.  
    113. 	for (int i = 0; i < 50; i++)
    114. 	{
    115. 		int x = 600 + int(180 * sin(PI * 2 * i / 60));
    116. 		int y = 200 + int(180 * cos(PI * 2 * i / 60));
    117. 		cleardevice();
    118. 		settextstyle(i, 0, "楷体");
    119. 		outtextxy(x - 80, y, "浪漫表白日");
    120. 		outtextxy(x - 10, y + 100, "献给挚爱的你");
    121. 		Sleep(30);
    122. 	}
    123. 	Sleep(5000);
    124. 	getchar();
    125. 	cleardevice();
    126. 	settextstyle(25, 0, "楷体");
    127. 	outtextxy(400, 200, "原来你是我最想留住的幸运");
    128. 	outtextxy(400, 250, "原来我们和爱情曾经靠得那么近");
    129. 	outtextxy(400, 300, "那为我对抗世界的决定");
    130. 	outtextxy(400, 350, "那陪我淋的雨");
    131. 	outtextxy(400, 400, "一幕幕都是你");
    132. 	outtextxy(400, 450, "一尘不染的真心。");
    133. 	outtextxy(600, 500, "----《小幸运》");
    134. 	Sleep(10000);
    135. 	getchar();
    136. }
    137.  
    138. // 初始化烟花参数
    139. void Init(int i)
    140. {
    141. 	// 分别为：烟花中心到图片边缘的最远距离、烟花中心到图片左上角的距离 (x、y) 两个分量
    142. 	int r[13] = { 120, 120, 155, 123, 130, 147, 138, 138, 130, 135, 140, 132, 155 };
    143. 	int x[13] = { 120, 120, 110, 117, 110, 93, 102, 102, 110, 105, 100, 108, 110 };
    144. 	int y[13] = { 120, 120, 85, 118, 120, 103, 105, 110, 110, 120, 120, 104, 85 };
    145.  
    146. 	/**** 初始化烟花 *****/
    147.  
    148. 	Fire[i].x = 0;				// 烟花中心坐标
    149. 	Fire[i].y = 0;
    150. 	Fire[i].width = 240;				// 图片宽
    151. 	Fire[i].height = 240;				// 图片高
    152. 	Fire[i].max_r = r[i];				// 最大半径
    153. 	Fire[i].cen_x = x[i];				// 中心距左上角距离
    154. 	Fire[i].cen_y = y[i];
    155. 	Fire[i].show = false;			// 是否绽放
    156. 	Fire[i].dt = 5;				// 绽放时间间隔
    157. 	Fire[i].t1 = timeGetTime();
    158. 	Fire[i].r = 0;				// 从 0 开始绽放
    159.  
    160. 	/**** 初始化烟花弹 *****/
    161.  
    162. 	Jet[i].x = -240;				// 烟花弹左上角坐标
    163. 	Jet[i].y = -240;
    164. 	Jet[i].hx = -240;				// 烟花弹发射最高点坐标
    165. 	Jet[i].hy = -240;
    166. 	Jet[i].height = 0;				// 发射高度
    167. 	Jet[i].t1 = timeGetTime();
    168. 	Jet[i].dt = rand() % 10;		// 发射速度时间间隔
    169. 	Jet[i].n = 0;				// 烟花弹闪烁图片下标
    170. 	Jet[i].shoot = false;			// 是否发射
    171. }
    172.  
    173.  
    174. // 加载图片
    175. void Load()
    176. {
    177. 	/**** 储存烟花的像素点颜色 ****/
    178. 	IMAGE fm, gm;
    179. 	loadimage(&fm, "D:/program/yanhua/yanhua.jpg", 3120, 240);
    180.  
    181. 	for (int i = 0; i < 13; i++)
    182. 	{
    183. 		SetWorkingImage(&fm);
    184. 		getimage(&gm, i * 240, 0, 240, 240);
    185. 		SetWorkingImage(&gm);
    186.  
    187. 		for (int a = 0; a < 240; a++)
    188. 			for (int b = 0; b < 240; b++)
    189. 				Fire[i].xy[a][b] = getpixel(a, b);
    190. 	}
    191.  
    192. 	/**** 加载烟花弹 ************/
    193. 	IMAGE sm;
    194. 	loadimage(&sm, "D:/program/yanhua/dan.jpg", 200, 50);
    195.  
    196. 	for (int i = 0; i < 13; i++)
    197. 	{
    198. 		SetWorkingImage(&sm);
    199. 		int n = rand() % 5;
    200.  
    201. 		getimage(&Jet[i].img[0], n * 20, 0, 20, 50);			// 暗
    202. 		getimage(&Jet[i].img[1], (n + 5) * 20, 0, 20, 50);		// 亮
    203. 	}
    204.  
    205.  
    206. 	SetWorkingImage();		// 设置回绘图窗口
    207. }
    208.  
    209.  
    210. // 在一定范围内筛选可发射的烟花，并初始化发射参数，输出烟花弹到屏幕，播放声音
    211. void Chose(DWORD& t1)
    212. {
    213. 	DWORD t2 = timeGetTime();
    214.  
    215. 	if (t2 - t1 > 100)
    216. 	{
    217. 		int n = rand() % 20;
    218.  
    219. 		if (n < 13 && Jet[n].shoot == false && Fire[n].show == false)
    220. 		{
    221. 			/**** 重置烟花弹，预备发射 *****/
    222. 			Jet[n].x = rand() % 1200;
    223. 			Jet[n].y = rand() % 100 + 600;
    224. 			Jet[n].hx = Jet[n].x;
    225. 			Jet[n].hy = rand() % 400;
    226. 			Jet[n].height = Jet[n].y - Jet[n].hy;
    227. 			Jet[n].shoot = true;
    228. 			putimage(Jet[n].x, Jet[n].y, &Jet[n].img[Jet[n].n], SRCINVERT);
    229.  
    230. 			/**** 播放每个烟花弹的声音 *****/
    231. 			/*char c1[50], c2[30], c3[30];
    232. 			sprintf(c1, "open ./fire/shoot.mp3 alias s%d", n);
    233. 			sprintf(c2, "play s%d", n);
    234. 			sprintf(c3, "close n%d", n);
    235.  
    236. 			mciSendString(c3, 0, 0, 0);
    237. 			mciSendString(c1, 0, 0, 0);
    238. 			mciSendString(c2, 0, 0, 0);*/
    239. 		}
    240. 		t1 = t2;
    241. 	}
    242. }
    243.  
    244.  
    245. // 扫描烟花弹并发射
    246. void Shoot()
    247. {
    248. 	for (int i = 0; i < 13; i++)
    249. 	{
    250. 		Jet[i].t2 = timeGetTime();
    251.  
    252. 		if (Jet[i].t2 - Jet[i].t1 > Jet[i].dt && Jet[i].shoot == true)
    253. 		{
    254. 			/**** 烟花弹的上升 *****/
    255. 			putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);
    256.  
    257. 			if (Jet[i].y > Jet[i].hy)
    258. 			{
    259. 				Jet[i].n++;
    260. 				Jet[i].y -= 5;
    261. 			}
    262.  
    263. 			putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);
    264.  
    265. 			/**** 上升到高度的 3 / 4，减速 *****/
    266. 			if ((Jet[i].y - Jet[i].hy) * 4 < Jet[i].height)
    267. 				Jet[i].dt = rand() % 4 + 10;
    268.  
    269. 			/**** 上升到最大高度 *****/
    270. 			if (Jet[i].y <= Jet[i].hy)
    271. 			{
    272. 				// 播放爆炸声
    273. 				/*char c1[50], c2[30], c3[30];
    274. 				sprintf(c1, "open ./fire/bomb.wav alias n%d", i);
    275. 				sprintf(c2, "play n%d", i);
    276. 				sprintf(c3, "close s%d", i);
    277.  
    278. 				mciSendString(c3, 0, 0, 0);
    279. 				mciSendString(c1, 0, 0, 0);
    280. 				mciSendString(c2, 0, 0, 0);*/
    281.  
    282. 				putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);	// 擦掉烟花弹
    283. 				Fire[i].x = Jet[i].hx + 10;											// 在烟花弹中间爆炸
    284. 				Fire[i].y = Jet[i].hy;												// 在最高点绽放
    285. 				Fire[i].show = true;					// 开始绽放
    286. 				Jet[i].shoot = false;					// 停止发射
    287.  
    288. 			}
    289. 			Jet[i].t1 = Jet[i].t2;
    290. 		}
    291. 	}
    292. }
    293.  
    294.  
    295.  
    296. // 显示花样
    297. void Style(DWORD& st1)
    298. {
    299. 	DWORD st2 = timeGetTime();
    300.  
    301. 	if (st2 - st1 > 20000)		// 一首歌的时间
    302. 	{
    303. 		// 心形坐标
    304. 		int x[13] = { 60, 75, 91, 100, 95, 75, 60, 45, 25, 15, 25, 41, 60 };
    305. 		int y[13] = { 65, 53, 40, 22, 5, 4, 20, 4, 5, 22, 40, 53, 65 };
    306. 		for (int i = 0; i < NUM; i++)
    307. 		{
    308. 			//cleardevice();
    309. 			/**** 规律分布烟花弹 ***/
    310. 			Jet[i].x = x[i] * 10;
    311. 			Jet[i].y = (y[i] + 75) * 10;
    312. 			Jet[i].hx = Jet[i].x;
    313. 			Jet[i].hy = y[i] * 10;
    314. 			Jet[i].height = Jet[i].y - Jet[i].hy;
    315. 			Jet[i].shoot = true;
    316. 			Jet[i].dt = 7;
    317. 			putimage(Jet[i].x, Jet[i].y, &Jet[i].img[Jet[i].n], SRCINVERT);	// 显示烟花弹
    318.  
    319. 			/**** 设置烟花参数 ***/
    320. 			Fire[i].x = Jet[i].x + 10;
    321. 			Fire[i].y = Jet[i].hy;
    322. 			Fire[i].show = false;
    323. 			Fire[i].r = 0;
    324.  
    325. 			/**** 播放发射声音 ***/
    326. 			/*char c1[50], c2[30], c3[30];
    327. 			sprintf(c1, "open ./fire/shoot.mp3 alias s%d", i);
    328. 			sprintf(c2, "play s%d", i);
    329. 			sprintf(c3, "close n%d", i);
    330.  
    331. 			mciSendString(c3, 0, 0, 0);
    332. 			mciSendString(c1, 0, 0, 0);
    333. 			mciSendString(c2, 0, 0, 0);*/
    334. 		}
    335. 		st1 = st2;
    336. 	}
    337. }
    338.  
    339.  
    340. // 绽放烟花
    341. void Show(DWORD* pMem)
    342. {
    343. 	// 烟花个阶段绽放时间间隔，制作变速绽放效果
    344. 	int drt[16] = { 5, 5, 5, 5, 5, 6, 25, 25, 25, 25, 55, 55, 55, 55, 55 };
    345.  
    346. 	for (int i = 0; i < NUM; i++)
    347. 	{
    348. 		Fire[i].t2 = timeGetTime();
    349.  
    350. 		// 增加爆炸半径，绽放烟花，增加时间间隔做变速效果
    351. 		if (Fire[i].t2 - Fire[i].t1 > Fire[i].dt && Fire[i].show == true)
    352. 		{
    353. 			if (Fire[i].r < Fire[i].max_r)
    354. 			{
    355. 				Fire[i].r++;
    356. 				Fire[i].dt = drt[Fire[i].r / 10];
    357. 				Fire[i].draw = true;
    358. 			}
    359.  
    360. 			if (Fire[i].r >= Fire[i].max_r - 1)
    361. 			{
    362. 				Fire[i].draw = false;
    363. 				Init(i);
    364. 			}
    365. 			Fire[i].t1 = Fire[i].t2;
    366. 		}
    367.  
    368. 		// 如果该号炮花可爆炸，根据当前爆炸半径画烟花，颜色值接近黑色的不输出。
    369. 		if (Fire[i].draw)
    370. 		{
    371. 			for (double a = 0; a <= 6.28; a += 0.01)
    372. 			{
    373. 				int x1 = (int)(Fire[i].cen_x + Fire[i].r * cos(a));				// 相对于图片左上角的坐标
    374. 				int y1 = (int)(Fire[i].cen_y - Fire[i].r * sin(a));
    375.  
    376. 				if (x1 > 0 && x1 < Fire[i].width && y1 > 0 && y1 < Fire[i].height)	// 只输出图片内的像素点
    377. 				{
    378. 					int b = Fire[i].xy[x1][y1] & 0xff;
    379. 					int g = (Fire[i].xy[x1][y1] >> 8) & 0xff;
    380. 					int r = (Fire[i].xy[x1][y1] >> 16);
    382. 					// 烟花像素点在窗口上的坐标
    383. 					int xx = (int)(Fire[i].x + Fire[i].r * cos(a));
    384. 					int yy = (int)(Fire[i].y - Fire[i].r * sin(a));
    385.  
    386. 					// 较暗的像素点不输出、防止越界
    387. 					if (r > 0x20 && g > 0x20 && b > 0x20 && xx > 0 && xx < 1200 && yy > 0 && yy < 800)
    388. 						pMem[yy * 1200 + xx] = BGR(Fire[i].xy[x1][y1]);	// 显存操作绘制烟花
    389. 				}
    390. 			}
    391. 			Fire[i].draw = false;
    392. 		}
    393. 	}
    394. }

    总代码参考于:Easyx-----c语言实现烟花表白程序_小雪菜本菜的博客-CSDN博客_c语言表白浪漫烟花效果代码

  • 相关阅读:
    WEB前端 网页设计 简介
    民办二本计算机毕业以后
    Vuex的简介以及入门案例
    第149篇 笔记-web3
    gin路由
    凯云科技 | 专业嵌入式测试软硬件整体解决方案供应商
    基于神经网络的图像识别研究
    《小狗钱钱》阅读笔记（四）
    Raiden Network（二）—— Mediated transfers（多跳支付里的中介传输）
    【模型渲染】前端如何让glb模型转3dtiles
  • 原文地址：https://blog.csdn.net/Lukegood/article/details/128117253