Initial import with skill sheet working

module/applications/sheets/arcane-sheet.mjs

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

module/applications/sheets/armor-sheet.mjs

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

module/applications/sheets/base-actor-sheet.mjs

@@ -0,0 +1,292 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class CthulhuEternalActorSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2) {
+  /**
+   * Different sheet modes.r
+   * @enum {number}
+   */
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
+
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-cthulhu-eternal", "actor"],
+    position: {
+      width: 1400,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: '[data-drag="true"], .rollable', dropSelector: null }],
+    actions: {
+      editImage: CthulhuEternalActorSheet.#onEditImage,
+      toggleSheet: CthulhuEternalActorSheet.#onToggleSheet,
+      edit: CthulhuEternalActorSheet.#onItemEdit,
+      delete: CthulhuEternalActorSheet.#onItemDelete,
+      createSpell: CthulhuEternalActorSheet.#onCreateSpell,
+    },
+  }
+
+  /**
+   * The current sheet mode.
+   * @type {number}
+   */
+  _sheetMode = this.constructor.SHEET_MODES.PLAY
+
+  /**
+   * Is the sheet currently in 'Play' mode?
+   * @type {boolean}
+   */
+  get isPlayMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY
+  }
+
+  /**
+   * Is the sheet currently in 'Edit' mode?
+   * @type {boolean}
+   */
+  get isEditMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = {
+      fields: this.document.schema.fields,
+      systemFields: this.document.system.schema.fields,
+      actor: this.document,
+      system: this.document.system,
+      source: this.document.toObject(),
+      enrichedDescription: await TextEditor.enrichHTML(this.document.system.description, { async: true }),
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isEditable: this.isEditable,
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+    // Add listeners to rollable elements
+    const rollables = this.element.querySelectorAll(".rollable")
+    rollables.forEach((d) => d.addEventListener("click", this._onRoll.bind(this)))
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   * @returns {DragDrop[]}     An array of DragDrop handlers
+   * @private
+   */
+  #createDragDropHandlers() {
+    return this.options.dragDrop.map((d) => {
+      d.permissions = {
+        dragstart: this._canDragStart.bind(this),
+        drop: this._canDragDrop.bind(this),
+      }
+      d.callbacks = {
+        dragstart: this._onDragStart.bind(this),
+        dragover: this._onDragOver.bind(this),
+        drop: this._onDrop.bind(this),
+      }
+      return new DragDrop(d)
+    })
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {}
+
+  /**
+   * Define whether a user is able to begin a dragstart workflow for a given drag selector
+   * @param {string} selector       The candidate HTML selector for dragging
+   * @returns {boolean}             Can the current user drag this selector?
+   * @protected
+   */
+  _canDragStart(selector) {
+    return this.isEditable
+  }
+
+  /**
+   * Define whether a user is able to conclude a drag-and-drop workflow for a given drop selector
+   * @param {string} selector       The candidate HTML selector for the drop target
+   * @returns {boolean}             Can the current user drop on this selector?
+   * @protected
+   */
+  _canDragDrop(selector) {
+    return this.isEditable && this.document.isOwner
+  }
+
+  /**
+   * Callback actions which occur at the beginning of a drag start workflow.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragStart(event) {
+    if ("link" in event.target.dataset) return
+
+    const el = event.currentTarget.closest('[data-drag="true"]')
+    const dragType = el.dataset.dragType
+
+    let dragData = {}
+
+    let target
+    switch (dragType) {
+      case "save":
+        target = event.currentTarget.querySelector("input")
+        dragData = {
+          actorId: this.document.id,
+          type: "roll",
+          rollType: target.dataset.rollType,
+          rollTarget: target.dataset.rollTarget,
+          value: target.value,
+        }
+        break
+      case "resource":
+        target = event.currentTarget.querySelector("select")
+        dragData = {
+          actorId: this.document.id,
+          type: "roll",
+          rollType: target.dataset.rollType,
+          rollTarget: target.dataset.rollTarget,
+          value: target.value,
+        }
+        break
+      case "damage":
+        dragData = {
+          actorId: this.document.id,
+          type: "rollDamage",
+          rollType: el.dataset.dragType,
+          rollTarget: el.dataset.itemId,
+        }
+        break
+      case "attack":
+        dragData = {
+          actorId: this.document.id,
+          type: "rollAttack",
+          rollValue: el.dataset.rollValue,
+          rollTarget: el.dataset.rollTarget,
+        }
+        break
+      default:
+        // Handle other cases or do nothing
+        break
+    }
+
+    // Extract the data you need
+
+    if (!dragData) return
+
+    // Set data transfer
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData))
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is over a drop target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragOver(event) {}
+
+  async _onDropItem(item) {
+    let itemData = item.toObject()
+    await this.document.createEmbeddedDocuments("Item", [itemData], { renderSheet: false })
+  }
+
+  // #endregion
+
+  // #region Actions
+  /**
+   * Handle toggling between Edit and Play mode.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onToggleSheet(event, target) {
+    const modes = this.constructor.SHEET_MODES
+    this._sheetMode = this.isEditMode ? modes.PLAY : modes.EDIT
+    this.render()
+  }
+
+  /**
+   * Handle changing a Document's image.
+   *
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event   The originating click event
+   * @param {HTMLElement} target   The capturing HTML element which defined a [data-action]
+   * @returns {Promise}
+   * @private
+   */
+  static async #onEditImage(event, target) {
+    const attr = target.dataset.edit
+    const current = foundry.utils.getProperty(this.document, attr)
+    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
+    const fp = new FilePicker({
+      current,
+      type: "image",
+      redirectToRoot: img ? [img] : [],
+      callback: (path) => {
+        this.document.update({ [attr]: path })
+      },
+      top: this.position.top + 40,
+      left: this.position.left + 10,
+    })
+    return fp.browse()
+  }
+
+  /**
+   * Edit an existing item within the Actor
+   * Start with the uuid, if it's not found, fallback to the id (as Embedded item in the actor)
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event The originating click event
+   * @param {HTMLElement} target the capturing HTML element which defined a [data-action]
+   */
+  static async #onItemEdit(event, target) {
+    const id = target.getAttribute("data-item-id")
+    const uuid = target.getAttribute("data-item-uuid")
+    let item
+    item = await fromUuid(uuid)
+    if (!item) item = this.document.items.get(id)
+    if (!item) return
+    item.sheet.render(true)
+  }
+
+  /**
+   * Delete an existing talent within the Actor
+   * Use the uuid to display the talent sheet
+   * @param {PointerEvent} event The originating click event
+   * @param {HTMLElement} target the capturing HTML element which defined a [data-action]
+   */
+  static async #onItemDelete(event, target) {
+    const itemUuid = target.getAttribute("data-item-uuid")
+    const talent = await fromUuid(itemUuid)
+    await talent.deleteDialog()
+  }
+
+  /**
+   * Handles the creation of a new attack item.
+   *
+   * @param {Event} event The event that triggered the creation of the attack.
+   * @param {Object} target The target object where the attack will be created.
+   * @private
+   * @static
+   */
+  static #onCreateSpell(event, target) {
+    const item = this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
+  }
+
+  // #endregion
+}

