fvtt-lethal-fantasy/module/applications/sheets/character-sheet.mjs

import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
import { ROLL_TYPE } from "../../config/system.mjs"

export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
  /** @override */
  static DEFAULT_OPTIONS = {
    classes: ["character"],
    position: {
      width: 1150,
      height: 780,
    },
    window: {
      contentClasses: ["character-content"],
    },
    actions: {
      createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
    },
  }

  /** @override */
  static PARTS = {
    main: {
      template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
    },
    tabs: {
      template: "templates/generic/tab-navigation.hbs",
    },
    skills: {
      template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
    },
    weapons: {
      template: "systems/fvtt-lethal-fantasy/templates/character-weapons.hbs",
    },
    spells: {
      template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
    },
    biography: {
      template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
    },
  }

  /** @override */
  tabGroups = {
    sheet: "skills",
  }

  /**
   * Prepare an array of form header tabs.
   * @returns {Record<string, Partial<ApplicationTab>>}
   */
  #getTabs() {
    const tabs = {
      skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
      weapons: { id: "weapons", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.weapons" },
      spells: { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" },
      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
    }
    for (const v of Object.values(tabs)) {
      v.active = this.tabGroups[v.group] === v.id
      v.cssClass = v.active ? "active" : ""
    }
    return tabs
  }

  /** @override */
  async _prepareContext() {
    const context = await super._prepareContext()
    context.tabs = this.#getTabs()

    context.tooltipsCaracteristiques = {
    }

    context.tooltipsRessources = {
    }

    context.rollType = {
    }
    return context
  }

  _generateTooltip(type, target) {
  }

  /** @override */
  async _preparePartContext(partId, context) {
    const doc = this.document
    switch (partId) {
      case "main":
        break
      case "skills":
        context.tab = context.tabs.skills
        context.skills = doc.itemTypes.skill
        context.gifts = doc.itemTypes.gifts
        context.vulnerabilities = doc.itemTypes.vulnerability
        break
      case "spells":
        context.tab = context.tabs.spells
        context.spells = doc.itemTypes.spell
        context.hasSpells = context.spells.length > 0
        break
      case "weapons":
        context.tab = context.tabs.weapons
        context.weapons = doc.itemTypes.weapon
        context.armors = doc.itemTypes.armor
        context.equipments = doc.itemTypes.equipment
        break
      case "biography":
        context.tab = context.tabs.biography
        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
        break
    }
    return context
  }

  // #region Drag-and-Drop Workflow

  /**
   * Callback actions which occur when a dragged element is dropped on a target.
   * @param {DragEvent} event       The originating DragEvent
   * @protected
   */
  async _onDrop(event) {
    if (!this.isEditable || !this.isEditMode) return
    const data = TextEditor.getDragEventData(event)

    // Handle different data types
    switch (data.type) {
      case "Item":
        const item = await fromUuid(data.uuid)
        return this._onDropItem(item)
    }
  }

  async #onDropPathItem(item) {
    await this.document.addPath(item)
  }


  /**
   * Creates a new attack item directly from the sheet and embeds it into the document.
   * @param {Event} event             The initiating click event.
   * @param {HTMLElement} target      The current target of the event listener.
   */
  static #onCreateEquipment(event, target) {
    // Création d'une armure
    if (event.shiftKey) {
      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newArmor"), type: "armor" }])
    }
    // Création d'une arme
    else {
      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("LETHALFANTASY.Label.newWeapon"), type: "weapon" }])
    }
  }

  /**
   * Handles the roll action triggered by user interaction.
   *
   * @param {PointerEvent} event The event object representing the user interaction.
   * @param {HTMLElement} target The target element that triggered the roll.
   *
   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
   *
   * @throws {Error} Throws an error if the roll type is not recognized.
   *
   * @description This method checks the current mode (edit or not) and determines the type of roll
   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
   * corresponding value from the document's system and performs the roll.
   */
  async _onRoll(event, target) {
    if (this.isEditMode) return
    console.log(event, target)
    const rollType = event.target.dataset.rollType
    let rollTarget
    switch (rollType) {
      case "challenge":
        let rollKey = event.target.dataset.rollKey
        rollTarget = foundry.utils.duplicate(this.document.system.challenges[rollKey])
        rollTarget.rollKey = rollKey
        break
      case ROLL_TYPE.RESOURCE:
        rollTarget = elt.dataset.rollTarget
        break
      case ROLL_TYPE.DAMAGE:
        rollTarget = elt.dataset.itemId
        break
      default:
        break
    }
    await this.document.system.roll(rollType, rollTarget)
  }
  // #endregion
}