Initial import

module/applications/_module.mjs

@@ -0,0 +1,12 @@
+export { default as PrismRPGCharacterSheet } from "./sheets/character-sheet.mjs";
+export { default as PrismRPGMonsterSheet } from "./sheets/monster-sheet.mjs"
+export { default as PrismRPGWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as PrismRPGSkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as PrismRPGGiftSheet } from "./sheets/gift-sheet.mjs"
+export { default as PrismRPGVulnerabilitySheet } from "./sheets/vulnerability-sheet.mjs"
+export { default as PrismRPGArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as PrismRPGSpellSheet } from "./sheets/spell-sheet.mjs"
+export { default as PrismRPGEquipmentSheet } from "./sheets/equipment-sheet.mjs"
+export { default as PrismRPGShieldSheet } from "./sheets/shield-sheet.mjs"
+export { default as PrismRPGMiracleSheet } from "./sheets/miracle-sheet.mjs"
+

module/applications/combat.mjs

@@ -0,0 +1,220 @@
+
+/* -------------------------------------------- */
+export class PrismRPGCombatTracker extends foundry.applications.sidebar.tabs.CombatTracker {
+
+  static PARTS = {
+    "header": {
+      "template": "systems/fvtt-prism-rpg/templates/combat-tracker-header-v2.hbs"
+    },
+    "tracker": {
+      "template": "systems/fvtt-prism-rpg/templates/combat-tracker-v2.hbs"
+    },
+    "footer": {
+      "template": "systems/fvtt-prism-rpg/templates/combat-tracker-footer-v2.hbs"
+    }
+  }
+
+  static DEFAULT_OPTIONS = foundry.utils.mergeObject(super.DEFAULT_OPTIONS, {
+    actions: {
+      initiativePlus: PrismRPGCombatTracker.#initiativePlus,
+      initiativeMinus: PrismRPGCombatTracker.#initiativeMinus,
+    },
+  });
+
+  async _prepareContext(options) {
+    let data = await super._prepareContext(options);
+    console?.log("Combat Tracker Data", data);
+    /*for (let u of data.turns) {
+      let c = game.combat.combatants.get(u.id);
+      u.progressionCount = c.system.progressionCount
+      u.isMonster = c.actor.type === "monster"
+    }
+    console.log("Combat Data", data);*/
+    return data;
+  }
+
+  static #initiativePlus(ev) {
+    ev.preventDefault();
+    let cId = ev.target.closest(".combatant").dataset.combatantId;
+    let c = game.combat.combatants.get(cId);
+    c.update({ 'initiative': c.initiative + 1 });
+    console.log("Initiative Plus");
+  }
+
+  static #initiativeMinus(ev) {
+    ev.preventDefault();
+    let cId = ev.target.closest(".combatant").dataset.combatantId;
+    let c = game.combat.combatants.get(cId);
+    let newInit = Math.max(c.initiative - 1, 0);
+    c.update({ 'initiative': newInit });
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+    // Display Combat settings
+    html.find(".initiative-plus").click(ev => {
+      ev.preventDefault();
+      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
+      let c = game.combat.combatants.get(cId);
+      c.update({ 'initiative': c.initiative + 1 });
+    });
+
+    html.find(".initiative-minus").click(ev => {
+      ev.preventDefault();
+      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
+      let c = game.combat.combatants.get(cId);
+      c.update({ 'initiative': c.initiative - 1 });
+      console.log("Initiative Minus");
+    });
+  }
+
+  /* -------------------------------------------- */
+  static get defaultOptions() {
+    let path = "systems/fvtt-prism-rpg/templates/combat-tracker.hbs";
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      template: path,
+    });
+  }
+}
+
+export class PrismRPGCombat extends Combat {
+
+  /**
+ * Return the Array of combatants sorted into initiative order, breaking ties alphabetically by name.
+ * @returns {Combatant[]}
+ */
+  setupTurns() {
+    console?.log("Setup Turns....");
+    this.turns ||= [];
+
+    // Determine the turn order and the current turn
+    const turns = this.combatants.contents.sort(this.sortCombatantsLF);
+    if (this.turn !== null) this.turn = Math.clamp(this.turn, 0, turns.length - 1);
+
+    // Update state tracking
+    let c = turns[this.turn];
+    this.current = this._getCurrentState(c);
+    if (!this.previous) this.previous = this.current;
+
+    // Return the array of prepared turns
+    return this.turns = turns;
+  }
+
+  async rollInitiative(ids, options) {
+    console.log("%%%%%%%%% Roll Initiative", ids, options);
+
+    ids = typeof ids === "string" ? [ids] : ids;
+    let messages = [];
+    let rollMode = game.settings.get("core", "rollMode");
+
+    let updates = [];
+    for (let cId of ids) {
+      const c = this.combatants.get(cId);
+      let user = game.users.find(u => u.active && u.character && u.character.id === c.actor.id);
+      if (user?.hasPlayerOwner) {
+        console.log("Rolling initiative for", c.actor.name);
+        game.socket.emit(`system.${SYSTEM.id}`, { type: "rollInitiative", actorId: c.actor.id, combatId: this.id, combatantId: c.id });
+      } else {
+        user = game.users.find(u => u.active && u.isGM);
+        c.actor.system.rollInitiative(this.id, c.id);
+      }
+    }
+
+    return this;
+  }
+
+  resetProgression(cId) {
+    let c = this.combatants.get(cId);
+    c.update({ 'system.progressionCount': 0 });
+  }
+
+  setCasting(cId) {
+    let c = this.combatants.get(cId);
+    c.setFlag(SYSTEM.id, "casting", true);
+  }
+
+  resetCasting(cId) {
+    let c = this.combatants.get(cId);
+    c.setFlag(SYSTEM.id, "casting", false);
+  }
+
+  isCasting(cId) {
+    let c = this.combatants.get(cId);
+    return c.getFlag(SYSTEM.id, "casting");
+  }
+
+  async nextTurn() {
+    console.log("NEXT TURN");
+
+    let turn = this.turn ?? -1;
+    let skipDefeated = this.settings.skipDefeated;
+
+    // Determine the next turn number
+    let next = null;
+    for (let [i, t] of this.turns.entries()) {
+      console.log("Turn", t);
+      if (i <= turn) continue;
+      if (skipDefeated && t.isDefeated) continue;
+      next = i;
+      break;
+    }
+
+    // Maybe advance to the next round
+    let round = this.round;
+    if ((this.round === 0) || (next === null) || (next >= this.turns.length)) {
+      return this.nextRound();
+    }
+
+    // Update the document, passing data through a hook first
+    const updateData = { round, turn: next };
+    const updateOptions = { advanceTime: CONFIG.time.turnTime, direction: 1 };
+    Hooks.callAll("combatTurn", this, updateData, updateOptions);
+    return this.update(updateData, updateOptions);
+  }
+
+  async nextRound() {
+    this.turnsDone = false
+
+    let turn = this.turn === null ? null : 0; // Preserve the fact that it's no-one's turn currently.
+    console.log("ROUND", this);
+
+    let advanceTime = Math.max(this.turns.length - this.turn, 0) * CONFIG.time.turnTime;
+    advanceTime += CONFIG.time.roundTime;
+    let nextRound = this.round + 1;
+
+    let initOK = true;
+    for (let c of this.combatants) {
+      if (c.initiative === null) {
+        initOK = false;
+        break;
+      }
+    }
+    if (!initOK) {
+      ui.notifications.error("All combatants must have initiative rolled before the round can advance.");
+      return this;
+    }
+
+    for (let c of this.combatants) {
+      if (nextRound >= c.initiative) {
+        let user = game.users.find(u => u.active && u.character && u.character.id === c.actor.id);
+        if (user?.hasPlayerOwner) {
+          game.socket.emit(`system.${SYSTEM.id}`, { type: "rollProgressionDice", progressionCount: c.system.progressionCount + 1, actorId: c.actor.id, combatId: this.id, combatantId: c.id });
+        } else {
+          user = game.users.find(u => u.active && u.isGM);
+          c.actor.system.rollProgressionDice(this.id, c.id);
+        }
+      }
+    }
+
+    // Update the document, passing data through a hook first
+    const updateData = { round: nextRound, turn };
+    const updateOptions = { advanceTime, direction: 1 };
+    Hooks.callAll("combatRound", this, updateData, updateOptions);
+    return this.update(updateData, updateOptions);
+  }
+
+
+  sortCombatantsLF(a, b) {
+    return a.initiative - b.initiative;
+  }
+}

