仿《雷霆战机》飞行射击手游开发--飞机（含源码库地址）

转载请注明：http://www.cnblogs.com/thorqq/p/6323156.html

代码库：https://git.oschina.net/thorqq/RaidenFree

下面我们继续分析这款游戏。

飞机

这是一款打飞机游戏，所以主角当然是飞机。游戏里，飞机包括以下几种：

• 玩家飞机：玩家控制的主飞机
• 僚机：在玩家飞机左右的小飞机，相对于玩家飞机的位置是固定不变的。
• 普通敌机：不会变形的敌机
• 变形敌机：飞到指定位置后变形，然后开始射击。被击落时，屏幕会震动
• BOSS：从屏幕上方飞下来，飞到指定位置后变形，然后开始左右移动，同时开始射击。boss可以有多次变形，当血量低于一定值时会触发变形，同时攻击力增强。Boss被击落后，飞机上会产生多次爆炸，屏幕会伴随着震动。
• 必杀僚机：必杀技。当玩家点击必杀按钮时，会从屏幕下方出现一个庞大的飞机，发射超级激光

飞机的基本属性

• 名字
• 类型
• 骨骼动画（飞行、左右侧飞、变形、暴走、尾部火焰）
• 生命值
• 攻击值：当飞机与飞机相撞时，对对方飞机产生的伤害值
• 碰撞体（刚体）的中心坐标和大小（只有当子弹的碰撞体与飞机的碰撞体发生重叠时，才会产生伤害）
• 缩放比例
• 血槽的样式和位置
• 飞机的初始位置（对于玩家飞机来说，一般是从屏幕下方飞入；对于敌机来说，一般是从上半个屏幕的某个地方飞出来）
• 子弹（弹夹BulletGroup+子弹Bullet）
• 僚机
• 飞机爆炸帧动画和音效
• 扩展属性（可扩展，用map来实现）

我们用结构体TAircraftData来表示：

struct TAircraftData
{
	int id;
	std::string name;//名字
	std::string type;//类型，值为AircraftType
　　　　 //飞机动画即支持帧动画，又支持骨骼动画
	std::vector<std::string> styleArray;  //飞机动画
	float aniDura; //动画帧时长
	std::string armatureName; //骨骼动画名称

	int hp;           //当前生命值
	int maxHp;        //最大生命值
	float defence;    //防御
	int attack;       //攻击

	float bodyCenterX; //刚体中心坐标
	float bodyCenterY;
	float bodySizeW;   //刚体尺寸
	float bodySizeH;
	float scale;       //缩放比例

	std::string hpBgStyle; //血槽背景样式
	std::string hpStyle;   //血槽样式
	float hpPosX;          //血槽的位置
	float hpPosY;          //血槽的位置

	std::vector<std::vector<int>*> bulletIdArray;  //多种子弹

	std::vector<std::string> fireFameNameArray; //尾部火焰动画，图片列表
	float fireAniDura; //动画帧时长
	int   fireOnTop;
	float fireOffsetX;//火焰中心点相对于飞机底部中心点的偏移。如果等于0，则只有一个火焰；否则是两个火焰
	float fireOffsetY;

	float startPosX;  //飞机的起始位置
	float startPosY;

	std::vector<int> wingmanArray; //僚机

	std::vector<std::string> blastStyleArray; //飞机爆炸的动画
	float blastAniDura;
	int blastMusicId; //飞机爆炸的音效id

	std::map<std::string, std::string> paramMap; //飞机参数
}

基本方法

• 初始化、复位、销毁
• 生命的减少或增加、判断是否活着
• 开始射击、停止射击、是否正在射击
• 飞行
• 爆炸

高级方法

• 开始自动射击、停止自动射击、自动改变子弹级别
• 子弹升一个等级
• 子弹升到最高等级
• 子弹降一个等级
• 是否是最高级别子弹
• 是否是最低级别子弹
• 获取子弹等级
• 重置子弹等级
• 子弹用完发出的通知
• 更新装备
• 防御效果的增加、去除

 详细代码如下：

//飞机的基类
class Aircraft : public GameObject, public IBulletUseUpListener
{
public:
	Aircraft();
	virtual ~Aircraft();