module/applications/sheets/base-item-sheet.mjs

@@ -0,0 +1,193 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class CthulhuEternalItemSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
+  /**
+   * Different sheet modes.
+   * @enum {number}
+   */
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
+
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-cthulhu-eternal", "item"],
+    position: {
+      width: 600,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: "[data-drag]", dropSelector: null }],
+    actions: {
+      toggleSheet: CthulhuEternalItemSheet.#onToggleSheet,
+      editImage: CthulhuEternalItemSheet.#onEditImage,
+    },
+  }
+
+  /**
+   * The current sheet mode.
+   * @type {number}
+   */
+  _sheetMode = this.constructor.SHEET_MODES.PLAY
+
+  /**
+   * Is the sheet currently in 'Play' mode?
+   * @type {boolean}
+   */
+  get isPlayMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY
+  }
+
+  /**
+   * Is the sheet currently in 'Edit' mode?
+   * @type {boolean}
+   */
+  get isEditMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = {
+      fields: this.document.schema.fields,
+      systemFields: this.document.system.schema.fields,
+      item: this.document,
+      system: this.document.system,
+      source: this.document.toObject(),
+      enrichedDescription: await TextEditor.enrichHTML(this.document.system.description, { async: true }),
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isEditable: this.isEditable,
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   * @returns {DragDrop[]}     An array of DragDrop handlers
+   * @private
+   */
+  #createDragDropHandlers() {
+    return this.options.dragDrop.map((d) => {
+      d.permissions = {
+        dragstart: this._canDragStart.bind(this),
+        drop: this._canDragDrop.bind(this),
+      }
+      d.callbacks = {
+        dragstart: this._onDragStart.bind(this),
+        dragover: this._onDragOver.bind(this),
+        drop: this._onDrop.bind(this),
+      }
+      return new DragDrop(d)
+    })
+  }
+
+  /**
+   * Define whether a user is able to begin a dragstart workflow for a given drag selector
+   * @param {string} selector       The candidate HTML selector for dragging
+   * @returns {boolean}             Can the current user drag this selector?
+   * @protected
+   */
+  _canDragStart(selector) {
+    return this.isEditable
+  }
+
+  /**
+   * Define whether a user is able to conclude a drag-and-drop workflow for a given drop selector
+   * @param {string} selector       The candidate HTML selector for the drop target
+   * @returns {boolean}             Can the current user drop on this selector?
+   * @protected
+   */
+  _canDragDrop(selector) {
+    return this.isEditable && this.document.isOwner
+  }
+
+  /**
+   * Callback actions which occur at the beginning of a drag start workflow.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragStart(event) {
+    const el = event.currentTarget
+    if ("link" in event.target.dataset) return
+
+    // Extract the data you need
+    let dragData = null
+
+    if (!dragData) return
+
+    // Set data transfer
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData))
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is over a drop target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragOver(event) {}
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {}
+
+  // #endregion
+
+  // #region Actions
+  /**
+   * Handle toggling between Edit and Play mode.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onToggleSheet(event, target) {
+    const modes = this.constructor.SHEET_MODES
+    this._sheetMode = this.isEditMode ? modes.PLAY : modes.EDIT
+    this.render()
+  }
+
+  /**
+   * Handle changing a Document's image.
+   *
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event   The originating click event
+   * @param {HTMLElement} target   The capturing HTML element which defined a [data-action]
+   * @returns {Promise}
+   * @private
+   */
+  static async #onEditImage(event, target) {
+    const attr = target.dataset.edit
+    const current = foundry.utils.getProperty(this.document, attr)
+    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
+    const fp = new FilePicker({
+      current,
+      type: "image",
+      redirectToRoot: img ? [img] : [],
+      callback: (path) => {
+        this.document.update({ [attr]: path })
+      },
+      top: this.position.top + 40,
+      left: this.position.left + 10,
+    })
+    return fp.browse()
+  }
+  // #endregion
+}