module/applications/sheets/armor-sheet.mjs

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

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

@@ -0,0 +1,292 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class PrismRPGActorSheet 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: ["prismrpg", "actor"],
+    position: {
+      width: 1400,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: '[data-drag="true"], .rollable', dropSelector: null }],
+    actions: {
+      editImage: PrismRPGActorSheet.#onEditImage,
+      toggleSheet: PrismRPGActorSheet.#onToggleSheet,
+      edit: PrismRPGActorSheet.#onItemEdit,
+      delete: PrismRPGActorSheet.#onItemDelete,
+      createSpell: PrismRPGActorSheet.#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 foundry.applications.ux.TextEditor.implementation.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 foundry.applications.ux.DragDrop.implementation(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 PrismRPGCharacterSheet
+   * @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 PrismRPGCharacterSheet
+   * @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 PrismRPGItemSheet 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: ["prismrpg", "item"],
+    position: {
+      width: 600,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: "[data-drag]", dropSelector: null }],
+    actions: {
+      toggleSheet: PrismRPGItemSheet.#onToggleSheet,
+      editImage: PrismRPGItemSheet.#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() {
+    let context = await super._prepareContext()
+    context.fields = this.document.schema.fields
+    context.systemFields = this.document.system.schema.fields
+    context.item = this.document
+    context.system = this.document.system
+    context.source = this.document.toObject()
+    context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.description, { async: true })
+    context.isEditMode = this.isEditMode
+    context.isPlayMode = this.isPlayMode
+    context.isEditable = this.isEditable
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    super._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 foundry.applications.ux.DragDrop.implementation(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 PrismRPGCharacterSheet
+   * @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/character-sheet.mjs

@@ -0,0 +1,257 @@
+import PrismRPGActorSheet from "./base-actor-sheet.mjs"
+import PrismRPGRoll from "../../documents/roll.mjs"
+
+export default class PrismRPGCharacterSheet extends PrismRPGActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 972,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: PrismRPGCharacterSheet.#onCreateEquipment,
+      rangedAttackDefense: PrismRPGCharacterSheet.#onRangedAttackDefense,
+      rollInitiative: PrismRPGCharacterSheet.#onRollInitiative,
+      armorHitPointsPlus: PrismRPGCharacterSheet.#onArmorHitPointsPlus,
+      armorHitPointsMinus: PrismRPGCharacterSheet.#onArmorHitPointsMinus,
+      divinityPointsPlus: PrismRPGCharacterSheet.#onDivinityPointsPlus,
+      divinityPointsMinus: PrismRPGCharacterSheet.#onDivinityPointsMinus,
+      aetherPointsPlus: PrismRPGCharacterSheet.#onAetherPointsPlus,
+      aetherPointsMinus: PrismRPGCharacterSheet.#onAetherPointsMinus,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-prism-rpg/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-prism-rpg/templates/character-skills.hbs",
+    },
+    combat: {
+      template: "systems/fvtt-prism-rpg/templates/character-combat.hbs",
+    },
+    equipment: {
+      template: "systems/fvtt-prism-rpg/templates/character-equipment.hbs",
+    },
+    spells: {
+      template: "systems/fvtt-prism-rpg/templates/character-spells.hbs",
+    },
+    miracles: {
+      template: "systems/fvtt-prism-rpg/templates/character-miracles.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-prism-rpg/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "skills",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    let tabs = {
+      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "PRISMRPG.Label.skills" },
+      combat: { id: "combat", group: "sheet", icon: "fa-solid fa-swords", label: "PRISMRPG.Label.combat" },
+      equipment: { id: "equipment", group: "sheet", icon: "fa-solid fa-backpack", label: "PRISMRPG.Label.equipment" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "PRISMRPG.Label.biography" },
+    }
+    if (this.actor.system.biodata.magicUser) {
+      tabs.spells = { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "PRISMRPG.Label.spells" }
+    }
+    if (this.actor.system.biodata.clericUser) {
+      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-hands-praying", label: "PRISMRPG.Label.miracles" }
+    }
+    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
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.gifts = doc.itemTypes.gift
+        context.vulnerabilities = doc.itemTypes.vulnerability
+        break
+      case "spells":
+        context.tab = context.tabs.spells
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "miracles":
+        context.tab = context.tabs.miracles
+        context.miracles = doc.itemTypes.miracle
+        context.hasMiracles = context.miracles.length > 0
+        break
+      case "combat":
+        context.tab = context.tabs.combat
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.shields = doc.itemTypes.shield
+        break
+      case "equipment":
+        context.tab = context.tabs.equipment
+        context.equipments = doc.itemTypes.equipment
+        break
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.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 = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)
+
+    // Handle different data types
+    if (data.type === "Item") {
+      const item = await fromUuid(data.uuid)
+      return this._onDropItem(item)
+    }
+  }
+
+  static async #onRangedAttackDefense(event, target) {
+    // Future use : const hasTarget = false
+
+    let roll = await PrismRPGRoll.promptRangedDefense({
+      actorId: this.actor.id,
+      actorName: this.actor.name,
+      actorImage: this.actor.img,
+    })
+    if (!roll) return null
+
+    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+  }
+
+  static async #onRollInitiative(event, target) {
+    await this.document.system.rollInitiative()
+  }
+
+  static #onArmorHitPointsPlus(event, target) {
+    let armorHP = this.actor.system.combat.armorHitPoints
+    armorHP += 1
+    this.actor.update({ "system.combat.armorHitPoints": armorHP })
+  }
+
+  static #onArmorHitPointsMinus(event, target) {
+    let armorHP = this.actor.system.combat.armorHitPoints
+    armorHP -= 1
+    this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
+  }
+
+  static #onDivinityPointsPlus(event, target) {
+    let points = this.actor.system.divinityPoints.value
+    points += 1
+    points = Math.min(points, this.actor.system.divinityPoints.max)
+    this.actor.update({ "system.divinityPoints.value": points })
+  }
+
+  static #onDivinityPointsMinus(event, target) {
+    let points = this.actor.system.divinityPoints.value
+    points -= 1
+    points = Math.max(points, 0)
+    this.actor.update({ "system.divinityPoints.value": points })
+  }
+
+  static #onAetherPointsPlus(event, target) {
+    let points = this.actor.system.aetherPoints.value
+    points += 1
+    points = Math.min(points, this.actor.system.aetherPoints.max)
+    this.actor.update({ "system.aetherPoints.value": points })
+  }
+
+  static #onAetherPointsMinus(event, target) {
+    let points = this.actor.system.aetherPoints.value
+    points -= 1
+    points = Math.max(points, 0)
+    this.actor.update({ "system.aetherPoints.value": points })
+  }
+
+  static #onCreateEquipment(event, target) {
+  }
+
+  _onRender(context, options) {
+    // Inputs with class `item-quantity`
+    const woundDescription = this.element.querySelectorAll('.wound-data')
+    for (const input of woundDescription) {
+      input.addEventListener("change", (e) => {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+        const newValue = e.currentTarget.value
+        const index = e.currentTarget.dataset.index
+        const fieldName = e.currentTarget.dataset.name
+        let tab = foundry.utils.duplicate(this.actor.system.hp.wounds)
+        tab[index][fieldName] = newValue
+        console.log(tab, index, fieldName, newValue)
+        this.actor.update({ "system.hp.wounds": tab });
+      })
+    }
+    super._onRender();
+  }
+
+
+  /**
+   * 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
+    const rollType = event.target.dataset.rollType
+    let rollKey = event.target.dataset.rollKey;
+    let rollDice = event.target.dataset?.rollDice;
+
+    this.actor.prepareRoll(rollType, rollKey, rollDice)
+
+  }
+  // #endregion
+}

module/applications/sheets/equipment-sheet.mjs

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

module/applications/sheets/gift-sheet.mjs

@@ -0,0 +1,22 @@
+import PrismRPGItemSheet from "./base-item-sheet.mjs"
+
+export default class PrismRPGGiftSheet extends PrismRPGItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["gift"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["gift-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-prism-rpg/templates/gift.hbs",
+    },
+  }
+
+}

module/applications/sheets/miracle-sheet.mjs

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

module/applications/sheets/monster-sheet.mjs

@@ -0,0 +1,170 @@
+import PrismRPGActorSheet from "./base-actor-sheet.mjs"
+import PrismRPGRoll from "../../documents/roll.mjs"
+
+export default class PrismRPGMonsterSheet extends PrismRPGActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["monster"],
+    position: {
+      width: 1060,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["monster-content"],
+    },
+    actions: {
+      rangedAttackDefense: PrismRPGMonsterSheet.#onRangedAttackDefense,
+      rollInitiative: PrismRPGMonsterSheet.#onRollInitiative,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-prism-rpg/templates/monster-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    combat: {
+      template: "systems/fvtt-prism-rpg/templates/monster-combat.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-prism-rpg/templates/monster-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "combat",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    let tabs = {
+      combat: { id: "combat", group: "sheet", icon: "fa-solid fa-swords", label: "PRISMRPG.Label.combat" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "PRISMRPG.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()
+
+    return context
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "combat":
+        context.tab = context.tabs.combat
+        context.weapons = doc.itemTypes.weapon
+        break
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        return this._onDropItem(item)
+    }
+  }
+
+  static async #onRangedAttackDefense(event, target) {
+    const hasTarget = false
+
+    let roll = await PrismRPGRoll.promptRangedDefense({
+      actorId: this.actor.id,
+      actorName: this.actor.name,
+      actorImage: this.actor.img,
+    })
+    if (!roll) return null
+
+    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+  }
+
+  static async #onRollInitiative(event, target) {
+    await this.document.system.rollInitiative(event, target)
+  }
+
+  getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {
+    let maxValue = 0
+    let goodSkill = skills[0]
+    for (let s of skills) {
+      if (rollType === "weapon-attack") {
+        if (s.system.weaponBonus.attack > maxValue) {
+          maxValue = Number(s.system.weaponBonus.attack)
+          goodSkill = s
+        }
+      }
+      if (rollType === "weapon-defense") {
+        if (s.system.weaponBonus.defense > maxValue) {
+          maxValue = Number(s.system.weaponBonus.defense)
+          goodSkill = s
+        }
+      }
+      if (rollType.includes("weapon-damage")) {
+        if (s.system.weaponBonus.damage > maxValue) {
+          maxValue = Number(s.system.weaponBonus.damage)
+          goodSkill = s
+        }
+      }
+    }
+    goodSkill.weaponSkillModifier = maxValue * multiplier
+    return goodSkill
+  }
+
+  /**
+   * 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
+    const rollType = event.target.dataset.rollType
+    let rollKey = event.target.dataset.rollKey
+    let rollDice = event.target.dataset?.rollDice || "0"
+    this.actor.system.prepareMonsterRoll(rollType, rollKey, rollDice)
+  }
+}

module/applications/sheets/shield-sheet.mjs

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

module/applications/sheets/skill-sheet.mjs

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

module/applications/sheets/spell-sheet.mjs

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

module/applications/sheets/vulnerability-sheet.mjs

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

module/applications/sheets/weapon-sheet.mjs

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