Cleaner includes

include/characteristic.hpp

@@ -0,0 +1,113 @@
+#ifndef BILLYSHEET_CHARACTERISTIC_HPP
+#define BILLYSHEET_CHARACTERISTIC_HPP
+
+#include <cstdint>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+namespace character {
+    class BillyObjects;
+}
+
+namespace character::characteristic {
+    enum class characType : std::uint8_t {
+        Adresse = 0,
+        Endurance = 1,
+        Chance = 2,
+        Habilete = 3
+    };
+
+    class Characteristic {
+    protected:
+        friend character::BillyObjects;
+        using defaultValue = std::numeric_limits<std::int32_t>;
+        mutable std::int32_t total{ defaultValue::max() };
+        const std::uint32_t base{ 0 };
+        std::uint32_t carac{ 0 };
+        std::uint32_t materiel{ 0 };
+        std::uint32_t additional{ 0 };
+
+        static std::uint32_t get_base(const characType inType) noexcept {
+            switch (inType) {
+                case characType::Adresse:
+                    return 1;
+                case characType::Chance:
+                    return 3;
+                case characType::Endurance:
+                case characType::Habilete:
+                    return 2;
+            }
+        }
+
+    public:
+        const characType type{ characType::Adresse };
+
+        Characteristic() noexcept = default;
+
+        Characteristic(const characType inType,
+                const std::uint32_t carac,
+                const std::uint32_t materiel,
+                const std::uint32_t additional) :
+                base(get_base(inType)),
+                carac(carac),
+                materiel(materiel),
+                additional(additional),
+                type(inType) { (void) get_total(); }
+
+        explicit Characteristic(const characType inType) : Characteristic(inType, 0, 0, 0) {}
+
+        Characteristic(const Characteristic &charac) noexcept = default;
+
+        Characteristic &operator=(const Characteristic &charac) noexcept {
+            const_cast<std::uint32_t &>(base) = charac.base;
+            const_cast<characType &>(type) = charac.type;
+            carac = charac.carac;
+            materiel = charac.materiel;
+            additional = charac.additional;
+            total = charac.get_total();
+            return *this;
+        }
+
+        virtual ~Characteristic() noexcept = default;
+
+        [[nodiscard]] std::uint32_t get_base() const { return base; }
+
+        [[nodiscard]] std::uint32_t get_carac() const { return carac; }
+
+        [[nodiscard]] std::uint32_t get_materiel() const { return materiel; }
+
+        [[nodiscard]] std::uint32_t get_additional() const { return additional; }
+
+        [[nodiscard]] std::size_t get_total() const noexcept {
+            if (total == defaultValue::max()) {
+                total = static_cast<std::int32_t>(base + carac + materiel + additional);
+                if (total < 0) {
+                    total = 0;
+                }
+            }
+            return total;
+        }
+
+        friend void from_json(const json &j, Characteristic &charac) {
+            const_cast<std::uint32_t &>(charac.base) = j.at("base").get<std::uint32_t>();
+            const_cast<characType &>(charac.type) = static_cast<characType>(j.at("type").get<std::uint8_t>());
+            charac.carac = j.at("carac").get<std::uint32_t>();
+            charac.materiel = j.at("materiel").get<std::uint32_t>();
+            charac.additional = j.at("additional").get<std::uint32_t>();
+            charac.total = j.at("total").get<std::int32_t>();
+        }
+    };
+
+    static void to_json(json &j, const Characteristic &charac) {
+        j["base"] = charac.get_base();
+        j["type"] = charac.type;
+        j["carac"] = charac.get_carac();
+        j["materiel"] = charac.get_materiel();
+        j["additional"] = charac.get_additional();
+        j["total"] = charac.get_total();
+    }
+}
+
+
+#endif //BILLYSHEET_CHARACTERISTIC_HPP