diff --git a/src/billy_objects.rs b/src/billy_objects.rs
deleted file mode 100644
index b422b43..0000000
--- a/src/billy_objects.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-use crate::billy_objects::Weapons::*;
-use crate::sheet::CharacteristicType;
-use crate::sheet::CharacteristicType::*;
-use serde::{Deserialize, Serialize};
-
-pub trait GenericObject {
-    fn add_armor(&self) -> u32 {
-        0
-    }
-    fn add_critique(&self) -> u32 {
-        0
-    }
-    fn add_damage(&self) -> u32 {
-        0
-    }
-    fn add_materiel(&self, in_type: &CharacteristicType) -> i32;
-}
-
-#[derive(Debug, Serialize, Deserialize, Hash, Eq, PartialEq, Clone)]
-pub enum Weapons {
-    Sword,
-    Lance,
-    Morgenstern,
-    Bow,
-}
-
-#[derive(Debug, Serialize, Deserialize, Hash, Eq, PartialEq, Clone)]
-pub enum Equipments {
-    Chainmail,
-    CookingPot,
-    PamphletTourist,
-    MedicKit,
-}
-
-#[derive(Debug, Serialize, Deserialize, Hash, Eq, PartialEq, Clone)]
-pub enum Tools {
-    Fourche,
-    Dagger,
-    RockClimbingKit,
-    SackOfGrain,
-}
-
-#[derive(Debug, Serialize, Deserialize, Hash, Eq, PartialEq, Clone)]
-pub enum Objects {
-    Weapons(Weapons),
-    Equipments(Equipments),
-    Tools(Tools),
-}
-
-impl GenericObject for Weapons {
-    fn add_damage(&self) -> u32 {
-        if let Morgenstern = &self {
-            1
-        } else {
-            0
-        }
-    }
-
-    fn add_materiel(&self, in_type: &CharacteristicType) -> i32 {
-        match self {
-            Sword => {
-                if let Skill(_) = &in_type {
-                    4
-                } else {
-                    0
-                }
-            }
-            Lance => match in_type {
-                Address(_) => 1,
-                Skill(_) => 3,
-                _ => 0,
-            },
-            Morgenstern => match in_type {
-                Stamina(_) | Skill(_) => 1,
-                _ => 0,
-            },
-            Bow => match in_type {
-                Address(_) => 1,
-                Skill(_) => 3,
-                _ => 0,
-            },
-        }
-    }
-}
-
-impl GenericObject for Equipments {
-    fn add_armor(&self) -> u32 {
-        match self {
-            Equipments::Chainmail => 2,
-            Equipments::CookingPot => 1,
-            _ => 0,
-        }
-    }
-
-    fn add_materiel(&self, in_type: &CharacteristicType) -> i32 {
-        match self {
-            Equipments::Chainmail => match in_type {
-                Address(_) | Skill(_) => -1,
-                Stamina(_) => 1,
-                _ => 0,
-            },
-            Equipments::CookingPot => {
-                if let Stamina(_) = in_type {
-                    2
-                } else {
-                    0
-                }
-            }
-            Equipments::PamphletTourist => {
-                if let Luck(_) = in_type {
-                    4
-                } else {
-                    0
-                }
-            }
-            Equipments::MedicKit => {
-                if let Luck(_) = in_type {
-                    1
-                } else {
-                    0
-                }
-            }
-        }
-    }
-}
-
-impl GenericObject for Tools {
-    fn add_critique(&self) -> u32 {
-        if let Tools::Dagger = &self {
-            6
-        } else {
-            0
-        }
-    }
-
-    fn add_materiel(&self, in_type: &CharacteristicType) -> i32 {
-        match self {
-            Tools::Fourche => match in_type {
-                Stamina(_) => 3,
-                Skill(_) => 1,
-                _ => 0,
-            },
-            Tools::Dagger => {
-                if let Skill(_) = in_type {
-                    1
-                } else {
-                    0
-                }
-            }
-            Tools::RockClimbingKit => {
-                if let Address(_) = in_type {
-                    1
-                } else {
-                    0
-                }
-            }
-            Tools::SackOfGrain => match in_type {
-                Stamina(_) | Luck(_) => 2,
-                _ => 0,
-            },
-        }
-    }
-}
-
-impl GenericObject for Objects {
-    fn add_armor(&self) -> u32 {
-        match self {
-            Objects::Weapons(a) => a.add_armor(),
-            Objects::Equipments(a) => a.add_armor(),
-            Objects::Tools(a) => a.add_armor(),
-        }
-    }
-
-    fn add_critique(&self) -> u32 {
-        match self {
-            Objects::Weapons(a) => a.add_critique(),
-            Objects::Equipments(a) => a.add_critique(),
-            Objects::Tools(a) => a.add_critique(),
-        }
-    }
-
-    fn add_damage(&self) -> u32 {
-        match self {
-            Objects::Weapons(a) => a.add_damage(),
-            Objects::Equipments(a) => a.add_damage(),
-            Objects::Tools(a) => a.add_damage(),
-        }
-    }
-
-    fn add_materiel(&self, in_type: &CharacteristicType) -> i32 {
-        match self {
-            Objects::Weapons(a) => a.add_materiel(in_type),
-            Objects::Equipments(a) => a.add_materiel(in_type),
-            Objects::Tools(a) => a.add_materiel(in_type),
-        }
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index eea7074..8d3728f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,2 @@
-pub mod billy_objects;
 pub mod gui;
 pub mod sheet;
diff --git a/src/main.rs b/src/main.rs
index 112ce70..0c905d7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use eframe::egui;
 use eframe::egui::KeyboardShortcut;
-use log::{error, info, warn};
+use log::{info, warn, error};
 
 use billy_sheet::gui::SheetGui;
 
@@ -38,7 +38,7 @@ impl Default for Gui {
 impl eframe::App for Gui {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         egui::TopBottomPanel::top("menu").show(ctx, |ui| {
-            egui::MenuBar::new().ui(ui, |ui| {
+            egui::MenuBar::new().ui(ui,  |ui| {
                 egui::widgets::global_theme_preference_buttons(ui);
                 ui.menu_button("File", |ui| {
                     if ui.button("Open (Ctrl + O)").clicked() {
diff --git a/src/sheet.rs b/src/sheet.rs
index b5c1cf0..ac177f8 100644
--- a/src/sheet.rs
+++ b/src/sheet.rs
@@ -1,26 +1,9 @@
-use crate::billy_objects::{Equipments::*, GenericObject, Objects, Tools::*, Weapons::*};
-use crate::gui::SheetGui;
-use eframe::egui::{widgets::DragValue, Ui};
+use eframe::egui::widgets::DragValue;
+use eframe::egui::Ui;
 use serde::{Deserialize, Serialize};
-use std::collections::hash_set;
 use std::io::Write as _;
 
-const ALL_OBJECTS: [Objects; 12] = [
-    Objects::Weapons(Sword),
-    Objects::Weapons(Lance),
-    Objects::Weapons(Morgenstern),
-    Objects::Weapons(Bow),
-    Objects::Equipments(Chainmail),
-    Objects::Equipments(CookingPot),
-    Objects::Equipments(PamphletTourist),
-    Objects::Equipments(MedicKit),
-    Objects::Tools(Fourche),
-    Objects::Tools(Dagger),
-    Objects::Tools(RockClimbingKit),
-    Objects::Tools(SackOfGrain),
-];
-
-const MAX_OBJ: usize = 3;
+use crate::gui::SheetGui;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Classe {
@@ -31,11 +14,11 @@ pub enum Classe {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub enum CharacteristicType {
-    Address(Characteristic),
-    Stamina(Characteristic),
-    Luck(Characteristic),
-    Skill(Characteristic),
+enum CharacteristicType {
+    Address,
+    Stamina,
+    Luck,
+    Skill,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -43,94 +26,15 @@ pub struct CharacterSheet {
     character_class: Classe,
     /// Field to write the personality/
     pub character: String,
-    address: CharacteristicType,
-    stamina: CharacteristicType,
-    luck: CharacteristicType,
-    skill: CharacteristicType,
-    objects: hash_set::HashSet<Objects>,
+    address: Characteristic,
+    stamina: Characteristic,
+    luck: Characteristic,
+    skill: Characteristic,
     health: u32,
     armor: u32,
     damage: u32,
     glory: u32,
     money: u32,
-    critique: u32,
-    nb_weapons: u8,
-    nb_equipments: u8,
-    nb_tools: u8,
-}
-
-#[derive(Debug)]
-pub struct SheetRuler {
-    pub available_objects: hash_set::HashSet<Objects>,
-}
-
-impl Default for SheetRuler {
-    fn default() -> Self {
-        Self {
-            available_objects: hash_set::HashSet::from_iter(ALL_OBJECTS),
-        }
-    }
-}
-
-impl SheetRuler {
-    fn change_carac(
-        object: &Objects,
-        sheet: &mut CharacterSheet,
-        operation: impl Fn(u32, i32) -> u32,
-    ) {
-        sheet.address_mut().materiel = operation(
-            sheet.address_mut().materiel,
-            object.add_materiel(&sheet.address),
-        );
-        sheet.skill_mut().materiel = operation(
-            sheet.skill_mut().materiel,
-            object.add_materiel(&sheet.skill),
-        );
-        sheet.luck_mut().materiel =
-            operation(sheet.luck_mut().materiel, object.add_materiel(&sheet.luck));
-        sheet.stamina_mut().materiel = operation(
-            sheet.stamina_mut().materiel,
-            object.add_materiel(&sheet.stamina),
-        );
-        sheet.armor = operation(sheet.armor, object.add_armor() as i32);
-        sheet.damage = operation(sheet.armor, object.add_damage() as i32);
-        sheet.critique = operation(sheet.critique, object.add_critique() as i32);
-    }
-    pub fn insert_object(&mut self, sheet: &mut CharacterSheet, object: Objects) -> bool {
-        if self.available_objects.len() >= MAX_OBJ || sheet.objects.contains(&object) {
-            false
-        } else {
-            Self::change_carac(&object, sheet, |a, b| a + b as u32);
-            let remove = self.available_objects.remove(&object);
-            let r = sheet.objects.insert(object.clone()) && remove;
-            if r {
-                match object {
-                    Objects::Weapons(_) => sheet.nb_weapons += 1,
-                    Objects::Equipments(_) => sheet.nb_equipments += 1,
-                    Objects::Tools(_) => sheet.nb_tools += 1,
-                }
-            }
-            r
-        }
-    }
-
-    pub fn erase_object(&mut self, sheet: &mut CharacterSheet, object: Objects) -> bool {
-        if sheet.objects.contains(&object) {
-            Self::change_carac(&object, sheet, |a, b| a - b as u32);
-            let remove = sheet.objects.remove(&object);
-            let r = self.available_objects.insert(object.clone()) && remove;
-            if r {
-                match object {
-                    Objects::Weapons(_) => sheet.nb_weapons -= 1,
-                    Objects::Equipments(_) => sheet.nb_equipments -= 1,
-                    Objects::Tools(_) => sheet.nb_tools -= 1,
-                }
-            }
-            r
-        } else {
-            false
-        }
-    }
 }
 
 pub fn write_sheet(path: &std::path::Path, sheet: &CharacterSheet) -> std::io::Result<()> {
@@ -147,61 +51,16 @@ impl CharacterSheet {
         &self.character
     }
     pub fn address(&self) -> &Characteristic {
-        if let CharacteristicType::Address(addr) = &self.address {
-            addr
-        } else {
-            unreachable!()
-        }
-    }
-    fn address_mut(&mut self) -> &mut Characteristic {
-        if let CharacteristicType::Address(addr) = &mut self.address {
-            addr
-        } else {
-            unreachable!()
-        }
+        &self.address
     }
     pub fn stamina(&self) -> &Characteristic {
-        if let CharacteristicType::Stamina(sta) = &self.stamina {
-            sta
-        } else {
-            unreachable!()
-        }
-    }
-    fn stamina_mut(&mut self) -> &mut Characteristic {
-        if let CharacteristicType::Stamina(sta) = &mut self.stamina {
-            sta
-        } else {
-            unreachable!()
-        }
+        &self.stamina
     }
     pub fn luck(&self) -> &Characteristic {
-        if let CharacteristicType::Luck(luck) = &self.luck {
-            luck
-        } else {
-            unreachable!()
-        }
-    }
-    fn luck_mut(&mut self) -> &mut Characteristic {
-        if let CharacteristicType::Luck(luck) = &mut self.luck {
-            luck
-        } else {
-            unreachable!()
-        }
+        &self.luck
     }
     pub fn skill(&self) -> &Characteristic {
-        if let CharacteristicType::Skill(sk) = &self.skill {
-            sk
-        } else {
-            unreachable!()
-        }
-    }
-
-    fn skill_mut(&mut self) -> &mut Characteristic {
-        if let CharacteristicType::Skill(sk) = &mut self.skill {
-            sk
-        } else {
-            unreachable!()
-        }
+        &self.skill
     }
     pub fn health(&self) -> u32 {
         self.health
@@ -220,17 +79,6 @@ impl CharacterSheet {
     }
 }
 
-impl CharacteristicType {
-    fn check(&self) {
-        match self {
-            CharacteristicType::Address(_) => todo!("Rules for address"),
-            CharacteristicType::Stamina(_) => todo!("Rules for stamina"),
-            CharacteristicType::Luck(_) => todo!("Rules for luck"),
-            CharacteristicType::Skill(_) => todo!("Rules for skill"),
-        }
-    }
-}
-
 impl SheetGui for CharacterSheet {
     fn shortcut(
         &self,
@@ -259,39 +107,27 @@ impl SheetGui for CharacterSheet {
 
     fn gui_address(&mut self, ui: &mut Ui) {
         let workaround = self as &CharacterSheet;
-        (
-            self.address_mut().base,
-            self.address_mut().carac,
-            self.address_mut().materiel,
-        ) = self.shortcut(ui, "Adresse", workaround.address());
+        (self.address.base, self.address.carac, self.address.materiel) =
+            self.shortcut(ui, "Adresse", workaround.address());
         ui.label("Ne peut dépasser 5");
     }
 
     fn gui_stamina(&mut self, ui: &mut Ui) {
         let workaround = self as &CharacterSheet;
-        (
-            self.stamina_mut().base,
-            self.stamina_mut().carac,
-            self.stamina_mut().materiel,
-        ) = self.shortcut(ui, "Endurance", workaround.stamina());
+        (self.stamina.base, self.stamina.carac, self.stamina.materiel) =
+            self.shortcut(ui, "Endurance", workaround.stamina());
     }
 
     fn gui_luck(&mut self, ui: &mut Ui) {
         let workaround = self as &CharacterSheet;
-        (
-            self.luck_mut().base,
-            self.luck_mut().carac,
-            self.luck_mut().materiel,
-        ) = self.shortcut(ui, "Chance", workaround.luck());
+        (self.luck.base, self.luck.carac, self.luck.materiel) =
+            self.shortcut(ui, "Chance", workaround.luck());
     }
 
     fn gui_skill(&mut self, ui: &mut Ui) {
         let workaround = self as &CharacterSheet;
-        (
-            self.skill_mut().base,
-            self.skill_mut().carac,
-            self.skill_mut().materiel,
-        ) = self.shortcut(ui, "Habileté", workaround.skill());
+        (self.skill.base, self.skill.carac, self.skill.materiel) =
+            self.shortcut(ui, "Habileté", workaround.skill());
     }
 
     fn secondary_stats(&mut self, ui: &mut Ui) {
@@ -310,13 +146,12 @@ impl SheetGui for CharacterSheet {
             ui.add(DragValue::new(&mut armor));
         });
         ui.label("Critique");
-        self.damage = damage;
-        self.armor = armor;
     }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Characteristic {
+    characteristic_type: CharacteristicType,
     pub base: u32,
     pub carac: u32,
     pub materiel: u32,
@@ -328,40 +163,39 @@ impl Default for CharacterSheet {
         Self {
             character_class: Classe::Warrior,
             character: "Billy".to_string(),
-            address: CharacteristicType::Address(Characteristic {
-                base: 1,
+            address: Characteristic {
+                characteristic_type: CharacteristicType::Address,
+                base: 0,
                 carac: 0,
                 materiel: 0,
-                additional: 0,
-            }),
-            stamina: CharacteristicType::Stamina(Characteristic {
+                additional: 1,
+            },
+            stamina: Characteristic {
+                characteristic_type: CharacteristicType::Stamina,
                 base: 2,
                 carac: 0,
                 materiel: 0,
                 additional: 0,
-            }),
-            luck: CharacteristicType::Luck(Characteristic {
+            },
+            luck: Characteristic {
+                characteristic_type: CharacteristicType::Luck,
                 base: 3,
                 carac: 0,
                 materiel: 0,
                 additional: 0,
-            }),
-            skill: CharacteristicType::Skill(Characteristic {
+            },
+            skill: Characteristic {
+                characteristic_type: CharacteristicType::Skill,
                 base: 2,
                 carac: 0,
                 materiel: 0,
                 additional: 0,
-            }),
-            objects: hash_set::HashSet::default(),
+            },
             health: 0,
             armor: 0,
             damage: 0,
             glory: 0,
             money: 0,
-            critique: 0,
-            nb_weapons: 0,
-            nb_equipments: 0,
-            nb_tools: 0,
         }
     }
 }