DAtaModels + Appv2 migration : OK

modules/applications/mournblade-cyd2-roll-dialog.mjs

@@ -0,0 +1,84 @@
+import { MournbladeCYD2Utility } from "../mournblade-cyd2-utility.js";
+
+/**
+ * Dialogue de jet de dé pour MournbladeCYD2 - Version DialogV2
+ */
+export class MournbladeCYD2RollDialog {
+
+  /**
+   * Create and display the roll dialog
+   * @param {MournbladeCYD2Actor} actor
+   * @param {Object} rollData
+   */
+  static async create(actor, rollData) {
+    const context = {
+      ...rollData,
+      difficulte: String(rollData.difficulte || 0),
+      img: actor.img,
+      name: actor.name,
+      config: game.system.mournbladecyd2.config
+    };
+
+    if (rollData.attrKey === "tochoose") {
+      context.selectableAttributes = actor.system.attributs;
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-mournblade-cyd2/templates/roll-dialog-generic.hbs",
+      context
+    );
+
+    return foundry.applications.api.DialogV2.wait({
+      window: { title: "Test de Capacité", icon: "fa-solid fa-dice-d20" },
+      classes: ["mournblade-cyd2-roll-dialog"],
+      position: { width: 360 },
+      modal: false,
+      content,
+      buttons: [
+        {
+          action: "rolld10",
+          label: "Lancer 1d10",
+          icon: "fa-solid fa-dice-d10",
+          default: true,
+          callback: (event, button, dialog) => {
+            MournbladeCYD2RollDialog._updateRollDataFromForm(rollData, button.form.elements, actor);
+            rollData.mainDice = "1d10";
+            MournbladeCYD2Utility.rollMournbladeCYD2(rollData);
+          }
+        },
+        {
+          action: "rolld20",
+          label: "Lancer 1d20",
+          icon: "fa-solid fa-dice-d20",
+          callback: (event, button, dialog) => {
+            MournbladeCYD2RollDialog._updateRollDataFromForm(rollData, button.form.elements, actor);
+            rollData.mainDice = "1d20";
+            MournbladeCYD2Utility.rollMournbladeCYD2(rollData);
+          }
+        },
+        {
+          action: "cancel",
+          label: "Annuler",
+          icon: "fa-solid fa-times"
+        }
+      ]
+    });
+  }
+
+  /* -------------------------------------------- */
+  static _updateRollDataFromForm(rollData, elements, actor) {
+    if (elements.modificateur) rollData.modificateur = Number(elements.modificateur.value);
+    if (elements.difficulte) rollData.difficulte = Number(elements.difficulte.value);
+    if (elements.attrKey) rollData.attrKey = String(elements.attrKey.value);
+    if (elements.attrKey2) rollData.attrKey2 = String(elements.attrKey2.value);
+    if (elements["select-maitrise"]) rollData.maitriseId = String(elements["select-maitrise"].value);
+    if (elements["competence-talents"]) {
+      const sel = elements["competence-talents"];
+      rollData.selectedTalents = Array.from(sel.selectedOptions).map(o => o.value);
+    }
+    if (elements["taille-cible"]) rollData.tailleCible = String(elements["taille-cible"].value);
+    if (elements["tireur-deplacement"]) rollData.tireurDeplacement = String(elements["tireur-deplacement"].value);
+    if (elements["cible-couvert"]) rollData.cibleCouvert = String(elements["cible-couvert"].value);
+    if (elements["distance-tir"]) rollData.distanceTir = String(elements["distance-tir"].value);
+  }
+}

modules/applications/sheets/_module.mjs

