Initial system import

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

@@ -0,0 +1,218 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class HellbornActorSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2) {
+  /**
+   * Different sheet modes.r
+   * @enum {number}
+   */
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
+
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-hellborn", "actor"],
+    position: {
+      width: 1400,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: '[data-drag="true"], .rollable', dropSelector: null }],
+    actions: {
+      editImage: HellbornActorSheet.#onEditImage,
+      toggleSheet: HellbornActorSheet.#onToggleSheet,
+      edit: HellbornActorSheet.#onItemEdit,
+      delete: HellbornActorSheet.#onItemDelete
+    },
+  }
+
+  /**
+   * 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(),
+      isEncumbered: this.document.system.isEncumbered(),
+      enrichedDescription: await TextEditor.enrichHTML(this.document.system.description, { async: true }),
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isEditable: this.isEditable,
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+    // Add listeners to rollable elements
+    const rollables = this.element.querySelectorAll(".rollable")
+    rollables.forEach((d) => d.addEventListener("click", this._onRoll.bind(this)))
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   * @returns {DragDrop[]}     An array of DragDrop handlers
+   * @private
+   */
+  #createDragDropHandlers() {
+    return this.options.dragDrop.map((d) => {
+      d.permissions = {
+        dragstart: this._canDragStart.bind(this),
+        drop: this._canDragDrop.bind(this),
+      }
+      d.callbacks = {
+        dragover: this._onDragOver.bind(this),
+        drop: this._onDrop.bind(this),
+      }
+      return new DragDrop(d)
+    })
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+  }
+
+
+  /**
+   * Define whether a user is able to begin a dragstart workflow for a given drag selector
+   * @param {string} selector       The candidate HTML selector for dragging
+   * @returns {boolean}             Can the current user drag this selector?
+   * @protected
+   */
+  _canDragStart(selector) {
+    return this.isEditable
+  }
+
+  /**
+   * Define whether a user is able to conclude a drag-and-drop workflow for a given drop selector
+   * @param {string} selector       The candidate HTML selector for the drop target
+   * @returns {boolean}             Can the current user drop on this selector?
+   * @protected
+   */
+  _canDragDrop(selector) {
+    return true //this.isEditable && this.document.isOwner
+  }
+
+  /**
+   * 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) {
+    console.log("Dropped item", 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 HellbornActorSheet
+   * @param {PointerEvent} event   The originating click event
+   * @param {HTMLElement} target   The capturing HTML element which defined a [data-action]
+   * @returns {Promise}
+   * @private
+   */
+  static async #onEditImage(event, target) {
+    const attr = target.dataset.edit
+    const current = foundry.utils.getProperty(this.document, attr)
+    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
+    const fp = new FilePicker({
+      current,
+      type: "image",
+      redirectToRoot: img ? [img] : [],
+      callback: (path) => {
+        this.document.update({ [attr]: path })
+      },
+      top: this.position.top + 40,
+      left: this.position.left + 10,
+    })
+    return fp.browse()
+  }
+
+  /**
+   * Edit an existing item within the Actor
+   * Start with the uuid, if it's not found, fallback to the id (as Embedded item in the actor)
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event The originating click event
+   * @param {HTMLElement} target the capturing HTML element which defined a [data-action]
+   */
+  static async #onItemEdit(event, target) {
+    const id = target.getAttribute("data-item-id")
+    const uuid = target.getAttribute("data-item-uuid")
+    let item
+    item = await fromUuid(uuid)
+    if (!item) item = this.document.items.get(id)
+    if (!item) return
+    item.sheet.render(true)
+  }
+
+  /**
+   * Delete an existing talent within the Actor
+   * Use the uuid to display the talent sheet
+   * @param {PointerEvent} event The originating click event
+   * @param {HTMLElement} target the capturing HTML element which defined a [data-action]
+   */
+  static async #onItemDelete(event, target) {
+    const itemUuid = target.getAttribute("data-item-uuid")
+    const item = await fromUuid(itemUuid)
+    await item.deleteDialog()
+  }
+
+  // #endregion
+}

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

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

module/applications/sheets/character-sheet.mjs

