• 用VS软件开发“浪漫烟花“＜笔记摘录＞

    此处主要讲:如何开发一个连续的烟花弹上升并进行烟花爆炸的程序.

    第一步自然是创建窗口,设置窗口宽度为1200,高度为800(#include )

    	initgraph(1200, 800);//创建窗口,宽度1200,高度800

     第二步我们需要为这个窗口添加背景音乐,这里我们添加了一首"周杰伦的告白气球.mp3",打开并且播放.因为我们并不需要暂停或者关闭,所以便注释掉对应的程序.

    注意,添加音乐的时候要记住添加头文件

    1. #include//媒体头文件
    2.  
    3. #pragma comment(lib,"winmm.lib")//媒体库文件
    1. 	mciSendString("open 告白气球.mp3",0,0,0);
    2. 	mciSendString("play 告白气球.mp3", 0, 0, 0);
    3. 	//mciSendString("pause 周杰伦 - 告白气球(Live).mp3", 0, 0, 0);
    4. 	//mciSendString("close 周杰伦 - 告白气球(Live).mp3", 0, 0, 0);

    第三步我们开始在窗口上面添加文本,记不记得学习C++的第一个程序,"hello,world!"

    这里类同,只不过是讲对应的文本输入到窗口对应的位置.程序如下:

    1. 	settextcolor(YELLOW);//设置字体的颜色
    2. 	settextstyle(25,0,"微软雅黑");//设置字体的字号					 
    3. 	//outtextxy(320,240,"赵哥真帅");//在创建的窗口,(320,240)的位置的输入赵哥真帅
    4. 	outtextxy(400, 200, "XXXXXXXXXX");
    5. 	outtextxy(400, 250, "XXXXXXXXXX");
    6. 	outtextxy(400, 300, "XXXXXXXXXX");
    7. 	outtextxy(400, 350, "XXXXXXXXXX");
    8. 	outtextxy(400, 400, "XXXXXXXXXX");
    9. 	outtextxy(600, 450, "------小子");

    然后在显示的时候,我们可以给这段文本延时5s

    	Sleep(5000);

    文本结束后,就开始进入烟花弹和烟花的爆炸现场.

    第四步,定义烟花弹和烟花

    1. //烟花弹
    2. struct Jet//烟花弹属性
    3. {
    4. 	int x, y;//当前坐标
    5. 	int hx, hy;//最高点的坐标
    6. 	unsigned long t1, t2, dt;//时间来控制速度
    7. 	IMAGE img;//保存烟花弹的图片
    8. 	bool isshoot;//烟花弹是否属于正在上升的状态
    9. }jet;
    10.  
    11. //烟花
    12. struct Fire//从中心往外面进行拓展
    13. {
    14. 	int r;//当前半径
    15. 	int maxr;//最大半径
    16. 	int x, y;//中心点的左边//窗口
    17. 	int cx, cy;//中心点左边,坐标系不同//图片
    18. 	int xy[240][240];   //保存图片当中每一个像素点
    19. 	bool isboom;//是否开始爆炸
    20. 	bool isdram;//是否开始显示
    21. 	unsigned long t1, t2, dt; //爆炸的速度
    22. }fire;

    简单解释:烟花弹属性包括了他的当前坐标和最高坐标,因为烟花弹是垂直向上的,所以速度,采用时间t1,t2和dt来进行描述,IMAGE用来保存烟花弹的图片.并定义一个布尔类型isshoot,判断烟花弹是否处于上升状态

    关于IMAGE函数的有关解释,可以参考:EasyX 文档 - IMAGE

    烟花的基本属性在于:要明白烟花爆炸是从一个中心点,向外速度越来越慢地拓展开来的,因此我们定义烟花的当前半径和最大半径,烟花爆炸的点相对于窗口的坐标,和烟花爆炸上面点相对于图片的坐标,及其设定一个二维数组用于保存图片当中每一个像素点.最后定义两个布尔类型,判断烟花是否爆炸和显示.

    第五步 初始化烟花弹和烟花

    1. //初始化烟花弹
    2. void startjet()
    3. {
    4. 	jet.x = rand() % (1200 - 20);
    5. 	jet.y = 750;
    6. 	jet.hx = jet.x;//垂直上升
    7. 	jet.hy = rand() % 400;//0-399爆炸
    8. 	jet.t1 = GetTickCount(); //获取系统时间
    9. 	jet.dt = 10;//dt  10ms
    10. 	jet.isshoot = true;
    11. 	loadimage(&jet.img, "jet.jpg", 20, 50);
    12. 	putimage(jet.x, jet.y, &jet.img, SRCINVERT);
    13. }
    14.  
    15. //初始化烟花
    16. void startfire() {
    17. 	fire.r=0;//当前半径
    18. 	fire.maxr=120;//最大半径
    19. 	fire.x=0, fire.y=0;//中心点的左边//窗口//等于烟花弹最高点的坐标
    20. 	fire.cx=120, fire.cy=120;//中心点左边,坐标系不同//图片
    21. 	fire.isboom=false;//是否开始爆炸
    22. 	fire.isdram=false;//是否开始显示
    23. 	fire.t1 = GetTickCount();
    24. 	fire.dt = 5; //爆炸的速度
    25. 	fire.xy[239][239];   //保存图片当中每一个像素点
    26. 	IMAGE fimg;
    27. 	loadimage(&fimg, "flower.jpg", 240,240);
    28.  
    29. 	SetWorkingImage(&fimg);//获取fimg地址的图片
    30. 	for (int a = 0; a < 240; a++)//把图片的所有像素点定义在一个数组当中
    31. 	{
    32. 		for (int b = 0; b < 240; b++)
    33. 		{
    34. 			fire.xy[a][b]=getpixel(a, b);//窗口获取(a,b)像素点
    35.  
    36. 		}
    37. 	}
    38. 	SetWorkingImage();//放开对应的图片
    39. }

    其次对应上面定义的烟花和烟花弹的结构,对其进行初始状态定义.此处要注意,烟花和烟花弹图片显示的方式不同,烟花弹是作为一个整体,垂直上升的,而烟花是从一个点,爆炸开来的,显示的是每一个范围的像素图.

    第六步 发射烟花弹

    1. void shootjet()
    2. {
    3. 	//biubiubiu
    4. 	jet.t2 = GetTickCount();//t2
    5. 	if (jet.t2 - jet.t1 > jet.dt && jet.isshoot == true)
    6. 	{
    7. 		putimage(jet.x, jet.y, &jet.img, SRCINVERT);
    8.  
    9. 		if (jet.y > jet.hy)//停止在这个烟花的最高位置附近,然后要准备进行爆炸
    10. 			jet.y -= 5;
    11. 		putimage(jet.x, jet.y, &jet.img, SRCINVERT);//y-5之后再演示烟花弹下一个位置
    12.  
    13. 		if (jet.y <= jet.hy)//到达最高点了
    14. 		{
    15. 			//擦除烟花弹
    16. 			putimage(jet.x, jet.y, &jet.img, SRCINVERT);
    17. 			fire.isboom = true;//开始爆炸烟花
    18. 			jet.isshoot = false;
    19. 			fire.x = jet.x;
    20. 			fire.y = jet.y+10;
    21. 			//showfire(pMem);
    22.  
    23. 		}
    24. 		if (jet.isshoot == false)
    25. 		{
    26. 			//再次初始化烟花弹
    27. 			startjet();
    28. 			//fire.isdram = false;
    29. 		}
    30. 		jet.t1 = jet.t2;
    31. 	}
    32. }

    当到达最高点的时候,要将烟花弹擦除,并且记录下此时的坐标,将其赋给烟花相对于窗口的中心点坐标,开始爆炸烟花,如果烟花弹的上升状态转换为false了,那么便再设定一个新的发射烟花弹函数,也就是回溯的调用,最后要记住循环完,将t2的数值赋值给t1;确保能够一直循环运行下去.

    运行到这里,就可以看到一个又一个烟花弹上升并擦除的界面了.

    第七步  烟花爆炸

    先设定一个时间数组,用来控制自内向外爆炸的时间长度,越往外面速度越慢

    1. //爆炸烟花
    2. void showfire(DWORD *pMem)
    3. {
    4. 	//dt数组
    5. //爆炸速度:在半径小的时候爆炸特别快
    6. //半径越大,爆炸越来越慢
    7. 	int drt[12] = { 5,5,5,6,6,15,25,25,25,55,55,65 };//12个为什么?120%10
    8. 	fire.t2 = GetTickCount();
    9. 	if (fire.t2 - fire.t1 > fire.dt && fire.isboom == true)
    10. 	{
    11. 		if (fire.r < fire.maxr)
    12. 		{
    13. 			fire.r++;//半径不断地变大
    14. 			fire.dt = drt[fire.r / 10];
    15. 			fire.isdram = true;
    16. 		}
    17. 		if (fire.r >= fire.maxr - 1)
    18. 		{
    19. 			fire.isdram = false;
    20. 			fire.isboom = false;
    21. 			fire.dt = 5;
    22. 			fire.t1 = GetTickCount();
    23. 			fire.r = 0;
    24. 		}
    25. 		fire.t1 = fire.t2;
    26. 	}
    27. 	if (fire.isdram == true)//可以开始绘制
    28. 	{
    29. 		//628次  2Π
    30. 		for (double a = 0; a <= 6.28; a += 0.01)
    31. 		{
    32. 			//相对于图片左上角的坐标
    33. 			int x1 = fire.cx + fire.r * cos(a);
    34. 			int y1 = fire.cy - fire.r * sin(a);
    35. 			//x1 y1  628个来自于图片的像素点坐标<240
    36. 			fire.xy[x1][y1];//存储上面的像素点坐标
    37. 			
    38. 			if (x1 > 0 && x1 < 240 && y1>0 && y1 < 240 )   //图片像素是240*240,所以只输出像素内的点
    39. 			{
    40. 				int b = fire.xy[x1][y1] & 0xff;
    41. 				int g = (fire.xy[x1][y1] >> 8) & 0xff;
    42. 				int r = (fire.xy[x1][y1] >> 16);
    43. 				//烟花像素点在窗口上的坐标
    44. 				int xx = fire.x + fire.r * cos(a);
    45. 				int yy = fire.y - fire.r * sin(a);
    46. 				// 较暗的像素点不输出、防止越界
    47. 				if (r > 0x20 && g > 0x20 && b > 0x20 && xx > 0 && xx < 1200 && yy > 0 && yy < 800)
    48. 					pMem[yy * 1200 + xx] = BGR(fire.xy[x1][y1]);	// 显存操作绘制烟花
    49.  
    50. 			}
    51.  
    52. 		}
    53. 	}
    54.  
    55. 	fire.isdram = false;
    56. }

    如果fire.isdram==true的时候,也就是可以开始绘制爆炸烟花了.循环当中采用了数学函数,可以定义到每一个像素点的坐标,然后再根据前面烟花弹停止上升的最高点,来确定烟花像素点在窗口上的坐标.设定一个条件判断,如果像素点较暗,则不输出,其他像素点输出.

    最后在每一次循环结束的时候要将isdram设置成false

    最后,运行主函数

    1. int main()
    2. {
    3. 	srand(time(0));
    4. 	initgraph(1200, 800);//创建窗口,宽度1200,高度800
    5. 	
    6. 	mciSendString("open 告白气球.mp3",0,0,0);
    7. 	mciSendString("play 告白气球.mp3", 0, 0, 0);
    8. 	//mciSendString("pause 周杰伦 - 告白气球(Live).mp3", 0, 0, 0);
    9. 	//mciSendString("close 周杰伦 - 告白气球(Live).mp3", 0, 0, 0);
    10. 	//mci send  string  
    11.  
    12. 	settextcolor(YELLOW);//设置字体的颜色
    13. 	settextstyle(25,0,"微软雅黑");//设置字体的字号					 
    14. 	//outtextxy(320,240,"赵哥真帅");//在创建的窗口,(320,240)的位置的输入赵哥真帅
    15. 	outtextxy(400, 200, "XXXXXXXXXX");
    16. 	outtextxy(400, 250, "XXXXXXXXXX");
    17. 	outtextxy(400, 300, "XXXXXXXXXX");
    18. 	outtextxy(400, 350, "XXXXXXXXXX");
    19. 	outtextxy(400, 400, "XXXXXXXXXX");
    20. 	outtextxy(600, 450, "------小子");
    21. 	
    22. 	int uuu=getchar();//按回车键继续
    23. 	Sleep(5000);
    24. 	//DWORD st1 = timeGetTime();			// 播放花样计时
    25. 	DWORD* pMem = GetImageBuffer();		// 获取窗口显存指针
    26. 	//初始化烟花弹
    27. 	startjet();
    28. 	//初始化烟花
    29. 	startfire();
    30. 	while (1)
    31. 	{
    32. 			Sleep(1);
    33. 			// 随机选择 4000 个像素点擦除
    34. 			for (int clr = 0; clr < 2000; clr++)
    35. 			{
    36.  
    37. 				for (int j = 0; j < 2; j++)
    38. 				{
    39. 					int px1 = rand() % 1200;
    40. 					int py1 = rand() % 800;
    41.  
    42. 					if (py1 < 799)				// 防止越界
    43. 						pMem[py1 * 1200 + px1] = pMem[py1 * 1200 + px1 + 1] = BLACK;	// 对显存赋值擦出像素点
    44.  
    45. 					//Style(st1);
    46. 				}
    47. 				shootjet();
    48. 			
    49. 				showfire(pMem);
    50.  
    51. 			}
    52. 			//Style(st1);
    53. 			FlushBatchDraw();	// 显示前面的所有绘图操作
    54. 		
    55. 	}
    56. 	
    57.  
    58. 	while (1);
    59. 	return 0;
    60. }

    总代码和相关素材如下:

    1. #pragma warning(disable:4996)//忽略4996错误提示
    2. #pragma comment(linker,"/entry:mainCRTStartup /subsystem:windows")
    3. #include <graphics.h>
    4. #include <stdio.h>
    5. #include <conio.h>
    6. #include <easyx.h>//图形界面库
    7. #include<time.h>
    8. #include<math.h>
    9. #include<string.h>
    10. //歌曲需要的头文件
    11. #include<mmsystem.h>//媒体头文件
    12.  
    13. #pragma comment(lib,"winmm.lib")//媒体库文件
    14. //烟花弹
    15. struct Jet//烟花弹属性
    16. {
    17. 	int x, y;//当前坐标
    18. 	int hx, hy;//最高点的坐标
    19. 	unsigned long t1, t2, dt;//时间来控制速度
    20. 	IMAGE img;//保存烟花弹的图片
    21. 	bool isshoot;//烟花弹是否属于正在上升的状态
    22. }jet;
    23.  
    24. //烟花
    25. struct Fire//从中心往外面进行拓展
    26. {
    27. 	int r;//当前半径
    28. 	int maxr;//最大半径
    29. 	int x, y;//中心点的左边//窗口
    30. 	int cx, cy;//中心点左边,坐标系不同//图片
    31. 	int xy[240][240];   //保存图片当中每一个像素点
    32. 	bool isboom;//是否开始爆炸
    33. 	bool isdram;//是否开始显示
    34. 	unsigned long t1, t2, dt; //爆炸的速度
    35. }fire;
    36.  
    37. //初始化烟花弹
    38. void startjet()
    39. {
    40. 	jet.x = rand() % (1200 - 20);
    41. 	jet.y = 750;
    42. 	jet.hx = jet.x;//垂直上升
    43. 	jet.hy = rand() % 400;//0-399爆炸
    44. 	jet.t1 = GetTickCount(); //获取系统时间
    45. 	jet.dt = 10;//dt  10ms
    46. 	jet.isshoot = true;
    47. 	loadimage(&jet.img, "jet.jpg", 20, 50);
    48. 	putimage(jet.x, jet.y, &jet.img, SRCINVERT);
    49. }
    50.  
    51. //初始化烟花
    52. void startfire() {
    53. 	fire.r=0;//当前半径
    54. 	fire.maxr=120;//最大半径
    55. 	fire.x=0, fire.y=0;//中心点的左边//窗口//等于烟花弹最高点的坐标
    56. 	fire.cx=120, fire.cy=120;//中心点左边,坐标系不同//图片
    57. 	fire.isboom=false;//是否开始爆炸
    58. 	fire.isdram=false;//是否开始显示
    59. 	fire.t1 = GetTickCount();
    60. 	fire.dt = 5; //爆炸的速度
    61. 	fire.xy[239][239];   //保存图片当中每一个像素点
    62. 	IMAGE fimg;
    63. 	loadimage(&fimg, "flower.jpg", 240,240);
    64.  
    65. 	SetWorkingImage(&fimg);//获取fimg地址的图片
    66. 	for (int a = 0; a < 240; a++)//把图片的所有像素点定义在一个数组当中
    67. 	{
    68. 		for (int b = 0; b < 240; b++)
    69. 		{
    70. 			fire.xy[a][b]=getpixel(a, b);//窗口获取(a,b)像素点
    71.  
    72. 		}
    73. 	}
    74. 	SetWorkingImage();//放开对应的图片
    75. }
    76.  
    77. //发射烟花弹
    78. void shootjet()
    79. {
    80. 	//biubiubiu
    81. 	jet.t2 = GetTickCount();//t2
    82. 	if (jet.t2 - jet.t1 > jet.dt && jet.isshoot == true)
    83. 	{
    84. 		putimage(jet.x, jet.y, &jet.img, SRCINVERT);
    85.  
    86. 		if (jet.y > jet.hy)//停止在这个烟花的最高位置附近,然后要准备进行爆炸
    87. 			jet.y -= 5;
    88. 		putimage(jet.x, jet.y, &jet.img, SRCINVERT);//y-5之后再演示烟花弹下一个位置
    89.  
    90. 		if (jet.y <= jet.hy)//到达最高点了
    91. 		{
    92. 			//擦除烟花弹
    93. 			putimage(jet.x, jet.y, &jet.img, SRCINVERT);
    94. 			fire.isboom = true;//开始爆炸烟花
    95. 			jet.isshoot = false;
    96. 			fire.x = jet.x;
    97. 			fire.y = jet.y+10;
    98. 			//showfire(pMem);
    99.  
    100. 		}
    101. 		if (jet.isshoot == false)
    102. 		{
    103. 			//再次初始化烟花弹
    104. 			startjet();
    105. 			//fire.isdram = false;
    106. 		}
    107. 		jet.t1 = jet.t2;
    108. 	}
    109. }
    110. //爆炸烟花
    111. void showfire(DWORD *pMem)
    112. {
    113. 	//dt数组
    114. //爆炸速度:在半径小的时候爆炸特别快
    115. //半径越大,爆炸越来越慢
    116. 	int drt[12] = { 5,5,5,6,6,15,25,25,25,55,55,65 };//12个为什么?120%10
    117. 	fire.t2 = GetTickCount();
    118. 	if (fire.t2 - fire.t1 > fire.dt && fire.isboom == true)
    119. 	{
    120. 		if (fire.r < fire.maxr)
    121. 		{
    122. 			fire.r++;//半径不断地变大
    123. 			fire.dt = drt[fire.r / 10];
    124. 			fire.isdram = true;
    125. 		}
    126. 		if (fire.r >= fire.maxr - 1)
    127. 		{
    128. 			fire.isdram = false;
    129. 			fire.isboom = false;
    130. 			fire.dt = 5;
    131. 			fire.t1 = GetTickCount();
    132. 			fire.r = 0;
    133. 		}
    134. 		fire.t1 = fire.t2;
    135. 	}
    136. 	if (fire.isdram == true)//可以开始绘制
    137. 	{
    138. 		//628次  2Π
    139. 		for (double a = 0; a <= 6.28; a += 0.01)
    140. 		{
    141. 			//相对于图片左上角的坐标
    142. 			int x1 = fire.cx + fire.r * cos(a);
    143. 			int y1 = fire.cy - fire.r * sin(a);
    144. 			//x1 y1  628个来自于图片的像素点坐标<240
    145. 			fire.xy[x1][y1];//存储上面的像素点坐标
    146. 			
    147. 			if (x1 > 0 && x1 < 240 && y1>0 && y1 < 240 )   //图片像素是240*240,所以只输出像素内的点
    148. 			{
    149. 				int b = fire.xy[x1][y1] & 0xff;
    150. 				int g = (fire.xy[x1][y1] >> 8) & 0xff;
    151. 				int r = (fire.xy[x1][y1] >> 16);
    152. 				//烟花像素点在窗口上的坐标
    153. 				int xx = fire.x + fire.r * cos(a);
    154. 				int yy = fire.y - fire.r * sin(a);
    155. 				// 较暗的像素点不输出、防止越界
    156. 				if (r > 0x20 && g > 0x20 && b > 0x20 && xx > 0 && xx < 1200 && yy > 0 && yy < 800)
    157. 					pMem[yy * 1200 + xx] = BGR(fire.xy[x1][y1]);	// 显存操作绘制烟花
    158.  
    159. 			}
    160.  
    161. 		}
    162. 	}
    163.  
    164. 	fire.isdram = false;
    165. }
    166.  
    167.  
    168. // 显示花样  //本程序不显示
    169. void Style(DWORD& st1)
    170. {
    171. 	DWORD st2 = timeGetTime();
    172.  
    173. 	if (st2 - st1 > 2000)		// 一首歌的时间
    174. 	{
    175. 		// 心形坐标
    176. 		int x[13] = { 60, 75, 91, 100, 95, 75, 60, 45, 25, 15, 25, 41, 60 };
    177. 		int y[13] = { 65, 53, 40, 22, 5, 4, 20, 4, 5, 22, 40, 53, 65 };
    178. 		for (int i = 0; i < 13; i++)
    179. 		{
    180. 			//cleardevice();
    181. 			/**** 规律分布烟花弹 ***/
    182. 			jet.x = x[i] * 10;
    183. 			jet.y = (y[i] + 75) * 10;
    184. 			jet.hx = jet.x;
    185. 			jet.hy = y[i] * 10;
    186. 			jet.isshoot = true;
    187. 			jet.dt = 5;
    188. 			putimage(jet.x, jet.y, &jet.img, SRCINVERT);	// 显示烟花弹
    189.  
    190. 			/**** 设置烟花参数 ***/
    191. 			fire.x = jet.x + 10;
    192. 			fire.y = jet.hy;
    193. 			//fire.isdram = false;
    194. 			//fire.r = 0;
    195.  
    196. 			/**** 播放发射声音 ***/
    197. 			/*char c1[50], c2[30], c3[30];
    198. 			sprintf(c1, "open ./fire/shoot.mp3 alias s%d", i);
    199. 			sprintf(c2, "play s%d", i);
    200. 			sprintf(c3, "close n%d", i);
    201.  
    202. 			mciSendString(c3, 0, 0, 0);
    203. 			mciSendString(c1, 0, 0, 0);
    204. 			mciSendString(c2, 0, 0, 0);*/
    205. 		}
    206. 		st1 = st2;
    207. 	}
    208. }
    209.  
    210.  
    211.  
    212.  
    213. int main()
    214. {
    215. 	srand(time(0));
    216. 	initgraph(1200, 800);//创建窗口,宽度1200,高度800
    217. 	
    218. 	mciSendString("open 告白气球.mp3",0,0,0);
    219. 	mciSendString("play 告白气球.mp3", 0, 0, 0);
    220. 	//mciSendString("pause 周杰伦 - 告白气球(Live).mp3", 0, 0, 0);
    221. 	//mciSendString("close 周杰伦 - 告白气球(Live).mp3", 0, 0, 0);
    222. 	//mci send  string  
    223.  
    224. 	settextcolor(YELLOW);//设置字体的颜色
    225. 	settextstyle(25,0,"微软雅黑");//设置字体的字号					 
    226. 	//outtextxy(320,240,"赵哥真帅");//在创建的窗口,(320,240)的位置的输入赵哥真帅
    227. 	outtextxy(400, 200, "XXXXXXXXXX");
    228. 	outtextxy(400, 250, "XXXXXXXXXX");
    229. 	outtextxy(400, 300, "XXXXXXXXXX");
    230. 	outtextxy(400, 350, "XXXXXXXXXX");
    231. 	outtextxy(400, 400, "XXXXXXXXXX");
    232. 	outtextxy(600, 450, "------小子");
    233. 	
    234. 	int uuu=getchar();//按回车键继续
    235. 	Sleep(5000);
    236. 	//DWORD st1 = timeGetTime();			// 播放花样计时
    237. 	DWORD* pMem = GetImageBuffer();		// 获取窗口显存指针
    238. 	//初始化烟花弹
    239. 	startjet();
    240. 	//初始化烟花
    241. 	startfire();
    242. 	while (1)
    243. 	{
    244. 			Sleep(1);
    245. 			// 随机选择 4000 个像素点擦除
    246. 			for (int clr = 0; clr < 2000; clr++)
    247. 			{
    248.  
    249. 				for (int j = 0; j < 2; j++)
    250. 				{
    251. 					int px1 = rand() % 1200;
    252. 					int py1 = rand() % 800;
    253.  
    254. 					if (py1 < 799)				// 防止越界
    255. 						pMem[py1 * 1200 + px1] = pMem[py1 * 1200 + px1 + 1] = BLACK;	// 对显存赋值擦出像素点
    256.  
    257. 					//Style(st1);
    258. 				}
    259. 				shootjet();
    260. 			
    261. 				showfire(pMem);
    262.  
    263. 			}
    264. 			//Style(st1);
    265. 			FlushBatchDraw();	// 显示前面的所有绘图操作
    266. 		
    267. 	}
    268. 	
    269.  
    270. 	while (1);
    271. 	return 0;
    272. }

  • 相关阅读:
    WPF 依赖属性原理、 附加属性
    sql 脚本 WITH 作用
    事务+事务并发+事务隔离级别【Interview Question】
    DevTools failed to parse SourceMap 警告解决方法
    【Qt控件之微调框、进度条】QSpinBox、QDoubleSpinBox、QDial、QProgressBar介绍及使用
    python的str.find()用法及实例
    异地局域网对接：异地组网原理与实操
    期货开户交易要控制自己的消极情绪
    【Python】利用matplotlib在Pycharm中显示本地图片
    JAVA毕业设计Vue网上书籍购买商城登录计算机源码+lw文档+系统+调试部署+数据库
  • 原文地址：https://blog.csdn.net/Lukegood/article/details/128115946