collecting exp/gold reward in battle state

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

diff --git a/src/battle/BattleState.h b/src/battle/BattleState.h
index 40dd51d9f671d8b79fb8a9c63d72d2586ad62c14..9f30fb5a1d439effc3b4ef8857ac1d7d69d1df60 100644 (file)
--- a/src/battle/BattleState.h
+++ b/src/battle/BattleState.h
@@ -22,6 +22,7 @@
 #include "../graphics/Animation.h"
 #include "../graphics/Menu.h"
 
+#include <cassert>
 #include <vector>
 #include <SDL.h>
 
@@ -41,6 +42,7 @@ namespace graphics {
 namespace battle {
 
 class PartyLayout;
+class Stats;
 
 class BattleState
 : public app::State {
@@ -55,7 +57,10 @@ public:
        , moveMenu(res->moveIcons)
        , numHeroes(0)
        , activeHero(-1)
-       , ranAway(false) { }
+       , attackCursor(-1)
+       , expReward(0)
+       , goldReward(0)
+       , ranAway(false) { assert(background && res); }
 
 public:
        void AddMonster(const Monster &);
@@ -73,6 +78,7 @@ public:
        virtual void UpdateWorld(float deltaT);
        virtual void Render(SDL_Surface *);
 
+       // TODO: turn this mess into a well stuctured interface
 public:
        const Resources &Res() const { return *res; }
        AttackTypeMenu &GetAttackTypeMenu() { return attackTypeMenu; }
@@ -92,18 +98,21 @@ public:
        Hero &ActiveHero() { return heroes[activeHero]; }
        const Hero &ActiveHero() const { return heroes[activeHero]; }
 
-       Hero &HeroAt(int index) { return heroes[index]; }
-       const Hero &HeroAt(int index) const { return heroes[index]; }
-       Monster &MonsterAt(int index) { return monsters[index]; }
-       const Monster &MonsterAt(int index) const { return monsters[index]; }
-
-       const HeroTag &HeroTagAt(int index) const { return heroTags[index]; }
-       const geometry::Point<int> &HeroTagPositionAt(int index) const { return heroTagPositions[index]; }
-
-       bool HasChosenAttackType() const { return attackChoices[activeHero].GetType() != AttackChoice::UNDECIDED; }
-       AttackChoice &ActiveHeroAttackChoice() { return attackChoices[activeHero]; }
-       const AttackChoice &ActiveHeroAttackChoice() const { return attackChoices[activeHero]; }
-       const AttackChoice &AttackChoiceAt(int index) const { return attackChoices[index]; }
+       Hero &HeroAt(int index) { assert(index >= 0 && index < NumHeroes()); return heroes[index]; }
+       const Hero &HeroAt(int index) const { assert(index >= 0 && index < NumHeroes()); return heroes[index]; }
+       Monster &MonsterAt(int index) { assert(index >= 0 && index < NumHeroes()); return monsters[index]; }
+       const Monster &MonsterAt(int index) const { assert(index >= 0 && index < NumHeroes()); return monsters[index]; }
+
+       const HeroTag &HeroTagAt(int index) const { assert(index >= 0 && index < NumHeroes()); return heroTags[index]; }
+       const geometry::Point<int> &HeroTagPositionAt(int index) const { assert(index >= 0 && index < NumHeroes()); return heroTagPositions[index]; }
+
+       bool HasChosenAttackType() const { return ActiveHeroAttackChoice().GetType() != AttackChoice::UNDECIDED; }
+       AttackChoice &ActiveHeroAttackChoice() { return AttackChoiceAt(activeHero); }
+       const AttackChoice &ActiveHeroAttackChoice() const { return AttackChoiceAt(activeHero); }
+       AttackChoice &AttackChoiceAt(int index) { assert(index >= 0 && index < NumHeroes()); return attackChoices[index]; }
+       const AttackChoice &AttackChoiceAt(int index) const { assert(index >= 0 && index < NumHeroes()); return attackChoices[index]; }
+       AttackChoice &MonsterAttackChoiceAt(int index) { assert(index >= 0 && index < MaxMonsters()); return monsterAttacks[index]; }
+       const AttackChoice &MonsterAttackChoiceAt(int index) const { assert(index >= 0 && index < MaxMonsters()); return monsterAttacks[index]; }
        bool AttackSelectionDone() const { return activeHero >= numHeroes; }
 
        int NumHeroes() const { return numHeroes; }
@@ -116,16 +125,34 @@ public:
        bool HeroPositionOccupied(int index) const { return index >= 0 && index < numHeroes; }
 
        void SetRunaway() { ranAway = true; }
+
+       struct Order {
+               Order(int index, bool isMonster)
+               : index(index), isMonster(isMonster) { }
+               int index;
+               bool isMonster;
+       };
+
+       void CalculateAttackOrder();
+       void NextAttack();
+       bool AttacksFinished() const;
+       void CalculateDamage();
+       void ApplyDamage();
+       const Order &CurrentAttack() const { assert(attackCursor >= 0 && attackCursor < int(attackOrder.size())); return attackOrder[attackCursor]; };
+       AttackChoice &CurrentAttackAttackChoice();
        void ClearAllAttacks();
 
+       bool Victory() const;
+       bool Defeat() const;
+
 public:
        geometry::Vector<int> CalculateScreenOffset(SDL_Surface *screen) const {
                return geometry::Vector<int>(
                                (screen->w - background->w) / 2,
                                (screen->h - background->h) / 2);
        }
-       int BackgroundWidth() const { return background->w; }
-       int BackgroundHeight() const { return background->h; }
+       int Width() const { return background->w; }
+       int Height() const { return background->h; }
 
        void RenderBackground(SDL_Surface *screen, const geometry::Vector<int> &offset);
        void RenderMonsters(SDL_Surface *screen, const geometry::Vector<int> &offset);
@@ -138,6 +165,8 @@ private:
        void LoadIkariMenu(std::vector<Hero>::size_type heroIndex);
        void LoadInventory();
 
+       Uint16 CalculateDamage(const Stats &attacker, const Stats &defender) const;
+
 private:
        SDL_Surface *background;
        const PartyLayout *monstersLayout;
@@ -149,6 +178,8 @@ private:
        std::vector<geometry::Point<int> > monsterPositions;
        std::vector<geometry::Point<int> > heroesPositions;
        std::vector<Monster> monsters;
+       std::vector<AttackChoice> monsterAttacks;
+       std::vector<Order> attackOrder;
        Hero heroes[4];
        graphics::Menu<const common::Spell *> spellMenus[4];
        graphics::Menu<const common::Item *> itemMenu;
@@ -160,6 +191,9 @@ private:
        AttackChoice attackChoices[4];
        int numHeroes;
        int activeHero;
+       int attackCursor;
+       int expReward;
+       int goldReward;
        bool ranAway;
 
 };