@@ -0,0 +1,189 @@
+import HellbornActorSheet from "./base-actor-sheet.mjs"
+
+export default class HellbornCharacterSheet extends HellbornActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 860,
+      height: 620,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      createEquipment: HellbornCharacterSheet.#onCreateEquipment,
+      createArmor: HellbornCharacterSheet.#onCreateArmor,
+      createWeapon: HellbornCharacterSheet.#onCreateWeapon,
+      createTalent: HellbornCharacterSheet.#onCreateTalent,
+      createImplant: HellbornCharacterSheet.#onCreateImplant,
+      createPsionic: HellbornCharacterSheet.#onCreatePsionic,
+      createLanguage: HellbornCharacterSheet.#onCreateLanguage
+
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-hellborn/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    talents: {
+      template: "systems/fvtt-hellborn/templates/character-talents.hbs",
+    },
+    equipment: {
+      template: "systems/fvtt-hellborn/templates/character-equipment.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-hellborn/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "talents",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      talents: { id: "talents", group: "sheet", icon: "fa-solid fa-compass", label: "HELLBORN.Label.talents" },
+      equipment: { id: "equipment", group: "sheet", icon: "fa-solid fa-shapes", label: "HELLBORN.Label.equipment" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "HELLBORN.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.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    context.enrichedNotes = await TextEditor.enrichHTML(this.document.system.notes, { async: true })
+
+    return context
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "talents":
+        context.tab = context.tabs.talents
+        context.talents = doc.itemTypes.talent
+        context.talents.sort((a, b) => a.name.localeCompare(b.name))
+        context.implants = doc.itemTypes.implant
+        context.implants.sort((a, b) => a.name.localeCompare(b.name))
+        context.psionics = doc.itemTypes.psionic
+        context.psionics.sort((a, b) => a.name.localeCompare(b.name))
+        context.languages = doc.itemTypes.language
+        context.languages.sort((a, b) => a.name.localeCompare(b.name))
+        break
+      case "equipment":
+        context.tab = context.tabs.equipment
+        context.weapons = doc.itemTypes.weapon
+        context.weapons.sort((a, b) => a.name.localeCompare(b.name))
+        context.armors = doc.itemTypes.armor
+        context.armors.sort((a, b) => a.name.localeCompare(b.name))
+        context.equipments = doc.itemTypes.equipment
+        context.equipments.sort((a, b) => a.name.localeCompare(b.name))
+        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
+  }
+
+
+  static #onCreateEquipment(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newEquipment"), type: "equipment" }])
+  }
+
+  static #onCreateWeapon(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newWeapon"), type: "weapon" }])
+  }
+
+  static #onCreateArmor(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newArmor"), type: "armor" }])
+  }
+
+  static #onCreateTalent(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newTalent"), type: "talent" }])
+  }
+
+  static #onCreateImplant(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newImplant"), type: "implant" }])
+  }
+
+  static #onCreatePsionic(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newPsionic"), type: "psionic" }])
+  }
+
+  static #onCreateLanguage(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newLanguage"), type: "language" }])
+  }
+
+
+  /**
+   * 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) {
+    const rollType = $(event.currentTarget).data("roll-type")
+    let item
+    let li
+    switch (rollType) {
+      case "skill":
+        let skillId = $(event.currentTarget).data("skill-id");
+        item = this.actor.system.skills[skillId];
+        break
+      case "weapon":
+      case "damage":
+        li = $(event.currentTarget).parents(".item");
+        item = this.actor.items.get(li.data("item-id"));
+        break
+      default:
+        throw new Error(`Unknown roll type ${rollType}`)
+    }
+    await this.document.system.roll(rollType, item)
+  }
+
+  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 super._onDropItem(item)
+    }
+  }
+
+}

module/applications/sheets/creature-sheet.mjs

@@ -0,0 +1,158 @@
+import HellbornActorSheet from "./base-actor-sheet.mjs"
+
+export default class HellbornCreatureSheet extends HellbornActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["creature"],
+    position: {
+      width: 860,
+      height: 620,
+    },
+    window: {
+      contentClasses: ["creature-content"],
+    },
+    actions: {
+      createTrait: HellbornCreatureSheet.#onCreateTrait,
+      createAbility: HellbornCreatureSheet.#onCreateAbility
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-hellborn/templates/creature-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    traits: {
+      template: "systems/fvtt-hellborn/templates/creature-sheet-trait.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-hellborn/templates/creature-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "traits",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      traits: { id: "traits", group: "sheet", icon: "fa-solid fa-shapes", label: "HELLBORN.Label.traits" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "HELLBORN.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.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    context.enrichedNotes = await TextEditor.enrichHTML(this.document.system.notes, { async: true })
+
+    return context
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "traits":
+        context.tab = context.tabs.traits
+        context.abilities = doc.itemTypes["creature-ability"]
+        context.abilities.sort((a, b) => a.name.localeCompare(b.name))
+        context.traits = doc.itemTypes["creature-trait"]
+        context.traits.sort((a, b) => a.name.localeCompare(b.name))
+        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
+  }
+
+  /**
+   * 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 #onCreateTrait(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newTrait"), type: "creature-trait" }])
+  }
+
+  static #onCreateAbility(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newAbility"), type: "creature-ability" }])
+  }
+
+  /**
+   * 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) {
+    const rollType = $(event.currentTarget).data("roll-type")
+    let item
+    let formula
+    let roll
+    switch (rollType) {
+      case "skill":
+        let skillId = $(event.currentTarget).data("skill-id");
+        item = this.actor.system.skills[skillId];
+        await this.document.system.roll(rollType, item)
+        break
+      case "creature-damage":
+        formula = this.actor.system.damage
+        // Rolll the damage
+        roll = new Roll(formula)
+        await roll.evaluate()
+        roll.toMessage( { flavor: `${this.actor.name} : Damage roll` })
+        break
+      case "creature-number":
+        formula = this.actor.system.numberAppearing
+        // Rolll the damage
+        roll = new Roll(formula)
+        await roll.evaluate()
+        roll.toMessage({flavor: `${this.actor.name} : Number Appearing roll`})
+        break
+      default:
+        throw new Error(`Unknown roll type ${rollType}`)
+    }
+  }
+
+  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 super._onDropItem(item)
+    }
+  }
+}

module/applications/sheets/equipment-sheet.mjs

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

module/applications/sheets/maleficias-sheet.mjs

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

module/applications/sheets/perk-sheet.mjs

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

module/applications/sheets/ritual-sheet.mjs

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

module/applications/sheets/species-trait-sheet.mjs

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

module/applications/sheets/vehicle-sheet.mjs

@@ -0,0 +1,134 @@
+import HellbornActorSheet from "./base-actor-sheet.mjs"
+
+export default class HellbornVehicleSheet extends HellbornActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["vehicle"],
+    position: {
+      width: 680,
+      height: 540,
+    },
+    window: {
+      contentClasses: ["vehicle-content"],
+    },
+    actions: {
+      createEquipment: HellbornVehicleSheet.#onCreateEquipment,
+      createWeapon: HellbornVehicleSheet.#onCreateWeapon,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-hellborn/templates/vehicle-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    equipment: {
+      template: "systems/fvtt-hellborn/templates/vehicle-equipment.hbs",
+    },
+    description: {
+      template: "systems/fvtt-hellborn/templates/vehicle-description.hbs",
+    },
+  }
+
+   /** @override */
+   tabGroups = {
+    sheet: "equipment",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      equipment: { id: "equipment", group: "sheet", icon: "fa-solid fa-shapes", label: "HELLBORN.Label.equipment" },
+      description: { id: "description", group: "sheet", icon: "fa-solid fa-book", label: "HELLBORN.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()
+
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    context.enrichedNotes = await TextEditor.enrichHTML(this.document.system.notes, { async: true })
+
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        break
+      case "equipment":
+        context.tab = context.tabs.equipment
+        context.weapons = doc.itemTypes.weapon
+        context.weapons.sort((a, b) => a.name.localeCompare(b.name))
+        context.equipments = doc.itemTypes.equipment
+        context.equipments.sort((a, b) => a.name.localeCompare(b.name))
+        break
+      case "description":
+        context.tab = context.tabs.description
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  /**
+   * 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) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newEquipment"), type: "equipment" }])
+  }
+
+  static #onCreateWeapon(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HELLBORN.Label.newWeapon"), type: "weapon" }])
+  }
+
+  async _onRoll(event, target) {
+    const rollType = $(event.currentTarget).data("roll-type")
+    let item
+    let li
+    switch (rollType) {
+      case "damage":
+        li = $(event.currentTarget).parents(".item");
+        item = this.actor.items.get(li.data("item-id"));
+        break
+      default:
+        throw new Error(`Unknown roll type ${rollType}`)
+    }
+    await this.document.system.roll(rollType, item)
+  }
+
+
+  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 super._onDropItem(item)
+    }
+  }
+
+}

module/applications/sheets/weapon-sheet.mjs

@@ -0,0 +1,21 @@
+import HellbornItemSheet from "./base-item-sheet.mjs"
+
+export default class HellbornWeaponSheet extends HellbornItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-hellborn/templates/weapon.hbs",
+    },
+  }
+}