Migration datamodels !

modules/applications/sheets/_module.mjs

@@ -0,0 +1,27 @@
+/**
+ * Index des applications AppV2 pour Wasteland
+ * Ce fichier centralise tous les exports des applications
+ */
+
+// Applications de feuilles d'acteurs
+export { default as WastelandPersonnageSheet } from './wasteland-personnage-sheet.mjs';
+export { default as WastelandCreatureSheet } from './wasteland-creature-sheet.mjs';
+
+// Applications de feuilles d'items
+export { default as WastelandArmeSheet } from './wasteland-arme-sheet.mjs';
+export { default as WastelandArtifexSheet } from './wasteland-artifex-sheet.mjs';
+export { default as WastelandBouclierSheet } from './wasteland-bouclier-sheet.mjs';
+export { default as WastelandCapaciteSheet } from './wasteland-capacite-sheet.mjs';
+export { default as WastelandCharmeSheet } from './wasteland-charme-sheet.mjs';
+export { default as WastelandCompetenceSheet } from './wasteland-competence-sheet.mjs';
+export { default as WastelandDonSheet } from './wasteland-don-sheet.mjs';
+export { default as WastelandEquipementSheet } from './wasteland-equipement-sheet.mjs';
+export { default as WastelandHeritageSheet } from './wasteland-heritage-sheet.mjs';
+export { default as WastelandHubrisSheet } from './wasteland-hubris-sheet.mjs';
+export { default as WastelandMetierSheet } from './wasteland-metier-sheet.mjs';
+export { default as WastelandMonnaieSheet } from './wasteland-monnaie-sheet.mjs';
+export { default as WastelandMutationSheet } from './wasteland-mutation-sheet.mjs';
+export { default as WastelandOrigineSheet } from './wasteland-origine-sheet.mjs';
+export { default as WastelandPeupleSheet } from './wasteland-peuple-sheet.mjs';
+export { default as WastelandPouvoirSheet } from './wasteland-pouvoir-sheet.mjs';
+export { default as WastelandProtectionSheet } from './wasteland-protection-sheet.mjs';

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

