• Day18：C++飞机大战

     0.基本效果界面展示:

    一、思路与细节

    1.仍然采用单例设计模式，高度抽象出几个类如point、graph、element(敌机、主机（role包含数据成员包含子弹）均包含其作为一个数据成员，进行共通的操作)。

    2.子弹十分密集，按一下空格会发出很多子弹：写一个timer定时器
    (注:当声明和实现放在同一个文件去实现的时候，可以以.hpp结尾)
    MyTimer::Timer(100,0) #100ms产生一颗

    3.注：虽然作了前向声明，但是在.cpp文件中，找不到其相应的成员函数，
    那一定是没有在.cpp中包含其相关的头文件。

    4.我承认：debug最好的定位方式，注释掉疑似代码，看相关功能的变化。

    二、具体实现：

    公共头文件：common.h

    1. #pragma once
    2. #include<graphics.h>
    3. #include<iostream>
    4.  
    5. #include<thread>		/*c++多线程*/
    6. #include<ctime>
    7.  
    8. #include<string>
    9. #include<map>
    10. #include<list>
    11. #include<vector>
    12.  
    13. #include<mmsystem.h>
    14. #pragma commment(lib,"winmm.lib")
    15. using namespace std;

    计时器:timer.h

    1. #pragma once
    2. #include"common.h"
    3. class MyTimer
    4. {
    5. public:
    6. 	static bool Timer(int duration, int id);
    7. protected:
    8. };

    time.cpp

    1. #include "timer.h"
    2.  
    3. bool MyTimer::Timer(int duration, int id)
    4. {
    5. 	static int startTime[10];/*自动初始化为0*/
    6. 	int endTime = clock();
    7. 	if (endTime - startTime[id] >= duration)
    8. 	{
    9. 		startTime[id] = endTime;
    10. 		return true;
    11. 	}
    12. 	return false;
    13. }

    资源存放类: res.h

            在上个推箱子的项目中已经讲过单例设计的基本操作了。在此大致提几个点，都是相通的，大部分的数据成员和成员函数都是static,直接通过类名调用。

            ①构造函数是私有！

            ②给一个公有接口,返回资源类的指针，进行对其内部的相关函数以及成员的操作

            ③数据成员用的map进行映射相关的资源！方便后面对资源的索引与调用。

    1. #pragma once
    2. #include"common.h"
    3. /*仍然采用单例设计模式*/
    4. class Res
    5. {
    6. public:
    7. 	static int WIDTH(string name);				/*获取资源的宽度和高度*/
    8. 	static int HEIGHT(string name);
    9. 	static Res* GetInstance();
    10. 	static void DrawIMG(int x, int y,string name);
    11. 	static void DrawRole(int x, int y, string name, int preIndex);
    12.     /*注；角色有不同的，用preIndex来索引*/
    13. 	//static DWORD WINAPI PlayMusic(LPVOID lparame);	/*播放音乐的线程处理函数*/
    14.  
    15. public:
    16. 	static map<string,IMAGE*> img;				/*图片*/
    17. 	static map<string, string> music;			/*音乐*/
    18.  
    19. public:
    20. 	~Res();
    21.  
    22. private:
    23. 	Res();
    24. };

    res.cpp

    (静态数据成员的初始化，

            此外，此处还涉及一个细节，如何去掉一个物体图片周围的阴影部分：大致的实现原理是：准备原图一份，需要切除部分一张图片，/*NOTSRCERASE 先对遮罩进行处理 , 使得遮罩白色变黑 ,黑色区域变透明*//*SRCINVERT 在对小鸟原图处理*/->按位合&，实现背景部分的透明化操作)

    参考博客：c愤怒小鸟

    1. #include "res.h"
    2.  
    3. /*step1：类外对静态数据成员进行初始化*/
    4. map<string, IMAGE*>Res::img;            /*图片*/
    5. map<string, string>Res::music;          /*音乐*/
    6.  
    7. /*获取图片的宽度和高度*/
    8. int Res::WIDTH(string name)
    9. {
    10.     return GetInstance()->img[name]->getwidth();        //img是一个map容器,通过name去映射出IMAGE*类型的数组，
    11. }                                                       //IMAGE自带获取图片的宽度和高度的相关功能
    12.  
    13.  
    14. int Res::HEIGHT(string name)
    15. {
    16.     return GetInstance()->img[name]->getheight();
    17. }
    18.  
    19. Res* Res::GetInstance()
    20. {
    21.     static Res* res = new Res;
    22.     return res;/*单例设计模式的固定写法*/
    23. }
    24. //只有一张图片的贴图:即背景图贴图
    25. void Res::DrawIMG(int x, int y, string name)
    26. {
    27.     putimage(x, y, GetInstance()->img[name]);
    28. }
    29.  
    30. void Res::DrawRole(int x, int y, string name, int preIndex)
    31. {
    32.     //透明贴图（注意:一个固定的贴图方式->去掉背景!!!!）
    33.     /*留有白色区域棱角就不好看了 ,此时就需要用函数去处理 , 是白色区域透明化,拿到小鸟的遮罩和原图*/
    34.     putimage(x, y, GetInstance()->img[name] + preIndex, NOTSRCERASE);/*NOTSRCERASE 先对遮罩进行处理 , 使得遮罩白色变黑 ,黑色区域变透明*/
    35.     putimage(x, y, GetInstance()->img[name] + preIndex+1, SRCINVERT);/*SRCINVERT 在对小鸟原图处理*/
    36. }
    37.  
    38. Res::~Res()
    39. {
    40.     delete img["背景"];
    41.     delete[]img["角色"];
    42.     delete[]img["敌机"];
    43.     delete[]img["子弹"];
    44. }
    45.  
    46. Res::Res()
    47. {
    48.     /*路径处理*/
    49.     string background = "..//res//background.jpg";
    50.     string roleImg[4] = { "..//res//planeExplode_1.jpg","..//res//planeExplode_2.jpg",
    51.         "..//res//planeNormal_1.jpg","..//res//planeNormal_2.jpg" };        //->注：只有下标0和2为有效的人物角色，下标1和3是0和2的遮罩，用于去阴影的。
    52.     string ballImg[2] = {"..//res//bullet1.jpg","..//res//bullet2.jpg"};
    53.     string enemy[4] = { "..//res//enemy_1.jpg","..//res//enemy_2.jpg",
    54.         "..//res//enemyPlane1.jpg", "..//res//enemyPlane2.jpg", };
    55.     img["背景"] = new IMAGE;
    56.     img["角色"] = new IMAGE[4];
    57.     img["子弹"] = new IMAGE[2];
    58.     img["敌机"] = new IMAGE[4];
    59.     loadimage(img["背景"], background.c_str());
    60.     for (int i = 0; i < 4; i++)
    61.     {
    62.         loadimage(img["角色"] + i, roleImg[i].data());
    63.         loadimage(img["敌机"] + i, enemy[i].data());
    64.     }
    65.     for (int i = 0; i < 2; i++)
    66.     {
    67.         loadimage(img["子弹"] + i, ballImg[i].c_str()); /*c_str()和data()等效，都是转化为c语言风格的string*/
    68.     }
    69. }

    专门用于地图操作的类: graph.h

            负责①创建句柄，并②将地图绘制好！

    1. #pragma once
    2.  
    3. class Graph
    4. {
    5. public:
    6. 	Graph();
    7. 	~Graph();
    8. 	void DrawMap();			/*对于地图的切换*/
    9. protected:
    10.  
    11. };

     graph.cpp

    1. #include "graph.h"
    2. #include"res.h"
    3. Graph::Graph()
    4. {
    5. 	/*用图片的大小来初始化这个窗口*/
    6. 	initgraph(Res::GetInstance()->img["背景"]->getwidth(),
    7. 		Res::GetInstance()->img["背景"]->getheight());
    8.  
    9. }
    10.  
    11. Graph::~Graph()
    12. {
    13. 	closegraph();
    14. }
    15.  
    16. void Graph::DrawMap()
    17. {
    18. 	Res::DrawIMG(0, 0, "背景");		/*第3个参数是用来map索引相关的资源的*/
    19. }

    抽象出敌机、玩家(主机)、子弹的共性类: element.h

            共同的特征方法：①x、y坐标②是否存活（bool状态）③血量④相关图片的宽度和高度

                    ⑤自身的绘制(直接调用Res类中的绘制函数即可。) ⑥自身的移动(直接调用point类的相关方法即可(见下))

            共同的数据成员:①坐标②名称③是否存活标记④血量

    1. #include"common.h"
    2. #include"res.h"
    3. #include"point.h"
    4. /*抽象出一个元素类，所有的敌机和角色都是由这个进行派生的*/
    5. class Element
    6. {
    7. public:
    8. 	virtual ~Element();
    9. 	Element();
    10. 	Element(int x, int y, string name, bool live, int hp = 0);
    11. 	int& GetX();
    12. 	int& GetY();
    13. 	bool& GetLive();
    14. 	int& GetHp();
    15. 	int GetWidth();
    16. 	int GetHeight();
    17. 	void DrawElement(int pre);
    18. 	void MoveElement(int speed,Point::Dir dir);
    19. protected:
    20. 	Point point;		/*元素在窗口上的位置*/
    21. 	string name;		/*元素的名字->用处之一：获取元素的高度和宽度*/
    22. 	bool live;			/*是否存活的标记*/
    23. 	int hp;				/*血量*/
    24. };

    element.cpp

    1. #include "element.h"
    2. #include"res.h"
    3. Element::~Element()
    4. {
    5.  
    6. }
    7.  
    8. Element::Element()
    9. {
    10.  
    11. }
    12.  
    13. Element::Element(int x, int y, string name, bool live, int hp):point(x,y),name(name)/*类的组合->初始化参数列表*/
    14. {
    15. 	this->live = live;
    16. 	this->hp = hp;
    17. }
    18.  
    19. int& Element::GetX()
    20. {
    21. 	return point.getX();
    22. }
    23.  
    24. int& Element::GetY()
    25. {
    26. 	return point.getY();
    27. }
    28.  
    29. bool& Element::GetLive()
    30. {
    31. 	return live;
    32. }
    33.  
    34. int& Element::GetHp()
    35. {
    36. 	return hp;
    37. }
    38.  
    39. int Element::GetWidth()
    40. {
    41. 	return Res::GetInstance()->WIDTH(name);/*直接调用相应的接口,调用中间函数*/
    42. }
    43.  
    44. int Element::GetHeight()
    45. {
    46. 	return Res::GetInstance()->HEIGHT(name);
    47. }
    48.  
    49. void Element::DrawElement(int pre)
    50. {
    51. 	Res::GetInstance()->DrawRole(point.getX(), point.getY(), name, pre);
    52. }
    53.  
    54. void Element::MoveElement(int speed, Point::Dir dir)
    55. {
    56. 	point.move(speed, dir);
    57. }

    内部物体的移动原理抽象出来的类: point.h

            关键：枚举类型->上下左右

            成员函数：①x、y坐标的接口②构造函数、拷贝构造函数③关键还是move()方法:如何实现物体的移动，要做好与Element类的对接。

    1. #pragma once
    2. #include"common.h"
    3. /*重点:所有物体的运转，都是坐标的改变，于是抽象出此坐标类*/
    4. class Point
    5. {
    6. public:
    7. 	enum Dir{left,right,down,up};
    8. 	Point(int x = 0, int y = 0);
    9. 	Point(const Point& point);
    10. 	int& getX();
    11. 	int& getY();
    12. 	/*移动点*/
    13. 	void move(int speed, Dir dir);
    14. protected:
    15. 	int x;
    16. 	int y;
    17. };

    point.cpp

    1. #include "point.h"
    2.  
    3. Point::Point(int x, int y)
    4. {
    5. 	this->x = x;
    6. 	this->y = y;
    7. }
    8.  
    9. Point::Point(const Point& point)
    10. {
    11. 	this->x = point.x;
    12. 	this->y = point.y;
    13. }
    14.  
    15. int& Point::getX()
    16. {
    17. 	return x;
    18. }
    19.  
    20. int& Point::getY()
    21. {
    22. 	return y;
    23. }
    24.  
    25. void Point::move(int speed, Dir dir)
    26. {
    27. 	switch (dir)
    28. 	{
    29. 	case Point::left:
    30. 		this->x -= speed;
    31. 		break;
    32. 	case Point::right:
    33. 		this->x += speed;
    34. 		break;
    35. 	case Point::up:
    36. 		this->y -= speed;
    37. 		break;
    38. 	case Point::down:
    39. 		this->y += speed;
    40. 		break;
    41. 	}
    42. }

    主机的具体实现类: role.h

            数据成员：主角Element*类型的指针plane、和一个存放Element*类型的list

    容器(当做bullet来用！)

            方法：①构造函数（飞机的居中，hp和live状态的设置）

                    ②画飞机和子弹(遍历调用)只需要调用element中写好的方法即可。

                    ③数据成员的接口

                    ④子弹的移动（只会向前移动，遍历每一个子弹-=速度，改变y坐标即可）

                    ⑤plane的移动(异步函数的调用)，GetAsyncKeyState()函数调用（具体说明看实现部分的注释！）

                    注：plane的移动中，核心的几点：（i）按上下左右键实现移动调用element类中写好的方法暂且不提，（ii）还有按下空格键，产生子弹(塞到链表中，new出来(注意产生的位置))，为了不让子弹过于密集，采用timer计时器！（iii）子弹的移动后，移动子弹+绘制子弹！！control中就直接调用此函数即可。

    1. #pragma once
    2. #include"common.h"
    3. class Element;				/*因为只用到了该类的指针,所以直接前向声明即可！！！*/
    4. class Role
    5. {
    6. public:
    7. 	Role();
    8. 	~Role();
    9. 	void DrawPlane(int preIndex);
    10. 	void MovePlane(int speed);
    11. 	void DrawBullet();
    12. 	void MoveBullet(int speed);
    13.  
    14. 	Element*& GetPlane();
    15. 	list<Element*>& GetBullet();
    16. protected:
    17. 	Element* plane;			/*角色*/
    18. 	list<Element*>bullet;	/*子弹*/
    19.  
    20. };

     role.cpp

    1. #include "role.h"
    2. #include"res.h"
    3. #include"element.h"
    4. #include"timer.h"
    5.  
    6. Role::Role()
    7. {
    8. 	plane = new Element(Res::GetInstance()->WIDTH("背景")/2-Res::GetInstance()->WIDTH("角色")/2,    //x
    9. 		Res::GetInstance()->HEIGHT("背景")-Res::GetInstance()->HEIGHT("角色"),						//y
    10. 		"角色",																						//角色名
    11. 		true,																						//存活状态
    12. 		100);		/*产生一个居中的飞机*/															//hp						
    13. 	
    14. }
    15.  
    16. Role::~Role()
    17. {
    18. }
    19.  
    20. void Role::DrawPlane(int preIndex)
    21. {
    22. 	plane->DrawElement(preIndex);			/*元素类已经做好了*/
    23. }
    24.  
    25. void Role::MovePlane(int speed)
    26. {
    27. 	/*GetAsyncKeyState是一个用来判断函数调用时指定虚拟键的状态，确定用户当前是否按下了键盘上的一个键的函数。如果按下，则返回值最高位为1。*/
    28. 	/*另一个函数GetKeyState与GetAsyncKeyState函数不同。GetAsyncKeyState在按下某键的同时调用，判断正在按下某键。
    29. 	GetKeyState则在按过某键之后再调用，它返回最近的键盘消息从线程的队列中移出时的键盘状态，判断刚按过了某键。
    30. 	GetAsyncKeyState 取异步键状态。*/
    31. 	if (GetAsyncKeyState(VK_UP) && plane->GetY() >= 0)
    32. 	{
    33. 		plane->MoveElement(speed, Point::up);
    34. 	}
    35. 	if (GetAsyncKeyState(VK_DOWN) && plane->GetY() <= Res::GetInstance()->HEIGHT("背景") - Res::GetInstance()->HEIGHT("角色"))
    36. 	{
    37. 		plane->MoveElement(speed, Point::down);
    38. 	}
    39. 	/*if (GetAsyncKeyState(VK_RIGHT)&& plane->GetX() <= Res::GetInstance()->WIDTH("背景") - Res::GetInstance()->WIDTH("角色"));
    40. 	{
    41. 		plane->MoveElement(speed, Point::right);
    42. 	}*/
    43. 	if (GetAsyncKeyState(VK_RIGHT) &&
    44. 		plane->GetX() <= Res::GetInstance()->WIDTH("背景") - Res::GetInstance()->WIDTH("角色"))
    45. 	{
    46. 		plane->MoveElement(speed, Point::right);
    47. 	}
    48. 	if (GetAsyncKeyState(VK_LEFT) && plane->GetX() >= 0)
    49. 	{
    50. 		plane->MoveElement(speed, Point::left);
    51. 	}
    52. 	/*子弹按空格产生*/     
    53. 	if (GetAsyncKeyState(VK_SPACE)&&MyTimer::Timer(100,0))   /*100ms产生一颗*/
    54. 	{  
    55. 		/*每产生一个子弹,就播放音乐*/
    56. 		//HANDLE threadID = CreateThread(NULL, 0, Res::PlayMusic, (int*)1, 0, 0);
    57. 		bullet.push_back(new Element(plane->GetX()+45,plane->GetY()-10,"子弹",1));
    58. 		//CloseHandle(threadID);
    59. 	}
    60. 	MoveBullet(1);
    61. 	DrawBullet();
    62. }
    63. /*子弹是存在容器中的,要把其都画出来*/
    64. void Role::DrawBullet()
    65. {
    66. 	for (auto v : bullet)
    67. 	{
    68. 		if (v->GetLive())				/*细节：首先是要存活*/
    69. 		{
    70. 			v->DrawElement(0);
    71. 		}
    72. 	}
    73. }
    74.  
    75. void Role::MoveBullet(int speed)
    76. {
    77. 	for (auto v : bullet)
    78. 	{
    79. 		v->GetY() -= speed;						/*子弹只会向前跑*/
    80. 	}
    81. }
    82.  
    83. Element*& Role::GetPlane()
    84. {
    85. 	return plane;
    86. }
    87.  
    88. list<Element*>& Role::GetBullet()
    89. {
    90. 	return bullet;
    91. }
    92.  
    93.  
    94.  
    95.  
    96.

    敌机的具体实现类: enemy.h

            数据成员：由于有多个敌机，本质上和子弹一样，创建一个list容器存放Element*（当做enemy来用）

            成员函数:①构造+析构

                            ②for逐一地遍历绘制

                            ③敌机的移动(调用element中封装好的move(方向固定向下))

                            ④敌机的创建(不在构造函数中写),设计到随机生成+从边界一点一点飞出来的效果，单独写一个create函数，随机生成rand()%宽度，起始创建位置在-1*敌机的高度处。

    1. #pragma once
    2. #include"common.h"
    3.  
    4. class Element;
    5. class Enemy
    6. {
    7. public:
    8. 	Enemy();
    9. 	~Enemy();
    10. 	void DrawEnemy(int preIndex);
    11. 	void MoveEnemy(int speed);
    12. 	Element* CreateEnemy();
    13.  
    14. 	list<Element*>& GetEnemy();
    15. protected:
    16. 	list<Element*> enemyPlane;		/*有多个敌机,用链表存储*/
    17. };

     enemy.cpp

    1. #include "enemy.h"
    2. #include"element.h"
    3. #include"res.h"
    4. Enemy::Enemy()
    5. {
    6. }
    7.  
    8. Enemy::~Enemy()
    9. {
    10. }
    11.  
    12. void Enemy::DrawEnemy(int preIndex)
    13. {
    14. 	for (auto v : enemyPlane)
    15. 	{
    16. 		if (v->GetLive())
    17. 		{
    18. 			v->DrawElement(preIndex);
    19. 		}
    20. 	}
    21. }
    22.  
    23. void Enemy::MoveEnemy(int speed)
    24. {
    25. 	for (auto v : enemyPlane)
    26. 	{
    27. 		v->MoveElement(speed, Point::down);
    28. 	}
    29. }
    30.  
    31.  
    32. Element* Enemy::CreateEnemy()
    33. {
    34. 	return new Element(rand() % Res::GetInstance()->WIDTH("背景"),
    35. 		-1 * Res::GetInstance()->HEIGHT("敌机"), "敌机", 1, 3);					/*3点血量，需要打三次才能消失*/
    36. }
    37.  
    38. list<Element*>& Enemy::GetEnemy()
    39. {
    40. 	return enemyPlane;
    41. }

    函数流程的具体操作封装的类: control.h

            数据成员：①敌机                                的指针

                              ②主机（包含子弹）           的指针

                              ③地图                                的指针

            成员函数：①构造函数+析构函数

                              ②绘制：

                                    （i）地图，就直接调用graph类的绘制地图函数即可

                                    （ii）主机,调用绘制主机的同时，调用move函数（包含了检测键盘信息的功能，传参速度）

                                    （iii）敌机：A:每过1s即1000ms产生敌机，并放置到容器中

                                                        B:每过10ms，敌机进行移动

                                                        C：绘制敌机

                            ③打飞机的核心逻辑：

                                    （i）碰撞处理：碰到子弹，把子弹的live置为0（这个地方只改标记,删除放在第二步，思路清晰）

                                    （ii）通过标记去删除相应的数据(否则内存会越来越大)

                                                    （注意：迭代器删除的细节！）

    1. #pragma once
    2. #include"role.h"
    3. #include"graph.h"
    4. class Role;
    5. class pMap;
    6. class Enemy;
    7. class Control
    8. {
    9. public:
    10. 	Control(Graph* pMap = nullptr, Role* pRole = nullptr,Enemy*pEnemy=nullptr);
    11. 	~Control();
    12. 	void DrawMap();
    13. 	void DrawRole();
    14. 	void DrawEnemy();
    15. 	void PlayEnemy();
    16. protected:
    17. 	/*所有的组成部分都可以在此封装好*/
    18. 	Role* pRole;
    19. 	Graph* pMap;
    20. 	Enemy* pEnemy;
    21.  
    22. };

     control.cpp

    1. #include "control.h"
    2. #include"timer.h"
    3. #include"role.h"
    4. #include"graph.h"
    5. #include"enemy.h"
    6. #include"element.h"
    7. #include"res.h"
    8. Control::Control(Graph* pMap, Role* pRole,Enemy* pEnemy)
    9. {
    10. 	this->pMap = pMap;
    11. 	this->pRole = pRole;
    12. 	this->pEnemy = pEnemy;
    13. }
    14.  
    15. Control::~Control()
    16. {
    17. }
    18.  
    19. void Control::DrawMap()
    20. {
    21. 	pMap->DrawMap();
    22. }
    23.  
    24. void Control::DrawRole()
    25. {
    26. 	pRole->DrawPlane(0);
    27. 	pRole->MovePlane(1);
    28. }
    29.  
    30. void Control::DrawEnemy()
    31. {
    32. 	if (MyTimer::Timer(1000, 1))
    33. 	{
    34. 		pEnemy->GetEnemy().push_back(pEnemy->CreateEnemy());/*每过一秒就随机产生一个飞机*/
    35. 	}
    36. 	if (MyTimer::Timer(10, 2))
    37. 	{
    38. 		pEnemy->MoveEnemy(1);
    39. 	}
    40. 	pEnemy->DrawEnemy(0);
    41. }
    42.  
    43. void Control::PlayEnemy()
    44. {
    45. 	 /*1.碰撞处理：碰到子弹，把子弹的live置为0（这个地方只改标记,删除放在第二步，思路清晰）*/
    46. 	for (auto bullet : pRole->GetBullet())					/*角色里面自带子弹的数据成员*/
    47. 	{
    48. 		if (bullet->GetLive()==0)
    49. 		{
    50. 			continue;
    51. 		}
    52. 		if (bullet->GetY() < 0)						/*子弹出了边界*/
    53. 		{
    54. 			bullet->GetLive() = false;
    55. 		}
    56. 		for (auto enemy : pEnemy->GetEnemy())
    57. 		{
    58. 			if (enemy->GetLive() &&													/*首先得活着！*/
    59. 				bullet->GetX() > enemy->GetX() &&
    60. 				bullet->GetX() < enemy->GetX() + Res::WIDTH("敌机") &&
    61. 				bullet->GetY() > enemy->GetY() &&
    62. 				bullet->GetY() < enemy->GetY() + Res::HEIGHT("敌机"))
    63. 			{
    64. 				enemy->GetHp() --;
    65. 				if (enemy->GetHp() <= 0)
    66. 				{
    67. 					enemy->GetLive() = false;
    68. 				}
    69. 				bullet->GetLive() = false;  /*子弹碰到敌机也要消失*/
    70. 			}
    71. 			/*敌机出了窗口边界，也要消失*/
    72. 			if (enemy->GetY() >= Res::HEIGHT("背景"))
    73. 			{
    74. 				enemy->GetLive() = false;
    75. 			}
    76. 		}
    77. 	}
    78. 	 /*2.通过标记去删除相应的数据(否则内存会越来越大)*/
    79. 	for (auto iterE = pEnemy->GetEnemy().begin(); iterE != pEnemy->GetEnemy().end();)
    80. 	{	//细节:迭代的删除，一定要分开，不把++放在for中(否则会删不干净)
    81. 		if ((*iterE)->GetLive()==false)
    82. 		{
    83. 			iterE = pEnemy->GetEnemy().erase(iterE);
    84. 		}
    85. 		else
    86. 		{
    87. 			iterE++;
    88. 		}
    89. 	}
    90. 	for (auto iterB = pRole->GetBullet().begin(); iterB != pRole->GetBullet().end();)
    91. 	{	//细节:迭代的删除，一定要分开，不把++放在for中(否则会删不干净)
    92. 		if ((*iterB)->GetLive() == false)
    93. 		{
    94. 			iterB = pRole->GetBullet().erase(iterB);
    95. 		}
    96. 		else
    97. 		{
    98. 			iterB++;
    99. 		}
    100. 	}
    101. }

    主函数：MainControl.cpp

            生成随机数种子->pControl初始化->双缓冲绘制图片(防闪屏)->

                    while(1)

                            {cleardevice()->绘制核心物件->打飞机核心逻辑检测}；

    1. #include"control.h"
    2. #include"graph.h"
    3. #include"role.h"
    4. #include"enemy.h"
    5. int main()
    6. {
    7. 	srand((size_t)time(NULL));
    8. 	Graph* pMap = new Graph;
    9. 	Role* pRole = new Role;
    10. 	Enemy* pEnemy = new Enemy;
    11.  
    12. 	Control*pControl=new Control(pMap,pRole,pEnemy);
    13. 	BeginBatchDraw();
    14. 	while (1)
    15. 	{
    16. 		cleardevice();
    17. 		pControl->DrawMap();
    18. 		pControl->DrawRole();
    19. 		pControl->DrawEnemy();
    20. 		pControl->PlayEnemy();
    21.  
    22. 		FlushBatchDraw();
    23. 	}
    24. 	while (1);/*防止闪屏*/
    25. 	return 0;
    26. }

    三、资源：

    C++飞机大战项目代码和素材icon-default.png?t=M5H6https://download.csdn.net/download/zjjaibc/85802748​​​​​​​

  • 相关阅读:
    npm install卡住与node-npy的各种奇怪报错
    CASIO4850万能程序
    并查集模版以及两道例题
    Linux Ubuntu 22.04常用系统快捷键
    css取消移动端长按元素背景色
    Java Random.setseed()方法具有什么功能呢？
    蓝桥杯物联网竞赛_STM32L071_19_输出方波信号（PWM）
    行列均按段分组汇总
    细说React组件性能优化
    QMenu的基本使用:实现右键弹出菜单栏
  • 原文地址：https://blog.csdn.net/zjjaibc/article/details/125492166