	virtual bool init(Node* parent, const TAircraftData* pData, const TAircraftLevelData* pLevelData = nullptr);
	virtual void reset();
	virtual void destory();

	virtual void reduceHp(int hp);
	virtual void recoverHp(int hp);
	virtual bool isAlive();

	virtual void startShoot();
	virtual void stopShoot();
	virtual bool isShooting();

	virtual void autoShoot();
	virtual void stopAutoShoot();
	virtual void autoChangeBulletGrade();

	//自动飞行
	virtual void fly(){};

	//爆炸
	virtual void blast();
	
	//更新装备
	bool updateEquip();

	//子弹升级
	virtual bool upgradeBullet();
	virtual bool upgradeMaxBullet();
	//子弹降级
	virtual bool downgradeBullet();
	//是否暴走
	virtual bool isMaxLevelBullet();
	//是否最低级子弹
	virtual bool isMinLevelBullet();
	//获取子弹等级
	virtual int getBulletLevel();
	//重置子弹级别
	virtual bool resetBulletLevel();

	//子弹用完通知
	virtual void bulletUseUp() override;

	//量子护盾
	void addShield();
	void removeShield();
	//防御效果结束
	virtual void defenceDone(float dt);

	//碰撞检测
	virtual bool isCollsion(const Rect& rect, Rect* pCollsionRect = nullptr);

	//获取攻击、防御、导弹、僚机、综合性能
	inline int getAttrAttack(){ return m_iAttrAttack; }
	inline int getAttrArmor() { return m_iAttrArmor; }
	inline int getAttrMissile(){ return m_iAttrMissile; }
	inline int getAttrWingman() { return m_iAttrWingman; }
	inline int getAttrTotal() { return m_iAttrTotal; }

	void calculateAttr();

	inline int getId()
	{
		return m_data.id;
	}

	inline int getLevelId()
	{
		if (m_data.pAircraftLevelData)
		{
			return m_data.pAircraftLevelData->id;
		}
		else
		{
			return -1;
		}
	}

	inline int getHp()
	{
		return m_data.hp;
	}

	inline void setHp(int hp)
	{
		m_data.hp = hp;
	}

	inline int getMaxHp()
	{
		return m_data.maxHp;
	}

	inline void setMaxHp(int max)
	{
		m_data.maxHp = max;
	}

	inline int getAttack()
	{
		//两机相撞时，对对方产生的伤害就是自己的血量
		return getHp();
	}

	inline void setAttack(int a)
	{
		m_data.attack = a;
	}

	void setNoDie(bool b);

	inline bool isNoDie()
	{
		return m_bNoDie;
	}

	inline Vector<BulletGroup*>* getBulletGroupArray()
	{
		return &m_bulletGroupArray;
	}

	inline EAircraftType getAircraftType()
	{
		return m_eAircraftType;
	}

	inline const std::string& getAttr(const std::string& key)
	{
		static std::string empty = "";
		auto it = m_data.paramMap.find(key);
		if (it != m_data.paramMap.end())
		{
			return it->second;
		}
		else
		{
			return empty;
		}
	}

	inline int getAircraftLevelId()
	{
		if (m_data.pAircraftLevelData)
		{
			return m_data.pAircraftLevelData->id;
		}
		else
		{
			return -1;
		}
	}

	Vector<Aircraft*>* getOtherSidePlane() const;
	void setOtherSidePlane(Vector<Aircraft*>* const planes);

	//回收
	virtual void recycle();
	//重用
	virtual void reuse();
	//是否已回收（是否可用）
	bool isRecycled();

protected:
	virtual void setBulletGrade(unsigned grade){ m_iBulletGrade = grade; }
	virtual void setAttackAdjust(float adjust){ m_fAttackAdjust = adjust; }
	virtual void setMissileAdjust(float adjust){ m_fMissileAdjust = adjust; }
	virtual void setBulletSpeedAdjust(float adjust){ m_fBulletSpeedAdjust = adjust; }