@@ -0,0 +1,25 @@
+/**
+ * Index des applications AppV2 pour Mournblade CYD 2.0
+ */
+
+// Fiches d'acteurs
+export { default as MournbladeCYD2PersonnageSheet } from './mournblade-cyd2-personnage-sheet.mjs';
+export { default as MournbladeCYD2CreatureSheet } from './mournblade-cyd2-creature-sheet.mjs';
+
+// Fiches d'items
+export { default as MournbladeCYD2ArmeSheet } from './mournblade-cyd2-arme-sheet.mjs';
+export { default as MournbladeCYD2CompetenceSheet } from './mournblade-cyd2-competence-sheet.mjs';
+export { default as MournbladeCYD2DonSheet } from './mournblade-cyd2-don-sheet.mjs';
+export { default as MournbladeCYD2EquipementSheet } from './mournblade-cyd2-equipement-sheet.mjs';
+export { default as MournbladeCYD2HistoriqueSheet } from './mournblade-cyd2-historique-sheet.mjs';
+export { default as MournbladeCYD2MonnaieSheet } from './mournblade-cyd2-monnaie-sheet.mjs';
+export { default as MournbladeCYD2PacteSheet } from './mournblade-cyd2-pacte-sheet.mjs';
+export { default as MournbladeCYD2ProfilSheet } from './mournblade-cyd2-profil-sheet.mjs';
+export { default as MournbladeCYD2ProtectionSheet } from './mournblade-cyd2-protection-sheet.mjs';
+export { default as MournbladeCYD2RessourceSheet } from './mournblade-cyd2-ressource-sheet.mjs';
+export { default as MournbladeCYD2RuneSheet } from './mournblade-cyd2-rune-sheet.mjs';
+export { default as MournbladeCYD2RuneEffectSheet } from './mournblade-cyd2-runeeffect-sheet.mjs';
+export { default as MournbladeCYD2TalentSheet } from './mournblade-cyd2-talent-sheet.mjs';
+export { default as MournbladeCYD2TendanceSheet } from './mournblade-cyd2-tendance-sheet.mjs';
+export { default as MournbladeCYD2TraitChaotiqueSheet } from './mournblade-cyd2-traitchaotique-sheet.mjs';
+export { default as MournbladeCYD2TraitEspeceSheet } from './mournblade-cyd2-traitespece-sheet.mjs';

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

