• 用VSC++做一个飞机大战的游戏

    每天更新代软件功能，每天有做不完的事情，所以，今天，我做了一个飞机大战的游戏来放松一下。

     

    一、文件框架

    首先，我们先打开VS，我用的是VS2019，推荐这个版本，功能足够我们打代码了，而且BUG很少。

     

    615a4a3b82744490a0aa434527c51754.png

     f5df2f54c8f341ee9362c14295a018df.png

     

    然后，我们创建一个控制台项目，就可以做一个飞机大战的游戏了。

    我们打开了之后，我们就可以开始制作飞机大战的游戏了。

    首先，我们先创建几个文件，如下图所示：

    7943830c76384aefa73df6700df52f27.png

     

    然后，我们就可以开始敲代码了！👨‍💻

    二、函数

    想要实现像市面上的那种飞机大战的效果，这个是C++几乎无法实现的。（如果你能实现的话，博主希望你能发在评论区，被博主采纳的有红包哦~）

    C++是一种多范式编程语言，它包含了过程化、面向对象、泛型等不同的编程范式。它是一种高效的编程语言，可以编写性能很高的程序，同时也具有良好的可移植性。C++的主要概念和用途如下：

    1. 类和对象：C++中的核心概念是类和对象，可以用类来描述具有相同属性和行为的一组对象。它是面向对象编程的基础。

    2. 继承和多态：C++支持继承，可以从已有类派生出新类，并且可以重写父类的方法实现多态性。

    3. 泛型编程：C++支持模板，可以实现泛型编程和函数重载。

    4. 异常处理机制：C++提供了一种处理程序运行时错误的机制，可以使用try、catch和throw关键字来实现异常处理。

    5. 标准库：C++有一个丰富的标准库，包含了大量的函数和类，可以帮助程序员更容易地实现一些常见的任务，如输入输出、字符串处理、容器和算法等。

    C++的应用范围很广，包括系统编程、游戏开发、图形界面设计、数据库应用、网络编程、嵌入式开发等。由于C++是一种高效的语言，适合编写对性能要求很高的应用程序。同时，C++的可移植性也很好，可以在不同的平台上编译和运行。

    但是，C++更偏向于计算方面，如果要进行美观的图形化界面的设置，那建议你使用Python或者是JavaScript来进行实现，因为它们能更方便。

    话不多说，我们来解决函数困难。

    游戏界面

    game.h:

    1. #pragma once
    2. #include
    3. #include//定义控制台应用程序的入口点
    4.  
    5. using namespace std;
    6.  
    7. //定义敌人结构 其中最后面Frame代表结构体类型 若不加typedef代表定义的结构体变量
    8. typedef struct Frame
    9. {
    10. 	COORD position[2];
    11. 	//  COORD 是Windows API中定义的一种结构，表示一个字符在控制台屏幕上的坐标。
    12. 	// 其定义为：
    13. 	// typedef struct _COORD {
    14. 	//         SHORT X; 
    15. 	//         SHORT Y;
    16. 	//       } COORD;
    17. 	int flag;
    18. }Frame;
    19.  
    20. class Game
    21. {
    22. public:
    23. 	COORD position[10];
    24. 	COORD bullet[10];//子弹坐标
    25. 	Frame enemy[8];//敌人数量
    26.  
    27. 	int score;
    28. 	int rank;//级别,难度
    29. 	int rankf;//等级标志
    30. 	string title;
    31.  
    32. 	int flag_rank;//等级标志
    33. 	//构造函数
    34. 	Game();
    35. 	//初始化所有  //设定位置
    36. 	void initPlane();
    37. 	void initBullet();
    38. 	void initEnemy();
    39. 	//填充所有  --画出形状和消失的形状
    40. 	void drawPlane();
    41. 	void drawPlaneToNull();
    42. 	void drawBullet();
    43. 	void drawBulletToNull();
    44. 	void drawEnemy();
    45. 	void drawEnemyToNull();
    46. 	//执行某一个操作
    47. 	void Playing();//游戏主循环
    48. 	void planeMove(char x);//飞机移动
    49. 	void judgePlane();//判断飞机是否与敌机重叠
    50. 	void GameOver();//游戏失败
    51. 	void Pause();// 该成员函数用来使得游戏暂停
    52. 	void Shoot();//发射子弹
    53. 	void bulletMove();//子弹移动
    54. 	void drawThisBulletToNull(COORD c);//画出失效子弹
    55. 	void judgeEnemy();//判断子弹是否击中敌机
    56. 	void drawThisEnemyToNull(Frame f);	//击败的敌机清空
    57. 	void enemyMove();//敌机移动
    58. 	void printScore();//输出分数
    59. };
    60. //主菜单
    61. int drawMenu();
    62. //隐藏光标
    63. void HideCursor();
    64.  
    65.  
    66. void SetPos(int i, int j);//设置光标
    67. COORD random(COORD a, COORD b);//产生随机敌机位置
    68. void drawFrame(COORD a, COORD  b, char row, char col);//画出敌机
    69. //把第y行，[x1, x2) 之间的坐标填充为 ch
    70. void drawRow(int y, int x1, int x2, char ch);
    71. //把第x列，[y1, y2] 之间的坐标填充为 ch
    72. void drawCol(int x, int y1, int y2, char ch);
    73. // 绘制游戏界面
    74. void drawPlaying();
    75. void drawFrame(Frame frame, char row, char col);//画坠毁后的战机
    76. // 该函数用来判断战机的某一部分是否与敌机有接触
    77. bool  judgeCoordInFrame(Frame frame, COORD spot);
    78.  
    79. void drawRow(COORD a, COORD b, char ch);

    注释都在上边了，看不懂的可以私聊博主。

    然后，我们来做游戏的另一个函数，也就是敌机和战机✈的外观和移动函数，这个函数是游戏的核心，没有了这个函数，那这个游戏就像一个图片，只能呈现出游戏的界面，而不能做出移动的效果，会让人第一个感觉就是一个字——丑。

    战机和敌机的外观及其移动方式

    首先，我们先打开一个黑框（可以用CMD代替）：

    7e5d6d1847c54a2fbecf99a67a2c088e.png

    我们需要让敌机从上往下移动，而战机是需要玩家自己上下左右进行控制的。然后，我们先定义战机的外观：

    1.  
    2. 	// 这个函数体类的代码其实就是为了初始化战机的十个部分的位置，战机的组成如下所示：   
    3. 	//                   |       5 
    4. 	//				     |       9    
    5. 	//				   *****   12034
    6. 	//				    ***     678
    7. 	//   第一排5个0的坐标依次对应了position[1]position[2]position[0]position[3]position[4]
    8. 	//   第二排三个0的坐标依次对应了position[6]position[7]position[8]
    9. 	//   两排0上面的两|的坐标从上往下依次对应了position[5]position[9]
    10. }
    11. void Game::drawPlane()
    12. {
    13. 	for (int i = 0; i < 9; i++)
    14. 	{
    15. 		SetPos(position[i].X, position[i].Y);
    16. 		if (i != 5)
    17. 		{
    18. 			cout << "*";
    19. 		}
    20. 		else if (i == 5)
    21. 		{
    22. 			cout << "|";
    23. 		}
    24. 	}
    25. }

    战机的样子在上面的代码块注释里面应该能看到，我们用WinAPI和for循环语句进行战机的输入与输出。

    然后，我们来绘制敌机的样子：

    1. // 接下来要根据敌机的左上角坐标和右下角坐标画出敌机，
    2. // 显然，敌机的外形如下所示：
    3. //   --
    4. //  |  |
    5. //   --
    6. void Game::drawEnemy()
    7. {
    8. 	for (int i = 0; i < 8; i++)
    9. 	{
    10. 		drawFrame(enemy[i].position[0], enemy[i].position[1], '-', '|');
    11. 	}
    12. }

    敌机的代码和样子都在上面了，我们用“-”和“|”来绘制敌机。

    其他的移动代码和子弹等角色的代码有“亿”点复杂，如果我在这里讲的话，人家CSDN要打电话给我了。（因为如果写的话，这篇博文估计要5万多字）

    现在供上角色的代码（game.cpp）：

    1. #include"game.h"
    2. #include
    3. #include
    4. Game::Game()
    5. {
    6. 	// 调用类成员函数来进行初始化
    7. 	initPlane();
    8.  
    9. 	initBullet();
    10.  
    11. 	initEnemy();
    12.  
    13. 	// 初始化四个int型数据成员，采用赋值的方式进行初始化
    14. 	// string类型的数据成员title没有进行初始化，因为：
    15. 	// string本身就是一个标准库类类型，它的类定义中设置了默认构造函数，
    16. 	// 这些默认构造函数会将对象初始化为合理的默认状态，
    17. 	//  string的默认构造函数会产生空字符串，相当于"" 。
    18. 	this->score = 0;
    19. 	rank = 25;
    20. 	rankf = 25;
    21. 	flag_rank = 0;
    22. }
    23. void Game::initPlane()
    24. {
    25. 	COORD centren;
    26. 	centren.X = 39;
    27. 	centren.Y = 22;
    28.  
    29. 	position[0].X = position[5].X = position[7].X = position[9].X = centren.X;
    30. 	position[1].X = centren.X - 2;
    31. 	position[2].X = position[6].X = centren.X - 1;
    32. 	position[3].X = position[8].X = centren.X + 1;
    33. 	position[4].X = centren.X + 2;
    34. 	for (int i = 0; i <= 4; i++)
    35. 	{
    36. 		position[i].Y = centren.Y;
    37. 	}
    38. 	for (int i = 6; i <= 8; i++)
    39. 	{
    40. 		position[i].Y = centren.Y + 1;
    41. 	}
    42. 	position[5].Y = centren.Y - 1;
    43. 	position[9].Y = centren.Y - 2;
    44. 		
    45. 	// 这个函数体类的代码其实就是为了初始化战机的十个部分的位置，战机的组成如下所示：   
    46. 	//                   |       5 
    47. 	//				     |       9    
    48. 	//				   *****   12034
    49. 	//				    ***     678
    50. 	//   第一排5个0的坐标依次对应了position[1]position[2]position[0]position[3]position[4]
    51. 	//   第二排三个0的坐标依次对应了position[6]position[7]position[8]
    52. 	//   两排0上面的两|的坐标从上往下依次对应了position[5]position[9]
    53. }
    54. void Game::drawPlane()
    55. {
    56. 	for (int i = 0; i < 9; i++)
    57. 	{
    58. 		SetPos(position[i].X,position[i].Y);
    59. 		if (i != 5)
    60. 		{
    61. 			cout << "*";
    62. 		}
    63. 		else if (i == 5)
    64. 		{
    65. 			cout << "|";
    66. 		}
    67. 	}
    68. }
    69. // 这个成员函数通过将战机的每个坐标处输出" "来代替"0"和"|"，
    70. // 来达到将战机消除的目的。
    71. void Game::drawPlaneToNull()
    72. {
    73. 	for (int i = 0; i < 9; i++)
    74. 	{
    75. 		SetPos(position[i].X, position[i].Y);
    76. 		cout << " ";
    77. 	}
    78. }
    79. // 该成员函数用来初始化子弹，
    80. // 即将每个子弹的Y坐标初始化为30（bullet[i].Y = 30）来表示子弹处于失效状态
    81. void Game::initBullet()
    82. {
    83. 	for (int i = 0; i < 10; i++)
    84. 	{
    85. 		bullet[i].Y = 30;
    86. 	}	
    87. }
    88. // 该成员函数用来画出子弹
    89. // 首先检查每颗子弹的有效性，如果子弹有效，则定位到该子弹的坐标处，输出 "^"，表示该子弹，
    90. // 如果子弹是无效的，则不绘制
    91. void Game::drawBullet()
    92. {
    93. 	for (int i = 0; i < 10; i++)
    94. 	{
    95. 		if (bullet[i].Y != 30)
    96. 		{
    97. 			SetPos(bullet[i].X,bullet[i].Y);
    98. 			cout << "^";
    99. 		}
    100. 	}
    101. }
    102. //子弹失效
    103. void Game::drawBulletToNull()
    104. {
    105. 	for (int i = 0; i < 10; i++)
    106. 		if (bullet[i].Y != 30)
    107. 		{
    108. 			SetPos(bullet[i].X, bullet[i].Y + 1);
    109. 			cout << " ";
    110. 		}
    111. }
    112. // 这个函数用来初始敌机的位置，
    113. // 屏幕当中只能同时存在八架敌机，
    114. // 且每架敌机用如下结构体Frame来表示，如下所示：
    115. //     typedef struct Frame
    116. //        {
    117. //	      COORD position[2];
    118. //      	int flag;
    119. //        }Frame;
    120. COORD random(COORD a, COORD b)
    121. {
    122. 	int x = rand() % (a.X - b.X) + a.X;
    123. 	int y = rand() % (a.Y - b.Y) + a.Y;
    124. 	COORD c = { x,y };
    125. 	return c;
    126. }
    127. void Game::initEnemy()
    128. {
    129. 	COORD a = { 1, 1 };
    130. 	COORD b = { 45, 15 };
    131. 	for (int i = 0; i < 8; i++)
    132. 	{
    133. 		enemy[i].position[0] = random(a, b);
    134. 		//  random(a, b)是调用了一个重载的函数，它表示在坐标a、b之间的矩形框
    135. 		//  内随机生成一个坐标值，并将该坐标值作为敌机的左上角的坐标。
    136. 		// enemy[i].position[0]中是一个Frame结构体类型的变量，存放了敌机i的左上角的坐标。
    137. 		enemy[i].position[1].X = enemy[i].position[0].X + 3;
    138. 		enemy[i].position[1].Y = enemy[i].position[0].Y + 2;
    139. 		// enemy[i].position[1]也中是一个Frame结构体类型的变量，存放了敌机i的右下角的坐标。
    140. 	}
    141. }
    142. // 接下来要根据敌机的左上角坐标和右下角坐标画出敌机，
    143. // 显然，敌机的外形如下所示：
    144. //   --
    145. //  |  |
    146. //   --
    147. void Game::drawEnemy()
    148. {
    149. 	for (int i = 0; i < 8; i++)
    150. 	{
    151. 		drawFrame(enemy[i].position[0], enemy[i].position[1], '-', '|');
    152. 	}	
    153. }
    154. // 将敌机消除，通过输出空白的方式
    155. void Game::drawEnemyToNull()
    156. {
    157. 	for (int i = 0; i < 8; i++)
    158. 	{
    159. 		drawFrame(enemy[i].position[0], enemy[i].position[1], ' ', ' ');
    160. 	}
    161. }
    162.  
    163. //隐藏光标
    164. void HideCursor()
    165. {
    166. 	CONSOLE_CURSOR_INFO cursor_info = { 1,0 };//第二个值0表示隐藏光标
    167. 	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
    168. }
    169. void SetPos(int i, int j)//设置坐标点位（光标）
    170. {
    171. 	HANDLE hout;
    172. 	COORD coord;
    173. 	coord.X = i;
    174. 	coord.Y = j;
    175. 	hout = GetStdHandle(STD_OUTPUT_HANDLE);
    176. 	SetConsoleCursorPosition(hout, coord);
    177. }
    178.  
    179. //左上角坐标、右下角坐标、用row填充行、用col填充列
    180. void drawFrame(COORD a, COORD  b, char row, char col)
    181. {
    182. 	drawRow(a.Y, a.X + 1, b.X - 1, row);
    183. 	drawRow(b.Y, a.X + 1, b.X - 1, row);
    184. 	drawCol(a.X, a.Y + 1, b.Y - 1, col);
    185. 	drawCol(b.X, a.Y + 1, b.Y - 1, col);
    186. }
    187.  
    188. //把第y行，[x1, x2) 之间的坐标填充为 ch
    189. void drawRow(int y, int x1, int x2, char ch)
    190. {
    191. 	SetPos(x1, y);
    192. 	for (int i = 0; i <= (x2 - x1); i++)
    193. 	{
    194. 		cout << ch;
    195. 	}
    196. }
    197. //把第x列，[y1, y2] 之间的坐标填充为 ch
    198. void drawCol(int x, int y1, int y2, char ch)
    199. {
    200. 	int y = y1;
    201. 	while (y != y2 + 1)
    202. 	{
    203. 		SetPos(x, y);
    204. 		cout << ch;
    205. 		y++;
    206. 	}
    207. }
    208.  
    209. //主菜单绘制
    210. int drawMenu()
    211. {
    212. 	SetPos(30,1);
    213. 	cout << "飞 机 大 战";
    214. 	drawRow(3, 0, 79, '-');
    215. 	drawRow(5, 0, 79, '-');
    216. 	SetPos(28, 4);
    217. 	cout << "w 和 s选择，k确定";
    218. 	int j = 11;
    219. 	SetPos(12, j);
    220. 	cout << ">>";
    221. 	SetPos(15, 11);
    222. 	cout << "1. 简单的敌人";
    223. 	SetPos(15, 13);
    224. 	cout << "2. 冷酷的敌人";
    225. 	drawRow(20, 0, 79, '-');
    226. 	SetPos(47, 11);
    227. 	cout << "简单的敌人：";
    228. 	SetPos(47, 13);
    229. 	cout << "简单敌人有着较慢的移动速度。";
    230. 	SetPos(30, 21);
    231. 	cout << "copy right@风兮木萧";
    232. 	drawRow(22, 0, 79, '-');
    233.  
    234. 	while (true)
    235. 	{
    236. 		if (_kbhit())
    237. 		{
    238. 			char x = _getch();
    239. 			switch (x)
    240. 			{
    241. 			case'w':
    242. 			{
    243. 				if (j == 13)
    244. 				{
    245. 					SetPos(12, j);
    246. 					cout << "  ";
    247. 					j = 11;
    248. 					SetPos(12, j);
    249. 					cout << ">>";
    250. 					SetPos(51, 13);
    251. 					cout << "　　　　　　　　　　　　";
    252. 					SetPos(47, 11);
    253. 					cout << "简单的敌人：";
    254. 					SetPos(51, 13);
    255. 					cout << "简单敌人有着较慢的移动速度，比较容易对付";
    256. 				}
    257. 				break;
    258. 			}
    259. 			case's':
    260. 			{
    261. 				if (j == 11)
    262.  
    263. 				{
    264. 					SetPos(12, j);
    265. 					cout << "　";
    266. 					j = 13;
    267. 					SetPos(12, j);
    268. 					cout << ">>";
    269. 					SetPos(51, 13);
    270. 					cout << "　　　　　　　　                 　　　　　　";
    271. 					SetPos(47, 11);
    272. 					cout << "冷酷的敌人：";
    273. 					SetPos(51, 13);
    274. 					cout << "冷酷的敌人移动速度较快，难对付哟。";
    275. 				}
    276.  
    277. 				break;
    278. 			}
    279. 			case 'k':
    280. 			{
    281. 				
    282. 				if (j == 11)//源代码为8？
    283. 					return 1;
    284. 				else
    285. 					return 2;
    286. 			}
    287. 			}
    288. 		}
    289. 	}
    290.  
    291. 	return 0;
    292. }
    293. void drawFrame(int x1, int y1, int x2, int y2, char row, char col)
    294. {
    295. 	COORD a = { x1, y1 };
    296. 	COORD b = { x2, y2 };
    297. 	drawFrame(a, b, row, col);
    298. }
    299. // 绘制游戏界面
    300. void drawPlaying()
    301. {
    302. 	drawFrame(0, 0, 48, 24, '=', '|');//	draw map frame主界面
    303. 	drawFrame(49, 0, 79, 4, '-', '|');//	draw output frame 状态界面
    304. 	drawFrame(49, 4, 79, 9, '-', '|');//	draw score frame 分数界面
    305. 	drawFrame(49, 9, 79, 20, '-', '|');//	draw operate frame 操作界面
    306. 	drawFrame(49, 20, 79, 24, '-', '|');//	draw other message frame 提示界面
    307. 	SetPos(52, 6);
    308. 	cout << "得分：";
    309. 	SetPos(52, 7);
    310. 	cout << "称号：";
    311. 	SetPos(52, 11);
    312. 	cout << "操作方式：";
    313. 	SetPos(52, 13);
    314. 	cout << "  a,s,d,w：控制战机移动。";
    315. 	SetPos(52, 15);
    316. 	cout << "  p：暂停游戏。";
    317. 	SetPos(52, 17);
    318. 	cout << "  e：退出游戏。";
    319. 	SetPos(52, 22);
    320. 	cout << " 游戏虽好玩，不要贪多哦 ";
    321. }
    322. // 该成员函数用过响应战机的一个动作
    323. // a,s,w,d,来控制战机的移动
    324. void Game::planeMove(char x)
    325. {
    326. 	if (x == 'a')
    327. 	{
    328. 		if (position[1].X != 1)
    329. 		{
    330. 			for (int i = 0; i <= 9; i++)
    331. 			{
    332. 				position[i].X -= 2;
    333. 			}
    334. 		}
    335. 	}
    336. 	// 如果玩家按下 'a' 键，说明玩家想让战机往左移动一个距离（2个单位），
    337. 	// 首先检测，战机的最左侧的位置坐标（即position[1].X）有没有达到左边界，
    338. 	// 如果到达了边界，那就不做出移动；如果没有达到边界，则将战机10个部分的X值减小2。
    339. 	if (x == 's')
    340. 	{
    341. 		if (position[7].Y != 23)
    342. 		{
    343. 			for (int i = 0; i <= 9; i++)
    344. 			{
    345. 				position[i].Y += 1;
    346. 			}
    347. 		}
    348. 	}		
    349. 	// 如果玩家按下 's' 键，说明玩家想让战机往下移动一个距离（1个单位），
    350. 	// 首先检测，战机的最底部的位置坐标（即position[6].Y或者position[7].Y或者position[8].Y）有没有达到下边界，
    351. 	//  如果到达了边界，那就不做出移动；如果没有达到边界，则将战机10个部分的Y值增加1。
    352. 	if (x == 'd' && (position[4].X != 47))
    353. 	{
    354. 		for (int i = 0; i <= 9; i++)
    355. 		{
    356. 			position[i].X += 2;
    357. 		}	
    358. 	}		
    359. 	// 如果玩家按下 'd' 键，说明玩家想让战机往右移动一个距离（2个单位），
    360. 	// 首先检测，战机的最右侧的位置坐标（即position[4].X）有没有达到右边界，
    361. 	//  如果到达了边界，那就不做出移动；如果没有达到边界，则将战机10个部分的X值增加2。
    362. 	if (x == 'w'&&(position[5].Y != 3))
    363. 	{
    364. 		for (int i = 0; i <= 9; i++)
    365. 		{
    366. 			position[i].Y -= 1;
    367. 		}
    368. 	}
    369. 	// 如果玩家按下'w'键，说明玩家想让战机往上移动一个距离（1个单位），
    370. 	// 首先检测，战机的最顶部的位置坐标（即position[5].Y）有没有达到上边界，
    371. 	//  如果到达了边界，那就不做出移动；如果没有达到边界，则将战机10个部分的Y值减少1。
    372. }
    373. // 该函数用来判断战机的某一部分是否与敌机有接触
    374. // 如果与敌机有接触在判断为坠毁
    375. bool  judgeCoordInFrame(Frame frame, COORD spot)
    376. {
    377. 	if ((spot.X >= frame.position[0].X) && (spot.X <= frame.position[1].X) && (spot.Y >= frame.position[0].Y) && (spot.Y <= frame.position[1].Y))
    378. 	{
    379. 		return true;
    380. 	}
    381. 	return false;
    382. }
    383. void drawFrame(Frame frame, char row, char col)
    384. {
    385. 	COORD a = frame.position[0];
    386. 	COORD b = frame.position[1];
    387. 	drawFrame(a, b, row, col);
    388. }
    389. //游戏结束
    390. void Game::GameOver()
    391. {
    392. 	system("cls");
    393. 	COORD p1 = { 28,9 };
    394. 	COORD p2 = { 53,15 };
    395. 	drawFrame(p1, p2, '=', '|');
    396. 	SetPos(36, 12);
    397. 	string str = "Game Over!";
    398. 	for (int i = 0; i < str.size(); i++)
    399. 	{
    400. 		Sleep(80);
    401. 		cout << str[i];
    402. 	}
    403. 	Sleep(1000);
    404. 	system("cls");
    405. 	drawFrame(p1, p2, '=', '|');
    406. 	SetPos(31, 11);
    407. 	cout << "击落敌机：" << score / 5 << " 架";
    408. 	SetPos(31, 12);
    409. 	cout << "得　　分：" << score;
    410. 	SetPos(31, 13);
    411. 	cout << "获得称号：" << title;
    412. 	SetPos(30, 18);
    413. 	Sleep(1000);
    414. 	cout << "继续？ 是（y）| 否（n）";
    415. as://goto 语句标签 直接跳转至此
    416. 	char x = _getch();
    417. 	if (x == 'n')
    418. 	{
    419. 		exit(0);
    420. 	}
    421. 	else if (x == 'y')
    422. 	{
    423. 		system("cls");
    424. 		Game game;
    425. 		int a = drawMenu();       // 绘制游戏开始界面主菜单
    426. 		if (a == 2)
    427. 			game.rank = 20;
    428. 		system("cls");
    429. 		drawPlaying();           // 绘制游戏界面框架
    430. 		game.Playing();
    431. 	}
    432. 	else 
    433. 		goto as;
    434. }
    435. // 该成员函数用来判断战机是否坠毁，
    436. // 依次判断每架敌机与战机的每个部分是否有接触，
    437. // 如果有接触，则表示战机坠毁
    438. void Game::judgePlane()
    439. {
    440. 	for (int i = 0; i < 8; i++)
    441. 	{
    442. 		for (int j = 0; j < 9; j++)
    443. 			// 此处的实参position[j]是指战机的10个部分的COORD坐标，
    444. 			// 类中的成员函数可以访问数据成员变量。
    445. 			// 此处也可以写成this-> position[j]，因为
    446. 			// 成员函数具有一个附加的隐含形参，即指向该类对象的一个指针，
    447. 			// 这个隐含形参命名为this，与调用成员函数的对象绑定在一起。
    448. 			// 成员函数不能定义this形参，而是由编译器隐含地定义。
    449. 			// 成员函数的函数体可以显式使用this指针，但不是必须这么做。
    450. 			if (judgeCoordInFrame(enemy[i], position[j]))
    451. 			{
    452. 				SetPos(62, 1);
    453. 				cout << "坠毁";
    454. 				drawFrame(enemy[i], '+', '+');
    455. 				// 将与战机相撞的敌机的形状绘制为:
    456. 				//    ++
    457. 				//   +  +
    458. 				//    ++
    459. 				Sleep(1000);
    460. 				GameOver();
    461. 				break;
    462. 			}
    463. 	}
    464. }
    465. // 该成员函数用来使得游戏暂停
    466. void Game::Pause()
    467. {
    468. 	SetPos(61, 2);
    469. 	cout << "         ";
    470. 	SetPos(61, 2);
    471. 	cout << "暂停中...";
    472. 	// 当出现"暂停中..."的提示以后，程序不停的接收按下的按键，
    473. 	// 当按下'p'键以后，说明要退出暂停状态，此时需要清除"暂停中..."的提示
    474. 	// 通过输出空白 "         "来将其覆盖，达到效果
    475. 	char c = _getch();
    476. 	while (c != 'p')
    477. 	{
    478. 		c = _getch();
    479. 	}
    480. 	SetPos(61, 2);
    481. 	cout << "         ";
    482. }
    483. // 这个成员函数用来响应一次射击操作，
    484. // 也就是，当游戏中的时候，玩家按下"k"键，就执行该函数。
    485. // 由于子弹是由COORD bullet[10]定义的，因此同一时刻，界面内只能有10颗子弹同时出现。
    486. // 如果界面内不够10颗子弹，按下"k"键后战机应该发射出一颗子弹，
    487. // 于是，依次遍历10颗子弹，当遇到第一颗失效的子弹后，
    488. // 立即将该子弹赋予新的坐标（战机的炮口，也就是（position[5].X，position[5].Y - 1）），
    489. // 让其激活。然后退出for循环，函数执行完毕。
    490. void Game::Shoot()
    491. {
    492. 	for (int i = 0; i < 10; i++)
    493. 	{ 
    494. 		if (bullet[i].Y == 30)
    495. 		{
    496. 			bullet[i].X = position[5].X;
    497. 			bullet[i].Y = position[5].Y - 1;
    498. 			break;
    499. 		}
    500. 	}
    501. }
    502. void Game::drawThisBulletToNull(COORD c)
    503. {
    504. 	SetPos(c.X,c.Y);
    505. 	cout << " ";
    506. }
    507. // 此成员函数用来响应一次子弹的运动
    508. // 每次子弹运动，屏幕子弹的坐标都会出现变化，即
    509. // 先判断子弹是否有效（即判断语句if (bullet[i].Y != 30)），
    510. // 若子弹有效，将该子弹的Y坐标减少1，X坐标不变，
    511. // 检测子弹坐标更改之后是否达到上边界，如果达到上边界，则将该子弹从屏幕上擦除，
    512. // 同时，将该子弹置为失效状态，即 bullet[i].Y = 30。
    513. void Game::bulletMove()
    514. {
    515. 	for (int i = 0; i < 10; i++)
    516. 	{
    517. 		if (bullet[i].Y != 30)
    518. 		{
    519. 			bullet[i].Y -= 1;
    520. 			if (bullet[i].Y == 1)
    521. 			{
    522. 				COORD pos = { bullet[i].X, bullet[i].Y + 1 };
    523. 				drawThisBulletToNull(pos);
    524. 				bullet[i].Y = 30;
    525. 			}
    526. 		}
    527. 	}
    528. }
    529. //击败的敌机清空
    530. void Game::drawThisEnemyToNull(Frame f)
    531. {
    532. 	drawFrame(f, ' ', ' ');
    533. }
    534.  
    535. // 该成员函数依次遍历每一架敌机，
    536. // 将每一架敌机依次与每一颗子弹进行检测，
    537. // 判断敌机是否与子弹有接触，如果有接触，则表示击中敌机，
    538. // 此时将敌机和子弹擦除，然后在界面顶部的位置处随机生成一架敌机
    539. void Game::judgeEnemy()
    540. {
    541. 	for (int i = 0; i < 8; i++)
    542. 	{
    543. 		for (int j = 0; j < 10; j++)
    544. 		{
    545. 			if (judgeCoordInFrame(enemy[i], bullet[j]))
    546. 			{
    547. 				score += 5;
    548. 				drawThisEnemyToNull(enemy[i]);
    549. 				COORD a = { 1, 1 };
    550. 				COORD b = { 45, 3 };
    551. 				enemy[i].position[0] = random(a, b);
    552. 				enemy[i].position[1].X = enemy[i].position[0].X + 3;
    553. 				enemy[i].position[1].Y = enemy[i].position[0].Y + 2;
    554. 				drawThisBulletToNull(bullet[j]);
    555. 				bullet[j].Y = 30;
    556. 			}
    557. 		}
    558. 	}
    559. }
    560.  
    561. // 该成员函数用来响应一次敌机的移动
    562. // 界面上必须同时出现八架敌机，因此，
    563. // 如果有某架敌机运动到下边界处，则重置该敌机的坐标
    564. void Game::enemyMove()
    565. {
    566. 	for (int i = 0; i < 8; i++)
    567. 	{
    568. 		for (int j = 0; j < 2; j++)
    569. 			enemy[i].position[j].Y++;
    570. 		// 我们将每架敌机的左上角和右下角坐标的Y值增加1，
    571. 		// 表示该敌机向下走了一个距离
    572. 		
    573. 		// 检测向下走一个距离后的敌机的右下角坐标的Y值是否达到24，
    574. 		// 如果达到，代表敌机已经运动到下边界了，
    575. 		// 此时需要随机重置该敌机的坐标
    576. 		if (enemy[i].position[1].Y==24)
    577. 		{
    578. 			COORD a = { 1, 1 };
    579. 			COORD b = { 45, 3 };
    580. 			enemy[i].position[0] = random(a, b);
    581. 			enemy[i].position[1].X = enemy[i].position[0].X + 3;
    582. 			enemy[i].position[1].Y = enemy[i].position[0].Y + 2;
    583. 		}
    584. 	}
    585. }
    586. void Game::printScore()
    587. {
    588. 	if (score <= 120)
    589. 	{
    590. 		flag_rank = 1;
    591. 	}
    592. 	else if (score > 120 && score <= 360)
    593. 	{
    594. 		flag_rank = 2;
    595. 	}
    596. 	else if (score > 360 && score <= 480)
    597. 	{
    598. 		flag_rank = 3;
    599. 	}
    600. 	else if (score > 480)
    601. 	{
    602. 		flag_rank = 4;
    603. 	}
    604. 	SetPos(60, 6);
    605. 	cout << score;
    606. 	SetPos(60, 7);
    607. 	if (flag_rank == 1)
    608. 	{
    609. 		title = "初级飞行员";
    610. 	}
    611. 	else if (flag_rank == 2)
    612. 	{
    613. 		title = "中级飞行员";
    614. 	}
    615. 	else if (flag_rank == 3)
    616. 	{
    617. 		title = "高级飞行员";
    618. 	}
    619. 	else if (flag_rank == 4)
    620. 	{
    621. 		title = "王牌飞行员";
    622. 	}
    623. 	cout << title;
    624. }
    625. // 这个成员函数是游戏的主循环函数，
    626. // 定义了整个游戏过程。
    627. void Game::Playing()
    628. {
    629. 	drawEnemy();
    630. 	drawPlane();
    631.  
    632. 	int flag_bullet = 0;
    633. 	int flag_enemy = 0;
    634.  
    635. 	while (true)
    636. 	{
    637. 		Sleep(20);
    638. 		// 函数名：kbhit()（VC++6.0下为_kbhit()）
    639. 		// 功能及返回值： 检查当前是否有键盘输入，若有则返回一个非0值，否则返回0
    640. 		// 用法：int kbhit(void);
    641. 		// 包含头文件： include 
    642. 		// kbhit()在执行时,检测是否有按键按下,有按下返回非0值，没有按下则返回0，是非阻塞函数；
    643. 		// 不同于getch()的在执行时, 检测按下什么键, 如果不按键该函数不返回，也就不进行下一步操作，是阻塞函数。
    644. 		if (_kbhit())
    645. 		{
    646. 			char x = _getch();
    647. 			// getch()是编程中所用的函数，这个函数是一个不回显函数，
    648. 			// 当用户按下某个字符时，函数自动读取，无需按回车
    649. 			// getch()并非标准C中的函数，不存在C语言中。
    650. 			// 所在头文件是conio.h，而不是stdio.h。
    651. 			// 用ch = getch(); 会等待你按下任意键之后，把该键字符所对应的ASCII码赋给ch, 再执行下面的语句。
    652. 			if ('a' == x || 's' == x || 'd' == x || 'w' == x)
    653. 			{
    654. 				drawPlaneToNull();     // 将战机先擦除
    655. 				planeMove(x);          // 根据所输入的操作符，对战机的坐标进行更改
    656. 				drawPlane();           // 访问类中的数据成员——战机的坐标，在新的坐标处重新绘制战机
    657.  
    658. 				judgePlane();          // 判断战机是否有坠毁
    659. 			}
    660. 			//  在某一循环当中，如果检测到有'p'键按下，
    661. 			// 首先在右侧游戏界面输出"暂停中..."，然后陷入while()循环一直等待'p'键再次按下，
    662. 			// 如果'p'键没有按下，就一直处在while()循环内，因此不能执行后面的程序，起到暂停的效果。
    663. 			else if ('p' == x)
    664. 			{
    665. 				Pause();
    666. 			}
    667. 			// 如果是检测到'k'键按下，则运行Shoot()函数，
    668. 			else if ('k' == x)
    669. 			{
    670. 				Shoot();
    671. 			}
    672. 			// 如果是检测到'k'键按下，则运行GameOver()函数，
    673. 			// GameOver()函数执行完毕后，执行break;语句跳出while循环（注意不是if (_kbhit())）。
    674. 			// break语句用于结束最近的while、do while、for或switch语句，并将程序的执行权传递给紧接在
    675. 			// 被终止语句之后的语句。
    676. 			else if ('e' == x)
    677. 			{
    678. 				//CloseHandle(MFUN)
    679. 				GameOver();
    680. 				break;
    681. 			}
    682. 		}
    683. 		// 接下来处理子弹
    684. 		// 判断子弹状态的程序一直在运行
    685. 		if (flag_bullet == 0)
    686. 		{
    687. 			bulletMove();           // 更新界面上有效子弹的坐标
    688. 			drawBulletToNull();     // 将处于旧坐标的子弹擦除
    689. 			drawBullet();           // 绘制出新坐标上的子弹
    690. 			judgeEnemy();          // 判断敌机是否被子弹击中
    691. 		}
    692. 		flag_bullet++;
    693. 		if (flag_bullet==1)
    694. 		{
    695. 			flag_bullet = 0;
    696. 		}
    697. 		//  接下来处理敌机
    698. 		if (flag_enemy==0)
    699. 		{
    700. 			drawEnemyToNull();     // 将所有的敌机都擦除
    701. 			enemyMove();           //  更新敌机的坐标
    702. 			drawEnemy();           // 绘制出处于新坐标上的敌机
    703. 			judgePlane();          // 判断敌机是否与战机接触
    704. 		}
    705. 		flag_enemy++;
    706. 		if (flag_enemy >= rank)
    707. 		{
    708. 			flag_enemy = 0;
    709. 		}
    710. 		/* 输出得分 */
    711.  
    712. 		printScore();
    713.  
    714. 	}
    715. }

    主函数总不需要我来详细讲解了吧，直接供上（main.cpp）：

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include"game.h"
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	system("title 飞机大战");
    8. 	srand((unsigned int)time(NULL));//随机时间种子
    9.  
    10. 	HideCursor();//隐藏光标
    11.  
    12. 	Game game;
    13. 	int a = drawMenu();
    14. 	if (a == 2)
    15. 	{
    16. 		game.rank = 20;
    17. 	}
    18. 	system("cls");
    19.  
    20. 	drawPlaying();
    21.  
    22. 	game.Playing();
    23. }

    文章来之不易，希望各位读者能打赏一下博主😉。

    升级版链接：飞机大战升级版

     

  • 相关阅读:
    iOS CocoaPod 打包：SDK开发、Pod组件生成等
    RK3568平台开发系列讲解（Linux系统篇）kernel config 配置解析
    makesense在线yolov5标注
    Linux进程间通信
    集群配置步骤_java培训
    BCD编码和ASCII码
    PAM从入门到精通（四）
    Java8 Stream流
    走进 Java 接口测试之简单解决写接口脏数据问题
    Thymeleaf流程控制语法
  • 原文地址：https://blog.csdn.net/Sjc158/article/details/132473091