randomized monsters' attack target selection

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

diff --git a/src/battle/BattleState.cpp b/src/battle/BattleState.cpp
index 649470e894dd20e9db70c690a02d39cc938c15ac..fe821fc416ad6999a30e314858f9ca84da1ab885 100644 (file)
--- a/src/battle/BattleState.cpp
+++ b/src/battle/BattleState.cpp
@@ -22,6 +22,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstdlib>
 #include <stdexcept>
 
 using app::Application;
@@ -33,6 +34,7 @@ using geometry::Point;
 using geometry::Vector;
 using graphics::Menu;
 
+using std::rand;
 using std::vector;
 
 namespace battle {
@@ -78,9 +80,8 @@ void BattleState::Resize(int w, int h) {
 
 
 void BattleState::EnterState(Application &ctrl, SDL_Surface *screen) {
-       monstersLayout->CalculatePositions(background->w, background->h, monsterPositions);
-       heroesLayout->CalculatePositions(background->w, background->h, heroesPositions);
        for (int i(0); i < 4; ++i) {
+               heroes[i].Position() = heroesLayout->CalculatePosition(i, background->w, background->h);
                heroes[i].SpellMenu() = res->spellMenuPrototype;
                heroes[i].UpdateSpellMenu();
                heroes[i].IkariMenu() = res->ikariMenuPrototype;
@@ -89,6 +90,10 @@ void BattleState::EnterState(Application &ctrl, SDL_Surface *screen) {
                smallHeroTags[i] = SmallHeroTag(this, i);
        }
 
+       for (int i(0); i < int(monsters.size()); ++i) {
+               monsters[i].Position() = monstersLayout->CalculatePosition(i, background->w, background->h);
+       }
+
        int tagHeight(attackTypeMenu.Height());
        int tagWidth(attackTypeMenu.Width() * 2 + attackTypeMenu.Width() / 2);
        int xOffset((Width() - 2 * tagWidth) / 2);
@@ -217,26 +222,43 @@ bool BattleState::AttacksFinished() const {
 }
 
 void BattleState::CalculateDamage() {
+       if (CurrentAttack().isMonster) {
+               DecideMonsterAttack(MonsterAt(CurrentAttack().index));
+       }
        AttackChoice &ac(CurrentAttack().isMonster ? MonsterAt(CurrentAttack().index).GetAttackChoice() : HeroAt(CurrentAttack().index).GetAttackChoice());
        if (ac.GetType() == AttackChoice::DEFEND) return;
+       TargetSelection &ts(ac.Selection());
 
+       // TODO: this only evaluates SWORD type attacks
        if (CurrentAttack().isMonster) {
                const Stats &attackerStats(MonsterAt(CurrentAttack().index).GetStats());
-               // TODO: run monster's attack script
-               ac.SetType(AttackChoice::SWORD);
-               ac.Selection().SelectSingle();
-               ac.Selection().SelectHeroes();
-               for (int i(0); i < NumHeroes(); ++i) {
-                       if (HeroAt(i).Health() > 0) {
-                               const Stats &defenderStats(HeroAt(i).GetStats());
-                               Uint16 damage(CalculateDamage(attackerStats, defenderStats));
-                               ac.Selection().SetBad(0, damage);
-                               break;
+               if (ts.TargetsEnemies()) {
+                       for (int i(0); i < MaxMonsters(); ++i) {
+                               if (ts.IsSelected(i)) {
+                                       if (MonsterAt(i).Health() > 0) {
+                                               const Stats &defenderStats(MonsterAt(i).GetStats());
+                                               Uint16 damage(CalculateDamage(attackerStats, defenderStats));
+                                               ts.SetBad(i, damage);
+                                       } else {
+                                               ts.Unselect(i);
+                                       }
+                               }
+                       }
+               } else {
+                       for (int i(0); i < NumHeroes(); ++i) {
+                               if (ts.IsSelected(i)) {
+                                       if (HeroAt(i).Health() > 0) {
+                                               const Stats &defenderStats(HeroAt(i).GetStats());
+                                               Uint16 damage(CalculateDamage(attackerStats, defenderStats));
+                                               ts.SetBad(i, damage);
+                                       } else {
+                                               ts.Unselect(i);
+                                       }
+                               }
                        }
                }
        } else {
                const Stats &attackerStats(HeroAt(CurrentAttack().index).GetStats());
-               TargetSelection &ts(ac.Selection());
                bool hitSome(false);
                if (ts.TargetsEnemies()) {
                        for (int i(0); i < MaxMonsters(); ++i) {
@@ -286,6 +308,21 @@ void BattleState::CalculateDamage() {
        }
 }
 
+void BattleState::DecideMonsterAttack(Monster &m) {
+       AttackChoice &ac(m.GetAttackChoice());
+       TargetSelection &ts(ac.Selection());
+       ac.Reset();
+       // TODO: run monster's attack script
+       int target(rand() % NumHeroes());
+       while (!HeroPositionOccupied(target)) {
+               target = rand() % NumHeroes();
+       }
+       ac.SetType(AttackChoice::SWORD);
+       ts.SelectHeroes();
+       ts.SetSingle();
+       ts.Select(target);
+}
+
 Uint16 BattleState::CalculateDamage(const Stats &attacker, const Stats &defender) const {
        // TODO: find out real formula and add some randomness
        return attacker.Attack() / 2 - defender.Defense() / 4;
@@ -369,9 +406,9 @@ void BattleState::RenderMonsters(SDL_Surface *screen, const Vector<int> &offset)
        for (vector<Monster>::size_type i(0), end(monsters.size()); i < end; ++i) {
                if (MonsterPositionOccupied(i)) {
                        if (monsters[i].GetAnimation().Running()) {
-                               monsters[i].GetAnimation().DrawCenter(screen, monsterPositions[i] + offset);
+                               monsters[i].GetAnimation().DrawCenter(screen, monsters[i].Position() + offset);
                        } else {
-                               monsters[i].Sprite()->DrawCenter(screen, monsterPositions[i] + offset);
+                               monsters[i].Sprite()->DrawCenter(screen, monsters[i].Position() + offset);
                        }
                }
        }
@@ -381,10 +418,10 @@ void BattleState::RenderHeroes(SDL_Surface *screen, const Vector<int> &offset) {
        assert(screen);
        for (int i(0); i < numHeroes; ++i) {
                if (heroes[i].GetAnimation().Running()) {
-                       heroes[i].GetAnimation().DrawCenter(screen, heroesPositions[i] + offset);
+                       heroes[i].GetAnimation().DrawCenter(screen, heroes[i].Position() + offset);
                } else {
                        int row(heroes[i].Health() > 0 ? 0 : 2);
-                       heroes[i].Sprite()->DrawCenter(screen, heroesPositions[i] + offset, 1, row);
+                       heroes[i].Sprite()->DrawCenter(screen, heroes[i].Position() + offset, 1, row);
                }
        }
 }