void RepairHpBar::setHp(int maxHp, int currentHp)
{
if (maxHp<=0)
{
log("maxHp is below zero");
maxHp=1;
}
this->maxHp=maxHp;
setCurrHp(currentHp);
}
void Arrow::removeBullet()
{
bool isMissed = true;
auto instance = GameManager::getInstance();
auto bulletRect = Rect(this->getPositionX() +this->getParent()->getPositionX() - this->getContentSize().width /2,
this->getPositionY() +this->getParent()->getPositionY() - this->getContentSize().height/2,
this->sprite->getContentSize().width,
this->sprite->getContentSize().height );
auto monsterVector = instance->monsterVector;
for (int j = 0; j < monsterVector.size(); j++)
{
auto monster = monsterVector.at(j);
auto monsterRect = monster->baseSprite->getBoundingBox();
if (monsterRect.intersectsRect(bulletRect) && monster->getAttackBySoldier())
{
auto currHp = monster->getCurrHp();
currHp = currHp - this->getMaxForce() + monster->getArmor();
if(currHp <= 0){
currHp = 0;
}
monster->setCurrHp( currHp );
monster->getHpBar()->setPercentage((currHp/monster->getMaxHp())*100);
monster->getHurt();
isMissed = false;
if(currHp == 0){
monster->death();
}
break;
}
}
if(isMissed){
sprite->setSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("decal_arrow.png"));
sprite->runAction(Sequence::create(FadeOut::create(1.0f)
,CallFuncN::create(CC_CALLBACK_0(Bullet::removeFromParent, this))
, NULL));
}else{
this->removeFromParent();
}
}
ReinforceSoldier2* ReinforceSoldier2::createReinforceSoldier(Point point)
{
auto reinforceSoldier = new ReinforceSoldier2();
if (reinforceSoldier && reinforceSoldier->init())
{
reinforceSoldier->setLocation(point);
reinforceSoldier->setMaxHp(80);
reinforceSoldier->setCurrHp(80);
reinforceSoldier->setForce(10);
reinforceSoldier->setState(SoldierStateNone);
reinforceSoldier->birth(point);
reinforceSoldier->autorelease();
return reinforceSoldier;
}
CC_SAFE_DELETE(reinforceSoldier);
return NULL;
}
EnemyDisableTower* EnemyDisableTower::createEnemyDisableTower(Vector<Node*> points, int hp)
{
auto dis = new EnemyDisableTower();
if (dis && dis->init())
{
dis->setPointsVector(points);
dis->runFollowPoint(); //这里就开始执行行走了
dis->autorelease();
dis->setMaxHp(hp);
dis->setCurrHp(hp);
return dis;
}
else
{
delete dis;
dis = nullptr;
return nullptr;
}
}
EnemyTest* EnemyTest::createEnemyTest(Vector<Node*> points, int hp)
{
auto test = new EnemyTest();
if (test && test->init())
{
test->setPointsVector(points);
test->runFollowPoint(); //这里就开始执行行走了
test->autorelease();
test->setMaxHp(hp);
test->setCurrHp(hp);
return test;
}
else
{
delete test;
test = nullptr;
return nullptr;
}
}
Raider* Raider::createMonster(std::vector<Point> points)
{
auto monster = new Raider();
if (monster && monster->init())
{
monster->setPointsVector(points);
monster->setMaxHp(160);
monster->setCurrHp(160);
monster->setMoney(30);
monster->setRunSpeed(40);
monster->setArmor(10);
monster->setForce(8);
monster->setAttackBySoldier(true);
monster->runNextPoint();
monster->autorelease();
return monster;
}
CC_SAFE_DELETE(monster);
return NULL;
}
Quetzal* Quetzal::createMonster(std::vector<Point> points)
{
auto monster = new Quetzal();
if (monster && monster->init())
{
monster->setPointsVector(points);
monster->setMaxHp(500);
monster->setCurrHp(500);
monster->setMoney(20);
monster->setForce(45);
monster->setArmor(10);
monster->setAttackBySoldier(false);
monster->setRunSpeed(60);
monster->runNextPoint();
monster->autorelease();
return monster;
}
CC_SAFE_DELETE(monster);
return NULL;
}
Gorilla* Gorilla::createMonster(std::vector<Point> points)
{
auto monster = new Gorilla();
if (monster && monster->init())
{
monster->setPointsVector(points);
monster->setMaxHp(2500);
monster->setCurrHp(2500);
monster->setMoney(500);
monster->setForce(60);
monster->setArmor(0);
monster->setAttackBySoldier(true);
monster->setRunSpeed(30);
monster->runNextPoint();
monster->autorelease();
return monster;
}
CC_SAFE_DELETE(monster);
return NULL;
}
Wolf* Wolf::createMonster(std::vector<Point> points)
{
auto monster = new Wolf();
if (monster && monster->init())
{
monster->setPointsVector(points);
monster->setMaxHp(35);
monster->setCurrHp(35);
monster->setRunSpeed(100);
monster->runNextPoint();
monster->setMoney(20);
monster->setArmor(0);
monster->setForce(2);
monster->setAttackBySoldier(true);
monster->autorelease();
return monster;
}
CC_SAFE_DELETE(monster);
return NULL;
}
Boss_Efreeti* Boss_Efreeti::createMonster(std::vector<Point> points,std::vector<std::vector<std::vector<Point>>> sonpath)
{
auto monster = new Boss_Efreeti();
if (monster && monster->init())
{
monster->setPointsVector(points);
monster->setMaxHp(5550);
monster->setCurrHp(5550);
monster->setMoney(1500);
monster->sonPath = sonpath;
monster->setForce(50);
monster->setArmor(10);
monster->setAttackByTower(true);
monster->setAttackBySoldier(true);
monster->setRunSpeed(20);
monster->runNextPoint();
monster->autorelease();
return monster;
}
CC_SAFE_DELETE(monster);
return NULL;
}
bool Thief::init()
{
if (!Sprite::init())
{
return false;
}
setRunSpeed(9);
setMaxHp(10);
setCurrHp(10);
sprite = Sprite::createWithSpriteFrameName("enemyRight1_1.png");
this->addChild(sprite);
animationRight = createAnimation("enemyRight1", 4, 0.1f);
AnimationCache::getInstance()->addAnimation(animationRight, "runright");
animationLeft = createAnimation("enemyLeft1", 4, 0.1f);
AnimationCache::getInstance()->addAnimation(animationLeft, "runleft");
animationExplode= createAnimation("explode", 6, 0.15f);
AnimationCache::getInstance()->addAnimation(animationExplode, "explode");
createAndSetHpBar();
schedule(schedule_selector(EnemyBase::changeDirection), 0.4f);
return true;
}
Tremor* Tremor::createMonster(std::vector<Point> points)
{
auto monster = new Tremor();
if (monster && monster->init())
{
monster->setPointsVector(points);
monster->setMaxHp(35);
monster->setCurrHp(35);
monster->setMoney(10);
monster->setForce(4);
monster->setArmor(0);
monster->setForce(8);
monster->setAttackByTower(false);
monster->setAttackBySoldier(true);
monster->setRunSpeed(50);
monster->runNextPoint();
monster->autorelease();
return monster;
}
CC_SAFE_DELETE(monster);
return NULL;
}
void PlayLayer::update(float dt)
{
GameManager *instance = GameManager::getInstance();
auto bulletVector = instance->bulletVector;
auto enemyVector = instance->enemyVector;
auto towerVector = instance->towerVector;
if(chooseTowerpanle != NULL )
{
auto type = chooseTowerpanle->getChooseTowerType();
if( type == TowerType::ARROW_TOWER)
{
TowerBase* tower = ArrowTower::create();
tower->setPosition(towerPos);
this->addChild(tower);
instance->towerVector.pushBack(tower);
type = TowerType::ANOTHER;
chooseTowerpanle->setChooseTowerType(type);
}
}
Vector<EnemyBase*> enemyNeedToDelete;
Vector<Sprite*> bulletNeedToDelete;
// 碰撞检测
for (int i = 0; i < bulletVector.size(); i++)
{
auto bullet = bulletVector.at(i);
bullet->boundingBox();
auto bulletRect = Rect(bullet->getPositionX()+bullet->getParent()->getPositionX() - bullet->getContentSize().width / 2,
bullet->getPositionY() +bullet->getParent()->getPositionY() - bullet->getContentSize().height / 2,
bullet->getContentSize().width,
bullet->getContentSize().height );
for (int j = 0; j < enemyVector.size(); j++)
{
auto enemy = enemyVector.at(j);
auto enemyRect = enemy->sprite->boundingBox();
if (bulletRect.intersectsRect(enemyRect))
{
auto currHp = enemy->getCurrHp();
currHp--;
enemy->setCurrHp( currHp );
auto currHpPercentage = enemy->getHpPercentage();
auto offHp = 100 / enemy->getMaxHp();
currHpPercentage -= offHp;
if(currHpPercentage < 0){
currHpPercentage = 0;
}
enemy->setHpPercentage(currHpPercentage);
enemy->getHpBar()->setPercentage(currHpPercentage);
if(currHp <= 0)
{
enemyNeedToDelete.pushBack(enemy);
}
bulletNeedToDelete.pushBack( bullet);
}
}
for (EnemyBase* enemyTemp : enemyNeedToDelete)
{
enemyTemp->enemyExpload();
instance->enemyVector.eraseObject(enemyTemp);
}
enemyNeedToDelete.clear();
}
for (const auto& bulletTemp : bulletNeedToDelete)
{
instance->bulletVector.eraseObject(bulletTemp);
bulletTemp->removeFromParent();
}
bulletNeedToDelete.clear();
}