@@ -0,0 +1,279 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api;
+
+import { MournbladeCYD2Utility } from "../../mournblade-cyd2-utility.js";
+
+export default class MournbladeCYD2ActorSheetV2 extends HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2) {
+
+  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-mournblade-cyd2", "sheet", "actor"],
+    position: {
+      width: 640,
+      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: MournbladeCYD2ActorSheetV2.#onEditImage,
+      toggleSheet: MournbladeCYD2ActorSheetV2.#onToggleSheet,
+      editItem: MournbladeCYD2ActorSheetV2.#onEditItem,
+      deleteItem: MournbladeCYD2ActorSheetV2.#onDeleteItem,
+      createItem: MournbladeCYD2ActorSheetV2.#onCreateItem,
+      equipItem: MournbladeCYD2ActorSheetV2.#onEquipItem,
+      modifyQuantity: MournbladeCYD2ActorSheetV2.#onModifyQuantity,
+      modifySante: MournbladeCYD2ActorSheetV2.#onModifySante,
+      modifyAme: MournbladeCYD2ActorSheetV2.#onModifyAme,
+      rollAttribut: MournbladeCYD2ActorSheetV2.#onRollAttribut,
+      rollCompetence: MournbladeCYD2ActorSheetV2.#onRollCompetence,
+      rollRune: MournbladeCYD2ActorSheetV2.#onRollRune,
+      rollArmeOffensif: MournbladeCYD2ActorSheetV2.#onRollArmeOffensif,
+      rollArmeSpecial: MournbladeCYD2ActorSheetV2.#onRollArmeSpecial,
+      rollArmeDegats: MournbladeCYD2ActorSheetV2.#onRollArmeDegats,
+      rollAssommer: MournbladeCYD2ActorSheetV2.#onRollAssommer,
+      rollImmobiliser: MournbladeCYD2ActorSheetV2.#onRollImmobiliser,
+      rollFuir: MournbladeCYD2ActorSheetV2.#onRollFuir,
+    },
+  };
+
+  get isPlayMode() {
+    if (this._sheetMode === undefined) this._sheetMode = this.constructor.SHEET_MODES.PLAY;
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY;
+  }
+
+  get isEditMode() {
+    if (this._sheetMode === undefined) this._sheetMode = this.constructor.SHEET_MODES.PLAY;
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT;
+  }
+
+  tabGroups = { primary: "stats" };
+
+  /** @override */
+  async _prepareContext() {
+    const actor = this.document;
+    return {
+      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.mournbladecyd2.config,
+      enrichedDescription: await foundry.applications.ux.TextEditor.implementation.enrichHTML(
+        actor.system.biodata?.description || "", { async: true }
+      ),
+      enrichedHabitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(
+        actor.system.biodata?.habitat || "", { async: true }
+      ),
+    };
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    super._onRender(context, options);
+    this.#dragDrop.forEach((d) => d.bind(this.element));
+
+    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 itemField = target.dataset.itemField;
+        const dataType = target.dataset.dtype;
+        const value = dataType === "Number" ? Number(target.value) : target.value;
+        const item = this.document.items.get(itemId);
+        if (item) await item.update({ [itemField]: value });
+      });
+    });
+
+    // Tab navigation
+    const nav = this.element.querySelector('nav.tabs[data-group]');
+    if (nav) {
+      const group = nav.dataset.group;
+      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();
+        });
+      });
+      this.element.querySelectorAll(`[data-group="${group}"][data-tab]`).forEach(content => {
+        content.classList.toggle('active', content.dataset.tab === activeTab);
+      });
+    }
+  }
+
+  #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 foundry.applications.ux.DragDrop.implementation(d);
+    });
+  }
+
+  _canDragStart(selector) { return this.isEditable; }
+  _canDragDrop(selector) { return this.isEditable; }
+
+  _onDragStart(event) {
+    const li = event.currentTarget.closest("[data-item-id]");
+    if (!li) return;
+    const item = this.document.items.get(li.dataset.itemId);
+    if (!item) return;
+    event.dataTransfer.setData("text/plain", JSON.stringify(item.toDragData()));
+  }
+
+  _onDragOver(event) { event.preventDefault(); }
+
+  async _onDrop(event) {
+    const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
+    if (data?.type === "Item") return this._onDropItem(event, data);
+    if (data?.type === "Actor") return this._onDropActor(event, data);
+  }
+
+  async _onDropItem(event, data) {
+    if (!this.document.isOwner) return;
+    const item = await Item.fromDropData(data);
+    if (!item) return;
+    if (this.document.uuid === item.parent?.uuid) return;
+    return this.document.createEmbeddedDocuments("Item", [item.toObject()]);
+  }
+
+  async _onDropActor(event, data) {}
+
+  // #region Actions
+
+  static async #onEditImage(event) {
+    const fp = new FilePicker({
+      type: "image",
+      current: this.document.img,
+      callback: (path) => this.document.update({ img: path })
+    });
+    fp.browse();
+  }
+
+  static #onToggleSheet(event) {
+    this._sheetMode = this.isEditMode
+      ? this.constructor.SHEET_MODES.PLAY
+      : this.constructor.SHEET_MODES.EDIT;
+    this.render();
+  }
+
+  static async #onEditItem(event, target) {
+    const li = target.closest(".item");
+    const item = this.document.items.get(li?.dataset.itemId);
+    item?.sheet.render(true);
+  }
+
+  static async #onDeleteItem(event, target) {
+    const li = target.closest(".item");
+    await MournbladeCYD2Utility.confirmDelete(this, li);
+  }
+
+  static async #onCreateItem(event, target) {
+    const itemType = target.dataset.type;
+    await this.document.createEmbeddedDocuments("Item", [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true });
+  }
+
+  static async #onEquipItem(event, target) {
+    const li = target.closest(".item");
+    const item = this.document.items.get(li?.dataset.itemId);
+    if (item) await item.update({ "system.equipped": !item.system.equipped });
+  }
+
+  static async #onModifyQuantity(event, target) {
+    const li = target.closest('[data-item-id]');
+    const item = this.document.items.get(li?.dataset.itemId);
+    const value = Number.parseInt(target.dataset.quantiteValue);
+    if (item) {
+      const newQty = Math.max(0, (item.system.quantite || 0) + value);
+      await item.update({ "system.quantite": newQty });
+    }
+  }
+
+  static async #onModifySante(event, target) {
+    const type = target.dataset.type;
+    const value = Number.parseInt(target.dataset.value);
+    const current = this.document.system.sante[type] || 0;
+    await this.document.update({ [`system.sante.${type}`]: Math.max(0, current + value) });
+  }
+
+  static async #onModifyAme(event, target) {
+    const value = Number.parseInt(target.dataset.value);
+    const current = this.document.system.ame.nbame || 0;
+    await this.document.update({ "system.ame.nbame": Math.max(0, current + value) });
+  }
+
+  static async #onRollAttribut(event, target) {
+    await this.document.rollAttribut(target.dataset.attrKey);
+  }
+
+  static async #onRollCompetence(event, target) {
+    const li = target.closest('[data-item-id]');
+    await this.document.rollCompetence(target.dataset.attrKey, li?.dataset.itemId);
+  }
+
+  static async #onRollRune(event, target) {
+    const li = target.closest('[data-item-id]');
+    await this.document.rollRune(li?.dataset.itemId);
+  }
+
+  static async #onRollArmeOffensif(event, target) {
+    await this.document.rollArmeOffensif(target.dataset.armeId);
+  }
+
+  static async #onRollArmeSpecial(event, target) {
+    await this.document.rollArmeSpecial(target.dataset.armeId);
+  }
+
+  static async #onRollArmeDegats(event, target) {
+    await this.document.rollArmeDegats(target.dataset.armeId);
+  }
+
+  static async #onRollAssommer(event, target) {
+    await this.document.rollAssomer();
+  }
+
+  static async #onRollImmobiliser(event, target) {
+    await this.document.rollImmobiliser();
+  }
+
+  static async #onRollFuir(event, target) {
+    await this.document.rollFuir();
+  }
+}

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

