Used ClangFormat style guide I'm happy with.

.clang-format

@@ -0,0 +1,121 @@
+# ClangFormatConfigureSource: 'LLVM'
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Merge
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        1
+  - Regex:           '.*'
+    Priority:        3
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseTab:          Never
+...

src/Battling/Flow/ChoiceQueue.hpp

@@ -9,11 +9,11 @@ namespace CreatureLib::Battling{
     class ChoiceQueue {
         std::vector<BaseTurnChoice*> _queue;
         size_t _current = 0;
+
     public:
         bool HasCompletedQueue = false;
 
-        explicit ChoiceQueue(std::vector<BaseTurnChoice*>  queue)
+        explicit ChoiceQueue(std::vector<BaseTurnChoice*> queue) : _queue(std::move(queue)) {}
-            :_queue(std::move(queue)){}
 
         BaseTurnChoice* Dequeue() {
             auto b = _queue[_current];
@@ -21,15 +21,10 @@ namespace CreatureLib::Battling{
             return b;
         }
 
-        [[nodiscard]] bool HasNext() const{
+        [[nodiscard]] bool HasNext() const { return _current < _queue.size(); }
-            return _current < _queue.size();
-        }
 
-        std::vector<BaseTurnChoice*>& GetInnerQueue(){
+        std::vector<BaseTurnChoice*>& GetInnerQueue() { return _queue; }
-            return _queue;
-        }
     };
 }
 
-
 #endif // CREATURELIB_CHOICEQUEUE_HPP

src/Battling/Flow/TurnHandler.cpp

@@ -1,6 +1,6 @@
 #include "TurnHandler.hpp"
-#include "../Models/Battle.hpp"
 #include "../../Core/Exceptions/NotImplementedException.hpp"
+#include "../Models/Battle.hpp"
 #include "../ScriptHandling/ScriptMacros.cpp"
 
 using namespace CreatureLib::Battling;
@@ -21,8 +21,7 @@ void TurnHandler::RunTurn(Battle* battle, ChoiceQueue* queue) {
 }
 
 void TurnHandler::ExecuteChoice(BaseTurnChoice* choice) {
-    if (choice == nullptr)
+    if (choice == nullptr) {
-    {
         return;
     }
     auto choiceKind = choice->GetKind();
@@ -46,12 +45,10 @@ void TurnHandler::ExecuteChoice(BaseTurnChoice *choice) {
 
     switch (choiceKind) {
         case TurnChoiceKind::Pass: throw NotReachableException();
-        case TurnChoiceKind::Attack:
+        case TurnChoiceKind::Attack: return ExecuteAttackChoice(dynamic_cast<AttackTurnChoice*>(choice));
-            return ExecuteAttackChoice(dynamic_cast<AttackTurnChoice*>(choice));
         case TurnChoiceKind::Item:
         case TurnChoiceKind::Switch:
-        case TurnChoiceKind::RunAway:
+        case TurnChoiceKind::RunAway: throw NotImplementedException();
-            throw NotImplementedException();
     }
 }
 
@@ -98,7 +95,8 @@ void TurnHandler::ExecuteAttackChoice(AttackTurnChoice *choice) {
     delete attack;
 }
 
-void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature *target, const ExecutingAttack::TargetData &targetData) {
+void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature* target,
+                                        const ExecutingAttack::TargetData& targetData) {
     auto user = attack->GetUser();
 
     ScriptSource* targetSource = target;
@@ -148,8 +146,7 @@ void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature *targe
 
         if (attackData->GetCategory() == Library::AttackCategory::Status) {
             HOOK(OnStatusMove, userSource, attack, target, hitIndex);
-        }
+        } else {
-        else{
             auto damage = hit.GetDamage();
             if (damage > target->GetCurrentHealth()) {
                 damage = target->GetCurrentHealth();

src/Battling/Flow/TurnHandler.hpp

@@ -1,9 +1,9 @@
 #ifndef CREATURELIB_TURNHANDLER_HPP
 #define CREATURELIB_TURNHANDLER_HPP
 
-#include "ChoiceQueue.hpp"
-#include "../TurnChoices/AttackTurnChoice.hpp"
 #include "../Models/ExecutingAttack.hpp"
+#include "../TurnChoices/AttackTurnChoice.hpp"
+#include "ChoiceQueue.hpp"
 
 namespace CreatureLib::Battling {
     class Battle;
@@ -12,7 +12,9 @@ namespace CreatureLib::Battling {
         static void ExecuteChoice(BaseTurnChoice* choice);
 
         static void ExecuteAttackChoice(AttackTurnChoice* choice);
-        static void HandleAttackForTarget(ExecutingAttack* attack, Creature* target, const ExecutingAttack::TargetData& targetData);
+        static void HandleAttackForTarget(ExecutingAttack* attack, Creature* target,
+                                          const ExecutingAttack::TargetData& targetData);
+
     public:
         static void RunTurn(Battle* battle, ChoiceQueue* queue);
     };

src/Battling/Flow/TurnOrdering.cpp

@@ -1,8 +1,7 @@
 #include "TurnOrdering.hpp"
-#include "../TurnChoices/AttackTurnChoice.hpp"
-#include "../Models/Battle.hpp"
-
 #include <algorithm>
+#include "../Models/Battle.hpp"
+#include "../TurnChoices/AttackTurnChoice.hpp"
 
 using namespace CreatureLib;
 using namespace Battling;

src/Battling/Flow/TurnOrdering.hpp

@@ -1,9 +1,9 @@
 #ifndef CREATURELIB_TURNORDERING_HPP
 #define CREATURELIB_TURNORDERING_HPP
 
-#include "../TurnChoices/BaseTurnChoice.hpp"
-#include "../../Core/Random.hpp"
 #include <vector>
+#include "../../Core/Random.hpp"
+#include "../TurnChoices/BaseTurnChoice.hpp"
 
 namespace CreatureLib::Battling {
     class TurnOrdering {

src/Battling/Library/BattleLibrary.cpp

@@ -1,16 +1,13 @@
-#include <cassert>
 #include "BattleLibrary.hpp"
+#include <cassert>
 
 using namespace CreatureLib::Battling;
 
-BattleLibrary::BattleLibrary(CreatureLib::Library::DataLibrary *staticLib,
+BattleLibrary::BattleLibrary(CreatureLib::Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator,
-                                                    BattleStatCalculator *statCalculator,
+                             DamageLibrary* damageLibrary, CriticalLibrary* criticalLibrary,
-                                                    DamageLibrary* damageLibrary,
+                             ScriptResolver* scriptResolver)
-                                                    CriticalLibrary* criticalLibrary, ScriptResolver* scriptResolver)
+    : _staticLib(staticLib), _statCalculator(statCalculator), _damageLibrary(damageLibrary),
-                                                    : _staticLib(staticLib), _statCalculator(statCalculator),
+      _criticalLibrary(criticalLibrary), _scriptResolver(scriptResolver) {}
-                                                    _damageLibrary(damageLibrary), _criticalLibrary(criticalLibrary),
-                                                    _scriptResolver(scriptResolver)
-                                                    {}
 
 BattleLibrary::~BattleLibrary() {
     delete _staticLib;
@@ -20,40 +17,27 @@ BattleLibrary::~BattleLibrary() {
     delete _scriptResolver;
 }
 
-const CreatureLib::Library::LibrarySettings& BattleLibrary::GetSettings() const {
+const CreatureLib::Library::LibrarySettings& BattleLibrary::GetSettings() const { return _staticLib->GetSettings(); }
-    return _staticLib->GetSettings();
-}
 
-const BattleStatCalculator *BattleLibrary::GetStatCalculator() const {
+const BattleStatCalculator* BattleLibrary::GetStatCalculator() const { return _statCalculator; }
-    return _statCalculator;
-}
 
 const CreatureLib::Library::SpeciesLibrary* BattleLibrary::GetSpeciesLibrary() const {
     return _staticLib->GetSpeciesLibrary();
 }
 
-const CreatureLib::Library::ItemLibrary* BattleLibrary::GetItemLibrary() const {
+const CreatureLib::Library::ItemLibrary* BattleLibrary::GetItemLibrary() const { return _staticLib->GetItemLibrary(); }
-    return _staticLib->GetItemLibrary();
-}
 
 const CreatureLib::Library::AttackLibrary* BattleLibrary::GetAttackLibrary() const {
     return _staticLib->GetAttackLibrary();
 }
 
-const CreatureLib::Library::TypeLibrary *BattleLibrary::GetTypeLibrary() const {
+const CreatureLib::Library::TypeLibrary* BattleLibrary::GetTypeLibrary() const { return _staticLib->GetTypeLibrary(); }
-    return _staticLib->GetTypeLibrary();
-}
 
-const DamageLibrary *BattleLibrary::GetDamageLibrary() const {
+const DamageLibrary* BattleLibrary::GetDamageLibrary() const { return _damageLibrary; }
-    return _damageLibrary;
-}
 
-const CriticalLibrary *BattleLibrary::GetCriticalLibrary() const {
+const CriticalLibrary* BattleLibrary::GetCriticalLibrary() const { return _criticalLibrary; }
-    return _criticalLibrary;
-}
 
 Script* BattleLibrary::LoadScript(ScriptResolver::ScriptCategory category, const std::string& scriptName) {
     assert(this->_scriptResolver != nullptr);
     return _scriptResolver->LoadScript(category, scriptName);
 }
-

src/Battling/Library/BattleLibrary.hpp

@@ -1,11 +1,11 @@
 #ifndef CREATURELIB_BATTLELIBRARY_HPP
 #define CREATURELIB_BATTLELIBRARY_HPP
 
-#include "BattleStatCalculator.hpp"
 #include "../../Library/DataLibrary.hpp"
-#include "DamageLibrary.hpp"
-#include "CriticalLibrary.hpp"
 #include "../ScriptHandling/ScriptResolver.hpp"
+#include "BattleStatCalculator.hpp"
+#include "CriticalLibrary.hpp"
+#include "DamageLibrary.hpp"
 
 namespace CreatureLib::Battling {
     class BattleLibrary {
@@ -14,9 +14,10 @@ namespace CreatureLib::Battling {
         DamageLibrary* _damageLibrary;
         CriticalLibrary* _criticalLibrary;
         ScriptResolver* _scriptResolver;
+
     public:
-        BattleLibrary(Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator, DamageLibrary* damageLibrary,
+        BattleLibrary(Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator,
-                CriticalLibrary* criticalLibrary, ScriptResolver* scriptResolver);
+                      DamageLibrary* damageLibrary, CriticalLibrary* criticalLibrary, ScriptResolver* scriptResolver);
         ~BattleLibrary();
 
         [[nodiscard]] const Library::LibrarySettings& GetSettings() const;

src/Battling/Library/BattleStatCalculator.cpp

@@ -1,36 +1,31 @@
 #include "BattleStatCalculator.hpp"
-#include "../Models/Creature.hpp"
 #include "../../Core/Exceptions/NotImplementedException.hpp"
+#include "../Models/Creature.hpp"
 
 using namespace CreatureLib;
 
-Core::StatisticSet<uint32_t>
+Core::StatisticSet<uint32_t> Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* creature) const {
-Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature *creature) const {
+    return Core::StatisticSet<uint32_t>(CalculateFlatStat(creature, Core::Statistic::Health),
-    return Core::StatisticSet<uint32_t>(
-            CalculateFlatStat(creature, Core::Statistic::Health),
                                         CalculateFlatStat(creature, Core::Statistic::PhysicalAttack),
                                         CalculateFlatStat(creature, Core::Statistic::PhysicalDefense),
                                         CalculateFlatStat(creature, Core::Statistic::MagicalAttack),
                                         CalculateFlatStat(creature, Core::Statistic::MagicalDefense),
-            CalculateFlatStat(creature, Core::Statistic::Speed)
+                                        CalculateFlatStat(creature, Core::Statistic::Speed));
-    );
 }
 
-Core::StatisticSet<uint32_t>
+Core::StatisticSet<uint32_t> Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creature) const {
-Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature *creature) const {
+    return Core::StatisticSet<uint32_t>(CalculateBoostedStat(creature, Core::Statistic::Health),
-return Core::StatisticSet<uint32_t>(
-        CalculateBoostedStat(creature, Core::Statistic::Health),
                                         CalculateBoostedStat(creature, Core::Statistic::PhysicalAttack),
                                         CalculateBoostedStat(creature, Core::Statistic::PhysicalDefense),
                                         CalculateBoostedStat(creature, Core::Statistic::MagicalAttack),
                                         CalculateBoostedStat(creature, Core::Statistic::MagicalDefense),
-        CalculateBoostedStat(creature, Core::Statistic::Speed)
+                                        CalculateBoostedStat(creature, Core::Statistic::Speed));
-);
 }
 
 uint32_t CalculateHealthStat(Battling::Creature* creature) {
     auto level = creature->GetLevel();
-    auto a = (creature->GetBaseStat(Core::Statistic::Health) + creature->GetStatPotential(Core::Statistic::Health)) * 2 +
+    auto a =
+        (creature->GetBaseStat(Core::Statistic::Health) + creature->GetStatPotential(Core::Statistic::Health)) * 2 +
         floor(sqrt(creature->GetStatExperience(Core::Statistic::Health) / 4)) * level;
     return floor(a / 100) + level + 10;
 }
@@ -42,13 +37,13 @@ uint32_t CalculateOtherStat(Battling::Creature *creature, Core::Statistic stat){
     return floor(a / 100) + 10;
 }
 
-
 uint32_t Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature, Core::Statistic stat) const {
     if (stat == Core::Statistic::Health)
         return CalculateHealthStat(creature);
     return CalculateOtherStat(creature, stat);
 }
 
-uint32_t Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature *creature, Core::Statistic stat) const{
+uint32_t Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* creature,
+                                                              Core::Statistic stat) const {
     throw NotImplementedException();
 }

src/Battling/Library/CriticalLibrary.hpp

@@ -11,5 +11,4 @@ namespace CreatureLib::Battling {
     };
 }
 
-
 #endif // CREATURELIB_CRITICALLIBRARY_HPP

src/Battling/Library/DamageLibrary.cpp

@@ -7,8 +7,8 @@ int DamageLibrary::GetDamage(ExecutingAttack *attack, Creature *target, uint8_t
     auto bp = hit.GetBasePower();
     auto statMod = GetStatModifier(attack, target, hitIndex);
     // HOOK: Modify stat modifier
-    int damage = static_cast<int>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2)
+    int damage = static_cast<int>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2) *
-            * GetDamageModifier(attack, target, hitIndex));
+                                  GetDamageModifier(attack, target, hitIndex));
     // HOOK: Override damage
     return damage;
 }
@@ -28,8 +28,7 @@ float DamageLibrary::GetStatModifier(ExecutingAttack *attack, Creature *target,
     if (attack->GetAttack()->GetAttack()->GetCategory() == Library::AttackCategory::Physical) {
         offensiveStat = Core::Statistic::PhysicalAttack;
         defensiveStat = Core::Statistic::PhysicalDefense;
-    }
+    } else {
-    else{
         offensiveStat = Core::Statistic::MagicalAttack;
         defensiveStat = Core::Statistic::MagicalDefense;
     }
@@ -63,4 +62,3 @@ float DamageLibrary::GetDamageModifier(ExecutingAttack *attack, Creature *target
     // HOOK: Modify damage modifier.
     return mod;
 }
-

src/Battling/Library/DamageLibrary.hpp

@@ -16,5 +16,4 @@ namespace CreatureLib::Battling{
     };
 }
 
-
 #endif // CREATURELIB_DAMAGELIBRARY_HPP

src/Battling/Models/AttackLearnMethod.hpp

@@ -2,10 +2,7 @@
 #define CREATURELIB_ATTACKLEARNMETHOD_HPP
 
 namespace CreatureLib::Battling {
-    enum class AttackLearnMethod {
+    enum class AttackLearnMethod { Unknown, Level };
-        Unknown,
-        Level
-    };
 }
 
 #endif // CREATURELIB_ATTACKLEARNMETHOD_HPP

src/Battling/Models/Battle.cpp

@@ -1,15 +1,12 @@
 #include "Battle.hpp"
-#include "../Flow/TurnHandler.hpp"
-#include "../TurnChoices/AttackTurnChoice.hpp"
-#include "../Flow/TurnOrdering.hpp"
 #include "../../Core/Exceptions/NotImplementedException.hpp"
+#include "../Flow/TurnHandler.hpp"
+#include "../Flow/TurnOrdering.hpp"
 
 using namespace CreatureLib;
 using namespace CreatureLib::Battling;
 
-const BattleLibrary *Battle::GetLibrary() const {
+const BattleLibrary* Battle::GetLibrary() const { return _library; }
-    return _library;
-}
 
 bool Battle::CanUse(const BaseTurnChoice* choice) {
     if (choice->GetKind() == TurnChoiceKind::Attack) {
@@ -60,13 +57,9 @@ void Battle::CheckChoicesSetAndRun() {
         _currentTurnQueue = nullptr;
 }
 
-ChoiceQueue* Battle::GetCurrentTurnQueue() const {
+ChoiceQueue* Battle::GetCurrentTurnQueue() const { return _currentTurnQueue; }
-    return _currentTurnQueue;
-}
 
-Core::Random &Battle::GetRandom(){
+Core::Random& Battle::GetRandom() { return _random; }
-    return _random;
-}
 
 bool Battle::CreatureInField(const Creature* creature) const {
     for (auto s : _sides) {
@@ -76,9 +69,7 @@ bool Battle::CreatureInField(const Creature *creature) const {
     return false;
 }
 
-bool Battle::HasRecalledSlots() const {
+bool Battle::HasRecalledSlots() const { return _numberOfRecalledSlots > 0; }
-    return _numberOfRecalledSlots > 0;
-}
 
 void Battle::ForceRecall(uint8_t side, uint8_t index) {
     _numberOfRecalledSlots++;
@@ -93,6 +84,4 @@ void Battle::FillRecall(uint8_t side, uint8_t, Creature *c) {
     }
 }
 
-void Battle::GetActiveScripts(std::vector<ScriptWrapper> &scripts) {
+void Battle::GetActiveScripts(std::vector<ScriptWrapper>& scripts) { scripts.emplace_back(&_volatile); }
-    scripts.emplace_back(&_volatile);
-}

src/Battling/Models/Battle.hpp

@@ -2,10 +2,10 @@
 #define CREATURELIB_BATTLE_HPP
 
 #include <vector>
-#include "BattleSide.hpp"
+#include "../Flow/ChoiceQueue.hpp"
 #include "../Library/BattleLibrary.hpp"
 #include "../TurnChoices/BaseTurnChoice.hpp"
-#include "../Flow/ChoiceQueue.hpp"
+#include "BattleSide.hpp"
 #include "Target.hpp"
 
 namespace CreatureLib::Battling {
@@ -19,6 +19,7 @@ namespace CreatureLib::Battling {
 
         uint8_t _numberOfRecalledSlots = 0;
         ScriptSet _volatile;
+
     public:
         [[nodiscard]] const BattleLibrary* GetLibrary() const;
 
@@ -46,5 +47,4 @@ namespace CreatureLib::Battling {
     };
 }
 
-
 #endif // CREATURELIB_BATTLE_HPP

src/Battling/Models/BattleSide.cpp

@@ -1,13 +1,11 @@
 #include "BattleSide.hpp"
-#include "../../Core/Exceptions/CreatureException.hpp"
 #include <algorithm>
+#include "../../Core/Exceptions/CreatureException.hpp"
 #include "Battle.hpp"
 
 using namespace CreatureLib::Battling;
 
-bool BattleSide::AllChoicesSet() const {
+bool BattleSide::AllChoicesSet() const { return _choicesSet == _creaturesPerSide; }
-    return _choicesSet == _creaturesPerSide;
-}
 
 void BattleSide::ResetChoices() {
     _choicesSet = 0;
@@ -16,9 +14,7 @@ void BattleSide::ResetChoices() {
     }
 }
 
-const std::vector<BaseTurnChoice *>& BattleSide::GetChoices() const{
+const std::vector<BaseTurnChoice*>& BattleSide::GetChoices() const { return _choices; }
-    return _choices;
-}
 
 void BattleSide::SetChoice(BaseTurnChoice* choice) {
     auto find = std::find(_creatures.begin(), _creatures.end(), choice->GetUser());
@@ -29,17 +25,13 @@ void BattleSide::SetChoice(BaseTurnChoice *choice) {
     _choicesSet++;
 }
 
-void BattleSide::SetCreature(Creature *creature, uint8_t index) {
+void BattleSide::SetCreature(Creature* creature, uint8_t index) { _creatures[index] = creature; }
-    _creatures[index] = creature;
-}
 
 bool BattleSide::CreatureOnSide(const Creature* creature) const {
     return std::find(_creatures.begin(), _creatures.end(), creature) != _creatures.end();
 }
 
-Creature *BattleSide::GetCreature(uint8_t index) const {
+Creature* BattleSide::GetCreature(uint8_t index) const { return _creatures[index]; }
-    return _creatures[index];
-}
 
 void BattleSide::GetActiveScripts(std::vector<ScriptWrapper>& scripts) {
     scripts.emplace_back(&_volatile);

src/Battling/Models/BattleSide.hpp

@@ -2,8 +2,8 @@
 #define CREATURELIB_BATTLESIDE_HPP
 
 #include <vector>
-#include "Creature.hpp"
 #include "../TurnChoices/BaseTurnChoice.hpp"
+#include "Creature.hpp"
 
 namespace CreatureLib::Battling {
     class BattleSide : public ScriptSource {
@@ -13,10 +13,11 @@ namespace CreatureLib::Battling{
         uint8_t _choicesSet = 0;
         ScriptSet _volatile;
         Battle* _battle;
+
     public:
         explicit BattleSide(Battle* battle, uint8_t creaturesPerSide)
-        : _creaturesPerSide(creaturesPerSide), _creatures(creaturesPerSide), _choices(creaturesPerSide), _battle(battle)
+            : _creaturesPerSide(creaturesPerSide), _creatures(creaturesPerSide), _choices(creaturesPerSide),
-        {
+              _battle(battle) {
             ResetChoices();
         }
 
@@ -32,9 +33,7 @@ namespace CreatureLib::Battling{
         bool CreatureOnSide(const Creature* creature) const;
 
         void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override;
-
     };
 }
 
-
 #endif // CREATURELIB_BATTLESIDE_HPP

src/Battling/Models/BattleTeam.cpp

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

src/Battling/Models/BattleTeam.hpp

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

src/Battling/Models/CreateCreature.cpp

@@ -1,7 +1,7 @@
+
 #include "CreateCreature.hpp"
-#include "../../Core/Exceptions/CreatureException.hpp"
-#include "../Library/BattleLibrary.hpp"
 #include <utility>
+#include "../Library/BattleLibrary.hpp"
 
 using namespace CreatureLib::Battling;
 
@@ -50,9 +50,8 @@ CreateCreature* CreateCreature::WithStatExperience(Core::Statistic stat, uint32_
     return this;
 }
 
-CreateCreature *
+CreateCreature* CreateCreature::WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense,
-CreateCreature::WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense, uint32_t magAttack,
+                                                    uint32_t magAttack, uint32_t magDefense, uint32_t speed) {
-                                    uint32_t magDefense, uint32_t speed) {
     _healthExperience = health;
     _physAttackExperience = physAttack;
     _physDefenseExperience = physDefense;
@@ -84,8 +83,7 @@ Creature *CreateCreature::Create() {
     int8_t talent;
     if (this->_talent.empty()) {
         talent = variant->GetRandomTalent(&rand);
-    }
+    } else {
-    else{
         talent = variant->GetTalentIndex(this->_talent);
     }
     auto identifier = this->_identifier;
@@ -103,17 +101,16 @@ Creature *CreateCreature::Create() {
     // FIXME: implement experience
     auto experience = 0;
 
-    auto statExperience = Core::StatisticSet(_healthExperience, _physAttackExperience,_physDefenseExperience, _magAttackExperience,
+    auto statExperience = Core::StatisticSet(_healthExperience, _physAttackExperience, _physDefenseExperience,
-                                             _magDefenseExperience, _speedExperience);
+                                             _magAttackExperience, _magDefenseExperience, _speedExperience);
-    auto statPotential = Core::StatisticSet(_healthPotential, _physAttackPotential,_physDefensePotential, _magAttackPotential,
+    auto statPotential = Core::StatisticSet(_healthPotential, _physAttackPotential, _physDefensePotential,
-                                             _magDefensePotential, _speedPotential);
+                                            _magAttackPotential, _magDefensePotential, _speedPotential);
 
     auto attacks = std::vector<LearnedAttack*>(_attacks.size());
     for (auto kv : _attacks) {
         attacks.push_back(new LearnedAttack(std::get<0>(kv), std::get<1>(kv)));
     }
 
-    return new Creature(species, variant, _level, experience, statExperience,statPotential, identifier,gender, _coloring,
+    return new Creature(species, variant, _level, experience, statExperience, statPotential, identifier, gender,
-            heldItem, _nickname, talent, attacks);
+                        _coloring, heldItem, _nickname, talent, attacks);
 }
-

src/Battling/Models/CreateCreature.hpp

@@ -1,7 +1,6 @@
 #ifndef CREATURELIB_CREATECREATURE_HPP
 #define CREATURELIB_CREATECREATURE_HPP
 
-
 #include "../../Library/DataLibrary.hpp"
 #include "Creature.hpp"
 
@@ -38,25 +37,21 @@ namespace CreatureLib::Battling {
 
     public:
         CreateCreature(const BattleLibrary* library, std::string species, uint8_t level)
-        : _library(library), _species(std::move(species)), _level(level)
+            : _library(library), _species(std::move(species)), _level(level) {}
-        {
-        }
 
         CreateCreature* WithVariant(std::string variant);
         CreateCreature* WithNickname(std::string nickname);
         CreateCreature* WithStatPotential(Core::Statistic stat, uint32_t value);
-        CreateCreature* WithStatPotentials(uint32_t health, uint32_t physAttack, uint32_t physDefense, uint32_t magAttack,
+        CreateCreature* WithStatPotentials(uint32_t health, uint32_t physAttack, uint32_t physDefense,
-                uint32_t magDefense,uint32_t speed);
+                                           uint32_t magAttack, uint32_t magDefense, uint32_t speed);
         CreateCreature* WithStatExperience(Core::Statistic stat, uint32_t value);
-        CreateCreature* WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense, uint32_t magAttack,
+        CreateCreature* WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense,
-                                           uint32_t magDefense,uint32_t speed);
+                                            uint32_t magAttack, uint32_t magDefense, uint32_t speed);
         CreateCreature* WithGender(Library::Gender gender);
         CreateCreature* WithAttack(const std::string& attackName, AttackLearnMethod learnMethod);
 
-
         Creature* Create();
     };
 }
 
-
 #endif // CREATURELIB_CREATECREATURE_HPP

src/Battling/Models/Creature.cpp

@@ -1,6 +1,6 @@
+#include "Creature.hpp"
 #include <algorithm>
 #include <utility>
-#include "Creature.hpp"
 #include "../Models/Battle.hpp"
 
 using namespace CreatureLib;
@@ -10,35 +10,19 @@ Battling::Creature::Creature(const Library::CreatureSpecies* species, const Libr
                              Core::StatisticSet<uint8_t> statPotential, uint32_t uid, Library::Gender gender,
                              uint8_t coloring, const Library::Item* heldItem, std::string nickname, int8_t talent,
                              std::vector<LearnedAttack*> attacks)
-                             :
+    : __Species(species), __Variant(variant), __Level(level), __Experience(experience), __StatExperience(statExp),
-                             __Species(species),
+      __StatPotential(statPotential), __UniqueIdentifier(uid), __Gender(gender), __Coloring(coloring),
-                             __Variant(variant),
+      __HeldItem(heldItem), _nickname(std::move(nickname)), _talentIndex(talent), _hasOverridenTalent(false),
-                             __Level(level),
+      _attacks(std::move(attacks)) {
-                             __Experience(experience),
-                             __StatExperience(statExp),
-                             __StatPotential(statPotential),
-                             __UniqueIdentifier(uid),
-                             __Gender(gender),
-                             __Coloring(coloring),
-                             __HeldItem(heldItem),
-                             _nickname(std::move(nickname)),
-                             _talentIndex(talent),
-                             _hasOverridenTalent(false),
-                             _attacks(std::move(attacks))
-{
     __CurrentHealth = GetBoostedStat(Core::Statistic::Health);
 }
 
-
-
 void Battling::Creature::ChangeLevel(int8_t amount) {
     this->__Level += amount;
     RecalculateFlatStats();
 }
 
-void Battling::Creature::SetBattle(Battling::Battle *battle) {
+void Battling::Creature::SetBattle(Battling::Battle* battle) { this->_battle = battle; }
-    this->_battle = battle;
-}
 
 void Battling::Creature::SetBattleLibrary(Battling::BattleLibrary* library) {
     this->_library = library;
@@ -73,29 +57,17 @@ void Battling::Creature::ChangeStatBoost(Core::Statistic stat, int8_t diffAmount
     this->RecalculateBoostedStat(stat);
 }
 
-uint32_t Battling::Creature::GetFlatStat(Core::Statistic stat) const{
+uint32_t Battling::Creature::GetFlatStat(Core::Statistic stat) const { return _flatStats.GetStat(stat); }
-    return _flatStats.GetStat(stat);
-}
 
-uint32_t Battling::Creature::GetBoostedStat(Core::Statistic stat) const{
+uint32_t Battling::Creature::GetBoostedStat(Core::Statistic stat) const { return _boostedStats.GetStat(stat); }
-    return _boostedStats.GetStat(stat);
-}
 
-uint32_t Battling::Creature::GetBaseStat(Core::Statistic stat) const {
+uint32_t Battling::Creature::GetBaseStat(Core::Statistic stat) const { return __Variant->GetStatistic(stat); }
-    return __Variant->GetStatistic(stat);
-}
 
-uint32_t Battling::Creature::GetStatPotential(Core::Statistic stat) const {
+uint32_t Battling::Creature::GetStatPotential(Core::Statistic stat) const { return __StatPotential.GetStat(stat); }
-    return __StatPotential.GetStat(stat);
-}
 
-uint32_t Battling::Creature::GetStatExperience(Core::Statistic stat) const {
+uint32_t Battling::Creature::GetStatExperience(Core::Statistic stat) const { return __StatExperience.GetStat(stat); }
-    return __StatExperience.GetStat(stat);
-}
 
-int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const {
+int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const { return _statBoost.GetStat(stat); }
-    return _statBoost.GetStat(stat);
-}
 
 void Battling::Creature::RecalculateFlatStats() {
     this->_flatStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
@@ -118,17 +90,11 @@ void Battling::Creature::RecalculateBoostedStat(Core::Statistic stat) {
 
 // endregion
 
-Battling::Battle *Battling::Creature::GetBattle() const{
+Battling::Battle* Battling::Creature::GetBattle() const { return _battle; }
-    return _battle;
-}
 
-Battling::BattleSide *Battling::Creature::GetBattleSide() const {
+Battling::BattleSide* Battling::Creature::GetBattleSide() const { return _side; }
-    return _side;
-}
 
-bool Battling::Creature::IsFainted() const {
+bool Battling::Creature::IsFainted() const { return this->__CurrentHealth <= 0; }
-    return this->__CurrentHealth <= 0;
-}
 
 void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source) {
     if (damage > __CurrentHealth) {

src/Battling/Models/Creature.hpp

@@ -4,11 +4,11 @@
 #include "../../GenericTemplates.cpp"
 #include "../../Library/CreatureData/CreatureSpecies.hpp"
 #include "../../Library/Items/Item.hpp"
-#include "LearnedAttack.hpp"
-#include "DamageSource.hpp"
-#include "../ScriptHandling/ScriptSet.hpp"
 #include "../ScriptHandling/ScriptAggregator.hpp"
+#include "../ScriptHandling/ScriptSet.hpp"
 #include "../ScriptHandling/ScriptSource.hpp"
+#include "DamageSource.hpp"
+#include "LearnedAttack.hpp"
 
 namespace CreatureLib::Battling {
     // Forward declare battle class
@@ -18,7 +18,7 @@ namespace CreatureLib::Battling{
 
     class Creature : public ScriptSource {
         GetProperty(const Library::CreatureSpecies*, Species);
-        GetProperty(const Library::SpeciesVariant*, Variant)
+        GetProperty(const Library::SpeciesVariant*, Variant);
 
         GetProperty(uint8_t, Level);
         GetProperty(uint32_t, Experience);
@@ -30,7 +30,6 @@ namespace CreatureLib::Battling{
         GetProperty(const Library::Item*, HeldItem);
         GetProperty(uint32_t, CurrentHealth);
 
-
     private:
         Core::StatisticSet<int8_t> _statBoost;
         Core::StatisticSet<uint32_t> _flatStats;
@@ -55,8 +54,8 @@ namespace CreatureLib::Battling{
     public:
         Creature(const Library::CreatureSpecies* species, const Library::SpeciesVariant* variant, uint8_t level,
                  uint32_t experience, Core::StatisticSet<uint8_t> statExp, Core::StatisticSet<uint8_t> statPotential,
-                uint32_t uid, Library::Gender gender, uint8_t coloring, const Library::Item* heldItem, std::string nickname,
+                 uint32_t uid, Library::Gender gender, uint8_t coloring, const Library::Item* heldItem,
-                int8_t talent, std::vector<LearnedAttack*> attacks);
+                 std::string nickname, int8_t talent, std::vector<LearnedAttack*> attacks);
 
         virtual ~Creature() = default;
 
@@ -75,7 +74,6 @@ namespace CreatureLib::Battling{
         void Damage(uint32_t damage, DamageSource source);
         void OverrideActiveTalent(const std::string& talent);
 
-
         void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override;
 
         // region Stat APIs
@@ -96,10 +94,7 @@ namespace CreatureLib::Battling{
         void RecalculateBoostedStat(Core::Statistic);
 
         // endregion
-
-
     };
 }
 
-
 #endif // CREATURELIB_CREATURE_HPP

src/Battling/Models/CreatureParty.hpp

@@ -5,17 +5,13 @@
 #include "Creature.hpp"
 
 namespace CreatureLib::Battling {
-    template <int max>
+    template <int max> class CreatureParty {
-    class CreatureParty {
         std::array<Creature*, max> _party;
 
     public:
-        CreatureParty(std::array<Creature*, max> party) : _party(party){
+        CreatureParty(std::array<Creature*, max> party) : _party(party) {}
-        }
 
-        Creature* GetAtIndex(int index) const{
+        Creature* GetAtIndex(int index) const { return _party[index]; }
-            return _party[index];
-        }
 
         void Switch(int a, int b) {
             auto ca = _party[a];
@@ -25,8 +21,10 @@ namespace CreatureLib::Battling{
 
         bool HasAvailableCreatures() const {
             for (Creature* c : _party) {
-                if (c == nullptr) continue;
+                if (c == nullptr)
-                if (c->IsFainted()) continue;
+                    continue;
+                if (c->IsFainted())
+                    continue;
                 return true;
             }
             return false;
@@ -34,5 +32,4 @@ namespace CreatureLib::Battling{
     };
 }
 
-
 #endif // CREATURELIB_CREATUREPARTY_HPP

src/Battling/Models/ExecutingAttack.hpp

@@ -2,8 +2,8 @@
 #define CREATURELIB_EXECUTINGATTACK_HPP
 
 #include <cstdint>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 #include "Creature.hpp"
 
 namespace CreatureLib::Battling {
@@ -15,6 +15,7 @@ namespace CreatureLib::Battling {
             float _effectiveness = 1;
             uint32_t _damage = 0;
             uint8_t _type = 0;
+
         public:
             HitData() {}
 
@@ -34,31 +35,22 @@ namespace CreatureLib::Battling {
         class TargetData {
             bool _isHit = true;
             std::vector<HitData> _hits;
+
         public:
-            explicit TargetData(uint8_t numberOfHits) : _hits(numberOfHits)
+            explicit TargetData(uint8_t numberOfHits) : _hits(numberOfHits) {
-            {
                 for (uint8_t i = 0; i < numberOfHits; i++) {
                     _hits[i] = HitData();
                 }
             }
             TargetData() = default;
 
-            const HitData& GetHit(uint8_t index) const{
+            const HitData& GetHit(uint8_t index) const { return _hits[index]; }
-                return _hits[index];
-            }
 
-            HitData* GetHitPtr(uint8_t index){
+            HitData* GetHitPtr(uint8_t index) { return &_hits[index]; }
-                return &_hits[index];
-            }
 
-            uint8_t GetNumberOfHits() const{
+            uint8_t GetNumberOfHits() const { return _hits.size(); }
-                return _hits.size();
-            }
-
-            bool IsHit() const{
-                return _isHit;
-            }
 
+            bool IsHit() const { return _isHit; }
         };
 
     private:
@@ -66,11 +58,11 @@ namespace CreatureLib::Battling {
         Creature* _user;
         LearnedAttack* _attack;
         Script* _script;
+
     public:
-        ExecutingAttack(const std::vector<Creature*>& targets, uint8_t numberHits, Creature* user, LearnedAttack* attack,
+        ExecutingAttack(const std::vector<Creature*>& targets, uint8_t numberHits, Creature* user,
-                Script* script)
+                        LearnedAttack* attack, Script* script)
-            : _user(user), _attack(attack), _script(script)
+            : _user(user), _attack(attack), _script(script) {
-        {
             _targets.reserve(targets.size());
             for (auto target : targets) {
                 _targets.insert({target, TargetData(numberHits)});
@@ -79,25 +71,15 @@ namespace CreatureLib::Battling {
 
         virtual ~ExecutingAttack() = default;
 
-        TargetData& GetAttackDataForTarget(Creature* creature){
+        TargetData& GetAttackDataForTarget(Creature* creature) { return _targets[creature]; }
-            return _targets[creature];
-        }
 
-        bool IsCreatureTarget(Creature* creature){
+        bool IsCreatureTarget(Creature* creature) { return _targets.find(creature) != _targets.end(); }
-            return _targets.find(creature) != _targets.end();
-        }
 
-        const std::unordered_map<Creature*, TargetData>& GetTargets(){
+        const std::unordered_map<Creature*, TargetData>& GetTargets() { return _targets; }
-            return _targets;
-        }
 
-        Creature* GetUser(){
+        Creature* GetUser() { return _user; }
-            return _user;
-        }
 
-        LearnedAttack* GetAttack(){
+        LearnedAttack* GetAttack() { return _attack; }
-            return _attack;
-        }
 
     protected:
         void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override {

src/Battling/Models/LearnedAttack.cpp

@@ -1,48 +1,32 @@
 #include "LearnedAttack.hpp"
 
-CreatureLib::Battling::LearnedAttack::LearnedAttack(CreatureLib::Library::AttackData *attack, uint8_t maxUses, AttackLearnMethod learnMethod)
+CreatureLib::Battling::LearnedAttack::LearnedAttack(CreatureLib::Library::AttackData* attack, uint8_t maxUses,
-    :_attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod)
+                                                    AttackLearnMethod learnMethod)
-{
+    : _attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod) {}
 
-}
+CreatureLib::Battling::LearnedAttack::LearnedAttack(const CreatureLib::Library::AttackData* attack,
+                                                    AttackLearnMethod learnMethod)
+    : _attack(attack), _maxUses(attack->GetBaseUsages()), _remainingUses(_maxUses), _learnMethod(learnMethod) {}
 
-CreatureLib::Battling::LearnedAttack::LearnedAttack(const CreatureLib::Library::AttackData *attack, AttackLearnMethod learnMethod)
+const CreatureLib::Library::AttackData* CreatureLib::Battling::LearnedAttack::GetAttack() const { return _attack; }
-    : _attack(attack), _maxUses(attack->GetBaseUsages()), _remainingUses(_maxUses), _learnMethod(learnMethod)
-{}
 
+uint8_t CreatureLib::Battling::LearnedAttack::GetMaxUses() const { return _maxUses; }
 
-const CreatureLib::Library::AttackData *CreatureLib::Battling::LearnedAttack::GetAttack() const {
+uint8_t CreatureLib::Battling::LearnedAttack::GetRemainingUses() const { return _remainingUses; }
-    return _attack;
-}
-
-uint8_t CreatureLib::Battling::LearnedAttack::GetMaxUses() const {
-    return _maxUses;
-}
-
-uint8_t CreatureLib::Battling::LearnedAttack::GetRemainingUses() const {
-    return _remainingUses;
-}
 
 CreatureLib::Battling::AttackLearnMethod CreatureLib::Battling::LearnedAttack::GetLearnMethod() const {
     return _learnMethod;
 }
 
-
 bool CreatureLib::Battling::LearnedAttack::TryUse(uint8_t uses) {
-    if (uses > _remainingUses) return false;
+    if (uses > _remainingUses)
+        return false;
     _remainingUses -= uses;
     return true;
 }
 
-void CreatureLib::Battling::LearnedAttack::DecreaseUses(uint8_t amount) {
+void CreatureLib::Battling::LearnedAttack::DecreaseUses(uint8_t amount) { _remainingUses -= amount; }
-    _remainingUses -= amount;
-}
 
-void CreatureLib::Battling::LearnedAttack::RestoreUses(uint8_t amount) {
+void CreatureLib::Battling::LearnedAttack::RestoreUses(uint8_t amount) { _remainingUses += amount; }
-    _remainingUses += amount;
-}
-
-void CreatureLib::Battling::LearnedAttack::RestoreUses() {
-    _remainingUses = _maxUses;
-}
 
+void CreatureLib::Battling::LearnedAttack::RestoreUses() { _remainingUses = _maxUses; }

src/Battling/Models/LearnedAttack.hpp

@@ -10,6 +10,7 @@ namespace CreatureLib::Battling{
         uint8_t _maxUses;
         uint8_t _remainingUses;
         AttackLearnMethod _learnMethod;
+
     public:
         LearnedAttack(Library::AttackData* attack, uint8_t maxUses, AttackLearnMethod learnMethod);
         LearnedAttack(const Library::AttackData* attack, AttackLearnMethod learnMethod);
@@ -26,5 +27,4 @@ namespace CreatureLib::Battling{
     };
 }
 
-
 #endif // CREATURELIB_LEARNEDATTACK_HPP

src/Battling/Models/Target.hpp

@@ -8,16 +8,13 @@ namespace CreatureLib::Battling {
     class Target {
         uint8_t _side;
         uint8_t _creature;
+
     public:
         Target(uint8_t side, uint8_t creature) : _side(side), _creature(creature) {}
 
-        uint8_t GetSideIndex() const{
+        uint8_t GetSideIndex() const { return _side; }
-            return _side;
-        }
 
-        uint8_t GetCreatureIndex() const{
+        uint8_t GetCreatureIndex() const { return _creature; }
-            return _creature;
-        }
     };
 }
 

src/Battling/ScriptHandling/Script.hpp

@@ -21,9 +21,7 @@ namespace CreatureLib::Battling{
 
         virtual void Stack(){};
 
-        const std::string& GetName(){
+        const std::string& GetName() { return _name; }
-            return _name;
-        }
 
         virtual void OnBeforeTurn(const BaseTurnChoice* choice){};
 
@@ -38,7 +36,8 @@ namespace CreatureLib::Battling{
         virtual void OnAttackMiss(ExecutingAttack* attack, Creature* target){};
         virtual void ChangeAttackType(ExecutingAttack* attack, Creature* target, uint8_t hitNumber, uint8_t& type){};
         virtual void OnStatusMove(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber){};
-        virtual void PreventSecondaryEffects(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber, bool& result){};
+        virtual void PreventSecondaryEffects(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber,
+                                             bool& result){};
         virtual void OnSecondaryEffect(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber){};
 
         virtual void OnAfterHits(const ExecutingAttack* attack, Creature* target){};

src/Battling/ScriptHandling/ScriptAggregator.hpp

@@ -3,9 +3,9 @@
 
 #include <any>
 #include <queue>
+#include "../../Core/Exceptions/NotReachableException.hpp"
 #include "Script.hpp"
 #include "ScriptSet.hpp"
-#include "../../Core/Exceptions/NotReachableException.hpp"
 #include "ScriptWrapper.hpp"
 
 namespace CreatureLib::Battling {
@@ -15,13 +15,11 @@ namespace CreatureLib::Battling{
         bool _isSetSet = false;
         const std::vector<Script*>* _setScripts;
         int _setIndex;
-    public:
-        ScriptAggregator(std::vector<ScriptWrapper> scripts) : _scripts(std::move(scripts)){
-        };
 
-        bool HasNext(){
+    public:
-            return _index < _scripts.size() || (_isSetSet && _setIndex < _setScripts->size());
+        ScriptAggregator(std::vector<ScriptWrapper> scripts) : _scripts(std::move(scripts)){};
-        }
+
+        bool HasNext() { return _index < _scripts.size() || (_isSetSet && _setIndex < _setScripts->size()); }
 
         Script* GetNext() {
             // We can probably do this in a cleaner version once C++ 20 drops with Coroutine support.
@@ -46,8 +44,7 @@ namespace CreatureLib::Battling{
                 if (scriptPtr == nullptr)
                     return GetNext();
                 return *scriptPtr;
-            }
+            } else {
-            else{
                 auto set = next.GetScriptSet();
                 if (set->Count() == 0)
                     return GetNext();

src/Battling/ScriptHandling/ScriptMacros.cpp

@@ -3,9 +3,8 @@
         auto aggregator = source->GetScriptIterator();                                                                 \
         while (aggregator.HasNext()) {                                                                                 \
             auto next = aggregator.GetNext();                                                                          \
-if (next == nullptr) continue; \
+            if (next == nullptr)                                                                                       \
+                continue;                                                                                              \
             next->hookName(__VA_ARGS__);                                                                               \
         }                                                                                                              \
     }
-
-

src/Battling/ScriptHandling/ScriptResolver.cpp

@@ -1,3 +1 @@
-
-
 #include "ScriptResolver.hpp"

src/Battling/ScriptHandling/ScriptResolver.hpp

@@ -19,11 +19,8 @@ namespace CreatureLib::Battling{
 
         };
 
-        virtual Script* LoadScript(ScriptCategory category, const std::string& scriptName){
+        virtual Script* LoadScript(ScriptCategory category, const std::string& scriptName) { return nullptr; };
-            return nullptr;
-        };
     };
 }
 
-
 #endif // CREATURELIB_SCRIPTRESOLVER_HPP

src/Battling/ScriptHandling/ScriptSet.hpp

@@ -9,6 +9,7 @@ namespace CreatureLib::Battling{
     class ScriptSet {
         std::vector<Script*> _scripts;
         std::unordered_map<std::string, size_t> _lookup;
+
     public:
         void Add(Script* script) {
             auto f = _lookup.find(script->GetName());
@@ -28,13 +29,9 @@ namespace CreatureLib::Battling{
             }
         }
 
-        size_t Count() const{
+        size_t Count() const { return _scripts.size(); }
-            return _scripts.size();
-        }
 
-        const std::vector<Script *> * GetIterator() const{
+        const std::vector<Script*>* GetIterator() const { return &_scripts; }
-            return &_scripts;
-        }
     };
 }
 

src/Battling/ScriptHandling/ScriptSource.hpp

@@ -9,8 +9,10 @@ namespace CreatureLib::Battling{
     class ScriptSource {
         bool _areScriptsInitialized = false;
         std::vector<ScriptWrapper> _scripts;
+
     protected:
         virtual void GetActiveScripts(std::vector<ScriptWrapper>& scripts) = 0;
+
     public:
         ScriptAggregator GetScriptIterator() {
             if (!_areScriptsInitialized) {

src/Battling/ScriptHandling/ScriptWrapper.cpp

@@ -1,3 +1 @@
-
-
 #include "ScriptWrapper.hpp"

src/Battling/ScriptHandling/ScriptWrapper.hpp

@@ -1,5 +1,3 @@
-
-
 #ifndef CREATURELIB_SCRIPTWRAPPER_HPP
 #define CREATURELIB_SCRIPTWRAPPER_HPP
 
@@ -11,23 +9,17 @@ namespace CreatureLib::Battling{
     class ScriptWrapper {
         std::variant<Script**, ScriptSet*> _value;
         bool _isSet;
+
     public:
         ScriptWrapper(Script** s) : _value(s), _isSet(false) {}
         ScriptWrapper(ScriptSet* s) : _value(s), _isSet(true) {}
 
-        bool IsSet() const{
+        bool IsSet() const { return _isSet; }
-            return _isSet;
-        }
 
-        Script** GetScript() const{
+        Script** GetScript() const { return std::get<Script**>(_value); }
-            return std::get<Script**>(_value);
-        }
 
-        ScriptSet* GetScriptSet() const{
+        ScriptSet* GetScriptSet() const { return std::get<ScriptSet*>(_value); }
-            return std::get<ScriptSet*>(_value);
-        }
     };
 }
 
-
 #endif // CREATURELIB_SCRIPTWRAPPER_HPP

src/Battling/TurnChoices/AttackTurnChoice.hpp

@@ -1,48 +1,39 @@
 #ifndef CREATURELIB_ATTACKTURNCHOICE_HPP
 #define CREATURELIB_ATTACKTURNCHOICE_HPP
 
-#include "BaseTurnChoice.hpp"
 #include "../Models/LearnedAttack.hpp"
 #include "../Models/Target.hpp"
+#include "BaseTurnChoice.hpp"
 
 namespace CreatureLib::Battling {
     class AttackTurnChoice : public BaseTurnChoice {
         LearnedAttack* _attack;
         Target _target;
         Script* _attackScript;
+
     public:
         AttackTurnChoice(Creature* user, LearnedAttack* attack, const Target& target)
             : BaseTurnChoice(user), _attack(attack), _target(target) {}
 
-        inline LearnedAttack* GetAttack() const{
+        inline LearnedAttack* GetAttack() const { return _attack; }
-            return _attack;
-        }
 
-        TurnChoiceKind GetKind() const override {
+        TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Attack; }
-            return TurnChoiceKind ::Attack;
-        }
 
         int8_t GetPriority() const {
             // HOOK: Change priority
             return _attack->GetAttack()->GetPriority();
         }
 
-        const Target& GetTarget() const{
+        const Target& GetTarget() const { return _target; }
-            return _target;
-        }
 
-        Script* GetAttackScript(){
+        Script* GetAttackScript() { return _attackScript; }
-            return _attackScript;
-        }
 
     protected:
         void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override {
             scripts.emplace_back(&_attackScript);
             GetUser()->GetActiveScripts(scripts);
         }
-
     };
 }
 
-
 #endif // CREATURELIB_ATTACKTURNCHOICE_HPP

src/Battling/TurnChoices/BaseTurnChoice.hpp

@@ -1,24 +1,23 @@
 #ifndef CREATURELIB_BASETURNCHOICE_HPP
 #define CREATURELIB_BASETURNCHOICE_HPP
 
-#include "TurnChoiceKind.hpp"
 #include "../ScriptHandling/ScriptSource.hpp"
+#include "TurnChoiceKind.hpp"
 
 namespace CreatureLib::Battling {
     class Creature;
 
     class BaseTurnChoice : public ScriptSource {
         Creature* _user;
+
     protected:
         BaseTurnChoice(Creature* user) : _user(user){};
+
     public:
         virtual ~BaseTurnChoice() = default;
         [[nodiscard]] virtual TurnChoiceKind GetKind() const = 0;
-        [[nodiscard]] inline Creature* GetUser() const{
+        [[nodiscard]] inline Creature* GetUser() const { return _user; }
-            return _user;
-        }
     };
 }
 
-
 #endif // CREATURELIB_BASETURNCHOICE_HPP

src/Battling/TurnChoices/PassTurnChoice.hpp

@@ -8,14 +8,10 @@ namespace CreatureLib::Battling {
     public:
         PassTurnChoice(Creature* c) : BaseTurnChoice(c) {}
 
-        TurnChoiceKind GetKind() const override {
+        TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Pass; }
-            return TurnChoiceKind ::Pass;
-        }
 
     protected:
-        void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
+        void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override { GetUser()->GetActiveScripts(scripts); }
-            GetUser()->GetActiveScripts(scripts);
-        }
     };
 }
 

src/Battling/TurnChoices/TurnChoiceKind.hpp

@@ -4,12 +4,6 @@
 #include <cstdint>
 
 namespace CreatureLib::Battling {
-    enum class TurnChoiceKind : uint8_t {
+    enum class TurnChoiceKind : uint8_t { Pass, Attack, Item, Switch, RunAway };
-        Pass,
-        Attack,
-        Item,
-        Switch,
-        RunAway
-    };
 }
 #endif // CREATURELIB_TURNCHOICEKIND_HPP

src/Core/Exceptions/CreatureException.hpp

@@ -6,13 +6,11 @@
 
 class CreatureException : std::exception {
     std::string _error;
+
 public:
     CreatureException(std::string error) {}
 
-    const char *what() const noexcept override {
+    const char* what() const noexcept override { return _error.c_str(); }
-        return _error.c_str();
-    }
 };
 
-
 #endif // CREATURELIB_CREATUREEXCEPTION_HPP

src/Core/Random.cpp

@@ -2,7 +2,8 @@
 #include <limits>
 
 // Seed parameterless constructor with current milliseconds since epoch.
-CreatureLib::Core::Random::Random() : _rng(std::mt19937(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count())){}
+CreatureLib::Core::Random::Random()
+    : _rng(std::mt19937(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count())) {}
 
 float CreatureLib::Core::Random::GetFloat() {
     return static_cast<float>(_rng()) / (static_cast<float>(std::mt19937::max() - std::mt19937::min()) - 0.5f);
@@ -23,8 +24,3 @@ int32_t CreatureLib::Core::Random::Get(int32_t max) {
 int32_t CreatureLib::Core::Random::Get(int32_t min, int32_t max) {
     return static_cast<int32_t>(GetDouble() * static_cast<float>(max - min) + min);
 }
-
-
-
-
-

src/Core/Random.hpp

@@ -1,13 +1,14 @@
 #ifndef CREATURELIB_RANDOM_HPP
 #define CREATURELIB_RANDOM_HPP
-#include <cstdint>
 #include <chrono>
+#include <cstdint>
 #include <random>
 using namespace std::chrono;
 namespace CreatureLib::Core {
     class Random {
     private:
         std::mt19937 _rng;
+
     public:
         Random();
         explicit Random(int32_t seed) : _rng(seed){};

src/Core/StatisticSet.hpp

@@ -1,10 +1,10 @@
 #ifndef CREATURELIB_STATISTICSET_HPP
 #define CREATURELIB_STATISTICSET_HPP
-#include <stdint.h>
 #include <exception>
-#include "Statistic.hpp"
+#include <stdint.h>
 #include "../GenericTemplates.cpp"
 #include "Exceptions/NotReachableException.hpp"
+#include "Statistic.hpp"
 
 namespace CreatureLib::Core {
     template <class T>
@@ -16,14 +16,13 @@ namespace CreatureLib::Core{
         T _magicalAttack;
         T _magicalDefense;
         T _speed;
+
     public:
         StatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense, T speed)
-                : _health(health), _physicalAttack(physicalAttack),
+            : _health(health), _physicalAttack(physicalAttack), _physicalDefense(physicalDefense),
-                  _physicalDefense(physicalDefense), _magicalAttack(magicalAttack),
+              _magicalAttack(magicalAttack), _magicalDefense(magicalDefense), _speed(speed) {}
-                  _magicalDefense(magicalDefense), _speed(speed){}
         StatisticSet()
-                : _health(0), _physicalAttack(0), _physicalDefense(0), _magicalAttack(0), _magicalDefense(0), _speed(0)
+            : _health(0), _physicalAttack(0), _physicalDefense(0), _magicalAttack(0), _magicalDefense(0), _speed(0) {}
-        {}
 
         inline T GetHealth() const { return _health; }
         inline T GetPhysicalAttack() const { return _physicalAttack; }
@@ -32,7 +31,6 @@ namespace CreatureLib::Core{
         inline T GetMagicalDefense() const { return _magicalDefense; }
         inline T GetSpeed() const { return _speed; }
 
-
         [[nodiscard]] inline T GetStat(Statistic stat) const {
             switch (stat) {
                 case Health: return _health;
@@ -82,5 +80,4 @@ namespace CreatureLib::Core{
     };
 }
 
-
 #endif //CREATURELIB_STATISTICSET_HPP

src/GenericTemplates.cpp

@@ -2,15 +2,22 @@
 \brief GetProperty creates a simple wrapper for a field, creating a private field, and a public getter method.
  */
 #define GetProperty(type, name)                                                                                        \
-private: type __##name; \
+private:                                                                                                               \
-public: [[nodiscard]] inline type Get##name() const{ return __##name; };
+    type __##name;                                                                                                     \
+                                                                                                                       \
+public:                                                                                                                \
+    [[nodiscard]] inline type Get##name() const { return __##name; };
 
 /*!
 \brief GetProperty creates a simple wrapper for a field, creating a private field, a public getter method, and a public
  setter method.
  */
 #define GetSetProperty(type, name)                                                                                     \
-private: type __##name; \
+private:                                                                                                               \
-public: [[nodiscard]] inline type Get##name() const{ return __##name; }; \
+    type __##name;                                                                                                     \
-public: inline void Set##name(type value) { __##name = value; };
+                                                                                                                       \
-
+public:                                                                                                                \
+    [[nodiscard]] inline type Get##name() const { return __##name; };                                                  \
+                                                                                                                       \
+public:                                                                                                                \
+    inline void Set##name(type value) { __##name = value; };

src/Library/AttackLibrary.cpp

@@ -13,8 +13,4 @@ void CreatureLib::Library::AttackLibrary::LoadAttack(const std::string &name,
     this->_attacks.insert({name, attack});
 }
 
-void CreatureLib::Library::AttackLibrary::DeleteAttack(const std::string &name) {
+void CreatureLib::Library::AttackLibrary::DeleteAttack(const std::string& name) { this->_attacks.erase(name); }
-    this->_attacks.erase(name);
-}
-
-

src/Library/AttackLibrary.hpp

@@ -9,6 +9,7 @@ namespace CreatureLib::Library {
     class AttackLibrary {
     private:
         std::unordered_map<std::string, const AttackData*> _attacks;
+
     public:
         AttackLibrary() = default;
 

src/Library/Attacks/AttackCategory.hpp

@@ -4,11 +4,7 @@
 #include <cstdint>
 
 namespace CreatureLib::Library {
-    enum class AttackCategory : uint8_t {
+    enum class AttackCategory : uint8_t { Physical, Magical, Status };
-        Physical,
-        Magical,
-        Status
-    };
 }
 
 #endif // CREATURELIB_ATTACKCATEGORY_HPP

src/Library/Attacks/AttackData.cpp

@@ -1,5 +1,4 @@
 #include "AttackData.hpp"
-
 #include <utility>
 
 CreatureLib::Library::AttackData::AttackData(std::string name, std::string type,
@@ -7,19 +6,9 @@ CreatureLib::Library::AttackData::AttackData(std::string name, std::string type,
                                              uint8_t accuracy, uint8_t baseUsage,
                                              CreatureLib::Library::AttackTarget target, uint8_t priority,
                                              std::unordered_set<std::string> flags)
-                                             :
+    : __Name(std::move(name)), __Type(std::move(type)), __Category(category), __BasePower(power), __Accuracy(accuracy),
-                                             __Name(std::move(name)),
+      __BaseUsages(baseUsage), __Target(target), __Priority(priority), _flags(std::move(flags)) {}
-                                             __Type(std::move(type)),
-                                             __Category(category),
-                                             __BasePower(power),
-                                             __Accuracy(accuracy),
-                                             __BaseUsages(baseUsage),
-                                             __Target(target),
-                                             __Priority(priority),
-                                             _flags(std::move(flags))
-                                             {}
 
 bool CreatureLib::Library::AttackData::HasFlag(const std::string& key) const {
     return this->_flags.find(key) != this->_flags.end();
 }
-

src/Library/Attacks/AttackData.hpp

@@ -3,11 +3,10 @@
 
 #include <string>
 #include <unordered_set>
+#include "../../GenericTemplates.cpp"
 #include "AttackCategory.hpp"
 #include "AttackTarget.hpp"
 
-#include "../../GenericTemplates.cpp"
-
 namespace CreatureLib::Library {
     class AttackData {
         GetProperty(std::string, Name);
@@ -18,8 +17,10 @@ namespace CreatureLib::Library {
         GetProperty(uint8_t, BaseUsages);
         GetProperty(AttackTarget, Target);
         GetProperty(uint8_t, Priority);
+
     private:
         std::unordered_set<std::string> _flags;
+
     public:
         AttackData(std::string name, std::string type, AttackCategory category, uint8_t power, uint8_t accuracy,
                    uint8_t baseUsage, AttackTarget target, uint8_t priority, std::unordered_set<std::string> flags);
@@ -28,5 +29,4 @@ namespace CreatureLib::Library {
     };
 }
 
-
 #endif // CREATURELIB_ATTACKDATA_HPP

src/Library/CreatureData/CreatureMoves.cpp

@@ -1,16 +1,8 @@
 #include "CreatureMoves.hpp"
 #include <utility>
 
-CreatureLib::Library::LevelMove::LevelMove(uint8_t level, std::string name)
+CreatureLib::Library::LevelMove::LevelMove(uint8_t level, std::string name) : _level(level), _name(std::move(name)) {}
-    :_level(level),
-    _name(std::move(name))
-{}
 
-uint8_t CreatureLib::Library::LevelMove::GetLevel() const {
+uint8_t CreatureLib::Library::LevelMove::GetLevel() const { return this->_level; }
-    return this->_level;
-}
-
-std::string CreatureLib::Library::LevelMove::GetName() const {
-    return this->_name;
-}
 
+std::string CreatureLib::Library::LevelMove::GetName() const { return this->_name; }

src/Library/CreatureData/CreatureMoves.hpp

@@ -10,6 +10,7 @@ namespace CreatureLib::Library{
     private:
         uint8_t _level;
         std::string _name;
+
     public:
         LevelMove(uint8_t level, std::string name);
         [[nodiscard]] inline uint8_t GetLevel() const;
@@ -23,10 +24,10 @@ namespace CreatureLib::Library{
         std::vector<std::string> _machineMoves;
         std::vector<std::string> _tutorMoves;
         std::vector<std::string> _variantDependentMoves;
+
     public:
         // TODO: Public API funcs
     };
 }
 
-
 #endif // CREATURELIB_CREATUREMOVES_HPP

src/Library/CreatureData/CreatureSpecies.cpp

@@ -2,30 +2,19 @@
 
 using namespace CreatureLib::Library;
 
-CreatureSpecies::CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant,
+CreatureSpecies::CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant, float genderRatio,
-        float genderRatio, std::string growthRate, uint8_t captureRate, uint8_t baseHappiness)
+                                 std::string growthRate, uint8_t captureRate, uint8_t baseHappiness)
-                             :
+    : __Id(id), __GenderRate(genderRatio), __GrowthRate(std::move(growthRate)), __CaptureRate(captureRate),
-                             __Id(id),
+      __BaseHappiness(baseHappiness), _variants({{"default", defaultVariant}}), _name(std::move(name)) {}
-                             __GenderRate(genderRatio),
-                             __GrowthRate(std::move(growthRate)),
-                             __CaptureRate(captureRate),
-                             __BaseHappiness(baseHappiness),
-                            _variants({{"default", defaultVariant}}),
-                            _name(std::move(name))
-{}
 
-const SpeciesVariant *CreatureSpecies::GetVariant(const std::string& key) const {
+const SpeciesVariant* CreatureSpecies::GetVariant(const std::string& key) const { return _variants.at(key); }
-    return _variants.at(key);
-}
 
 Gender CreatureSpecies::GetRandomGender(CreatureLib::Core::Random& rand) const {
     // TODO: Genderless creatures
     auto val = rand.GetDouble();
-    if (val >= this->__GenderRate) return Gender ::Female;
+    if (val >= this->__GenderRate)
+        return Gender ::Female;
     return Gender ::Male;
 }
 
-const std::string &CreatureSpecies::GetName() const {
+const std::string& CreatureSpecies::GetName() const { return _name; }
-    return _name;
-}
-

src/Library/CreatureData/CreatureSpecies.hpp

@@ -3,12 +3,13 @@
 
 #include <string>
 #include <unordered_map>
-#include "SpeciesVariant.hpp"
 #include "../Gender.hpp"
+#include "SpeciesVariant.hpp"
 
 namespace CreatureLib::Library {
     /*!
-\brief This holds the data required for a species of a creature, so the general data we can describe different creatures with.
+    \brief This holds the data required for a species of a creature, so the general data we can describe different
+    creatures with.
      */
     class CreatureSpecies {
         GetProperty(uint16_t, Id);
@@ -16,12 +17,14 @@ namespace CreatureLib::Library {
         GetProperty(std::string, GrowthRate);
         GetProperty(uint8_t, CaptureRate);
         GetProperty(uint8_t, BaseHappiness);
+
     private:
         std::unordered_map<std::string, const SpeciesVariant*> _variants;
         std::string _name;
+
     public:
-        CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant,
+        CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant, float genderRatio,
-                float genderRatio, std::string growthRate, uint8_t captureRate, uint8_t baseHappiness);
+                        std::string growthRate, uint8_t captureRate, uint8_t baseHappiness);
 
         ~CreatureSpecies() {
             for (auto v : _variants)

src/Library/CreatureData/LearnableAttacks.cpp

@@ -2,9 +2,7 @@
 
 using namespace CreatureLib::Library;
 
-void LearnableAttacks::AddLevelMove(uint8_t level, AttackData *attack) {
+void LearnableAttacks::AddLevelMove(uint8_t level, AttackData* attack) { _learnedByLevel[level].push_back(attack); }
-    _learnedByLevel[level].push_back(attack);
-}
 
 const std::vector<const AttackData*>& LearnableAttacks::GetMovesForLevel(uint8_t level) const {
     return _learnedByLevel[level];

src/Library/CreatureData/LearnableAttacks.hpp

@@ -7,9 +7,9 @@
 namespace CreatureLib::Library {
     class LearnableAttacks {
         std::vector<std::vector<const AttackData*>> _learnedByLevel;
+
     public:
-        LearnableAttacks(uint8_t maxLevel)
+        LearnableAttacks(uint8_t maxLevel) : _learnedByLevel(std::vector<std::vector<const AttackData*>>(maxLevel)) {}
-            :_learnedByLevel(std::vector<std::vector<const AttackData*>>(maxLevel)){}
 
         void AddLevelMove(uint8_t level, AttackData* attack);
 
@@ -17,5 +17,4 @@ namespace CreatureLib::Library {
     };
 }
 
-
 #endif // CREATURELIB_LEARNABLEATTACKS_HPP

src/Library/CreatureData/SpeciesVariant.cpp

@@ -2,17 +2,11 @@
 #include <algorithm>
 #include <utility>
 
-const std::vector<uint8_t>& CreatureLib::Library::SpeciesVariant::GetTypes() const {
+const std::vector<uint8_t>& CreatureLib::Library::SpeciesVariant::GetTypes() const { return _types; }
-    return _types;
-}
 
-size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const {
+size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const { return _types.size(); }
-    return _types.size();
-}
 
-uint8_t CreatureLib::Library::SpeciesVariant::GetType(size_t index) const {
+uint8_t CreatureLib::Library::SpeciesVariant::GetType(size_t index) const { return _types[index]; }
-    return _types[index];
-}
 
 uint32_t CreatureLib::Library::SpeciesVariant::GetStatistic(CreatureLib::Core::Statistic stat) const {
     return _baseStatistics.GetStat(stat);
@@ -54,18 +48,10 @@ CreatureLib::Library::SpeciesVariant::SpeciesVariant(std::string name, float hei
                                                      uint32_t baseExperience, std::vector<uint8_t> types,
                                                      CreatureLib::Core::StatisticSet<uint16_t> baseStats,
                                                      std::vector<std::string> talents,
-                                                     std::vector<std::string> secretTalents, const LearnableAttacks* attacks)
+                                                     std::vector<std::string> secretTalents,
-                                                     : __Name(std::move(name)),
+                                                     const LearnableAttacks* attacks)
-                                                     __Height(height),
+    : __Name(std::move(name)), __Height(height), __Weight(weight), __BaseExperience(baseExperience),
-                                                     __Weight(weight),
+      _types(std::move(types)), _baseStatistics(baseStats), _talents(std::move(talents)),
-                                                     __BaseExperience(baseExperience),
+      _secretTalents(std::move(secretTalents)), _attacks(attacks) {}
-                                                     _types(std::move(types)),
-                                                     _baseStatistics(baseStats),
-                                                     _talents(std::move(talents)),
-                                                     _secretTalents(std::move(secretTalents)),
-                                                     _attacks(attacks)
-                                                     {}
 
-CreatureLib::Library::SpeciesVariant::~SpeciesVariant() {
+CreatureLib::Library::SpeciesVariant::~SpeciesVariant() { delete _attacks; }
-    delete _attacks;
-}

src/Library/CreatureData/SpeciesVariant.hpp

@@ -3,10 +3,10 @@
 
 #include <string>
 #include <vector>
-#include "CreatureMoves.hpp"
+#include "../../Core/Random.hpp"
 #include "../../Core/StatisticSet.hpp"
 #include "../../GenericTemplates.cpp"
-#include "../../Core/Random.hpp"
+#include "CreatureMoves.hpp"
 #include "LearnableAttacks.hpp"
 
 namespace CreatureLib::Library {
@@ -18,16 +18,19 @@ namespace CreatureLib::Library {
         GetProperty(float, Height);
         GetProperty(float, Weight);
         GetProperty(uint32_t, BaseExperience);
+
     private:
         std::vector<uint8_t> _types;
         const Core::StatisticSet<uint16_t> _baseStatistics;
         std::vector<std::string> _talents;
         std::vector<std::string> _secretTalents;
         const LearnableAttacks* _attacks;
+
     public:
         SpeciesVariant(std::string name, float height, float weight, uint32_t baseExperience,
-                std::vector<uint8_t> types, Core::StatisticSet<uint16_t > baseStats, std::vector<std::string> talents,
+                       std::vector<uint8_t> types, Core::StatisticSet<uint16_t> baseStats,
-                std::vector<std::string> secretTalents, const LearnableAttacks* attacks);
+                       std::vector<std::string> talents, std::vector<std::string> secretTalents,
+                       const LearnableAttacks* attacks);
 
         ~SpeciesVariant();
 

src/Library/DataLibrary.cpp

@@ -1,15 +1,12 @@
 #include "DataLibrary.hpp"
 
-CreatureLib::Library::DataLibrary::DataLibrary(LibrarySettings settings,
+CreatureLib::Library::DataLibrary::DataLibrary(LibrarySettings settings, CreatureLib::Library::SpeciesLibrary* species,
-                                               CreatureLib::Library::SpeciesLibrary *species,
                                                CreatureLib::Library::AttackLibrary* attacks,
                                                CreatureLib::Library::ItemLibrary* items,
                                                CreatureLib::Library::GrowthRateLibrary* growthRates,
                                                TypeLibrary* typeLibrary)
-                                               : _settings(settings), _species(species), _attacks(attacks), _items(items),
+    : _settings(settings), _species(species), _attacks(attacks), _items(items), _growthRates(growthRates),
-                                               _growthRates(growthRates), _typeLibrary(typeLibrary){
+      _typeLibrary(typeLibrary) {}
-
-}
 
 const CreatureLib::Library::LibrarySettings& CreatureLib::Library::DataLibrary::GetSettings() const {
     return _settings;
@@ -23,9 +20,7 @@ const CreatureLib::Library::AttackLibrary *CreatureLib::Library::DataLibrary::Ge
     return _attacks;
 }
 
-const CreatureLib::Library::ItemLibrary *CreatureLib::Library::DataLibrary::GetItemLibrary() const {
+const CreatureLib::Library::ItemLibrary* CreatureLib::Library::DataLibrary::GetItemLibrary() const { return _items; }
-    return _items;
-}
 
 const CreatureLib::Library::GrowthRateLibrary* CreatureLib::Library::DataLibrary::GetGrowthRates() const {
     return _growthRates;
@@ -34,6 +29,3 @@ const CreatureLib::Library::GrowthRateLibrary *CreatureLib::Library::DataLibrary
 const CreatureLib::Library::TypeLibrary* CreatureLib::Library::DataLibrary::GetTypeLibrary() const {
     return _typeLibrary;
 }
-
-
-

src/Library/DataLibrary.hpp

@@ -1,11 +1,11 @@
 #ifndef CREATURELIB_DATALIBRARY_HPP
 #define CREATURELIB_DATALIBRARY_HPP
 
-#include "SpeciesLibrary.hpp"
 #include "AttackLibrary.hpp"
-#include "ItemLibrary.hpp"
 #include "GrowthRates/GrowthRateLibrary.hpp"
+#include "ItemLibrary.hpp"
 #include "LibrarySettings.hpp"
+#include "SpeciesLibrary.hpp"
 #include "TypeLibrary.hpp"
 
 namespace CreatureLib::Library {
@@ -20,14 +20,11 @@ namespace CreatureLib::Library {
         const ItemLibrary* _items;
         const GrowthRateLibrary* _growthRates;
         const TypeLibrary* _typeLibrary;
+
     public:
-        DataLibrary(LibrarySettings settings,
+        DataLibrary(LibrarySettings settings, CreatureLib::Library::SpeciesLibrary* species,
-                    CreatureLib::Library::SpeciesLibrary *species,
+                    CreatureLib::Library::AttackLibrary* attacks, CreatureLib::Library::ItemLibrary* items,
-                    CreatureLib::Library::AttackLibrary *attacks,
+                    CreatureLib::Library::GrowthRateLibrary* growthRates, TypeLibrary* typeLibrary);
-                    CreatureLib::Library::ItemLibrary *items,
-                    CreatureLib::Library::GrowthRateLibrary *growthRates,
-                    TypeLibrary* typeLibrary
-                    );
 
         ~DataLibrary() {
             delete _species;
@@ -46,5 +43,4 @@ namespace CreatureLib::Library {
     };
 }
 
-
 #endif // CREATURELIB_DATALIBRARY_HPP

src/Library/Gender.hpp

@@ -8,11 +8,7 @@ namespace CreatureLib::Library{
     \brief Might be somewhat controversial nowadays, but as many creature battling games only have two genders, we'll
      hardcode those.
      */
-    enum class Gender : uint8_t {
+    enum class Gender : uint8_t { Male, Female, Genderless };
-        Male,
-        Female,
-        Genderless
-    };
 }
 
 #endif // CREATURELIB_GENDER_HPP

src/Library/GrowthRates/GrowthRateLibrary.cpp

@@ -1,9 +1,11 @@
 #include "GrowthRateLibrary.hpp"
 
-uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const std::string &growthRate, uint32_t experience) const {
+uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const std::string& growthRate,
+                                                                uint32_t experience) const {
     return _growthRates.at(growthRate)->CalculateLevel(experience);
 }
 
-uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const std::string &growthRate, uint8_t level) const {
+uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const std::string& growthRate,
+                                                                      uint8_t level) const {
     return _growthRates.at(growthRate)->CalculateExperience(level);
 }

src/Library/GrowthRates/GrowthRateLibrary.hpp

@@ -10,6 +10,7 @@ namespace CreatureLib::Library{
     class GrowthRateLibrary {
     private:
         std::unordered_map<std::string, GrowthRate*> _growthRates;
+
     public:
         [[nodiscard]] uint8_t CalculateLevel(const std::string& growthRate, uint32_t experience) const;
         [[nodiscard]] uint32_t CalculateExperience(const std::string& growthRate, uint8_t level) const;

src/Library/ItemLibrary.cpp

@@ -12,6 +12,4 @@ void CreatureLib::Library::ItemLibrary::LoadItem(const std::string &name, const
     this->_items.insert({name, item});
 }
 
-void CreatureLib::Library::ItemLibrary::DeleteItem(const std::string &name) {
+void CreatureLib::Library::ItemLibrary::DeleteItem(const std::string& name) { this->_items.erase(name); }
-    this->_items.erase(name);
-}

src/Library/ItemLibrary.hpp

@@ -9,20 +9,17 @@ namespace CreatureLib::Library {
     class ItemLibrary {
     private:
         std::unordered_map<std::string, const Item*> _items;
+
     public:
         ItemLibrary() = default;
-        ~ItemLibrary(){
+        ~ItemLibrary() { _items.clear(); }
-            _items.clear();
-        }
 
         [[nodiscard]] const Item* GetItem(const std::string& name) const;
         [[nodiscard]] const Item* operator[](const std::string& name) const;
 
         void LoadItem(const std::string& name, const Item* item);
         void DeleteItem(const std::string& name);
-
     };
 }
 
-
 #endif // CREATURELIB_ITEMLIBRARY_HPP

src/Library/Items/BattleItemCategory.hpp

@@ -4,13 +4,7 @@
 #include <cstdint>
 
 namespace CreatureLib::Library {
-    enum class BattleItemCategory : uint8_t {
+    enum class BattleItemCategory : uint8_t { None, Healing, StatusHealing, CaptureDevice, MiscBattleItem };
-        None,
-        Healing,
-        StatusHealing,
-        CaptureDevice,
-        MiscBattleItem
-    };
 }
 
 #endif // CREATURELIB_BATTLEITEMCATEGORY_HPP

src/Library/Items/Item.hpp

@@ -3,9 +3,9 @@
 
 #include <string>
 #include <unordered_set>
-#include "ItemCategory.hpp"
-#include "BattleItemCategory.hpp"
 #include "../../GenericTemplates.cpp"
+#include "BattleItemCategory.hpp"
+#include "ItemCategory.hpp"
 
 namespace CreatureLib::Library {
     class Item {
@@ -13,8 +13,10 @@ namespace CreatureLib::Library {
         GetProperty(ItemCategory, Category);
         GetProperty(BattleItemCategory, BattleCategory);
         GetProperty(int32_t, Price);
+
     private:
         std::unordered_set<std::string> _flags;
+
     public:
         Item(std::string name, ItemCategory category, BattleItemCategory battleCategory, int32_t price,
              std::unordered_set<std::string> flags);

src/Library/LibrarySettings.hpp

@@ -7,17 +7,14 @@ namespace CreatureLib::Library {
     class LibrarySettings {
         uint8_t _maximalLevel;
         uint8_t _maximalMoves;
+
     public:
         LibrarySettings(uint8_t maximalLevel, uint8_t maximalMoves)
             : _maximalLevel(maximalLevel), _maximalMoves(maximalMoves) {}
 
-        inline uint8_t GetMaximalLevel() const{
+        inline uint8_t GetMaximalLevel() const { return _maximalLevel; }
-            return _maximalLevel;
-        }
 
-        inline uint8_t GetMaximalMoves() const{
+        inline uint8_t GetMaximalMoves() const { return _maximalMoves; }
-            return _maximalMoves;
-        }
     };
 }
 

src/Library/SpeciesLibrary.cpp

@@ -1,10 +1,12 @@
 #include "SpeciesLibrary.hpp"
 
-const CreatureLib::Library::CreatureSpecies *CreatureLib::Library::SpeciesLibrary::GetSpecies(const std::string& name) const{
+const CreatureLib::Library::CreatureSpecies*
+CreatureLib::Library::SpeciesLibrary::GetSpecies(const std::string& name) const {
     return _species.at(name);
 }
 
-const CreatureLib::Library::CreatureSpecies* CreatureLib::Library::SpeciesLibrary::operator[](const std::string &name) const{
+const CreatureLib::Library::CreatureSpecies*
+    CreatureLib::Library::SpeciesLibrary::operator[](const std::string& name) const {
     return GetSpecies(name);
 }
 
@@ -13,7 +15,4 @@ void CreatureLib::Library::SpeciesLibrary::LoadSpecies(const std::string &name,
     _species.insert({name, species});
 }
 
-void CreatureLib::Library::SpeciesLibrary::DeleteSpecies(const std::string &name) {
+void CreatureLib::Library::SpeciesLibrary::DeleteSpecies(const std::string& name) { _species.erase(name); }
-    _species.erase(name);
-}
-

src/Library/SpeciesLibrary.hpp

@@ -9,6 +9,7 @@ namespace CreatureLib::Library {
     class SpeciesLibrary {
     private:
         std::unordered_map<std::string, const CreatureSpecies*> _species;
+
     public:
         SpeciesLibrary() = default;
 
@@ -26,5 +27,4 @@ namespace CreatureLib::Library {
     };
 }
 
-
 #endif // CREATURELIB_SPECIESLIBRARY_HPP

src/Library/TypeLibrary.cpp

@@ -14,9 +14,7 @@ float TypeLibrary::GetSingleEffectiveness(uint8_t attacking, uint8_t defensive)
     return _effectiveness[attacking][defensive];
 }
 
-uint8_t TypeLibrary::GetTypeId(const std::string &s) const {
+uint8_t TypeLibrary::GetTypeId(const std::string& s) const { return _types.at(s); }
-    return _types.at(s);
-}
 
 uint8_t TypeLibrary::RegisterType(const std::string& typeName) {
     _types.insert({typeName, _types.size()});

src/Library/TypeLibrary.hpp

@@ -8,6 +8,7 @@ namespace CreatureLib::Library{
     class TypeLibrary {
         std::unordered_map<std::string, uint8_t> _types;
         std::vector<std::vector<float>> _effectiveness;
+
     public:
         uint8_t GetTypeId(const std::string& s) const;
         float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const;
@@ -18,5 +19,4 @@ namespace CreatureLib::Library{
     };
 }
 
-
 #endif // CREATURELIB_TYPELIBRARY_HPP

tests/BattleTests/ChoiceSetTests.cpp

@@ -1,9 +1,9 @@
 #ifdef TESTS_BUILD
 
-#include "../TestLibrary/TestLibrary.cpp"
 #include "../../src/Battling/Models/BattleSide.hpp"
 #include "../../src/Battling/Models/CreateCreature.hpp"
 #include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
+#include "../TestLibrary/TestLibrary.cpp"
 
 using namespace CreatureLib::Battling;
 
@@ -64,5 +64,4 @@ TEST_CASE( "Set Choice two-sized side, validate all choices set", "[Battling]" )
     delete c2;
 }
 
-
 #endif

tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp

@@ -1,12 +1,9 @@
 #ifdef TESTS_BUILD
 
 #include <utility>
-
 #include "../../../extern/catch.hpp"
 #include "../../../src/Battling/ScriptHandling/ScriptAggregator.hpp"
 
-
-
 using namespace CreatureLib;
 using namespace CreatureLib::Battling;
 
@@ -14,10 +11,7 @@ class TestScript : public Script{
 public:
     explicit TestScript(std::string name) : Script(std::move(name)){};
 
-    void TestMethod(int& runCount)  {
+    void TestMethod(int& runCount) { runCount++; }
-        runCount++;
-    }
-
 };
 
 TEST_CASE("Script Aggregator properly iterates containing script.", "[Battling, Scripting]") {
@@ -162,8 +156,4 @@ TEST_CASE( "Script Aggregator properly iterates empty Script Set.", "[Battling,
     CHECK(ran == 1);
 }
 
-
-
-
-
 #endif

tests/BattleTests/ScriptTests/ScriptSetTests.cpp

@@ -1,14 +1,12 @@
 #ifdef TESTS_BUILD
 
 #include <utility>
-
 #include "../../../extern/catch.hpp"
 #include "../../../src/Battling/ScriptHandling/ScriptSet.hpp"
 
 using namespace CreatureLib;
 using namespace CreatureLib::Battling;
 
-
 TEST_CASE("Empty script set count == 0", "[Battling, Scripting]") {
     auto set = ScriptSet();
     REQUIRE(set.Count() == 0);
@@ -85,9 +83,4 @@ TEST_CASE( "Add two scripts to script set, then remove them", "[Battling, Script
     delete s2;
 }
 
-
-
 #endif
-
-
-

tests/BattleTests/ScriptTests/ScriptSourceTest.cpp

@@ -1,9 +1,8 @@
 #ifdef TESTS_BUILD
 
-#include <utility>
-
-#include "../../../extern/catch.hpp"
 #include "../../../src/Battling/ScriptHandling/ScriptSource.hpp"
+#include <utility>
+#include "../../../extern/catch.hpp"
 #include "../../../src/Battling/ScriptHandling/ScriptAggregator.hpp"
 
 using namespace CreatureLib;
@@ -13,29 +12,24 @@ class TestScript : public Script{
 public:
     explicit TestScript(std::string name) : Script(std::move(name)){};
 
-    void TestMethod(int& runCount)  {
+    void TestMethod(int& runCount) { runCount++; }
-        runCount++;
-    }
 };
 
 class ScriptSourceWithScriptPtr : public ScriptSource {
 public:
     Script* ScriptPtr = nullptr;
+
 protected:
-    void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
+    void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override { scripts.emplace_back(&ScriptPtr); }
-        scripts.emplace_back(&ScriptPtr);
-    }
 };
 
 class ScriptSourceWithScriptSet : public ScriptSource {
 public:
     ScriptSet Set;
-protected:
-    void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
-        scripts.emplace_back(&Set);
-    }
-};
 
+protected:
+    void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override { scripts.emplace_back(&Set); }
+};
 
 TEST_CASE("Script source with unset script ptr.", "[Battling, Scripting]") {
     auto source = ScriptSourceWithScriptPtr();
@@ -100,6 +94,4 @@ TEST_CASE( "Script source with multiple item script set.", "[Battling, Scripting
     delete s2;
 }
 
-
 #endif
-

tests/BattleTests/TurnOrderTests.cpp

@@ -1,9 +1,9 @@
 #ifdef TESTS_BUILD
 
-#include "../TestLibrary/TestLibrary.cpp"
-#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
-#include "../../src/Battling/TurnChoices/AttackTurnChoice.hpp"
 #include "../../src/Battling/Flow/TurnOrdering.hpp"
+#include "../../src/Battling/TurnChoices/AttackTurnChoice.hpp"
+#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
+#include "../TestLibrary/TestLibrary.cpp"
 
 using namespace CreatureLib;
 using namespace CreatureLib::Battling;
@@ -113,6 +113,4 @@ TEST_CASE( "Turn ordering: No priority goes before low priority", "[Battling]" )
     delete a2;
 }
 
-
-
 #endif

tests/RandomTests.cpp

@@ -1,7 +1,7 @@
 #ifdef TESTS_BUILD
 #include "../extern/catch.hpp"
-#include "../src/Core/Random.hpp"
 #include "../src/Core/Exceptions/CreatureException.hpp"
+#include "../src/Core/Random.hpp"
 
 TEST_CASE("Random ints", "[Utilities]") {
     auto rand = CreatureLib::Core::Random(10);
@@ -39,7 +39,6 @@ TEST_CASE( "Random ints with limit", "[Utilities]" ) {
     CHECK(rand.Get(2) == 0);
     CHECK(rand.Get(2) == 0);
     CHECK(rand.Get(2) == 0);
-
 }
 
 TEST_CASE("Random ints with upper and bottom", "[Utilities]") {
@@ -81,8 +80,10 @@ TEST_CASE( "Random distribution (max 0, min 2)", "[Utilities]" ) {
     for (size_t i = 0; i < size; i++) {
         if (arr[i] != 0 && arr[i] != 1)
             throw CreatureException("We expected a value of 0 or 1 here, but got a " + std::to_string(arr[i]));
-        if (arr[i] == 0) numZeros++;
+        if (arr[i] == 0)
-        else numOnes++;
+            numZeros++;
+        else
+            numOnes++;
     }
     auto div = static_cast<float>(numZeros) / static_cast<float>(numOnes);
     INFO("Distribution: " << numZeros << "/" << numOnes);
@@ -102,9 +103,12 @@ TEST_CASE( "Random distribution (max 0, min 3)", "[Utilities]" ) {
     for (size_t i = 0; i < size; i++) {
         if (arr[i] != 0 && arr[i] != 1 && arr[i] != 2)
             throw CreatureException("We expected a value between 0 and 2 here, but got a " + std::to_string(arr[i]));
-        if (arr[i] == 0) numZeros++;
+        if (arr[i] == 0)
-        else if (arr[i] == 1) numOnes++;
+            numZeros++;
-        else numTwos++;
+        else if (arr[i] == 1)
+            numOnes++;
+        else
+            numTwos++;
     }
     INFO("Distribution: " << numZeros << "/" << numOnes << "/" << numTwos);
     CHECK(Approx(static_cast<float>(numZeros) / static_cast<float>(numOnes)).margin(0.01) == 1);
@@ -112,6 +116,4 @@ TEST_CASE( "Random distribution (max 0, min 3)", "[Utilities]" ) {
     CHECK(Approx(static_cast<float>(numOnes) / static_cast<float>(numTwos)).margin(0.01) == 1);
 }
 
-
-
 #endif

tests/TestLibrary/TestLibrary.cpp

@@ -9,25 +9,25 @@ static BattleLibrary* __library = nullptr;
 
 static SpeciesLibrary* BuildSpeciesLibrary() {
     auto l = new SpeciesLibrary();
-    l->LoadSpecies("testSpecies1", new CreatureSpecies(0, "testSpecies1",
+    l->LoadSpecies("testSpecies1",
-            new SpeciesVariant("default", 1,1, 10, {0, 1},
+                   new CreatureSpecies(
-                    StatisticSet<uint16_t >(10,10,10,10,10,10),
+                       0, "testSpecies1",
-                               {"testTalent"}, {"testSecretTalent"},
+                       new SpeciesVariant("default", 1, 1, 10, {0, 1}, StatisticSet<uint16_t>(10, 10, 10, 10, 10, 10),
-                               new LearnableAttacks(100)),
+                                          {"testTalent"}, {"testSecretTalent"}, new LearnableAttacks(100)),
                        0.5f, "testGrowthRate", 5, 100));
     return l;
 }
 
 static AttackLibrary* BuildAttackLibrary() {
     auto l = new AttackLibrary();
-    l->LoadAttack("standard", new AttackData("standard", "normal", AttackCategory::Physical,
+    l->LoadAttack("standard", new AttackData("standard", "normal", AttackCategory::Physical, 20, 100, 30,
-                                             20, 100, 30, AttackTarget::AdjacentOpponent,0, {}));
+                                             AttackTarget::AdjacentOpponent, 0, {}));
-    l->LoadAttack("highPriority", new AttackData("highPriority", "normal", AttackCategory::Physical,
+    l->LoadAttack("highPriority", new AttackData("highPriority", "normal", AttackCategory::Physical, 20, 100, 30,
-                                                 20, 100, 30, AttackTarget::AdjacentOpponent,1, {}));
+                                                 AttackTarget::AdjacentOpponent, 1, {}));
-    l->LoadAttack("higherPriority", new AttackData("higherPriority", "normal", AttackCategory::Physical,
+    l->LoadAttack("higherPriority", new AttackData("higherPriority", "normal", AttackCategory::Physical, 20, 100, 30,
-                                                   20, 100, 30, AttackTarget::AdjacentOpponent,2, {}));
+                                                   AttackTarget::AdjacentOpponent, 2, {}));
-    l->LoadAttack("lowPriority", new AttackData("lowPriority", "normal", AttackCategory::Physical,
+    l->LoadAttack("lowPriority", new AttackData("lowPriority", "normal", AttackCategory::Physical, 20, 100, 30,
-                                                   20, 100, 30, AttackTarget::AdjacentOpponent,-1, {}));
+                                                AttackTarget::AdjacentOpponent, -1, {}));
     return l;
 }
 
@@ -50,15 +50,14 @@ static TypeLibrary* BuildTypeLibrary(){
 }
 
 static BattleLibrary* BuildLibrary() {
-    auto l = new DataLibrary(LibrarySettings(100, 4), BuildSpeciesLibrary(), BuildAttackLibrary(),
+    auto l = new DataLibrary(LibrarySettings(100, 4), BuildSpeciesLibrary(), BuildAttackLibrary(), BuildItemLibrary(),
-            BuildItemLibrary(), BuildGrowthRateLibrary(), BuildTypeLibrary());
+                             BuildGrowthRateLibrary(), BuildTypeLibrary());
-    auto battleLib = new BattleLibrary(l, new BattleStatCalculator(), new DamageLibrary(),
+    auto battleLib = new BattleLibrary(l, new BattleStatCalculator(), new DamageLibrary(), new CriticalLibrary(),
-            new CriticalLibrary(), new ScriptResolver());
+                                       new ScriptResolver());
     return battleLib;
 }
 
-[[maybe_unused]]
+[[maybe_unused]] static BattleLibrary* GetLibrary() {
-static BattleLibrary* GetLibrary(){
     if (__library == nullptr) {
         __library = BuildLibrary();
     }