diff --git a/include/billy_objects.hpp b/include/billy_objects.hpp
index 7a9e765..f20b9ec 100644
--- a/include/billy_objects.hpp
+++ b/include/billy_objects.hpp
@@ -17,7 +17,8 @@
 
 namespace character {
     class CharacterSheet;
-    namespace characteristic{
+
+    namespace characteristic {
         class Characteristic;
     }
 
@@ -27,18 +28,18 @@ namespace character {
         using container = std::unordered_map<billyEnums, billyObjects>;
 
         static constexpr std::array<billyEnums, 12> all_objects{
-                weapons::Sword,
-                weapons::Lance,
-                weapons::Morgenstern,
-                weapons::Bow,
-                equipments::Chainmail,
-                equipments::CookingPot,
-                equipments::PamphletTourist,
-                equipments::MedicKit,
-                tools::Fourche,
-                tools::Dagger,
-                tools::RockClimbingKit,
-                tools::SackOfGrain,
+            weapons::Sword,
+            weapons::Lance,
+            weapons::Morgenstern,
+            weapons::Bow,
+            equipments::Chainmail,
+            equipments::CookingPot,
+            equipments::PamphletTourist,
+            equipments::MedicKit,
+            tools::Fourche,
+            tools::Dagger,
+            tools::RockClimbingKit,
+            tools::SackOfGrain,
         };
 
         static constexpr std::string_view json_key{ "billy_objects" };
@@ -61,9 +62,7 @@ namespace character {
 
         [[nodiscard]] const std::minus<std::uint32_t> &get_minus_operation() const { return minus; }
 
-        static void check_dagger_conditions(const CharacterSheet &sheet,
-                characteristic::Characteristic &localHabilete,
-                const std::function<std::uint32_t(std::uint32_t, std::uint32_t)> &operation);
+        static void check_dagger_conditions(CharacterSheet &sheet);
 
     private:
         std::plus<std::uint32_t> plus;
@@ -71,12 +70,12 @@ namespace character {
         std::minus<std::uint32_t> minus;
 
         static void change_carac(const billyObjects &arg,
-                CharacterSheet &sheet,
-                characteristic::Characteristic &localHabilete,
-                characteristic::Characteristic &localAdresse,
-                characteristic::Characteristic &localEndurance,
-                characteristic::Characteristic &localChance,
-                const std::function<std::uint32_t(std::uint32_t, std::uint32_t)> &operation) noexcept;
+            CharacterSheet &sheet,
+            characteristic::Characteristic &localHabilete,
+            characteristic::Characteristic &localAdresse,
+            characteristic::Characteristic &localEndurance,
+            characteristic::Characteristic &localChance,
+            const std::function<std::uint32_t(std::uint32_t, std::uint32_t)> &operation) noexcept;
     };
 }
 
diff --git a/src/billy_objects.cpp b/src/billy_objects.cpp
index 6b7ce6e..d1eb30d 100644
--- a/src/billy_objects.cpp
+++ b/src/billy_objects.cpp
@@ -17,11 +17,17 @@ namespace character {
 
     bool BillyObjects::insert_object(CharacterSheet &sheet, const billyEnums objType) noexcept {
         if (sheet.objects.size() < 3) {
-            sheet.objects.emplace(objType, std::visit(overloaded{
-                    [](const weapons &arg) { return std::unique_ptr<GenericObject>(std::make_unique<Weapons>(arg)); },
-                    [](const equipments &arg) { return std::unique_ptr<GenericObject>(std::make_unique<Equipments>(arg)); },
-                    [](const tools &arg) { return std::unique_ptr<GenericObject>(std::make_unique<Tools>(arg)); },
-            }, objType));
+            sheet.objects.emplace(objType,
+                std::visit(overloaded{
+                        [](const weapons &arg) {
+                            return std::unique_ptr<GenericObject>(std::make_unique<Weapons>(arg));
+                        },
+                        [](const equipments &arg) {
+                            return std::unique_ptr<GenericObject>(std::make_unique<Equipments>(arg));
+                        },
+                        [](const tools &arg) { return std::unique_ptr<GenericObject>(std::make_unique<Tools>(arg)); },
+                    },
+                    objType));
             const auto &object = sheet.objects[objType];
             sheet.available_objects.erase(objType);
 
@@ -34,7 +40,8 @@ namespace character {
                     [&](const weapons &arg) { ++sheet.nb_weapons; },
                     [&](const equipments &arg) { ++sheet.nb_equipments; },
                     [&](const tools &arg) { ++sheet.nb_tools; },
-            }, objType);
+                },
+                objType);
             change_carac(object, sheet, local_habilete, local_adresse, local_endurance, local_chance, plus);
             return true;
         }
@@ -56,18 +63,19 @@ namespace character {
                     [&](const weapons &arg) { --sheet.nb_weapons; },
                     [&](const equipments &arg) { --sheet.nb_equipments; },
                     [&](const tools &arg) { --sheet.nb_tools; }
-            }, objToErase);
+                },
+                objToErase);
             change_carac(obj, sheet, local_habilete, local_adresse, local_endurance, local_chance, minus);
         }
     }
 
     void BillyObjects::change_carac(const billyObjects &arg,
-            CharacterSheet &sheet,
-            Characteristic &localHabilete,
-            Characteristic &localAdresse,
-            Characteristic &localEndurance,
-            Characteristic &localChance,
-            const std::function<std::uint32_t(std::uint32_t, std::uint32_t)> &operation) noexcept {
+        CharacterSheet &sheet,
+        Characteristic &localHabilete,
+        Characteristic &localAdresse,
+        Characteristic &localEndurance,
+        Characteristic &localChance,
+        const std::function<std::uint32_t(std::uint32_t, std::uint32_t)> &operation) noexcept {
         localHabilete.materiel = operation(localHabilete.materiel, arg->add_materiel(localHabilete.type));
         localAdresse.materiel = operation(localAdresse.materiel, arg->add_materiel(localAdresse.type));
         localEndurance.materiel = operation(localEndurance.materiel, arg->add_materiel(localEndurance.type));
@@ -77,19 +85,17 @@ namespace character {
         sheet.critique = operation(sheet.critique, arg->add_critique());
     }
 
-    void BillyObjects::check_dagger_conditions(const CharacterSheet &sheet,
-            Characteristic &localHabilete,
-            const std::function<std::uint32_t(std::uint32_t, std::uint32_t)> &operation) {
-        if (const auto it_dagger = sheet.objects.find(tools::Dagger); it_dagger != sheet.objects.cend()) {
-            const std::size_t count_weapons = std::count_if(sheet.objects.cbegin(),
-                    sheet.objects.cend(),
-                    [](container::const_reference node) {
-                        return std::get_if<weapons>(&node.first) != nullptr;
-                    });
-            const bool is_there_bow = sheet.objects.find(weapons::Bow) != sheet.objects.cend();
-            if (count_weapons > 1 || is_there_bow) {
-                localHabilete.materiel = operation(localHabilete.materiel,
-                        -it_dagger->second->add_materiel(localHabilete.type));
+    void BillyObjects::check_dagger_conditions(CharacterSheet &sheet) {
+        if (const auto it_dagger = sheet.get_objects().find(tools::Dagger); it_dagger != sheet.get_objects().cend()) {
+            const std::size_t count_weapons = std::count_if(sheet.get_objects().cbegin(),
+                sheet.get_objects().cend(),
+                [](container::const_reference node) {
+                    return std::get_if<weapons>(&node.first) != nullptr;
+                }
+            );
+            if (const bool is_there_bow = sheet.get_objects().find(weapons::Bow) != sheet.get_objects().cend();
+                count_weapons > 1 || is_there_bow) {
+                sheet.habilete.materiel -= it_dagger->second->add_materiel(sheet.get_habilete().type);
             }
         }
     }
@@ -108,7 +114,7 @@ namespace character {
                     break;
                 case equipmentHash:
                     billy.emplace(static_cast<equipments>(value),
-                            std::make_unique<Equipments>(static_cast<equipments>(value)));
+                        std::make_unique<Equipments>(static_cast<equipments>(value)));
                     break;
                 case toolsHash:
                     billy.emplace(static_cast<tools>(value), std::make_unique<Tools>(static_cast<tools>(value)));
@@ -129,7 +135,8 @@ namespace character {
                     [&j](const tools tool) {
                         j.emplace_back(std::pair{ toolsHash, static_cast<std::uint8_t>(tool) });
                     }
-            }, object_type);
+                },
+                object_type);
         }
     }
-}
\ No newline at end of file
+}