Minor fixes

.history/module/applications/_module_20241201145411.mjs

@@ -0,0 +1,12 @@
+export { default as LethalFantasyCharacterSheet } from "./sheets/character-sheet.mjs";
+export { default as LethalFantasyOpponentSheet } from "./sheets/opponent-sheet.mjs"
+export { default as LethalFantasyWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as LethalFantasySkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as LethalFantasyGiftSheet } from "./sheets/gift-sheet.mjs"
+export { default as LethalFantasyVulnerabilitySheet } from "./sheets/vulnerability-sheet.mjs"
+export { default as LethalFantasySaveSheet } from "./sheets/save-sheet.mjs"
+export { default as LethalFantasyArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as LethalFantasySpellSheet } from "./sheets/spell-sheet.mjs"
+export { default as LethalFantasyEquipmentSheet } from "./sheets/equipment-sheet.mjs"
+export { default as LethalFantasyShieldSheet } from "./sheets/shield-sheet.mjs"
+export { default as LethalFantasyManager } from "./manager.mjs"

.history/module/applications/_module_20241209151255.mjs

@@ -0,0 +1,13 @@
+export { default as LethalFantasyCharacterSheet } from "./sheets/character-sheet.mjs";
+export { default as LethalFantasyOpponentSheet } from "./sheets/opponent-sheet.mjs"
+export { default as LethalFantasyWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as LethalFantasySkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as LethalFantasyGiftSheet } from "./sheets/gift-sheet.mjs"
+export { default as LethalFantasyVulnerabilitySheet } from "./sheets/vulnerability-sheet.mjs"
+export { default as LethalFantasySaveSheet } from "./sheets/save-sheet.mjs"
+export { default as LethalFantasyArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as LethalFantasySpellSheet } from "./sheets/spell-sheet.mjs"
+export { default as LethalFantasyEquipmentSheet } from "./sheets/equipment-sheet.mjs"
+export { default as LethalFantasyShieldSheet } from "./sheets/shield-sheet.mjs"
+export { default as LethalFantasyManager } from "./manager.mjs"
+

.history/module/applications/_module_20241209151257.mjs

@@ -0,0 +1,14 @@
+export { default as LethalFantasyCharacterSheet } from "./sheets/character-sheet.mjs";
+export { default as LethalFantasyOpponentSheet } from "./sheets/opponent-sheet.mjs"
+export { default as LethalFantasyWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as LethalFantasySkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as LethalFantasyGiftSheet } from "./sheets/gift-sheet.mjs"
+export { default as LethalFantasyVulnerabilitySheet } from "./sheets/vulnerability-sheet.mjs"
+export { default as LethalFantasySaveSheet } from "./sheets/save-sheet.mjs"
+export { default as LethalFantasyArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as LethalFantasySpellSheet } from "./sheets/spell-sheet.mjs"
+export { default as LethalFantasyEquipmentSheet } from "./sheets/equipment-sheet.mjs"
+export { default as LethalFantasyShieldSheet } from "./sheets/shield-sheet.mjs"
+
+export { default as LethalFantasyManager } from "./manager.mjs"
+

.history/module/applications/_module_20241209151258.mjs

@@ -0,0 +1,14 @@
+export { default as LethalFantasyCharacterSheet } from "./sheets/character-sheet.mjs";
+export { default as LethalFantasyOpponentSheet } from "./sheets/opponent-sheet.mjs"
+export { default as LethalFantasyWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as LethalFantasySkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as LethalFantasyGiftSheet } from "./sheets/gift-sheet.mjs"
+export { default as LethalFantasyVulnerabilitySheet } from "./sheets/vulnerability-sheet.mjs"
+export { default as LethalFantasySaveSheet } from "./sheets/save-sheet.mjs"
+export { default as LethalFantasyArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as LethalFantasySpellSheet } from "./sheets/spell-sheet.mjs"
+export { default as LethalFantasyEquipmentSheet } from "./sheets/equipment-sheet.mjs"
+export { default as LethalFantasyShieldSheet } from "./sheets/shield-sheet.mjs"
+export { default as LethalFantasyMiracleSheet } from "./sheets/miracle-sheet.mjs"
+export { default as LethalFantasyManager } from "./manager.mjs"
+

.history/module/applications/_module_20241210071442.mjs

@@ -0,0 +1,13 @@
+export { default as LethalFantasyCharacterSheet } from "./sheets/character-sheet.mjs";
+export { default as LethalFantasyOpponentSheet } from "./sheets/opponent-sheet.mjs"
+export { default as LethalFantasyWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as LethalFantasySkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as LethalFantasyGiftSheet } from "./sheets/gift-sheet.mjs"
+export { default as LethalFantasyVulnerabilitySheet } from "./sheets/vulnerability-sheet.mjs"
+export { default as LethalFantasyArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as LethalFantasySpellSheet } from "./sheets/spell-sheet.mjs"
+export { default as LethalFantasyEquipmentSheet } from "./sheets/equipment-sheet.mjs"
+export { default as LethalFantasyShieldSheet } from "./sheets/shield-sheet.mjs"
+export { default as LethalFantasyMiracleSheet } from "./sheets/miracle-sheet.mjs"
+export { default as LethalFantasyManager } from "./manager.mjs"
+

.history/module/applications/sheets/armor-sheet_20241121235703.mjs

