Initial work on battling

src/Battling/Library/BattleLibrary.cpp

@@ -0,0 +1,5 @@
+#include "BattleLibrary.hpp"
+
+const CreatureLib::Battling::BattleStatCalculator *CreatureLib::Battling::BattleLibrary::GetStatCalculator() const {
+    return _statCalculator;
+}

src/Battling/Library/BattleLibrary.hpp

@@ -0,0 +1,14 @@
+#ifndef CREATURELIB_BATTLELIBRARY_HPP
+#define CREATURELIB_BATTLELIBRARY_HPP
+
+#include "BattleStatCalculator.hpp"
+
+namespace CreatureLib::Battling {
+    class BattleLibrary {
+        BattleStatCalculator* _statCalculator;
+    public:
+        const BattleStatCalculator* GetStatCalculator() const;
+    };
+}
+
+#endif //CREATURELIB_BATTLELIBRARY_HPP

src/Battling/Library/BattleStatCalculator.cpp

@@ -0,0 +1,39 @@
+#include "BattleStatCalculator.hpp"
+#include "../Models/BattleCreature.hpp"
+
+using namespace CreatureLib;
+
+Core::StatisticSet<uint32_t>
+Battling::BattleStatCalculator::CalculateStats(Battling::BattleCreature *creature) const {
+    return Core::StatisticSet<uint32_t>(
+            CalculateStat(creature, Core::Statistic::Health),
+            CalculateStat(creature, Core::Statistic::PhysicalAttack),
+            CalculateStat(creature, Core::Statistic::PhysicalDefense),
+            CalculateStat(creature, Core::Statistic::MagicalAttack),
+            CalculateStat(creature, Core::Statistic::MagicalDefense),
+            CalculateStat(creature, Core::Statistic::Speed)
+            );
+}
+
+uint32_t CalculateHealthStat(Battling::BattleCreature *creature){
+    auto base = creature->GetBackingCreature();
+    auto level = creature->GetLevel();
+    auto a = (base->GetBaseStat(Core::Statistic::Health) + base->GetStatPotential(Core::Statistic::Health)) * 2 +
+            floor(sqrt(base->GetStatExperience(Core::Statistic::Health) / 4)) * level;
+    return floor(a / 100) + level + 10;
+}
+
+uint32_t CalculateOtherStat(Battling::BattleCreature *creature, Core::Statistic stat){
+    auto base = creature->GetBackingCreature();
+    auto level = creature->GetLevel();
+    auto a = (base->GetBaseStat(stat) + base->GetStatPotential(stat)) * 2 +
+             floor(sqrt(base->GetStatExperience(stat) / 4)) * level;
+    return floor(a / 100) + 10;
+}
+
+
+uint32_t Battling::BattleStatCalculator::CalculateStat(Battling::BattleCreature *creature, Core::Statistic stat) const{
+    if (stat == Core::Statistic::Health)
+        return CalculateHealthStat(creature);
+    return CalculateOtherStat(creature, stat);
+}

src/Battling/Library/BattleStatCalculator.hpp

@@ -0,0 +1,17 @@
+#ifndef CREATURELIB_BATTLESTATCALCULATOR_HPP
+#define CREATURELIB_BATTLESTATCALCULATOR_HPP
+
+#include "../../Core/StatisticSet.hpp"
+
+namespace CreatureLib::Battling {
+    //predeclare BattleCreature class
+    class BattleCreature;
+
+    class BattleStatCalculator {
+    public:
+        virtual Core::StatisticSet<uint32_t > CalculateStats(BattleCreature* creature) const;
+        virtual uint32_t CalculateStat(BattleCreature* creature, Core::Statistic stat) const;
+    };
+}
+
+#endif //CREATURELIB_BATTLESTATCALCULATOR_HPP

src/Battling/Models/Battle.cpp

@@ -0,0 +1,5 @@
+#include "Battle.hpp"
+
+const CreatureLib::Battling::BattleLibrary *CreatureLib::Battling::Battle::GetLibrary() const {
+    return _library;
+}

src/Battling/Models/Battle.hpp