@@ -0,0 +1,382 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+import { WastelandUtility } from "../../wasteland-utility.js"
+
+export default class WastelandActorSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2) {
+  /**
+   * Different sheet modes.
+   * @enum {number}
+   */
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
+
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+    this._sheetMode = this.constructor.SHEET_MODES.PLAY
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-wasteland", "sheet", "actor"],
+    position: {
+      width: 650,
+      height: 720,
+    },
+    form: {
+      submitOnChange: true,
+      closeOnSubmit: false,
+    },
+    window: {
+      resizable: true,
+    },
+    tabs: [
+      {
+        navSelector: 'nav[data-group="primary"]',
+        contentSelector: "section.sheet-body",
+        initial: "stats",
+      },
+    ],
+    dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+    actions: {
+      editImage: WastelandActorSheet.#onEditImage,
+      toggleSheet: WastelandActorSheet.#onToggleSheet,
+      editItem: WastelandActorSheet.#onEditItem,
+      deleteItem: WastelandActorSheet.#onDeleteItem,
+      createItem: WastelandActorSheet.#onCreateItem,
+      equipItem: WastelandActorSheet.#onEquipItem,
+      modifyQuantity: WastelandActorSheet.#onModifyQuantity,
+      incDecSante: WastelandActorSheet.#onIncDecSante,
+      rollAttribut: WastelandActorSheet.#onRollAttribut,
+      rollCompetence: WastelandActorSheet.#onRollCompetence,
+      rollCharme: WastelandActorSheet.#onRollCharme,
+      rollPouvoir: WastelandActorSheet.#onRollPouvoir,
+      rollArmeOffensif: WastelandActorSheet.#onRollArmeOffensif,
+      rollArmeDegats: WastelandActorSheet.#onRollArmeDegats,
+      resetPredilections: WastelandActorSheet.#onResetPredilections,
+      rollAssommer: WastelandActorSheet.#onRollAssommer,
+      rollFuir: WastelandActorSheet.#onRollFuir,
+      rollImmobiliser: WastelandActorSheet.#onRollImmobiliser,
+    },
+  }
+
+  /**
+   * Is the sheet currently in 'Play' mode?
+   * @type {boolean}
+   */
+  get isPlayMode() {
+    if (this._sheetMode === undefined) this._sheetMode = this.constructor.SHEET_MODES.PLAY
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY
+  }
+
+  /**
+   * Is the sheet currently in 'Edit' mode?
+   * @type {boolean}
+   */
+  get isEditMode() {
+    if (this._sheetMode === undefined) this._sheetMode = this.constructor.SHEET_MODES.PLAY
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT
+  }
+
+  /**
+   * Tab groups state
+   * @type {object}
+   */
+  tabGroups = { primary: "stats" }
+
+  /** @override */
+  async _prepareContext() {
+    const actor = this.document
+
+    const context = {
+      actor: actor,
+      system: actor.system,
+      source: actor.toObject(),
+      fields: actor.schema.fields,
+      systemFields: actor.system.schema.fields,
+      isEditable: this.isEditable,
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isGM: game.user.isGM,
+      config: game.system.wasteland.config,
+      enrichedDescription: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.description || "", { async: true }),
+      enrichedComportement: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.comportement || "", { async: true }),
+      enrichedHabitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.habitat || "", { async: true }),
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    super._onRender(context, options)
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+
+    // Handle edit-item-data changes
+    this.element.querySelectorAll('.edit-item-data').forEach(element => {
+      element.addEventListener('change', async (event) => {
+        const target = event.currentTarget
+        const itemElement = target.closest('[data-item-id]')
+        if (!itemElement) return
+        
+        const itemId = itemElement.dataset.itemId
+        const itemType = itemElement.dataset.itemType
+        const itemField = target.dataset.itemField
+        const dataType = target.dataset.dtype
+        const value = target.value
+        
+        await this.document.editItemField(itemId, itemType, itemField, dataType, value)
+      })
+    })
+
+    // Activate tab navigation manually
+    const nav = this.element.querySelector('nav.tabs[data-group]')
+    if (nav) {
+      const group = nav.dataset.group
+      // Activate the current tab
+      const activeTab = this.tabGroups[group] || "stats"
+      nav.querySelectorAll('[data-tab]').forEach(link => {
+        const tab = link.dataset.tab
+        link.classList.toggle('active', tab === activeTab)
+        link.addEventListener('click', (event) => {
+          event.preventDefault()
+          this.tabGroups[group] = tab
+          this.render()
+        })
+      })
+
+      // Show/hide tab content
+      this.element.querySelectorAll('[data-group="' + group + '"][data-tab]').forEach(content => {
+        content.classList.toggle('active', content.dataset.tab === activeTab)
+      })
+    }
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   */
+  #createDragDropHandlers() {
+    return []
+  }
+
+  // #region Actions
+
+  /**
+   * Handle editing the actor image
+   * @param {Event} event - The triggering event
+   */
+  static async #onEditImage(event) {
+    event.preventDefault()
+    const sheet = this
+    const filePicker = new FilePicker({
+      type: "image",
+      current: sheet.document.img,
+      callback: (path) => {
+        sheet.document.update({ img: path })
+      },
+    })
+    filePicker.browse()
+  }
+
+  /**
+   * Handle toggling the sheet mode
+   * @param {Event} event - The triggering event
+   */
+  static async #onToggleSheet(event) {
+    event.preventDefault()
+    const sheet = this
+    sheet._sheetMode = sheet._sheetMode === sheet.constructor.SHEET_MODES.PLAY ? sheet.constructor.SHEET_MODES.EDIT : sheet.constructor.SHEET_MODES.PLAY
+    sheet.render()
+  }
+
+  /**
+   * Handle editing an item
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onEditItem(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    const item = this.actor.items.get(itemId)
+    if (item) item.sheet.render(true)
+  }
+
+  /**
+   * Handle deleting an item
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onDeleteItem(event, target) {
+    const li = target.closest(".item")
+    await WastelandUtility.confirmDelete(this, li)
+  }
+
+  /**
+   * Handle creating an item
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onCreateItem(event, target) {
+    const itemType = target.dataset.type
+    await this.actor.createEmbeddedDocuments("Item", [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+  }
+
+  /**
+   * Handle equipping an item
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onEquipItem(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    await this.actor.equipItem(itemId)
+  }
+
+  /**
+   * Handle modifying item quantity
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onModifyQuantity(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    
+    const item = this.actor.items.get(itemId)
+    if (!item) return
+    
+    const qty = parseInt(target.dataset.qty) || 0
+    const currentQty = item.system.quantite || 0
+    const newQty = Math.max(0, currentQty + qty)
+    
+    await item.update({ 'system.quantite': newQty })
+  }
+
+  /**
+   * Handle modifying santé/psyché
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onIncDecSante(event, target) {
+    const field = target.dataset.field
+    const value = parseInt(target.dataset.value) || 0
+    
+    if (field === 'psyche') {
+      await this.actor.update({ 'system.psyche.value': this.actor.system.psyche.value + value })
+    } else if (field === 'nonletaux') {
+      await this.actor.update({ 'system.sante.nonletaux': this.actor.system.sante.nonletaux + value })
+    } else if (field === 'letaux') {
+      await this.actor.update({ 'system.sante.letaux': this.actor.system.sante.letaux + value })
+    }
+  }
+
+  /**
+   * Handle rolling an attribute
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollAttribut(event, target) {
+    const attrKey = target.dataset.attrKey
+    await this.actor.rollAttribut(attrKey)
+  }
+
+  /**
+   * Handle rolling a competence
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollCompetence(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    const attrKey = target.dataset.attrKey
+    if (!itemId) return
+    await this.actor.rollCompetence(attrKey, itemId)
+  }
+
+  /**
+   * Handle rolling a charme
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollCharme(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    await this.actor.rollCharme(itemId)
+  }
+
+  /**
+   * Handle rolling a pouvoir
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollPouvoir(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    await this.actor.rollPouvoir(itemId)
+  }
+
+  /**
+   * Handle rolling weapon attack
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollArmeOffensif(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    await this.actor.rollArmeOffensif(itemId)
+  }
+
+  /**
+   * Handle rolling weapon damage
+   * @param {Event} event - The triggering event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollArmeDegats(event, target) {
+    const li = target.closest(".item")
+    const itemId = li?.dataset.itemId
+    if (!itemId) return
+    await this.actor.rollArmeDegats(itemId)
+  }
+
+  /**
+   * Handle resetting all predilections
+   * @param {Event} event - The originating click event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onResetPredilections(event, target) {
+    await this.actor.resetAllPredilections()
+  }
+
+  /**
+   * Handle Assommer roll
+   * @param {Event} event - The originating click event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollAssommer(event, target) {
+    await this.actor.rollAssommer()
+  }
+
+  /**
+   * Handle Fuir roll
+   * @param {Event} event - The originating click event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollFuir(event, target) {
+    await this.actor.rollFuir()
+  }
+
+  /**
+   * Handle Immobiliser roll
+   * @param {Event} event - The originating click event
+   * @param {HTMLElement} target - The target element
+   */
+  static async #onRollImmobiliser(event, target) {
+    await this.actor.rollImmobiliser()
+  }
+}

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

