Fixes project being completely dirty every build requiring constant full rebuilds and slowing down tooling.

Signed-off-by: Deukhoofd <Deukhoofd@gmail.com>

CMakeLists.txt

@@ -60,7 +60,6 @@ endif ()
 file(GLOB_RECURSE LIBRARY_SRC_FILES
         "src/*.cpp" "src/*.hpp" "CInterface/*.cpp" "CInterface/*.hpp")
 add_library(CreatureLib ${LIBTYPE} ${LIBRARY_SRC_FILES})
-target_precompile_headers(CreatureLib PUBLIC src/Precompiled.hxx)
 
 # If interprocedural optimization is available, apply it
 check_ipo_supported(RESULT IPO_SUPPORTED)

CMakeLists.txt.in

@@ -40,6 +40,8 @@ function(include_arbutils)
     execute_process(COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/Arbutils/include)
     execute_process(COMMAND ln -s ${CMAKE_CURRENT_BINARY_DIR}/Arbutils/src/arbutils/src
             ${CMAKE_CURRENT_BINARY_DIR}/Arbutils/include/Arbutils)
+    execute_process(COMMAND ln -s ${CMAKE_CURRENT_BINARY_DIR}/Arbutils/src/arbutils/extern
+            ${CMAKE_CURRENT_BINARY_DIR}/Arbutils/include/extern)
 
     include_directories(${CMAKE_CURRENT_BINARY_DIR}/Arbutils/include)
 

src/Battling/EventHooks/EventDataKind.hpp

@@ -1,6 +1,8 @@
 #ifndef CREATURELIB_EVENTDATAKIND_HPP
 #define CREATURELIB_EVENTDATAKIND_HPP
 
