cocos2dx 植物大战僵尸 19 读报僵尸

今天实现读报僵尸，需要对僵尸类进行重写一下，目前的代码结构并不能很好地实现读报僵尸。

class ZombieBase : public Entity
{
SDL_BOOL_SYNTHESIZE(m_bDead,Dead);//是否死亡
SDL_SYNTHESIZE(int,m_nHitPoint,HitPoint);//当前血量
SDL_SYNTHESIZE(float,m_fCriticalPoint,CriticalPoint);//临界点
SDL_SYNTHESIZE(float,m_fBaseSpeed,BaseSpeed);//基础移动速度
SDL_SYNTHESIZE(int,m_nRow,Row);//当前行数
SDL_SYNTHESIZE(string,m_zombieName,ZombieName);//僵尸名称
SDL_SYNTHESIZE(ZombieDir,m_dir,ZombieDir);//僵尸当前移动方向
SDL_SYNTHESIZE(float,m_fColdDownTime,ColdDownTime);//攻击冷却时间
SDL_SYNTHESIZE(int,m_nDamage,Damage);//伤害值
protected:
Terrain*m_pAim;//当前塔基
ZombieDelegate*m_pDelegate;
MoveBehavior*m_pMoveBehavior;
HpBar*m_pHpBar;
Garnishry*m_pGarnishry;//饰品
protected:
static const int ANIMATION_TAG;
public:
ZombieBase();
~ZombieBase();

void setDelegate(ZombieDelegate*pDelegate);

void setAim(Terrain*plant);
Terrain*getAim();
void clearAim();
//设置饰品
void setGarnishry(Garnishry*garnishry);
Garnishry*getGarnishry();

bool isDying()const;
void hurt(int baseDamage,AttackType attackType);
void setMoveBehavior(MoveBehavior*behavior);
MoveBehavior*getMoveBehavior();
//绑定血量条
void bindHpBar(HpBar*hpBar);

virtual float getCurSpeed()const;
virtual Rect getCollisionBoundingBox()const;

virtual void update(float dt);
//活着更新函数
virtual void updateAlive(float dt) = 0;
//移动行为回调函数
virtual void performMove(float dt);
//受伤回调函数
virtual void onHurt();
//吞噬死亡回调函数
virtual void onSwallowDead();
//炸死回调函数
virtual void onBoomDead();
//死亡回调函数
virtual void onNormalDead();
//临界点死亡即为0回调函数
virtual void onCRPDead();
//饰品死亡函数
virtual void onGarnishryDead();
};临界点是所有僵尸共有的属性、所以把它放到僵尸基类中，同时，僵尸基类提供了很多hook钩子方法，负责对不同的情况做出相应的反应。
void ZombieBase::hurt(int baseDamage,AttackType attackType)
{
int afterDamage = baseDamage;
//调用饰品，吸收伤害
if (m_pGarnishry != nullptr && m_pGarnishry->getHitPoint() > 0)
{
afterDamage = m_pGarnishry->absorbDamage(baseDamage,attackType);
//如果饰品死亡，回调饰品死亡函数
if (m_pGarnishry->getHitPoint() <= 0)
onGarnishryDead();
}

if (afterDamage <= 0)
return ;

auto afterHP = this->getHitPoint() - afterDamage;
bool bDead = false;

if (afterHP <= 0)
{
afterHP = 0;
bDead = true;
}
this->setHitPoint(afterHP);
//设置血量条
if (m_pHpBar != nullptr)
{
m_pHpBar->setValue((float)afterHP);
}
onHurt();
//如果死亡，回调死亡函数
if (bDead)
{
if (attackType == AttackType::Swallow)
{
onSwallowDead();
}
else if (attackType == AttackType::Boom)
{
onBoomDead();
}
else
{
onNormalDead();
}
}
}后面增加了僵尸的死亡回调函数，分为吞噬(Swallow),炸死(Boom),正常死亡(Normal，然后进行回调不同的方法。

void ZombieBase::bindHpBar(HpBar*hpBar)
{
m_pHpBar = hpBar;

this->addChild(m_pHpBar);
}

以前的代码中，僵尸类只是保存了对饰品的引用而已，这里添加到僵尸类中，因为有的僵尸的饰品是需要显示在游戏中的。

void ZombieBase::update(float dt)
{
//当前僵尸血量小于0，死亡
if (this->getHitPoint() <= 0)
{
auto afterCRP = this->getCriticalPoint() - 0.4f;
this->setCriticalPoint(afterCRP);
//僵尸真正死亡
if (afterCRP <= 0.f)
{
onCRPDead();
}
}
else
{
updateAlive(dt);
}

performMove(dt);
}

update()函数也进行了更新，同样把临界点的操作放到了基类中，并且只有在僵尸还没死亡时才会调用updateAlive()函数。
void ZombieBase::performMove(float dt)
{
if (m_pMoveBehavior)
m_pMoveBehavior->performMove(this);
}perrformMove也是为了子类做出的扩展。
void ZombieBase::onNormalDead()
{
this->setDead(true);
}

void ZombieBase::onCRPDead()
{
this->setDead(true);
//显示死亡动画
m_pDelegate->showZombieDie(this->getPosition());
}

void ZombieBase::onSwallowDead()
{
this->setDead(true);
}

void ZombieBase::onBoomDead()
{
this->setDead(true);
m_pDelegate->showZombieBoomDie(this->getPosition());
}

void ZombieBase::onGarnishryDead()
{
}僵尸基类中对虚函数都定义了一个实现，如果子类和父类的需求不同重写这些方法就可以了。
接下来就是僵尸类了，以前的实现是让僵尸一开始处于站立状态，然后在updateAlive()中切换成行走状态，这里打算直接就是运动状态。站立动画只有在画面右移的时候能看到，是为了大概显示出当前关卡的僵尸的种类和相对的数目，我打算使用精灵显示这站立动画而不是僵尸类。

bool Zombie::init(const string&zombieName)
{
this->setZombieName(zombieName);
//设置类型todo
m_nType = 1;

//获取行走状态贴图
auto animationName = StringUtils::format("%sWalk%02d",m_zombieName.c_str(),m_nType);
auto animation = AnimationCache::getInstance()->getAnimation(animationName);
//设置贴图
auto firstFrame = animation->getFrames().front()->getSpriteFrame();

m_pSprite = Sprite::createWithSpriteFrame(firstFrame);

auto size = m_pSprite->getContentSize();

m_pSprite->setPosition(size.width/2,size.height/2);

this->setContentSize(size);
this->addChild(m_pSprite);
//运行动画
auto animate = Animate::create(animation);
animate->setTag(ANIMATION_TAG);

m_pSprite->runAction(animate);
//设置状态
m_state = State::Walk;

return true;
}这里只是简单地更改了贴图和动画以及状态。
void Zombie::updateAlive(float dt)
{
if (m_state == State::Idle)
return;
//当前存在攻击目标
if (m_pAim != nullptr)
{
if (m_pAim->getInnerPlant() != nullptr)
{
this->changeState(State::Attack);
m_elapsed += dt;
//到达攻击时间
if (m_elapsed >= this->getColdDownTime())
{
m_elapsed -= this->getColdDownTime();
//进行攻击
auto topPlant = m_pDelegate->getTopPlant(m_pAim);
topPlant->hurt(this->getDamage());
}
}
else//重新计时
{
this->clearAim();
m_elapsed = 0.f;
}

}
//没有攻击目标，行走
else if (m_pAim == nullptr)
{
this->changeState(State::Walk);
}
}updateAlive的更新就是，如果当前处于Idle状态，则不再进行其他的更新，算是对读报僵尸的一些改变。然后就是读报僵尸的实现了，读报僵尸类似于一般的僵尸，只不过多了一个报纸饰品，并且在饰品死亡后会发怒，主要的难题就是这些动画的更改，其他都好说，毕竟僵尸基类和僵尸类都为读报僵尸进行了更改。
class PaperZombie : public Zombie
{
private:
bool m_bIsAngry;//读报僵尸是否生气
public:
PaperZombie();
~PaperZombie();
static PaperZombie*create(const string&zombieName);
bool init(const string&zombieName);
protected:
virtual void changeState(State state);
virtual void showZombieHead();
virtual float getCurSpeed()const;
virtual void onGarnishryDead();
virtual void onCRPDead();
};读报僵尸是僵尸的子类，这样实现的就没那么多了，注意下面的虚函数，读报僵尸只要写下这些代码就能实现刚才所说的逻辑了，这就是刚才重写的好处，另外项目就是这样，没有哪个代码是一成不变的。

void PaperZombie::changeState(State state)
{
//状态没有发生改变，直接退出
if (m_state == state)
return ;

m_state = state;
string animationName;
int status = m_bIsAngry ? 0 : 1;

if (m_state == State::Walk)
{
animationName = StringUtils::format("%sWalk%d",m_zombieName.c_str(),status);
}
else if (m_state == State::Attack)
{
animationName = StringUtils::format("%sAttack%d",m_zombieName.c_str(),status);
}
else if (m_state == State::WalkDead)
{
animationName = StringUtils::format("%sLostHeadWalk%d",m_zombieName.c_str(),status);

this->showZombieHead();
}
else if (m_state == State::AttackDead)
{
animationName = StringUtils::format("%sLostHeadAttack%d",m_zombieName.c_str(),status);

this->showZombieHead();
}
//改变的状态没有动画，则直接返回
if (animationName.empty())
{
return;
}
//停止原先的动画
this->getSprite()->stopActionByTag(ANIMATION_TAG);

auto animation = AnimationCache::getInstance()->getAnimation(animationName);
auto animate = Animate::create(animation);
animate->setTag(ANIMATION_TAG);

this->getSprite()->runAction(animate);
}

这里需要注意的是，读报僵尸是有两套动画的，一套是发怒前，即报纸还在的情况下，一个是发怒后，这两个的行走，攻击动画都是不同的，其他的则是通用的。
void PaperZombie::showZombieHead()
{
//调整位置
Point bornPos = this->getPosition();
Size size = this->getContentSize();

bornPos.x += size.width/4.f;

m_pDelegate->showPaperZombieHead(bornPos);
}和僵尸类类似，只不过改变了要显示的是哪个特效

float PaperZombie::getCurSpeed()const
{
auto speed = this->getBaseSpeed();

if (m_bIsAngry)
speed *= 2.f;

return speed;
}

这里表示僵尸发怒后会加速，目前加速一倍。
void PaperZombie::onGarnishryDead()
{
m_bIsAngry = true;
//改为站立状态
this->changeState(State::Idle);
//停止原先动画
m_pSprite->stopActionByTag(ANIMATION_TAG);
//报纸掉落动画
auto animationName = "PaperZombieLostNewspaper";
auto animation = AnimationCache::getInstance()->getAnimation(animationName);
Animate*animate = Animate::create(animation);
animate->setTag(ANIMATION_TAG);

DelayTime*delay = DelayTime::create(animate->getDuration());
CallFunc*end = CallFunc::create([this]()
{
this->changeState(State::Walk);
});
auto seq = Sequence::createWithTwoActions(delay,end);

this->stopAllActions();
//开始动画
m_pSprite->runAction(animate);
this->runAction(seq);
}这里是饰品死亡后的回调函数，在这里读报僵尸会停止运动，并且会显示报纸掉落动画，之后开始发怒。
void PaperZombie::onCRPDead()
{
this->setDead(true);
//显示死亡动画
m_pDelegate->showPaperZombieDie(this->getPosition());
}
这个则是在临界点，即僵尸彻底死亡后的回调函数，这里调用的也是特效，因为读报僵尸和普通僵尸穿着打扮并不同。接着就是饰品报纸的实现了。

class Paper : public Garnishry
{
SDL_SYNTHESIZE(int,m_nHitPoint,HitPoint);//当前血量
private:
HpBar*m_pHpBar;
public:
Paper();
~Paper();
static Paper*create(int hp);
bool init(int hp);

virtual int absorbDamage(int baseDamage,AttackType attackType);
};

bool Paper::init(int hp)
{
this->setHitPoint(hp);
this->setType(Type::Common);
//添加血量条
m_pHpBar = HpBar::create("hpBar2.png","hpBarBG.png",(float)hp);
auto size = m_pHpBar->getContentSize();

m_pHpBar->setPosition(size.width/2.f,size.height/2.f);

this->addChild(m_pHpBar);
this->setContentSize(size);

return true;
}

int Paper::absorbDamage(int baseDamage,AttackType attackType)
{
int afterDamage = 0;
//跟踪性子弹，无法吸收
if (attackType == AttackType::Track)
{
afterDamage = baseDamage;
}
else//吸收伤害TODO
{
auto afterHP = this->getHitPoint() - baseDamage;
//饰品即将死亡
if (afterHP <= 0)
{
afterDamage = SDL_abs(afterHP);
afterHP = 0;
}
this->setHitPoint(afterHP);
m_pHpBar->setValue((float)afterHP);
}
return afterDamage;
}

报纸中添加了一个血条，表示当前的血量。同时absorbDamage()也需要对以后实现的屋顶类，大喷菇作个扩展，屋顶类植物是可以直接攻击到读报僵尸本身的，而大喷菇这种穿透型植物是一起伤害的。接着就是在ZombieFactory中实现对应的方法进行创建。

PaperZombie*ZombieFactory::createPaperZombie(const string&zombieName)
{
auto zombie = PaperZombie::create(zombieName);
//设置基础属性
zombie->setDead(false);
zombie->setHitPoint(200);
zombie->setBaseSpeed(0.15f);
zombie->setColdDownTime(1.f);
zombie->setDamage(100);
zombie->setCriticalPoint(70.f);
//添加血条
auto pos = this->bindHpBarForZombie(zombie);
//添加报纸装饰品
Paper*paper = Paper::create(150);
auto paperSize = paper->getContentSize();

zombie->setGarnishry(paper);

paper->setPosition(pos - Point(0,paperSize.height));

return zombie;
}

这里创建了一个读报僵尸，并且添加了饰品类。另外就是血条我封装了一个方法，因为所有的僵尸的血条都是类似的。

Point ZombieFactory::bindHpBarForZombie(ZombieBase*zombie)
{
HpBar*hpBar = HpBar::create("hpBar1.png","hpBarBG.png",200.f);
//设置血条位置
auto rect = zombie->getSprite()->getSpriteFrameRect();
Size size = zombie->getContentSize();
Point pos = Point(rect.origin.x + rect.size.width/2,rect.size.height/2 - size.height/2);

hpBar->setPosition(pos);

zombie->bindHpBar(hpBar);

return pos;
}

特效层函数的增加不再叙述。另外，大家有什么意见或者建议的话可以评论，有什么要批评的话也可以说，有则改之，无则加勉。本节截图。



可以看到，读报僵尸有两个血条，一个是报纸的，一个是自己本身的血条，因为目前的豌豆只能先打死报纸才能攻击到读报僵尸，所以这里读报僵尸的血量并没有减少。值得一提的是，读报僵尸卡片也需要添加，这里不再赘述。