@@ -0,0 +1,158 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class WastelandItemSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-wasteland", "item"],
+    position: {
+      width: 620,
+      height: 600,
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    tabs: [
+      {
+        navSelector: 'nav[data-group="primary"]',
+        contentSelector: "section.sheet-body",
+        initial: "description",
+      },
+    ],
+    dragDrop: [{ dragSelector: "[data-drag]", dropSelector: null }],
+    actions: {
+      editImage: WastelandItemSheet.#onEditImage,
+      postItem: WastelandItemSheet.#onPostItem,
+    },
+  }
+
+  /**
+   * Tab groups state
+   * @type {object}
+   */
+  tabGroups = { primary: "description" }
+
+  /** @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 foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.description, { async: true }),
+      isEditMode: true,
+      isEditable: this.isEditable,
+      isGM: game.user.isGM,
+      config: game.system.wasteland.config,
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    super._onRender(context, options)
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+
+    // Activate tab navigation manually
+    const nav = this.element.querySelector('nav.tabs[data-group]')
+    if (nav) {
+      const group = nav.dataset.group
+      // Activate the current tab
+      const activeTab = this.tabGroups[group] || "description"
+      nav.querySelectorAll('[data-tab]').forEach(link => {
+        const tab = link.dataset.tab
+        link.classList.toggle('active', tab === activeTab)
+        link.addEventListener('click', (event) => {
+          event.preventDefault()
+          this.tabGroups[group] = tab
+          this.render()
+        })
+      })
+
+      // Show/hide tab content
+      this.element.querySelectorAll('[data-group="' + group + '"][data-tab]').forEach(content => {
+        content.classList.toggle('active', content.dataset.tab === activeTab)
+      })
+    }
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   */
+  #createDragDropHandlers() {
+    return []
+  }
+
+  // #region Actions
+
+  /**
+   * Handle editing the item image
+   * @param {Event} event - The triggering event
+   */
+  static async #onEditImage(event) {
+    event.preventDefault()
+    const filePicker = new FilePicker({
+      type: "image",
+      current: this.document.img,
+      callback: (path) => {
+        this.document.update({ img: path })
+      },
+    })
+    filePicker.browse()
+  }
+
+  /**
+   * Handle posting the item to chat
+   * @param {Event} event - The triggering event
+   */
+  static async #onPostItem(event) {
+    event.preventDefault()
+    
+    // Prepare chat data
+    const chatData = {
+      name: this.document.name,
+      img: this.document.img,
+      type: this.document.type,
+      system: this.document.system,
+    }
+    
+    // Add actor reference if item is owned
+    if (this.document.actor) {
+      chatData.actor = { id: this.document.actor.id }
+    }
+    
+    // Don't post any image for the item if the default image is used
+    if (chatData.img && chatData.img.includes("/blank.png")) {
+      chatData.img = null
+    }
+    
+    // JSON object for easy creation
+    chatData.jsondata = JSON.stringify({
+      compendium: "postedItem",
+      payload: chatData,
+    })
+
+    // Render the chat card template
+    const html = await foundry.applications.handlebars.renderTemplate('systems/fvtt-wasteland/templates/post-item.hbs', chatData)
+    
+    // Create the chat message
+    const chatOptions = {
+      user: game.user.id,
+      content: html,
+      speaker: ChatMessage.getSpeaker({ actor: this.document.actor })
+    }
+    
+    ChatMessage.create(chatOptions)
+  }
+}