@@ -0,0 +1,125 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api;
+
+import { MournbladeCYD2Utility } from "../../mournblade-cyd2-utility.js";
+
+export default class MournbladeCYD2ItemSheetV2 extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
+
+  constructor(options = {}) {
+    super(options);
+    this.#dragDrop = this.#createDragDropHandlers();
+  }
+
+  #dragDrop;
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-mournblade-cyd2", "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: MournbladeCYD2ItemSheetV2.#onEditImage,
+      postItem: MournbladeCYD2ItemSheetV2.#onPostItem,
+      addPredilection: MournbladeCYD2ItemSheetV2.#onAddPredilection,
+      deletePredilection: MournbladeCYD2ItemSheetV2.#onDeletePredilection,
+    },
+  };
+
+  tabGroups = { primary: "description" };
+
+  /** @override */
+  async _prepareContext() {
+    return {
+      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.mournbladecyd2.config,
+    };
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    super._onRender(context, options);
+    this.#dragDrop.forEach((d) => d.bind(this.element));
+
+    // Tab navigation
+    const nav = this.element.querySelector('nav.tabs[data-group]');
+    if (nav) {
+      const group = nav.dataset.group;
+      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();
+        });
+      });
+      this.element.querySelectorAll(`[data-group="${group}"][data-tab]`).forEach(content => {
+        content.classList.toggle('active', content.dataset.tab === activeTab);
+      });
+    }
+  }
+
+  #createDragDropHandlers() {
+    return this.options.dragDrop.map(d => {
+      d.permissions = { dragstart: () => this.isEditable };
+      d.callbacks = { dragstart: this._onDragStart.bind(this) };
+      return new foundry.applications.ux.DragDrop.implementation(d);
+    });
+  }
+
+  _onDragStart(event) {}
+
+  // #region Actions
+
+  static async #onEditImage(event) {
+    const fp = new FilePicker({
+      type: "image",
+      current: this.document.img,
+      callback: (path) => this.document.update({ img: path })
+    });
+    fp.browse();
+  }
+
+  static async #onPostItem(event) {
+    await this.document.toChat?.();
+  }
+
+  static async #onAddPredilection(event) {
+    const preds = foundry.utils.duplicate(this.document.system.predilections || []);
+    preds.push({ id: foundry.utils.randomID(), name: "Nouvelle prédilection", description: "", acquise: false, maitrise: false, used: false });
+    await this.document.update({ "system.predilections": preds });
+  }
+
+  static async #onDeletePredilection(event, target) {
+    const idx = Number(target.dataset.predilectionIndex);
+    const preds = foundry.utils.duplicate(this.document.system.predilections || []);
+    preds.splice(idx, 1);
+    await this.document.update({ "system.predilections": preds });
+  }
+}

modules/applications/sheets/mournblade-cyd2-arme-sheet.mjs

@@ -0,0 +1,39 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2ArmeSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "arme"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.arme",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-arme-sheet.hbs",
+    },
+  };
+
+  #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/mournblade-cyd2-competence-sheet.mjs

@@ -0,0 +1,39 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2CompetenceSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "competence"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.competence",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-competence-sheet.hbs",
+    },
+  };
+
+  #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/mournblade-cyd2-creature-sheet.mjs

@@ -0,0 +1,42 @@
+import MournbladeCYD2ActorSheetV2 from "./base-actor-sheet.mjs";
+
+export default class MournbladeCYD2CreatureSheet extends MournbladeCYD2ActorSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Actor.creature",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    sheet: {
+      template: "systems/fvtt-mournblade-cyd2/templates/creature-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  tabGroups = { primary: "stats" };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    const actor = this.document;
+
+    context.skills = actor.getSkills?.() ?? [];
+    context.armes = foundry.utils.duplicate(actor.getWeapons?.() ?? []);
+    context.protections = foundry.utils.duplicate(actor.getArmors?.() ?? []);
+    context.runes = foundry.utils.duplicate(actor.getRunes?.() ?? []);
+    context.combat = actor.getCombatValues?.() ?? {};
+    context.equipements = foundry.utils.duplicate(actor.getEquipments?.() ?? []);
+    context.monnaies = foundry.utils.duplicate(actor.getMonnaies?.() ?? []);
+    context.talents = foundry.utils.duplicate(actor.getTalents?.() ?? []);
+    context.protectionTotal = actor.getProtectionTotal?.() ?? 0;
+    context.adversiteTotal = (actor.system.adversite?.bleue || 0) + (actor.system.adversite?.rouge || 0) + (actor.system.adversite?.noire || 0);
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-don-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2DonSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "don"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.don",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-don-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-equipement-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2EquipementSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "equipement"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.equipement",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-equipement-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-historique-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2HistoriqueSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "historique"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.historique",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-historique-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-monnaie-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2MonnaieSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "monnaie"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.monnaie",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-monnaie-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-pacte-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2PacteSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "pacte"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.pacte",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-pacte-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-personnage-sheet.mjs