+#include <Arbutils/Enum.hpp>
+
 namespace CreatureLib::Battling {
     ENUM(EventDataKind, uint8_t, Damage, Heal, Faint, Switch, TurnStart, TurnEnd, ExperienceGain, Miss, DisplayText,
          ChangeSpecies, ChangeVariant, AttackUse, ChangeStatBoost, Fail, Swap, StatusChange)

src/Battling/EventHooks/EventHook.hpp

@@ -1,12 +1,14 @@
 #ifndef CREATURELIB_EVENTHOOK_HPP
 #define CREATURELIB_EVENTHOOK_HPP
 
+#include <Arbutils/Exception.hpp>
 #include <functional>
 #include <thread>
 #include "../../Library/Exceptions/CreatureException.hpp"
 #include "Events/EventData.hpp"
 
-template <class T> concept EventDataType = std::is_base_of<CreatureLib::Battling::EventData, T>::value;
+template <class T>
+concept EventDataType = std::is_base_of<CreatureLib::Battling::EventData, T>::value;
 
 namespace CreatureLib::Battling {
     /// The Event Hook class allows users to write consumers for the battle events, for example to write User Interfaces

src/Battling/Library/ExperienceLibrary.hpp

@@ -1,6 +1,9 @@
 #ifndef CREATURELIB_EXPERIENCELIBRARY_HPP
 #define CREATURELIB_EXPERIENCELIBRARY_HPP
 
+#include <Arbutils/Memory/Memory.hpp>
+#include <unordered_set>
+
 namespace CreatureLib::Battling {
     class Creature;
 

src/Battling/Models/CreatureIndex.hpp

@@ -1,14 +1,15 @@
 #ifndef CREATURELIB_CREATUREINDEX_HPP
 #define CREATURELIB_CREATUREINDEX_HPP
+#include "../../Defines.hpp"
 
 namespace CreatureLib::Battling {
     class CreatureIndex {
-        uint8_t _side;
+        u8 _side;
-        uint8_t _creature;
+        u8 _creature;
 
     public:
         CreatureIndex() noexcept : _side(0), _creature(0) {}
-        CreatureIndex(uint8_t side, uint8_t creature) noexcept : _side(side), _creature(creature) {}
+        CreatureIndex(uint8_t side, u8 creature) noexcept : _side(side), _creature(creature) {}
 
         uint8_t GetSideIndex() const noexcept { return _side; }
 

src/Battling/Models/LearnedAttack.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_LEARNEDATTACK_HPP
 #define CREATURELIB_LEARNEDATTACK_HPP
 
+#include <Arbutils/Memory/Memory.hpp>
 #include "../../Library/Attacks/AttackData.hpp"
 #include "AttackLearnMethod.hpp"
 

src/Battling/ScriptHandling/BattleScript.hpp

@@ -1,6 +1,9 @@
 #ifndef CREATURELIB_SCRIPT_HPP
 #define CREATURELIB_SCRIPT_HPP
 
+#include <Arbutils/Collections/List.hpp>
+#include <Arbutils/Memory/Memory.hpp>
+#include <Arbutils/Misc.hpp>
 #include "../../Library/EffectParameter.hpp"
 
 namespace CreatureLib::Battling {

src/Battling/ScriptHandling/ItemUseScript.hpp

@@ -1,6 +1,7 @@
 #ifndef ITEMUSESCRIPT_HPP
 #define ITEMUSESCRIPT_HPP
 
+#include <Arbutils/Collections/List.hpp>
 #include "../../Library/EffectParameter.hpp"
 namespace CreatureLib::Battling {
     class Creature;

src/Battling/ScriptHandling/ScriptResolver.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_SCRIPTRESOLVER_HPP
 #define CREATURELIB_SCRIPTRESOLVER_HPP
 
+#include <unordered_set>
 #include "../../Library/Items/Item.hpp"
 #include "BattleScript.hpp"
 #include "ItemUseScript.hpp"

src/Battling/ScriptHandling/ScriptSet.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_SCRIPTSET_HPP
 #define CREATURELIB_SCRIPTSET_HPP
 
+#include <Arbutils/Collections/Dictionary.hpp>
 #include <any>
 #include "BattleScript.hpp"
 

src/Defines.hpp

@@ -1,5 +1,6 @@
 #ifndef CREATURELIB_DEFINES_HPP
 #define CREATURELIB_DEFINES_HPP
+#include <cstdint>
 
 #if LEVEL_U8
 using level_int_t = uint8_t;

src/Library/Attacks/AttackCategory.hpp

@@ -1,5 +1,6 @@
 #ifndef CREATURELIB_ATTACKCATEGORY_HPP
 #define CREATURELIB_ATTACKCATEGORY_HPP
+#include <Arbutils/Enum.hpp>
 
 namespace CreatureLib::Library {
     ENUM(AttackCategory, uint8_t, Physical, Magical, Status)

src/Library/Attacks/AttackData.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_ATTACKDATA_HPP
 #define CREATURELIB_ATTACKDATA_HPP
 
+#include <unordered_set>
 #include "AttackCategory.hpp"
 #include "AttackTarget.hpp"
 #include "SecondaryEffect.hpp"

src/Library/Attacks/AttackTarget.hpp

@@ -1,6 +1,8 @@
 #ifndef CREATURELIB_ATTACKTARGET_HPP
 #define CREATURELIB_ATTACKTARGET_HPP
 
+#include <Arbutils/Enum.hpp>
+
 namespace CreatureLib::Library {
     ENUM(AttackTarget, uint8_t, Adjacent, AdjacentAlly, AdjacentAllySelf, AdjacentOpponent,
 

src/Library/Attacks/SecondaryEffect.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_SECONDARYEFFECT_HPP
 #define CREATURELIB_SECONDARYEFFECT_HPP
 
+#include <Arbutils/Collections/List.hpp>
 #include <any>
 #include "../EffectParameter.hpp"
 

src/Library/BaseLibrary.hpp

@@ -1,7 +1,11 @@
 #ifndef CREATURELIB_BASELIBRARY_HPP
 #define CREATURELIB_BASELIBRARY_HPP
 
+#include <Arbutils/Collections/Dictionary.hpp>
+#include <Arbutils/Collections/List.hpp>
+#include <Arbutils/Memory/Memory.hpp>
 #include <Arbutils/Random.hpp>
+#include <Arbutils/String/StringView.hpp>
 
 namespace CreatureLib::Library {
     template <class T> class BaseLibrary {

src/Library/ClampedStatisticSet.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_CLAMPEDSTATISTICSET_HPP
 #define CREATURELIB_CLAMPEDSTATISTICSET_HPP
 
+#include <Arbutils/Exception.hpp>
 #include "Exceptions/CreatureException.hpp"
 #include "Statistic.hpp"
 

src/Library/CreatureData/CreatureSpecies.cpp

@@ -1,4 +1,5 @@
 #include "CreatureSpecies.hpp"
+#include <Arbutils/Collections/Dictionary.hpp>
 
 using namespace CreatureLib::Library;
 

src/Library/CreatureData/LearnableAttacks.cpp

@@ -1,4 +1,5 @@
 #include "LearnableAttacks.hpp"
+#include <Arbutils/Collections/Dictionary.hpp>
 
 namespace CreatureLib::Library {
     struct LearnableAttacks::impl {

src/Library/CreatureData/LearnableAttacks.hpp

@@ -1,7 +1,9 @@
 #ifndef CREATURELIB_LEARNABLEATTACKS_HPP
 #define CREATURELIB_LEARNABLEATTACKS_HPP
 
+#include <Arbutils/Memory/Memory.hpp>
 #include <Arbutils/Random.hpp>
+#include <optional>
 #include "../Attacks/AttackData.hpp"
 
 namespace CreatureLib::Library {

src/Library/EffectParameter.hpp

@@ -1,10 +1,13 @@
 #ifndef CREATURELIB_EFFECTPARAMETER_HPP
 #define CREATURELIB_EFFECTPARAMETER_HPP
+#include <Arbutils/Enum.hpp>
+#include <Arbutils/Exception.hpp>
 #include <variant>
+#include "../Defines.hpp"
 #include "Exceptions/CreatureException.hpp"
 
 namespace CreatureLib::Library {
-    ENUM(EffectParameterType, uint8_t, None, Bool, Int, Float, String);
+    ENUM(EffectParameterType, u8, None, Bool, Int, Float, String);
 
     class EffectParameter {
     private:

src/Library/Gender.hpp

@@ -1,5 +1,6 @@
 #ifndef CREATURELIB_GENDER_HPP
 #define CREATURELIB_GENDER_HPP
+#include <Arbutils/Enum.hpp>
 
 namespace CreatureLib::Library {
     /*!

src/Library/GrowthRates/ExternGrowthRate.hpp

@@ -1,8 +1,10 @@
 #ifndef CREATURELIB_EXTERNGROWTHRATE_HPP
 #define CREATURELIB_EXTERNGROWTHRATE_HPP
 
+#include <Arbutils/Ensure.hpp>
 #include "../../Defines.hpp"
 #include "GrowthRate.hpp"
+
 namespace CreatureLib::Library {
     class ExternGrowthRate : public GrowthRate {
         level_int_t (*_calcLevel)(uint32_t experience);

src/Library/GrowthRates/GrowthRateLibrary.cpp

@@ -1,4 +1,5 @@
 #include "GrowthRateLibrary.hpp"
+#include <Arbutils/Exception.hpp>
 #include "../Exceptions/CreatureException.hpp"
 
 uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ArbUt::BasicStringView& growthRate,

src/Library/GrowthRates/GrowthRateLibrary.hpp

@@ -1,6 +1,8 @@
 #ifndef CREATURELIB_GROWTHRATELIBRARY_HPP
 #define CREATURELIB_GROWTHRATELIBRARY_HPP
 
+#include <Arbutils/String/StringView.hpp>
+#include <unordered_map>
 #include "GrowthRate.hpp"
 
 namespace CreatureLib::Library {

src/Library/GrowthRates/LookupGrowthRate.hpp

@@ -1,6 +1,7 @@
 #ifndef CREATURELIB_LOOKUPGROWTHRATE_HPP
 #define CREATURELIB_LOOKUPGROWTHRATE_HPP
 
+#include <Arbutils/Collections/List.hpp>
 #include "GrowthRate.hpp"
 
 namespace CreatureLib::Library {

src/Library/Items/Item.hpp

@@ -1,6 +1,9 @@
 #ifndef CREATURELIB_ITEM_HPP
 #define CREATURELIB_ITEM_HPP
 
+#include <Arbutils/Memory/Memory.hpp>
+#include <Arbutils/Misc.hpp>
+#include <unordered_set>
 #include "../Attacks/SecondaryEffect.hpp"
 #include "BattleItemCategory.hpp"
 #include "ItemCategory.hpp"

src/Library/LibrarySettings.hpp

@@ -1,6 +1,9 @@
 #ifndef CREATURELIB_LIBRARYSETTINGS_HPP
 #define CREATURELIB_LIBRARYSETTINGS_HPP
 
+#include <memory>
+#include "../Defines.hpp"
+
 namespace CreatureLib::Library {
     /// @brief Hold the different runtime settings for a given library.
     class LibrarySettings {

src/Library/Statistic.hpp

@@ -1,5 +1,6 @@
 #ifndef CREATURELIB_STATISTIC_HPP
 #define CREATURELIB_STATISTIC_HPP
+#include <Arbutils/Enum.hpp>
 
 namespace CreatureLib::Library {
     ENUM(Statistic, uint8_t, Health, PhysicalAttack, PhysicalDefense, MagicalAttack, MagicalDefense, Speed)

src/Library/StatisticSet.hpp

@@ -1,10 +1,13 @@
 #ifndef CREATURELIB_STATISTICSET_HPP
 #define CREATURELIB_STATISTICSET_HPP
+
+#include <Arbutils/Exception.hpp>
 #include "Exceptions/CreatureException.hpp"
 #include "Statistic.hpp"
 
 namespace CreatureLib::Library {
-    template <typename T> concept StatisticSetType = std::is_integral<T>::value;
+    template <typename T>
+    concept StatisticSetType = std::is_integral<T>::value;
 
     /// @brief A class to hold all the different stats a creature can have.
     /// @tparam T An integer type that defines the kind the different fields in the set can have.

src/Library/TypeLibrary.hpp

@@ -1,19 +1,23 @@
 #ifndef CREATURELIB_TYPELIBRARY_HPP
 #define CREATURELIB_TYPELIBRARY_HPP
 
+#include <Arbutils/Collections/Dictionary.hpp>
+#include <Arbutils/Collections/List.hpp>
+#include <Arbutils/String/StringView.hpp>
+#include <numeric>
+#include "../Defines.hpp"
 #include "Exceptions/CreatureException.hpp"
 
 namespace CreatureLib::Library {
     class TypeLibrary {
-        ArbUt::Dictionary<ArbUt::StringView, uint8_t> _types;
+        ArbUt::Dictionary<ArbUt::StringView, u8> _types;
         ArbUt::List<ArbUt::List<float>> _effectiveness;
 
     public:
-        TypeLibrary(size_t initialCapacity = 20)
+        TypeLibrary(size_t initialCapacity = 20) : _types(ArbUt::Dictionary<ArbUt::StringView, u8>(initialCapacity)) {}
-            : _types(ArbUt::Dictionary<ArbUt::StringView, uint8_t>(initialCapacity)) {}
 
         inline uint8_t GetTypeId(const ArbUt::StringView& key) const { return _types.Get(key); }
-        [[nodiscard]] inline float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const {
+        [[nodiscard]] inline float GetSingleEffectiveness(u8 attacking, u8 defensive) const {
             try {
                 return _effectiveness[attacking][defensive];
             } catch (const std::exception& e) {
@@ -21,16 +25,16 @@ namespace CreatureLib::Library {
                                                                                 << (uint32_t)defensive);
             }
         }
-        [[nodiscard]] inline float GetEffectiveness(uint8_t attacking, const std::vector<uint8_t>& defensive) const {
+        [[nodiscard]] inline float GetEffectiveness(uint8_t attacking, const std::vector<u8>& defensive) const {
             return std::accumulate(defensive.begin(), defensive.end(), (float)1,
                                    [this, attacking](float init, uint8_t defense) {
                                        return init * GetSingleEffectiveness(attacking, defense);
                                    });
         }
-        const ArbUt::StringView& GetTypeName(uint8_t type) const;
+        const ArbUt::StringView& GetTypeName(u8 type) const;
 
         uint8_t RegisterType(const ArbUt::StringView& typeName);
-        void SetEffectiveness(uint8_t attacking, uint8_t defensive, float effectiveness);
+        void SetEffectiveness(uint8_t attacking, u8 defensive, float effectiveness);
     };
 }
 

src/Precompiled.hxx

@@ -1,39 +0,0 @@
-#ifndef CREATURELIB_PRECOMPILED_HXX
-#define CREATURELIB_PRECOMPILED_HXX
-
-// std
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <exception>
-#include <memory>
-#include <numeric>
-#include <optional>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <variant>
-#include <vector>
-
-// Arbutils
-#include <Arbutils/Collections/Dictionary.hpp>
-#include <Arbutils/Collections/List.hpp>
-#include <Arbutils/Ensure.hpp>
-#include <Arbutils/Enum.hpp>
-#include <Arbutils/Exception.hpp>
-#include <Arbutils/Memory/Memory.hpp>
-#include <Arbutils/Misc.hpp>
-#include <Arbutils/Precompiled.hxx>
-#include <Arbutils/StringView.hpp>
-
-// CreatureLib
-#include "Defines.hpp"
-
-#endif // CREATURELIB_PRECOMPILED_HXX