modules/applications/sheets/wasteland-arme-sheet.mjs

@@ -0,0 +1,49 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandArmeSheet extends WastelandItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["arme"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["arme-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-wasteland/templates/item-arme-sheet.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    primary: "details",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    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()
+    return context
+  }
+}

modules/applications/sheets/wasteland-artifex-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandArtifexSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["artifex"],
+    position: { width: 620 },
+    window: { contentClasses: ["artifex-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-artifex-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-bouclier-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandBouclierSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["bouclier"],
+    position: { width: 620 },
+    window: { contentClasses: ["bouclier-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-bouclier-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-capacite-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandCapaciteSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["capacite"],
+    position: { width: 620 },
+    window: { contentClasses: ["capacite-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-capacite-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-charme-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandCharmeSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["charme"],
+    position: { width: 620 },
+    window: { contentClasses: ["charme-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-charme-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-competence-sheet.mjs

@@ -0,0 +1,72 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandCompetenceSheet extends WastelandItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["competence"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["competence-content"],
+    },
+    actions: {
+      "add-predilection": this.#onAddPredilection,
+      "delete-predilection": this.#onDeletePredilection
+    }
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-wasteland/templates/item-competence-sheet.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    primary: "details",
+  }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    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()
+    return context
+  }
+
+  /**
+   * Handle adding a new predilection
+   * @param {PointerEvent} event - The triggering event
+   * @param {HTMLElement} target - The button element
+   */
+  static async #onAddPredilection(event, target) {
+    const predilections = foundry.utils.duplicate(this.document.system.predilections)
+    predilections.push({ name: "Nouvelle prédilection", used: false })
+    await this.document.update({ "system.predilections": predilections })
+  }
+
+  /**
+   * Handle deleting a predilection
+   * @param {PointerEvent} event - The triggering event
+   * @param {HTMLElement} target - The delete button element
+   */
+  static async #onDeletePredilection(event, target) {
+    const index = parseInt(target.dataset.index)
+    const predilections = foundry.utils.duplicate(this.document.system.predilections)
+    predilections.splice(index, 1)
+    await this.document.update({ "system.predilections": predilections })
+  }
+}

modules/applications/sheets/wasteland-creature-sheet.mjs

@@ -0,0 +1,40 @@
+import WastelandActorSheet from "./base-actor-sheet.mjs"
+
+export default class WastelandCreatureSheet extends WastelandActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "creature"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "Feuille de Créature",
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    sheet: {
+      template: "systems/fvtt-wasteland/templates/actor-creature-sheet.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    primary: "stats",
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    const actor = this.document
+
+    // Add creature-specific data
+    context.skills = actor.getSkills()
+    context.armes = foundry.utils.duplicate(actor.getWeapons())
+    context.protections = foundry.utils.duplicate(actor.getArmors())
+    context.capacites = foundry.utils.duplicate(actor.getCapacites())
+    context.combat = actor.getCombatValues()
+
+    return context
+  }
+}

modules/applications/sheets/wasteland-don-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandDonSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["don"],
+    position: { width: 620 },
+    window: { contentClasses: ["don-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-don-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-equipement-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandEquipementSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["equipement"],
+    position: { width: 620 },
+    window: { contentClasses: ["equipement-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-equipement-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-heritage-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandHeritageSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["heritage"],
+    position: { width: 620 },
+    window: { contentClasses: ["heritage-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-heritage-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-hubris-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandHubrisSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["hubris"],
+    position: { width: 620 },
+    window: { contentClasses: ["hubris-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-hubris-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-metier-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandMetierSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["metier"],
+    position: { width: 620 },
+    window: { contentClasses: ["metier-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-metier-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-monnaie-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandMonnaieSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["monnaie"],
+    position: { width: 620 },
+    window: { contentClasses: ["monnaie-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-monnaie-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-mutation-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandMutationSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["mutation"],
+    position: { width: 620 },
+    window: { contentClasses: ["mutation-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-mutation-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-origine-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandOrigineSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["origine"],
+    position: { width: 620 },
+    window: { contentClasses: ["origine-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-origine-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-personnage-sheet.mjs

@@ -0,0 +1,59 @@
+import WastelandActorSheet from "./base-actor-sheet.mjs"
+
+export default class WastelandPersonnageSheet extends WastelandActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "personnage"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "Feuille de Personnage",
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    sheet: {
+      template: "systems/fvtt-wasteland/templates/actor-personnage-sheet.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    primary: "stats",
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    const actor = this.document
+
+    // Add personnage-specific data
+    context.skills = actor.getSkills()
+    context.armes = foundry.utils.duplicate(actor.getWeapons())
+    context.protections = foundry.utils.duplicate(actor.getArmors())
+    context.pouvoirs = foundry.utils.duplicate(actor.getPouvoirs())
+    context.dons = foundry.utils.duplicate(actor.getDons())
+    context.hubrises = foundry.utils.duplicate(actor.getHubris())
+    context.tours = foundry.utils.duplicate(actor.getTours())
+    context.artifex = foundry.utils.duplicate(actor.getArtifex())
+    context.charmes = foundry.utils.duplicate(actor.getCharmes())
+    context.peuple = foundry.utils.duplicate(actor.getPeuple() || {})
+    context.origine = foundry.utils.duplicate(actor.getOrigine() || {})
+    context.heritage = foundry.utils.duplicate(actor.getHeritage() || {})
+    context.metier = foundry.utils.duplicate(actor.getMetier() || {})
+    context.combat = actor.getCombatValues()
+    context.capacites = foundry.utils.duplicate(actor.getCapacites())
+    context.equipements = foundry.utils.duplicate(actor.getEquipments())
+    context.monnaies = foundry.utils.duplicate(actor.getMonnaies())
+    context.mutations = foundry.utils.duplicate(actor.getMutations())
+
+    // Enrich HTML fields for biodata
+    context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.notes || "", { async: true })
+    context.enrichedGMNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.gmnotes || "", { async: true })
+    context.enrichedSequelles = await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.sequelles || "", { async: true })
+    context.enrichedTraumatismes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.biodata?.traumatismes || "", { async: true })
+
+    return context
+  }
+}

modules/applications/sheets/wasteland-peuple-sheet.mjs

@@ -0,0 +1,32 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandPeupleSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["peuple"],
+    position: { width: 620 },
+    window: { contentClasses: ["peuple-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-peuple-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "description" }
+
+  #getTabs() {
+    const tabs = {
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-pouvoir-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandPouvoirSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["pouvoir"],
+    position: { width: 620 },
+    window: { contentClasses: ["pouvoir-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-pouvoir-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/sheets/wasteland-protection-sheet.mjs

@@ -0,0 +1,33 @@
+import WastelandItemSheet from "./base-item-sheet.mjs"
+
+export default class WastelandProtectionSheet extends WastelandItemSheet {
+  static DEFAULT_OPTIONS = {
+    classes: ["protection"],
+    position: { width: 620 },
+    window: { contentClasses: ["protection-content"] },
+  }
+
+  static PARTS = {
+    main: { template: "systems/fvtt-wasteland/templates/item-protection-sheet.hbs" },
+  }
+
+  tabGroups = { primary: "details" }
+
+  #getTabs() {
+    const tabs = {
+      details: { id: "details", group: "primary", label: "Détails" },
+      description: { id: "description", group: "primary", label: "Description" }
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+    return context
+  }
+}

modules/applications/wasteland-roll-dialog.mjs

@@ -0,0 +1,156 @@
+import { WastelandUtility } from "../wasteland-utility.js"
+
+/**
+ * Dialogue de jet de dé pour Wasteland - Version DialogV2
+ */
+export class WastelandRollDialog {
+
+  /**
+   * Create and display the roll dialog
+   * @param {WastelandActor} actor - The actor making the roll
+   * @param {Object} rollData - Data for the roll
+   * @returns {Promise<WastelandRollDialog>}
+   */
+  static async create(actor, rollData) {
+    // Préparer le contexte pour le template
+    const context = {
+      ...rollData,
+      difficulte: String(rollData.difficulte || 0),
+      img: actor.img,
+      name: actor.name,
+      config: game.system.wasteland.config,
+    }
+
+    // Rendre le template en HTML
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-wasteland/templates/roll-dialog-v2.hbs",
+      context
+    )
+
+    // Utiliser DialogV2.wait avec le HTML rendu
+    return foundry.applications.api.DialogV2.wait({
+      window: { title: "Test de Capacité", icon: "fa-solid fa-dice-d20" },
+      classes: ["wasteland-roll-dialog"],
+      position: { width: 500 },
+      modal: false,
+      content,
+      buttons: rollData.charme ? [
+        {
+          action: "roll",
+          label: "Lancer",
+          icon: "fa-solid fa-dice-d20",
+          default: true,
+          callback: (event, button, dialog) => {
+            this._updateRollDataFromForm(rollData, button.form.elements, actor)
+            WastelandUtility.rollWasteland(rollData)
+          }
+        }
+      ] : [
+        {
+          action: "rolld10",
+          label: "Lancer 1d10",
+          icon: "fa-solid fa-dice-d10",
+          default: true,
+          callback: (event, button, dialog) => {
+            this._updateRollDataFromForm(rollData, button.form.elements, actor)
+            rollData.mainDice = "1d10"
+            WastelandUtility.rollWasteland(rollData)
+          }
+        },
+        {
+          action: "rolld20",
+          label: "Lancer 1d20",
+          icon: "fa-solid fa-dice-d20",
+          callback: (event, button, dialog) => {
+            this._updateRollDataFromForm(rollData, button.form.elements, actor)
+            rollData.mainDice = "1d20"
+            WastelandUtility.rollWasteland(rollData)
+          }
+        },
+      ],
+      rejectClose: false,
+    })
+  }
+
+  /**
+   * Mettre à jour rollData avec les valeurs du formulaire
+   * @param {Object} rollData - L'objet rollData à mettre à jour
+   * @param {HTMLFormControlsCollection} formElements - Les éléments du formulaire
+   * @param {WastelandActor} actor - L'acteur pour récupérer les attributs
+   * @private
+   */
+  static _updateRollDataFromForm(rollData, formElements, actor) {
+    // Attributs
+    if (formElements.attrKey) {
+      rollData.attrKey = formElements.attrKey.value
+      if (rollData.attrKey !== "tochoose" && actor) {
+        rollData.attr = foundry.utils.duplicate(actor.system.attributs[rollData.attrKey])
+      }
+    }
+
+    // Modificateurs de base
+    if (formElements.difficulte) {
+      rollData.difficulte = Number(formElements.difficulte.value)
+    }
+    if (formElements.modificateur) {
+      rollData.modificateur = Number(formElements.modificateur.value)
+    }
+
+    // Charme
+    if (formElements.charmeDice) {
+      rollData.charmeDice = String(formElements.charmeDice.value)
+    }
+
+    // Combat mêlée
+    if (formElements.typeAttaque) {
+      rollData.typeAttaque = String(formElements.typeAttaque.value)
+      rollData.typeAttaqueLabel = rollData.config.attaques[rollData.typeAttaque]
+    }
+    if (formElements.isMonte !== undefined) {
+      rollData.isMonte = formElements.isMonte.checked
+    }
+
+    // Combat distance
+    if (formElements.visee !== undefined) {
+      rollData.visee = formElements.visee.checked
+    }
+    if (formElements.cibleconsciente !== undefined) {
+      rollData.cibleconsciente = formElements.cibleconsciente.checked
+    }
+    if (formElements.ciblecourt !== undefined) {
+      rollData.ciblecourt = formElements.ciblecourt.checked
+    }
+    if (formElements.typeCouvert) {
+      rollData.typeCouvert = String(formElements.typeCouvert.value)
+      const couvert = rollData.config.couverts[rollData.typeCouvert]
+      if (rollData.typeCouvert !== "aucun" && couvert) {
+        rollData.typeCouvertLabel = couvert.name
+        rollData.typeCouvertValue = couvert.value
+      }
+    }
+
+    // Désavantages (avantages tactiques)
+    if (!rollData.desavantages) rollData.desavantages = {}
+    
+    if (formElements.cibleausol !== undefined) {
+      rollData.desavantages.cibleausol = formElements.cibleausol.checked
+    }
+    if (formElements.cibledesarmee !== undefined) {
+      rollData.desavantages.cibledesarmee = formElements.cibledesarmee.checked
+    }
+    if (formElements.ciblerestreint !== undefined) {
+      rollData.desavantages.ciblerestreint = formElements.ciblerestreint.checked
+    }
+    if (formElements.cibleimmobilisée !== undefined) {
+      rollData.desavantages.cibleimmobilisée = formElements.cibleimmobilisée.checked
+    }
+    if (formElements.ciblesurplomb !== undefined) {
+      rollData.desavantages.ciblesurplomb = formElements.ciblesurplomb.checked
+    }
+
+    // Double D20
+    if (formElements.doubleD20 !== undefined) {
+      rollData.doubleD20 = formElements.doubleD20.checked
+    }
+  }
+}