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