	virtual bool initBody(Node* parent, const TAircraftData* pData);
	virtual bool initPosition(Node* parent, const TAircraftData* pData);
	virtual bool initFire(Node* parent, const TAircraftData* pData);
	virtual bool initHpBar(Node* parent, const TAircraftData* pData);
	virtual bool initBullet(Node* parent, const TAircraftData* pData);
	virtual bool initWingman(Node* parent, const TAircraftData* pData);

	//添加尾部的左右两个火焰动画
	bool addFire(float offsetX, float offsetY, bool isFlipped);

protected:
	EAircraftType m_eAircraftType;
	TAircraftData m_data;
	const TAircraftData* m_pDataCopy;

	//战机所有的装备
	const TEquipmentData* m_pEquipAircraft;
	const TEquipmentData* m_pEquipArmature;
	const TEquipmentData* m_pEquipMissile;
	const TEquipmentData* m_pEquipWingman;

	int m_iBulletGrade;
	float m_fAttackAdjust;
	float m_fMissileAdjust;
	float m_fBulletSpeedAdjust;

	float m_fVipRelifeAttrAdjust;

	float m_fDefence;           //防御系数
	float m_fDefenceDura;       //防御持续时间
	int m_iCurBulletGrade; //当前子弹等级
	bool m_bNoDie;              //无敌
	cocostudio::Armature* m_pDefenceBall;     //护盾球
	HpBar* m_pHpBar;            //血槽精灵
	Vector<BulletGroup*> m_bulletGroupArray;  //多种子弹
	Vector<Aircraft*>    m_wingmanArray;      //僚机精灵
	Vector<Aircraft*>*   m_otherSideArray;    //对方飞机。对于玩家来说就是敌机，对于敌机来说就是玩家

	int m_iAttrAttack;
	int m_iAttrArmor;
	int m_iAttrMissile;
	int m_iAttrWingman;
	int m_iAttrTotal;

	bool m_bRecycled;

	bool m_bAutoShoot;
	int m_orignBulletGrade;
};

　　为了构建不同的飞机对象，我们增加一个飞机工厂。工厂的create函数中TAircraftData参数是从配置（sqlite数据库）中获取到的。

template<typename T>
class PlaneCreator
{
public:
	static T* create(Node* parent, const TAircraftData* data)
	{
		T *pRet = new(std::nothrow) T();
		if (pRet && pRet->init(parent, data))
		{
			pRet->autorelease();
			return pRet;
		}
		else
		{
			delete pRet;
			pRet = NULL;
			return NULL;
		}
	}

};

飞机池

    当界面上的飞机较多，并且频繁出现、被击落的时候，系统会不停的创建、销毁飞机对象，这样会严重影响游戏的帧率，所以，我们增加了一个简单的飞机池：当飞机被击落时，飞机对象并没有被销毁掉，而只是停止射击、停止所有动画并隐藏起来。当需要创建新的飞机时，会从池中查找有没有对应的已回收的飞机，如果找到，则对此对象重新进行初始化。代码如下：

class AircraftPool
{
public:
	static AircraftPool* getInstance();

	//获取一架飞机
	template<typename T>
	T* get(Node* parent, const TAircraftData* pAircraftData, const TAircraftLevelData* pAircraftLevelData)
	{
		//AircraftPool 只在急速模式下使用。其他两种模式反而会增加内存
		if (GameData::getInstance()->getValueToInt(GAMEDATA::MODE) != ModeBase::ModeRapid)
		{
			return PlaneCreator<T>::create(parent, pAircraftData, pAircraftLevelData);
		}

		auto it = m_aircraftMap.find(pAircraftLevelData->id);
		std::vector<Aircraft*>* pArray = nullptr;
		if (it != m_aircraftMap.end())
		{
			pArray = it->second;
		}
		else
		{
			pArray = new std::vector<Aircraft*>;
			m_aircraftMap.insert(std::map<int, std::vector<Aircraft*>*>::value_type(pAircraftLevelData->id, pArray));
		}

		//查找可用的飞机
		for (Aircraft* p : *pArray)
		{
			if (p && p->isRecycled())
			{
				p->reuse();
				T* ret = dynamic_cast<T*>(p);
				if (ret)
				{
					parent->addChild(ret);
					return ret;
				}
				else
				{
					DEBUG_LOG("fuck error type of aircraft");
				}
			}
		}

		//没找到，新建一个
		auto p = PlaneCreator<T>::create(parent, pAircraftData, pAircraftLevelData);
		p->retain();
		for (unsigned i = 0; i < pArray->size(); i++)
		{
			if ((*pArray)[i] == nullptr)
			{
				(*pArray)[i] = p;
				return p;
			}
		}

		pArray->push_back(p);
		return p;
	}

