仿《雷霆战机》飞行射击手游开发--飞机（含源码库地址）
转载请注明：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;
}
