added capsule attack/animation handling

[l2e.git] / src / battle / BattleState.cpp

diff --git a/src/battle/BattleState.cpp b/src/battle/BattleState.cpp
index 9830e8c6a0b976f41f26642f024d34d2032e6e6e..0171e1480f56a7d52b905a86e577525d0a2597a0 100644 (file)
--- a/src/battle/BattleState.cpp
+++ b/src/battle/BattleState.cpp
@@ -177,9 +177,7 @@ class OrderCompare {
        public:
                OrderCompare(BattleState *battle) : battle(battle) { }
                bool operator ()(const BattleState::Order &lhs, const BattleState::Order &rhs) {
-                       int lagl(lhs.isMonster ? battle->MonsterAt(lhs.index).GetStats().Agility() : battle->HeroAt(lhs.index).GetStats().Agility());
-                       int ragl(rhs.isMonster ? battle->MonsterAt(rhs.index).GetStats().Agility() : battle->HeroAt(rhs.index).GetStats().Agility());
-                       return lagl > ragl;
+                       return lhs.GetStats(*battle).Agility() > rhs.GetStats(*battle).Agility();
                }
        private:
                BattleState *battle;
@@ -188,12 +186,15 @@ class OrderCompare {
 void BattleState::CalculateAttackOrder() {
        attackOrder.reserve(monsters.size() + NumHeroes());
        for (int i(0); i < NumHeroes(); ++i) {
-               attackOrder.push_back(Order(i, false));
+               attackOrder.push_back(Order(Order::HERO, i));
        }
        for (vector<Monster>::size_type i(0), end(monsters.size()); i < end; ++i) {
-               attackOrder.push_back(Order(i, true));
+               attackOrder.push_back(Order(Order::MONSTER, i));
                MonsterAt(i).GetAttackChoice() = AttackChoice(this);
        }
+       if (capsule.Health() > 0) {
+               attackOrder.push_back(Order(Order::CAPSULE));
+       }
        std::sort(attackOrder.begin(), attackOrder.end(), OrderCompare(this));
 }
 
@@ -204,10 +205,12 @@ void BattleState::NextAttack() {
        }
        ++attackCursor;
        while (attackCursor < int(attackOrder.size())) {
-               if (attackOrder[attackCursor].isMonster) {
+               if (attackOrder[attackCursor].IsMonster()) {
                        if (MonsterAt(attackOrder[attackCursor].index).Health() > 0) break;
-               } else {
+               } else if (attackOrder[attackCursor].IsHero()) {
                        if (HeroAt(attackOrder[attackCursor].index).Health() > 0) break;
+               } else {
+                       if (capsule.Health() > 0) break;
                }
                ++attackCursor;
        }
@@ -219,23 +222,20 @@ bool BattleState::AttacksFinished() const {
 }
 
 void BattleState::CalculateDamage() {
-       if (CurrentAttack().isMonster) {
+       if (CurrentAttack().IsMonster()) {
                DecideMonsterAttack(MonsterAt(CurrentAttack().index));
+       } else if (CurrentAttack().IsCapsule()) {
+               DecideCapsuleAttack();
        }
-       AttackChoice &ac(CurrentAttack().isMonster ? MonsterAt(CurrentAttack().index).GetAttackChoice() : HeroAt(CurrentAttack().index).GetAttackChoice());
+       AttackChoice &ac = CurrentAttack().GetAttackChoice(*this);
        if (ac.GetType() == AttackChoice::DEFEND) return;
        TargetSelection &ts(ac.Selection());
 
-       if (CurrentAttack().isMonster) {
-               const Stats &attackerStats(MonsterAt(CurrentAttack().index).GetStats());
-               CalculateDamage(attackerStats, ts);
-       } else {
-               const Stats &attackerStats(HeroAt(CurrentAttack().index).GetStats());
-               CalculateDamage(attackerStats, ts);
-       }
+       const Stats &attackerStats = CurrentAttack().GetStats(*this);
+       CalculateDamage(attackerStats, ts);
 }
 
-void BattleState::DecideMonsterAttack(Monster &m) const {
+void BattleState::DecideMonsterAttack(Monster &m) {
        AttackChoice &ac(m.GetAttackChoice());
        TargetSelection &ts(ac.Selection());
        ac.Reset();
@@ -249,6 +249,46 @@ void BattleState::DecideMonsterAttack(Monster &m) const {
        ts.Select(target);
 }
 
+void BattleState::DecideCapsuleAttack() {
+       AttackChoice &ac(capsule.GetAttackChoice());
+       TargetSelection &ts(ac.Selection());
+       ac.Reset();
+       int target(rand() % monsters.size());
+       while (!MonsterPositionOccupied(target)) {
+               target = rand() % monsters.size();
+       }
+       ac.SetType(AttackChoice::SWORD);
+       ts.SelectMonsters();
+       ts.SetSingle();
+       ts.Select(target);
+}
+
+AttackChoice &BattleState::Order::GetAttackChoice(BattleState &b) const {
+       switch (by) {
+               case HERO:
+                       return b.HeroAt(index).GetAttackChoice();
+               case CAPSULE:
+                       return b.GetCapsule().GetAttackChoice();
+               case MONSTER:
+                       return b.MonsterAt(index).GetAttackChoice();
+               default:
+                       throw std::runtime_error("invalid case in BttleStats::Order::GetAttackChoice()");
+       }
+}
+
+Stats &BattleState::Order::GetStats(BattleState &b) const {
+       switch (by) {
+               case HERO:
+                       return b.HeroAt(index).GetStats();
+               case CAPSULE:
+                       return b.GetCapsule().GetStats();
+               case MONSTER:
+                       return b.MonsterAt(index).GetStats();
+               default:
+                       throw std::runtime_error("invalid case in BttleStats::Order::GetAttackChoice()");
+       }
+}
+
 void BattleState::CalculateDamage(const Stats &attackerStats, TargetSelection &ts) const {
        bool hitSome(false);
        if (ts.TargetsMonsters()) {
@@ -304,7 +344,7 @@ Uint16 BattleState::CalculateDamage(const Stats &attacker, const Stats &defender
 
 void BattleState::ApplyDamage() {
        if (attackCursor < 0) return;
-       AttackChoice &ac(CurrentAttack().isMonster ? MonsterAt(CurrentAttack().index).GetAttackChoice() : HeroAt(CurrentAttack().index).GetAttackChoice());
+       AttackChoice &ac = CurrentAttack().GetAttackChoice(*this);
        TargetSelection &ts(ac.Selection());
        if (ts.TargetsMonsters()) {
                for (int i(0); i < MaxMonsters(); ++i) {
@@ -328,11 +368,7 @@ void BattleState::ApplyDamage() {
 }
 
 AttackChoice &BattleState::CurrentAttackAttackChoice() {
-       if (CurrentAttack().isMonster) {
-               return MonsterAt(CurrentAttack().index).GetAttackChoice();
-       } else {
-               return HeroAt(CurrentAttack().index).GetAttackChoice();
-       }
+       return CurrentAttack().GetAttackChoice(*this);
 }
 
 void BattleState::ClearAllAttacks() {
@@ -344,6 +380,7 @@ void BattleState::ClearAllAttacks() {
        for (int i(0); i < MaxMonsters(); ++i) {
                MonsterAt(i).GetAttackChoice() = AttackChoice(this);
        }
+       capsule.GetAttackChoice() = AttackChoice(this);
        attackOrder.clear();
 }