• 【游戏专区】飞机大战

    打过飞机的人都知道，不是那么好打滴，求得麻袋，甩掉你那脑子里的黄色信息。活不多说，我们开始吧。

    1、easyX的原理

    基于Windows图形编程，将Windows下的复杂程序过程进行封装，仅给用户提供一个简单熟悉的接口。用户对于图形库中函数的调用，最终都会由Windows底层的API实现。

    2、easyX的安装

    仅支持vs系列

    点击跳转

    平常使用那个版本就点击对应的安装按钮即可。

    3，图片资源

    链接：点击获取图片
    提取码：1111

    4，创建窗口

    窗口我们需要创建多大呢，

    具体实现怎么操作，我们开始写代码

    窗口是有了，但是我们如何将图片绘制出来呢

    5，定义飞机结构

    想想我们飞机需要哪些结构，坐标，血量还有什么呢

    1. //创建飞机结构
    2. typedef struct Plane
    3. {
    4. 	int x;//飞机坐标
    5. 	int y;
    6. 	bool isDie;//是否健在
    7. 	int width;//宽度
    8. 	int height;//长度
    9. 	int frame;//当前帧
    10. 	int hp;//血量
    11. 	int type;//敌机类型
    12. }Plane;

    有了飞机的结构以及初始化，我们是不是还需要将其加载进入
    飞机图片

    6，透明贴图函数(可直接复制，使用也是可以的)

    1. #include "aircraft.h"
    2.  
    3. //把像素的颜色拆解出来 ARGB
    4. typedef struct _ARGB {
    5. 	byte a;
    6. 	byte r;
    7. 	byte g;
    8. 	byte b;
    9. }ARGB;
    10. //把颜色拆分
    11. ARGB color2Argb(DWORD c) {
    12. 	ARGB res;
    13. 	res.r = (byte)c;
    14. 	res.g = (byte)(c >> 8);
    15. 	res.b = (byte)(c >> 16);
    16. 	res.a = (byte)(c >> 24);
    17. 	return res;
    18. }
    19. DWORD argb2Color(ARGB c) {
    20. 	DWORD t = RGB(c.r, c.g, c.b);
    21. 	return ((DWORD)c.a) << 24 | t;
    22. }
    23. //把色彩图转成黑白图
    24. void toGray(IMAGE* src) {
    25. 	DWORD* psrc = GetImageBuffer(src);
    26. 	for (int i = 0; i < src->getwidth() * src->getheight(); i++) {
    27. 		//获取每一个像素点的颜色值
    28. 		ARGB t = color2Argb(psrc[i]);
    29. 		//灰度图，求三个或者四个颜色值的均值
    30. 		byte arv = (t.r + t.g + t.b) / 3;
    31. 		ARGB res = { t.a,arv,arv,arv };
    32. 		psrc[i] = argb2Color(res);
    33. 	}
    34. }
    35. /*
    36. * @png透明贴图
    37. */
    38. void drawImg(int x, int y, IMAGE* src) {
    39. 	// 变量初始化
    40. 	DWORD* pwin = GetImageBuffer();//窗口缓冲区指针
    41. 	DWORD* psrc = GetImageBuffer(src);//图片缓冲区指针
    42. 	int win_w = getwidth();//窗口宽高
    43. 	int win_h = getheight();
    44. 	int src_w = src->getwidth();//图片宽高
    45. 	int src_h = src->getheight();
    46. 	//计算贴图的实际长宽
    47. 	int real_w = (x + src_w > win_w) ? win_w - x : src_w;//处理超出右边界
    48. 	int real_h = (y + src_h > win_h) ? win_h - y : src_h;//处理超出右边界
    49. 	if (x < 0) {//处理超出左边界
    50. 		psrc += -x;
    51. 		real_w -= -x;
    52. 		x = 0;
    53. 	}
    54. 	if (y < 0) {//处理超出右边界
    55. 		psrc += (src_w * -y);
    56. 		real_h -= -y;
    57. 		y = 0;
    58. 	}
    59.  
    60. 	//修正贴图起始位置
    61. 	pwin += (win_w * y + x);
    62. 	//实现透明贴图
    63. 	for (int iy = 0; iy < real_h; iy++) {
    64. 		for (int ix = 0; ix < real_w; ix++) {
    65. 			byte a = (byte)(psrc[ix] >> 24);//计算透明通道的值[0,256] 0为完全透明 255完全不透明
    66. 			if (a > 100) {
    67. 				pwin[ix] = psrc[ix];
    68. 			}
    69. 		}
    70. 		//换到下一行
    71. 		pwin += win_w;
    72. 		psrc += src_w;
    73. 	}
    74. }

    当我们写到这里，只需要将绘制飞机的(putimage)替换成(drawLmg),就已经可以实现飞机的动态刷新了

    7，飞机的移动

    那我们要去移动飞机吧，不然他还只是一张图片，我们要写飞机的移动，就必须考虑它的边界问题。

    知道了这些，我们就可以开始写代码了

    当我们写完这个，你就会发现你的飞机走的非常快，这是我们电脑在处理帧的时候非常的迅速，所以我们还需要一个定时器，每秒刷新60帧，应该已经足够。

    1. //参数：frameRate 帧数
    2. void timerFunction(int frameRate) {
    3. 	clock_t startTime, currentTime;
    4. 	long elapsed;
    5.  
    6. 	// 计算每一帧的毫秒数
    7. 	int ms_per_frame = 1000 / frameRate;
    8.  
    9. 	// 获取初始时间
    10. 	startTime = clock();
    11.  
    12. 	while (1) {
    13. 		// 获取当前时间
    14. 		currentTime = clock();
    15.  
    16. 		// 计算已经过去的时间（以毫秒为单位）
    17. 		elapsed = (currentTime - startTime) * 1000;
    18.  
    19. 		// 如果已经过去的时间超过了下一帧的时间间隔，则输出一帧
    20. 		if (elapsed >= ms_per_frame) {
    21. 			
    22.  
    23. 			// 更新初始时间
    24. 			startTime = currentTime;
    25. 			// 暂停一段时间，使得每秒输出指定的帧率
    26. 			Sleep(1); // 暂停 1 毫秒
    27. 			break;
    28. 		}
    29. 	}
    30. }

    8，子弹的初始化绘制以及移动

    现在我们就来定义子弹的结构

    1. //子弹结构
    2. typedef struct Bullet
    3. {
    4.  
    5. 	int x;//坐标
    6. 	int y;
    7. 	bool isDie;//是否出界面以及碰到敌机
    8.  
    9. }Bullet;

    子弹的初始化，我们也可以在初始化函数中进行调用

    初始化完成后，我们还需加载资源以及绘制它

    1. //子弹图片有两张
    2. static IMAGE img_bullet[2];
    3.  
    4.  
    5. //加载子弹图片
    6. loadimage(img_bullet + 0, "images/bullet1.png");
    7. loadimage(img_bullet + 1, "images/bullet2.png");

    但是，当我们有了这些依旧无法发射子弹，我们设计的是需要空格去发射的，所以，我们还需要再移动飞机的函数中写一个发射子弹的判断

    这是因为我们发射子弹太快，重叠了，而且我们的子弹只会停留在我们发射的位置，不会移动，所有有了目标，接下来就好办多了。

    我们可以写一个定时器，让它隔几微妙后才能发射

    1. /*
    2. 类概述：
    3. 私有成员变量: std::vector<std::chrono::steady_clock::time_point> startTimes：存储每个计时器的起始时间，通过其ID进行标识。
    4. 构造函数：
    5. Timer(): 默认构造函数。
    6. 方法：
    7. bool hasElapsed(int ms, int id): 检查指定ID的计时器是否经过了ms毫秒。
    8. */
    9. class Timer {
    10. private:
    11.     std::vector<std::chrono::steady_clock::time_point> startTimes;
    12.  
    13. public:
    14.     Timer() {}
    15.  
    16.     bool hasElapsed(int ms, int id) {
    17.         if (id >= startTimes.size()) {
    18.             startTimes.resize(id + 1);
    19.             startTimes[id] = std::chrono::steady_clock::now();
    20.             return true; // Treat as elapsed since this is the first time for this timer
    21.         }
    22.  
    23.         auto now = std::chrono::steady_clock::now();
    24.         auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - startTimes[id]);
    25.         if (duration.count() >= ms) {
    26.             startTimes[id] = now;
    27.             return true;
    28.         }
    29.         return false;
    30.     }
    31. };
    32.

    接下来就是子弹的移动

    所以呢，这样看我们要写的移动就是Y轴的递减过程，飞出界外或者碰到敌人，我们将其置为false就可以了。（很容易写吧）

    9，创建敌机

    我们现在需要什么，当然是敌人啊

    我要打十个，敌人的结构我们可以直接用本机的结构，我们直接初始化敌机,当然，我们敌机的照片也是有好几种的，我这里只加载了两种敌对飞机，如果你们想，其实可以在等主机把小飞机打完之后，绘制打飞机，大飞机的血量可以多点，大飞机也可以发射子弹，当主角解决完大飞机后，可以产生一个界面吗，问其是否要继续挑战，进入下一关，逻辑也是相当简单的。

    10，检测子弹是否打到敌机以及敌机是否碰到本机

    到这里，我们就完成了第一关的制作，后续如果可以根据你们的意愿去做其他的处理

    11，aircraft.h

    1. #pragma once
    2. #include <stdio.h>
    3. #include <string.h>
    4. #include <stdlib.h>
    5. #include <windows.h>
    6. #include <time.h>
    7. #include <easyx.h>
    8. #include <chrono>
    9. #include <vector>
    10.  
    11.  
    12.  
    13. #define MOVE 5
    14. #define graph_height 700
    15. #define graph_width 480
    16. #define ENEMY_NUM 10//敌机数量
    17.  
    18. #define BULLET_NUM 25//子弹数量
    19. //子弹图片有两张
    20. static IMAGE img_bullet[2];
    21. static IMAGE img_bk;//背景图
    22. static IMAGE img_gamer[2];//飞机图片
    23. static IMAGE img_enemy[2][2];//敌机图片
    24.  
    25.  
    26.  
    27. //创建飞机结构
    28. typedef struct Plane
    29. {
    30. 	int x;//飞机坐标
    31. 	int y;
    32. 	bool isDie;//是否健在
    33. 	int width;//宽度
    34. 	int height;//长度
    35. 	int frame;//当前帧
    36. 	int hp;//血量
    37. 	int type;//敌机类型
    38. }Plane;
    39.  
    40. //子弹结构
    41. typedef struct Bullet
    42. {
    43.  
    44. 	int x;//坐标
    45. 	int y;
    46. 	bool isDie;//是否出界面以及碰到敌机
    47.  
    48. }Bullet;
    49. //敌机类型
    50. enum enemyType
    51. {
    52. 	BIG,//大飞机
    53. 	SMALL//小
    54. };
    55.  
    56.  
    57. //资源加载
    58. void Resource();
    59. //绘制函数
    60. void draw(Plane* gamer,Bullet* bullet, Plane* enemy);
    61. //初始化函数
    62. void init(Plane* gamer, Bullet* bullet, Plane* enemy);
    63. //透明贴图函数
    64. void drawImg(int x, int y, IMAGE* src);
    65. //定时器
    66. void timerFunction(int frameRate);
    67. //更新数据
    68. void Updata(Plane* gamer, Bullet* bullet, Plane* enemy);
    69. //void updateEnemyStatus(Plane* enemy);
    70. void checkCollision(Plane* gamer,Plane* enemy, Bullet* bullet);
    71. void createEnemy(Plane* enemy);

    12，aircraft.cpp

    1. #include "aircraft.h"
    2.  
    3. class Timer {
    4. private:
    5. 	std::vector<std::chrono::steady_clock::time_point> startTimes;
    6.  
    7. public:
    8. 	Timer() {}
    9. 	bool hasElapsed(int ms, int id) {
    10. 		if (id >= startTimes.size()) {
    11. 			startTimes.resize(id + 1);
    12. 			startTimes[id] = std::chrono::steady_clock::now();
    13. 			return true; // 重启计数器
    14. 		}
    15.  
    16. 		auto now = std::chrono::steady_clock::now();
    17. 		auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - startTimes[id]);
    18. 		if (duration.count() >= ms) {
    19. 			startTimes[id] = now;
    20. 			return true;
    21. 		}
    22. 		return false;
    23. 	}
    24. };
    25. Timer timer;
    26.  
    27. void enemyHP(int i, Plane* enemy)
    28. {
    29. 	
    30. 	int flag = rand() % 10;
    31. 	if (flag >= 0 && flag <= 1)
    32. 	{
    33. 		enemy[i].type = BIG;
    34. 		enemy[i].hp = 3;
    35. 		enemy[i].width = 169;
    36. 		enemy[i].height = 230;
    37. 	}
    38. 	else
    39. 	{
    40. 		enemy[i].type = SMALL;
    41. 		enemy[i].hp = 1;
    42. 		enemy[i].width = 57;
    43. 		enemy[i].height = 43;
    44. 	}
    45. }
    46. //资源加载
    47. void Resource()
    48. {
    49. 	
    50. 	//加载资源函数
    51. 	loadimage(&img_bk, "images/background.png");
    52. 	//加载玩家飞机图片
    53. 	loadimage(&img_gamer[0], "images/me1.png");
    54. 	loadimage(&img_gamer[1], "images/me2.png");
    55. 	//加载子弹图片
    56. 	loadimage(img_bullet + 0, "images/bullet1.png");
    57. 	loadimage(img_bullet + 1, "images/bullet2.png");
    58. 	//加载敌机图片
    59. 	loadimage(&img_enemy[0][0], "images/enemy1.png");
    60. 	loadimage(&img_enemy[0][1], "images/enemy1.png");
    61. 	loadimage(&img_enemy[1][0], "images/enemy2.png");
    62. 	loadimage(&img_enemy[1][1], "images/enemy2.png");
    63. }
    64.  
    65. //绘制桌面
    66. void draw_graph()
    67. {
    68. 	//绘制函数
    69. 	putimage(0, 0, &img_bk);
    70. }
    71. //绘制飞机
    72. void draw_gamer(Plane* gamer)
    73. {
    74. 	//通过初始化的飞机结构，确定其位置和加载哪一张图片
    75. 	drawImg(gamer->x, gamer->y, &img_gamer[gamer->frame]);
    76. 	gamer->frame = (++(gamer->frame)) % 2;
    77. }
    78. //绘制子弹
    79. void draw_bullet(Bullet* bullet)
    80. {
    81. 	for (int i = 0; i < BULLET_NUM; i++)
    82. 	{
    83. 		//发射绘制第一张
    84. 		if (bullet[i].isDie)
    85. 		{
    86. 			drawImg(bullet[i].x, bullet[i].y, img_bullet + 0);
    87. 		}
    88. 		//碰到敌人或者墙壁我们绘制第二张(后续我们会更改)
    89. 		if(bullet[i].y == 0)
    90. 		{
    91. 			drawImg(bullet[i].x, bullet[i].y, img_bullet + 1);
    92. 		}
    93.  
    94. 	}
    95. }
    96.  绘制敌机
    97. //void enemyDraw(Plane* enemy) {
    98. //	// 绘制敌机
    99. //	for (int num = 0; num < ENEMY_NUM; num++) {
    100. //		if (!enemy[num].isDie) {
    101. //			if (enemy[num].type == BIG) {
    102. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[1][0]);
    103. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[1][1]);
    104. //			}
    105. //			else if (enemy[num].type == SMALL) {
    106. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[0][0]);
    107. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[0][1]);
    108. //			}
    109. //		}
    110. //	}
    111. //}
    112.  
    113. // 创建敌机
    114. void createEnemy(Plane* enemy) {
    115. 	for (int i = 0; i < ENEMY_NUM; i++)
    116. 	{
    117. 		if (!enemy[i].isDie)
    118. 		{
    119. 			//创建随机坐标
    120. 			enemy[i].x = rand() % (getwidth() - 60);
    121. 			enemy[i].y = 0;
    122. 			enemyHP(i, enemy);
    123. 			enemy[i].isDie = true;//生成敌机
    124. 			break;
    125. 		}
    126. 	}
    127. }
    128. // 绘制敌机
    129. void enemyDraw(Plane* enemy) {
    130. 	
    131. 	//static int count = 0;
    132. 	
    133. 	for (int num = 0; num < ENEMY_NUM; num++)
    134. 	{
    135. 		if (enemy[num].isDie)
    136. 		{
    137. 			//printf("%d ", count++);
    138.  
    139. 			if (enemy[num].type == BIG)
    140. 			{
    141. 				drawImg(enemy[num].x, enemy[num].y, &img_enemy[1][0]);
    142. 				drawImg(enemy[num].x, enemy[num].y, &img_enemy[1][1]);
    143. 			}
    144. 			else
    145. 			{
    146. 				drawImg(enemy[num].x, enemy[num].y, &img_enemy[0][0]);
    147. 				drawImg(enemy[num].x, enemy[num].y, &img_enemy[0][1]);
    148. 			}
    149. 		}
    150.  
    151. 	}
    152.  
    153. }
    154. //void enemyDraw(Plane* enemy) {
    155. //	//绘制敌机
    156. //	for (int num = 0; num < ENEMY_NUM; num++)
    157. //	{
    158. //		if (enemy[num].isDie)
    159. //		{
    160. //			if (enemy[num].type == BIG)
    161. //			{
    162. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[1][0]);
    163. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[1][1]);
    164. //			}
    165. //			else
    166. //			{
    167. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[0][0]);
    168. //				drawImg(enemy[num].x, enemy[num].y, &img_enemy[0][1]);
    169. //			}
    170. //		}
    171. //	}
    172. //
    173. //}
    174. //绘制函数
    175. void draw(Plane* gamer,Bullet* bullet, Plane* enemy)
    176. {
    177.  
    178. 	draw_graph();
    179. 	draw_gamer(gamer);
    180. 	draw_bullet(bullet);
    181.  
    182. 	enemyDraw(enemy);
    183.  
    184. }
    185.  
    186. void init_gamer(Plane* gamer,int x,int y)
    187. {
    188. 	gamer->x = x;
    189. 	gamer->y = y;
    190. 	gamer->isDie = false;
    191. 	gamer->frame = 0;
    192. 	gamer->hp = 100;
    193. 	gamer->width = 102;
    194. 	gamer->height = 126;
    195. }
    196.  
    197. void init_bullet(Bullet* bullet)
    198. {
    199. 	for (int i = 0; i < BULLET_NUM; i++)
    200. 	{
    201. 		bullet[i].isDie = false;
    202. 		//bullet[i].x = x;
    203. 		//bullet[i].y = y;//我们这里通过按下空格键再去绘制它，所以在这里我们并不需要去更新坐标
    204. 	}
    205. }
    206.  
    207. void init_enemy(Plane* enemy)
    208. {
    209. 	for (int i = 0; i < ENEMY_NUM; i++)
    210. 	{
    211. 	
    212. 		enemy[i].isDie = false;
    213.  
    214. 	}
    215. }
    216. //初始化函数
    217. void init(Plane* gamer, Bullet* bullet, Plane* enemy)
    218. {
    219. 	//我们在初始化的时候就可以将，资源加载
    220. 	Resource();
    221. 	//初始化飞机
    222. 	init_gamer(gamer, ((getwidth() - img_gamer->getwidth()) / 2),
    223. 		(getheight() - img_gamer->getheight()));
    224. 	//(gamer->x) / 2, gamer->y + img_bullet->getheight()
    225. 	init_bullet(bullet);
    226. 	init_enemy(enemy);
    227. }
    228.  
    229.  
    230. void timerFunction(int frameRate) {
    231. 	clock_t startTime, currentTime;
    232. 	long elapsed;
    233.  
    234. 	// 计算每一帧的毫秒数
    235. 	int ms_per_frame = 1000 / frameRate;
    236.  
    237. 	// 获取初始时间
    238. 	startTime = clock();
    239.  
    240. 	while (1) {
    241. 		// 获取当前时间
    242. 		currentTime = clock();
    243.  
    244. 		// 计算已经过去的时间（以毫秒为单位）
    245. 		elapsed = (currentTime - startTime) * 1000;
    246.  
    247. 		// 如果已经过去的时间超过了下一帧的时间间隔，则输出一帧
    248. 		if (elapsed >= ms_per_frame) {
    249. 			
    250.  
    251. 			// 更新初始时间
    252. 			startTime = currentTime;
    253. 			// 暂停一段时间，使得每秒输出指定的帧率
    254. 			Sleep(1); // 暂停 1 毫秒
    255. 			break;
    256. 		}
    257. 	}
    258. }
    259.  
    260. void createBullet(Plane* gamer, Bullet* bullet)
    261. {
    262. 	//循环遍历找到可用的子弹，进行发射
    263. 	for (int i = 0; i < BULLET_NUM; i++)
    264. 	{
    265. 		if (!bullet[i].isDie)
    266. 		{
    267. 			bullet[i].isDie = true;
    268. 			bullet[i].x = gamer->x + img_gamer->getwidth() / 2;
    269. 			bullet[i].y = gamer->y;
    270. 			break;
    271. 		}
    272. 	}
    273. }
    274. //移动飞机，发射子弹
    275. void palygamer(Plane* gamer, Bullet* bullet)
    276. {
    277.  
    278. 	if (GetAsyncKeyState(VK_UP) && gamer->y > 0)
    279. 	{
    280. 		gamer->y -= MOVE;
    281. 	}
    282. 	if (GetAsyncKeyState(VK_DOWN) && gamer->y + img_gamer->getheight() < getheight())
    283. 	{
    284. 		gamer->y += MOVE;
    285. 	}
    286. 	if (GetAsyncKeyState(VK_LEFT) && gamer->x + img_gamer->getwidth() / 2 > 0)
    287. 	{
    288. 		gamer->x -= MOVE;
    289. 	}
    290. 	if (GetAsyncKeyState(VK_RIGHT) && gamer->x + img_gamer->getwidth() / 2 < getwidth())
    291. 	{
    292. 		gamer->x += MOVE;
    293. 	}
    294. 	if (GetAsyncKeyState(VK_SPACE) && timer.hasElapsed(100, 1))
    295. 	{
    296. 		createBullet(gamer, bullet);
    297. 	}
    298. }
    299. //子弹移动
    300. void movebullet(Bullet* bullet)
    301. {
    302. 	for (int i = 0; i < BULLET_NUM; i++)
    303. 	{
    304. 		if (bullet[i].isDie)
    305. 		{
    306. 			bullet[i].y -= MOVE;
    307. 			//如果子弹跑出窗口，则置为false
    308. 			if (bullet[i].y < 0)
    309. 			{
    310. 				bullet[i].isDie = false;
    311. 			}
    312. 		}
    313. 	}
    314. }
    315.  
    316. //void moveEnemy(Plane* enemy)
    317. //{
    318. //	for (int i = 0; i < ENEMY_NUM; i++)
    319. //	{
    320. //		if (enemy[i].isDie)
    321. //		{
    322. //			enemy[i].y += 3;
    323. //			if (enemy[i].y > getheight() || enemy[i].hp <= 0)
    324. //			{
    325. //				enemy[i].isDie = false;
    326. //			}
    327. //		}
    328. //	}
    329. //}
    330. // 移动敌机
    331. void moveEnemy(Plane* enemy) {
    332. 	for (int i = 0; i < ENEMY_NUM; i++)
    333. 	{
    334. 		if (enemy[i].isDie)
    335. 		{
    336. 			enemy[i].y += 3;
    337. 			if (enemy[i].y > getheight())
    338. 			{
    339. 				enemy[i].isDie = false;
    340. 			}
    341. 		}
    342. 	}
    343. }
    344. //碰撞检测
    345. void checkCollision(Plane* gamer,Plane* enemy, Bullet* bullet)
    346. {
    347.  
    348. 	for (int i = 0; i < ENEMY_NUM; i++)
    349. 	{
    350. 		if (!enemy[i].isDie)
    351. 			continue;
    352. 		for (int j = 0; j < BULLET_NUM; j++)
    353. 		{
    354. 			if (!bullet[j].isDie)
    355. 				continue;
    356. 			if (bullet[j].x > enemy[i].x &&
    357. 				bullet[j].x < enemy[i].x + enemy[i].width &&
    358. 				bullet[j].y > enemy[i].y &&
    359. 				bullet[j].y < enemy[i].y + enemy[i].height)
    360. 			{
    361. 				bullet[j].isDie = false;
    362. 				enemy[i].hp--;
    363.  
    364. 			}
    365. 		}
    366. 		if (enemy[i].hp <= 0) enemy[i].isDie = false;
    367. 	}
    368. 	for (int i = 0; i < ENEMY_NUM; i++)
    369. 	{
    370. 		if (gamer->x + gamer->width >= enemy[i].x &&
    371. 			gamer->x <= enemy[i].x + enemy[i].width &&
    372. 			gamer->y <= enemy[i].y + enemy[i].height &&
    373. 			gamer->y + gamer->height >= enemy[i].y)
    374. 		{
    375. 			//可以给一个窗口，问是否需要重来，或者可以加一些关机操作，都是没有问题的，根据你们想要的逻辑去改代码即可
    376. 			exit(1);
    377. 		}
    378. 	}
    379.  
    380.  
    381. }
    382.  
    383. //void checkCollision(Plane* enemy, Bullet* bullet) {
    384. //	if (!enemy || !bullet) {
    385. //		// 参数验证失败，输出错误信息并返回
    386. //		printf("Error: Invalid parameters in checkCollision function.\n");
    387. //		return;
    388. //	}
    389. //
    390. //	for (int j = 0; j < ENEMY_NUM; j++) {
    391. //		if (!enemy[j].isDie) {
    392. //			continue;
    393. //		}
    394. //		for (int i = 0; i < BULLET_NUM; i++) {
    395. //			if (!bullet[i].isDie) {
    396. //				continue;
    397. //			}
    398. //
    399. //			if (bullet[i].x > enemy[j].x && bullet[i].x < (enemy[j].x + enemy[j].width)
    400. //				&& bullet[i].y > enemy[j].y && (bullet[i].y < enemy[j].y + enemy[j].height)) {
    401. //				bullet[i].isDie = false;
    402. //				enemy[j].hp--;
    403. //			}
    404. //		}
    405. //	}
    406. //}
    407.  
    408. //void updateEnemyStatus(Plane* enemy) {
    409. //	if (!enemy) {
    410. //		// 参数验证失败，输出错误信息并返回
    411. //		printf("Error: Invalid parameters in updateEnemyStatus function.\n");
    412. //		return;
    413. //	}
    414. //
    415. //	for (int j = 0; j < ENEMY_NUM; j++) {
    416. //		if (enemy[j].hp == 0) {
    417. //			enemy[j].isDie = false;
    418. //		}
    419. //	}
    420. //}
    421.  
    422. //更新数据
    423. void Updata(Plane* gamer,Bullet* bullet, Plane* enemy)
    424. {
    425. 	//玩家移动
    426. 	palygamer(gamer, bullet);
    427. 	//子弹移动
    428. 	movebullet(bullet);
    429. 	//创建敌机
    430. 	if (timer.hasElapsed(1000, 1))
    431. 	{
    432. 		//printf("6");
    433. 		createEnemy(enemy);
    434. 	}
    435. 	//移动敌机
    436. 	moveEnemy(enemy);
    437. 	//子弹打到飞机
    438. 	checkCollision(gamer,enemy, bullet);
    439. }

    13，tools.cpp

    1. #include "aircraft.h"
    2.  
    3. //把像素的颜色拆解出来 ARGB
    4. typedef struct _ARGB {
    5. 	byte a;
    6. 	byte r;
    7. 	byte g;
    8. 	byte b;
    9. }ARGB;
    10. //把颜色拆分
    11. ARGB color2Argb(DWORD c) {
    12. 	ARGB res;
    13. 	res.r = (byte)c;
    14. 	res.g = (byte)(c >> 8);
    15. 	res.b = (byte)(c >> 16);
    16. 	res.a = (byte)(c >> 24);
    17. 	return res;
    18. }
    19. DWORD argb2Color(ARGB c) {
    20. 	DWORD t = RGB(c.r, c.g, c.b);
    21. 	return ((DWORD)c.a) << 24 | t;
    22. }
    23. //把色彩图转成黑白图
    24. void toGray(IMAGE* src) {
    25. 	DWORD* psrc = GetImageBuffer(src);
    26. 	for (int i = 0; i < src->getwidth() * src->getheight(); i++) {
    27. 		//获取每一个像素点的颜色值
    28. 		ARGB t = color2Argb(psrc[i]);
    29. 		//灰度图，求三个或者四个颜色值的均值
    30. 		byte arv = (t.r + t.g + t.b) / 3;
    31. 		ARGB res = { t.a,arv,arv,arv };
    32. 		psrc[i] = argb2Color(res);
    33. 	}
    34. }
    35. /*
    36. * @png透明贴图
    37. */
    38. void drawImg(int x, int y, IMAGE* src) {
    39. 	// 变量初始化
    40. 	DWORD* pwin = GetImageBuffer();//窗口缓冲区指针
    41. 	DWORD* psrc = GetImageBuffer(src);//图片缓冲区指针
    42. 	int win_w = getwidth();//窗口宽高
    43. 	int win_h = getheight();
    44. 	int src_w = src->getwidth();//图片宽高
    45. 	int src_h = src->getheight();
    46. 	//计算贴图的实际长宽
    47. 	int real_w = (x + src_w > win_w) ? win_w - x : src_w;//处理超出右边界
    48. 	int real_h = (y + src_h > win_h) ? win_h - y : src_h;//处理超出右边界
    49. 	if (x < 0) {//处理超出左边界
    50. 		psrc += -x;
    51. 		real_w -= -x;
    52. 		x = 0;
    53. 	}
    54. 	if (y < 0) {//处理超出右边界
    55. 		psrc += (src_w * -y);
    56. 		real_h -= -y;
    57. 		y = 0;
    58. 	}
    59.  
    60. 	//修正贴图起始位置
    61. 	pwin += (win_w * y + x);
    62. 	//实现透明贴图
    63. 	for (int iy = 0; iy < real_h; iy++) {
    64. 		for (int ix = 0; ix < real_w; ix++) {
    65. 			byte a = (byte)(psrc[ix] >> 24);//计算透明通道的值[0,256] 0为完全透明 255完全不透明
    66. 			if (a > 100) {
    67. 				pwin[ix] = psrc[ix];
    68. 			}
    69. 		}
    70. 		//换到下一行
    71. 		pwin += win_w;
    72. 		psrc += src_w;
    73. 	}
    74. }

    14，main.cpp

    1.  
    2. #include "aircraft.h"
    3.  
    4.  
    5. int main()
    6. {
    7.  
    8. 	Plane gamer;
    9. 	Bullet bullet[BULLET_NUM];
    10. 	Plane enemy[ENEMY_NUM];
    11. 	//创建窗口函数
    12. 	initgraph(graph_width, graph_height, 1);
    13. 	//获取当前时间
    14.  
    15. 	init(&gamer, bullet, enemy);
    16.  
    17. 	BeginBatchDraw();//双缓冲
    18. 	while (1)
    19. 	{
    20. 		draw(&gamer, bullet, enemy);
    21. 		
    22. 		FlushBatchDraw();//立即刷新缓冲区
    23. 		Updata(&gamer, bullet, enemy);
    24. 		timerFunction(60);
    25. 		//checkCollision(enemy, bullet);
    26. 		
    27.  
    28.  
    29. 	}
    30.  
    31. 	EndBatchDraw();//结束缓冲
    32.  
    33. 	return 0;
    34. }

    15，每期一问

    1. 上期答案:
    2. #define MY_OFFSETOF(s, m) ((size_t)(&(((s*)0)->m)))

    本期问题:

    环形链表的约瑟夫问题_牛客题霸_牛客网

    下期再见!

  • 相关阅读:
    软件设计师_面向对象_学习笔记
    股价暴跌了74.5%后,乐信第三季度财报可能会低于市场预期
    基于Three.js实现三维空间中的箭头移动动画
    IE退役倒计时， Edge接棒
    java计算机毕业设计机械生产企业办公设备管理系统MyBatis+系统+LW文档+源码+调试部署
    工作中一些计算日期的要求
    数据结构中常见的排序及其代码C语言版本
    【MySQL】Java的JDBC编程
    webpack5零基础入门-10babel的使用
    弱监督下的学习对象检测
  • 原文地址：https://blog.csdn.net/HH_KZ1314/article/details/137557239