	//回收一架飞机
	void recycle(Aircraft* pAircraft);

	//清空pool
	void release();

protected:
	AircraftPool();

private:
	static AircraftPool* m_pInstance;

	std::map<int, std::vector<Aircraft*>*> m_aircraftMap;
};

AircraftPool* AircraftPool::m_pInstance = nullptr;

AircraftPool* AircraftPool::getInstance()
{
	if (!m_pInstance)
	{
		m_pInstance = new AircraftPool();
	}

	return m_pInstance;
}

AircraftPool::AircraftPool()
{
}

//回收一架飞机
void AircraftPool::recycle(Aircraft* pAircraft)
{
	//如果在池中，则回收；否则直接销毁
	auto it = m_aircraftMap.find(pAircraft->getAircraftLevelId());
	std::vector<Aircraft*>* pArray = nullptr;
	if (it != m_aircraftMap.end())
	{
		pArray = it->second;
		for (Aircraft* p : *pArray)
		{
			if (p == pAircraft)
			{
				p->recycle();
				return;
			}
		}
	}

	pAircraft->destory();
}

//清空pool
void AircraftPool::release()
{
	for (auto it : m_aircraftMap)
	{
		bool bInUse = false;
		std::vector<Aircraft*>* pArray = it.second;
		for (Aircraft* p : *pArray)
		{
			if (p && p->isRecycled())
			{
				p->destory();
				p->release();
			}
			else if (p)
			{
				bInUse = true;
				DEBUG_LOG("Aircraft[%d] can't release", p->getId());
				//CCASSERT(false, "Release error aircraft");
			}
		}

		if (!bInUse)
		{
			pArray->clear();
			delete pArray;
		}
	}

	m_aircraftMap.clear();
}

//////////////////////////////////////////////////////////
//下面是Aircraft对象中的回收、重用等方法
//回收
void Aircraft::recycle()
{
	if (m_bRecycled)
	{
		return;
	}

	setNoDie(false);
	//for (int i = 0; i < m_bulletGroupArray.size(); i++)
	//{
	//	m_bulletGroupArray.at(i)->setPlane(NULL);
	//}
	stopShoot();

	for (int i = 0; i < m_wingmanArray.size(); i++)
	{
		//m_wingmanArray.at(i)->recycle();
		AircraftPool::getInstance()->recycle(m_wingmanArray.at(i));
	}

	pause();

	m_bRecycled = true;
}

//重用
void Aircraft::reuse()
{
	if (!m_bRecycled)
	{
		return;
	}

	if (m_pHpBar)
	{
		m_pHpBar->setMaxValue(m_data.maxHp);
		m_pHpBar->setCurValue(m_data.maxHp);
	}
	m_data.hp = m_data.maxHp;

	//for (int i = 0; i < m_bulletGroupArray.size(); i++)
	//{
	//	m_bulletGroupArray.at(i)->setPlane(this);
	//}
	m_iCurBulletGrade = 0;

	for (int i = 0; i < m_wingmanArray.size(); i++)
	{
		m_wingmanArray.at(i)->reuse();
	}

	if (m_pArmature)
	{
		m_pArmature->setColor(Color3B::WHITE);
		m_pArmature->getAnimation()->play(GlobalData::getInstance()->getArmatureData(m_data.armatureName)->defaultAction);
	}
	else
	{
		this->setColor(Color3B::WHITE);
	}

	resume();

	m_bRecycled = false;
}

//是否已回收（是否可用）
bool Aircraft::isRecycled()
{
	return m_bRecycled;
}

　　

转载请注明：http://www.cnblogs.com/thorqq/p/6323156.html