@@ -0,0 +1,27 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyArmorSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["armor"],
+    position: {
+      width: 400,
+    },
+    window: {
+      contentClasses: ["armor-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/armor.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}

.history/module/applications/sheets/armor-sheet_20241210071050.mjs

@@ -0,0 +1,22 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyArmorSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["armor"],
+    position: {
+      width: 400,
+    },
+    window: {
+      contentClasses: ["armor-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/armor.hbs",
+    },
+  }
+
+}

.history/module/applications/sheets/armor-sheet_20241210072306.mjs

@@ -0,0 +1,30 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyArmorSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["armor"],
+    position: {
+      width: 400,
+    },
+    window: {
+      contentClasses: ["armor-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/armor.hbs",
+    },
+  }
+
+
+    /** @override */
+    async _prepareContext() {
+      const context = await super._prepareContext()
+      context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+      return context
+    }
+  
+}

.history/module/applications/sheets/armor-sheet_20241210072307.mjs

@@ -0,0 +1,30 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyArmorSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["armor"],
+    position: {
+      width: 400,
+    },
+    window: {
+      contentClasses: ["armor-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/armor.hbs",
+    },
+  }
+
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+
+}

.history/module/applications/sheets/character-sheet_20241207085714.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153603.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "<i class="fa-solid fa-swords"></i>", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153604.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153607.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153608.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153649.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "<i class="fa-sharp-duotone fa-solid fa-wand-magic-sparkles"></i>", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153652.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "<i class="fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153655.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153656.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208153657.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154229.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spells
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154230.mjs

@@ -0,0 +1,194 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154238.mjs

@@ -0,0 +1,195 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.weapons
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154242.mjs

@@ -0,0 +1,195 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154244.mjs

@@ -0,0 +1,195 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154246.mjs

@@ -0,0 +1,195 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weaponss
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154249.mjs

@@ -0,0 +1,195 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154525.mjs

@@ -0,0 +1,196 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+        break;
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154526.mjs

@@ -0,0 +1,196 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+        break;
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154527.mjs

@@ -0,0 +1,196 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+        break;
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154528.mjs

@@ -0,0 +1,196 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+        break;
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/character-sheet_20241208154530.mjs

@@ -0,0 +1,196 @@
+import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
+import { ROLL_TYPE } from "../../config/system.mjs"
+
+export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
+    },
+    weapons: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
+      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
+      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gifts
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "weapons":
+        context.tab = context.tabs.weapons
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.equipments = doc.itemTypes.equipment
+        break
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      case ROLL_TYPE.SAVE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.RESOURCE:
+        rollTarget = elt.dataset.rollTarget
+        break
+      case ROLL_TYPE.DAMAGE:
+        rollTarget = elt.dataset.itemId
+        break
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

.history/module/applications/sheets/equipment-sheet_20241130083352.mjs

@@ -0,0 +1,27 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyEquipmentSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["equipment"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["equipment-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/equipment.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}

.history/module/applications/sheets/equipment-sheet_20241210072300.mjs

@@ -0,0 +1,28 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyEquipmentSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["equipment"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["equipment-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/equipment.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151225.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasySpellSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151230.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151231.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151234.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151237.mjs

@@ -0,0 +1,22 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["    classes: ["miracle"],
+-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151239.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151241.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151244.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209151245.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/miracle.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209231624.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/miracle.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209231625.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/miracle.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241209231626.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/miracle.hbs",
+    },
+  }
+}

.history/module/applications/sheets/miracle-sheet_20241210072248.mjs

@@ -0,0 +1,29 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/miracle.hbs",
+    },
+  }
+
+    /** @override */
+    async _prepareContext() {
+      const context = await super._prepareContext()
+      context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+      return context
+    }
+  
+}

.history/module/applications/sheets/miracle-sheet_20241210072251.mjs

@@ -0,0 +1,29 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyMiracleSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["miracle"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["miracle-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/miracle.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+
+}

.history/module/applications/sheets/shield-sheet_20241203125805.mjs

@@ -0,0 +1,27 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyShieldSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["shield"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["shield-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/shield.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}

.history/module/applications/sheets/shield-sheet_20241210072243.mjs

@@ -0,0 +1,28 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyShieldSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["shield"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["shield-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/shield.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}

.history/module/applications/sheets/spell-sheet_20241121235722.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasySpellSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+}

.history/module/applications/sheets/spell-sheet_20241210072209.mjs

@@ -0,0 +1,29 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasySpellSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+
+    /** @override */
+    async _prepareContext() {
+      const context = await super._prepareContext()
+      context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+      return context
+    }
+  
+}

.history/module/applications/sheets/spell-sheet_20241210072211.mjs

@@ -0,0 +1,29 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasySpellSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["spell"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["spell-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/spell.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+
+}

.history/module/applications/sheets/weapon-sheet_20241203131225.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyWeaponSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/weapon.hbs",
+    },
+  }
+}

.history/module/applications/sheets/weapon-sheet_20241210071054.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyWeaponSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/weapon.hbs",
+    },
+  }
+}

.history/module/applications/sheets/weapon-sheet_20241210072223.mjs

@@ -0,0 +1,28 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyWeaponSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/weapon.hbs",
+    },
+  }
+    /** @override */
+    async _prepareContext() {
+      const context = await super._prepareContext()
+      context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+      return context
+    }
+  
+}

.history/module/applications/sheets/weapon-sheet_20241210072225.mjs

@@ -0,0 +1,28 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyWeaponSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/weapon.hbs",
+    },
+  }
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+
+}

.history/module/applications/sheets/weapon-sheet_20241210072235.mjs

@@ -0,0 +1,29 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyWeaponSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-lethal-fantasy/templates/weapon.hbs",
+    },
+  }
+  
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+
+}