@@ -0,0 +1,51 @@
+import MournbladeCYD2ActorSheetV2 from "./base-actor-sheet.mjs";
+
+export default class MournbladeCYD2PersonnageSheet extends MournbladeCYD2ActorSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Actor.personnage",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    sheet: {
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  tabGroups = { primary: "principal" };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    const actor = this.document;
+
+    context.skills = actor.getSkills?.() ?? [];
+    context.armes = foundry.utils.duplicate(actor.getWeapons?.() ?? []);
+    context.protections = foundry.utils.duplicate(actor.getArmors?.() ?? []);
+    context.dons = foundry.utils.duplicate(actor.getDons?.() ?? []);
+    context.pactes = foundry.utils.duplicate(actor.getPactes?.() ?? []);
+    context.tendances = foundry.utils.duplicate(actor.getTendances?.() ?? []);
+    context.runes = foundry.utils.duplicate(actor.getRunes?.() ?? []);
+    context.traitsChaotiques = foundry.utils.duplicate(actor.getTraitsChaotiques?.() ?? []);
+    context.traitsEspeces = foundry.utils.duplicate(actor.getTraitsEspeces?.() ?? []);
+    context.profil = actor.getProfil?.() ?? null;
+    context.historiques = foundry.utils.duplicate(actor.getHistoriques?.() ?? []);
+    context.combat = actor.getCombatValues?.() ?? {};
+    context.equipements = foundry.utils.duplicate(actor.getEquipments?.() ?? []);
+    context.monnaies = foundry.utils.duplicate(actor.getMonnaies?.() ?? []);
+    context.runeEffects = foundry.utils.duplicate(actor.getRuneEffects?.() ?? []);
+    context.ressources = foundry.utils.duplicate(actor.getRessources?.() ?? []);
+    context.talents = foundry.utils.duplicate(actor.getTalents?.() ?? []);
+    context.protectionTotal = actor.getProtectionTotal?.() ?? 0;
+    context.adversiteTotal = (actor.system.adversite?.bleue || 0) + (actor.system.adversite?.rouge || 0) + (actor.system.adversite?.noire || 0);
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-profil-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2ProfilSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "profil"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.profil",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-profil-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-protection-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2ProtectionSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "protection"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.protection",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-protection-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-ressource-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2RessourceSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "ressource"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.ressource",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-ressource-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-rune-sheet.mjs

@@ -0,0 +1,39 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2RuneSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "rune"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.rune",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-rune-sheet.hbs",
+    },
+  };
+
+  #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/mournblade-cyd2-runeeffect-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2RuneEffectSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "runeeffect"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.runeeffect",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-runeeffect-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-talent-sheet.mjs

@@ -0,0 +1,39 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2TalentSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "talent"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.talent",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-talent-sheet.hbs",
+    },
+  };
+
+  #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/mournblade-cyd2-tendance-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2TendanceSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "tendance"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.tendance",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-tendance-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-traitchaotique-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2TraitChaotiqueSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "traitchaotique"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.traitchaotique",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-traitchaotique-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}

modules/applications/sheets/mournblade-cyd2-traitespece-sheet.mjs

@@ -0,0 +1,27 @@
+import MournbladeCYD2ItemSheetV2 from "./base-item-sheet.mjs";
+
+export default class MournbladeCYD2TraitEspeceSheet extends MournbladeCYD2ItemSheetV2 {
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    ...super.DEFAULT_OPTIONS,
+    classes: [...super.DEFAULT_OPTIONS.classes, "traitespece"],
+    window: {
+      ...super.DEFAULT_OPTIONS.window,
+      title: "SHEETS.Item.traitespece",
+    },
+  };
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-mournblade-cyd2/templates/item-traitespece-sheet.hbs",
+    },
+  };
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext();
+    return context;
+  }
+}