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 5898a2d4aa93920ffc9a5a20a1d366240d46de5c..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 {
@@ -56,7 +58,9 @@ public:
        , numHeroes(0)
        , activeHero(-1)
        , attackCursor(-1)
-       , ranAway(false) { }
+       , expReward(0)
+       , goldReward(0)
+       , ranAway(false) { assert(background && res); }
 
 public:
        void AddMonster(const Monster &);
@@ -74,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; }
@@ -93,19 +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]; }
-       AttackChoice &AttackChoiceAt(int index) { return attackChoices[index]; }
-       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; }
@@ -128,11 +135,16 @@ public:
 
        void CalculateAttackOrder();
        void NextAttack();
-       bool AttacksFinished() const { return attackCursor >= int(attackOrder.size()); }
+       bool AttacksFinished() const;
        void CalculateDamage();
-       const Order &CurrentAttack() const { return attackOrder[attackCursor]; };
+       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>(
@@ -153,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;
@@ -178,6 +192,8 @@ private:
        int numHeroes;
        int activeHero;
        int attackCursor;
+       int expReward;
+       int goldReward;
        bool ranAway;
 
 };