module/applications/sheets/bond-sheet.mjs

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

module/applications/sheets/gear-sheet.mjs

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

module/applications/sheets/injury-sheet.mjs

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

module/applications/sheets/mentaldisorder-sheet.mjs

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

module/applications/sheets/motivation-sheet.mjs

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

module/applications/sheets/protagonist-sheet.mjs

@@ -0,0 +1,173 @@
+import CthulhuEternalActorSheet from "./base-actor-sheet.mjs"
+
+export default class CthulhuEternalProtagonistSheet extends CthulhuEternalActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["protagonist"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["protagonist-content"],
+    },
+    actions: {
+      createEquipment: CthulhuEternalProtagonistSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "systems/fvtt-cthulhu-eternal/templates/generic/tab-navigation.hbs",
+    },
+    items: {
+      template: "systems/fvtt-cthulhu-eternal/templates/character-items.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-cthulhu-eternal/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "items",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      items: { id: "items", group: "sheet", icon: "fa-solid fa-shapes", label: "CTHULHUETERNAL.Character.Label.details" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "CTHULHUETERNAL.Character.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":
+        context.enrichedBiens = await TextEditor.enrichHTML(doc.system.biens, { async: true })
+        break
+      case "items":
+        context.tab = context.tabs.items
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        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)
+        if (!["path", "weapon", "armor", "spell"].includes(item.type)) return
+        if (item.type === "path") return this.#onDropPathItem(item)
+        if (item.type === "weapon") return super._onDropItem(item)
+        if (item.type === "armor") return this._onDropItem(item)
+        if (item.type === "spell") 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("CTHULHUETERNAL.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("CTHULHUETERNAL.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) {
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

module/applications/sheets/skill-sheet.mjs

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

module/applications/sheets/weapon-sheet.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-cthulhu-eternal/templates/weapon.hbs",
+    },
+  }
+}