@@ -0,0 +1,18 @@
+#ifndef CREATURELIB_BATTLE_HPP
+#define CREATURELIB_BATTLE_HPP
+
+#include <vector>
+#include "BattleSide.hpp"
+#include "../Library/BattleLibrary.hpp"
+
+namespace CreatureLib::Battling {
+    class Battle {
+        const BattleLibrary* _library;
+        std::vector<BattleSide*> _sides;
+    public:
+        const BattleLibrary* GetLibrary() const;
+    };
+}
+
+
+#endif //CREATURELIB_BATTLE_HPP

src/Battling/Models/BattleCreature.cpp

@@ -0,0 +1,37 @@
+#include "BattleCreature.hpp"
+#include "../Models/Battle.hpp"
+
+using namespace CreatureLib;
+
+Battling::BattleCreature::BattleCreature(Battling::Battle *battle,
+                                                      Library::Creature *creature)
+                                                      :__Battle(battle),
+                                                       __Level(creature->GetLevel()),
+                                                       _creature(creature),
+                                                       _statBoost(Core::StatisticSet<int8_t >())
+{
+
+}
+
+const Library::Creature* Battling::BattleCreature::GetBackingCreature() {
+    return _creature;
+}
+
+void Battling::BattleCreature::ApplyPostBattleEffects() {
+
+}
+
+uint32_t Battling::BattleCreature::GetStat(Core::Statistic stat) {
+    return _fullStats.GetStat(stat);
+}
+
+void Battling::BattleCreature::RecalculateStats() {
+    this->_fullStats = this->__Battle->GetLibrary()->GetStatCalculator()->CalculateStats(this);
+}
+
+void Battling::BattleCreature::RecalculateStat(Core::Statistic stat) {
+    auto s = this->__Battle->GetLibrary()->GetStatCalculator()->CalculateStat(this, stat);
+    this->_fullStats.SetStat(stat, s);
+}
+
+

src/Battling/Models/BattleCreature.hpp

@@ -0,0 +1,34 @@
+#ifndef CREATURELIB_BATTLECREATURE_HPP
+#define CREATURELIB_BATTLECREATURE_HPP
+
+#include "../../GenericTemplates.cpp"
+#include "../../Library/Creature.hpp"
+
+namespace CreatureLib::Battling{
+    // Forward declare battle class
+    class Battle;
+
+    class BattleCreature {
+        GetProperty(Battle*, Battle);
+        GetProperty(uint8_t, Level);
+
+    private:
+        Library::Creature* _creature;
+        Core::StatisticSet<int8_t > _statBoost;
+        Core::StatisticSet<uint32_t > _fullStats;
+
+    public:
+        BattleCreature(Battle* battle, Library::Creature* creature);
+
+        const Library::Creature* GetBackingCreature();
+        void ApplyPostBattleEffects();
+
+        uint32_t GetStat(Core::Statistic stat);
+        void RecalculateStats();
+
+        void RecalculateStat(Core::Statistic);
+    };
+}
+
+
+#endif //CREATURELIB_BATTLECREATURE_HPP

src/Battling/Models/BattleSide.cpp

@@ -0,0 +1 @@
+#include "BattleSide.hpp"

src/Battling/Models/BattleSide.hpp

@@ -0,0 +1,14 @@
+#ifndef CREATURELIB_BATTLESIDE_HPP
+#define CREATURELIB_BATTLESIDE_HPP
+
+#include <vector>
+#include "BattleCreature.hpp"
+
+namespace CreatureLib::Battling{
+    class BattleSide {
+        std::vector<BattleCreature*> _creatures;
+    };
+}
+
+
+#endif //CREATURELIB_BATTLESIDE_HPP

src/Battling/Models/BattleTeam.cpp

@@ -0,0 +1 @@
+#include "BattleTeam.hpp"

src/Battling/Models/BattleTeam.hpp

@@ -0,0 +1,10 @@
+#ifndef CREATURELIB_BATTLETEAM_HPP
+#define CREATURELIB_BATTLETEAM_HPP
+
+
+class BattleTeam {
+
+};
+
+
+#endif //CREATURELIB_BATTLETEAM_HPP