Fix actions/tour

2025-02-13 23:19:32 +01:00
parent 47dd1adb30
commit fa21d30994
4543 changed files with 680810 additions and 0 deletions
--- a/module/applications/_module.mjs
+++ b/module/applications/_module.mjs
@@ -0,0 +1,8 @@
+export { default as FTLNomadWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as FTLNomadArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as FTLNomadVehicleSheet } from "./sheets/vehicle-sheet.mjs"
+export { default as FTLNomadPsionicSheet } from "./sheets/psionic-sheet.mjs"
+export { default as FTLNomadLanguageSheet } from "./sheets/language-sheet.mjs"
+export { default as FTLNomadTalentSheet } from "./sheets/talent-sheet.mjs"
+export { default as FTLNomadNPCSheet } from "./sheets/npc-sheet.mjs"
+
--- a/module/applications/sheets/armor-sheet.mjs
+++ b/module/applications/sheets/armor-sheet.mjs
@@ -0,0 +1,27 @@
+import FTLNomadItemSheet from "./base-item-sheet.mjs"
+
+export default class FTLNomadArmorSheet extends FTLNomadItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["armor"],
+    position: {
+      width: 400,
+    },
+    window: {
+      contentClasses: ["armor-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/armor.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}
--- a/module/applications/sheets/base-actor-sheet.mjs
+++ b/module/applications/sheets/base-actor-sheet.mjs
@@ -0,0 +1,230 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class FTLNomadActorSheet 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-ftl-nomad", "actor"],
+    position: {
+      width: 1400,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: '[data-drag="true"], .rollable', dropSelector: null }],
+    actions: {
+      editImage: CthulhuEternalActorSheet.#onEditImage,
+      toggleSheet: CthulhuEternalActorSheet.#onToggleSheet,
+      edit: CthulhuEternalActorSheet.#onItemEdit,
+      delete: CthulhuEternalActorSheet.#onItemDelete,
+      updateCheckboxArray: CthulhuEternalActorSheet.#onUpdateCheckboxArray,
+    },
+  }
+
+  /**
+   * 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 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()
+  }
+
+  static #onUpdateCheckboxArray(event, target) {
+    console.log("Update checkbox array", event, target)
+    let arrayName = target.dataset.name
+    let arrayIdx = Number(target.dataset.index)
+    let dataPath = `system.san.${arrayName}`
+    let tab = foundry.utils.duplicate(this.document.system.san[arrayName])
+    tab[arrayIdx] = target.checked
+    this.actor.update( { [dataPath]: tab } )
+    // Dump
+    console.log("Array name", arrayName, arrayIdx, target.checked, dataPath)
+  }
+
+  /**
+   * 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()
+  }
+
+  /**
+   * 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
+}
--- a/module/applications/sheets/base-item-sheet.mjs
+++ b/module/applications/sheets/base-item-sheet.mjs
@@ -0,0 +1,193 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class FTLNomadItemSheet 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-ftl-nomad", "item"],
+    position: {
+      width: 600,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: "[data-drag]", dropSelector: null }],
+    actions: {
+      toggleSheet: CthulhuEternalItemSheet.#onToggleSheet,
+      editImage: CthulhuEternalItemSheet.#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
+}
--- a/module/applications/sheets/character-sheet.mjs
+++ b/module/applications/sheets/character-sheet.mjs
@@ -0,0 +1,252 @@
+import FTLNomadActorSheet from "./base-actor-sheet.mjs"
+
+export default class FTLNomadCharacterSheet extends FTLNomadActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["character"],
+    position: {
+      width: 860,
+      height: 620,
+    },
+    window: {
+      contentClasses: ["character-content"],
+    },
+    actions: {
+      setBP: FTLNomadCharacterSheet.#onSetBP,
+      createGear: FTLNomadCharacterSheet.#onCreateGear,
+      createArmor: FTLNomadCharacterSheet.#onCreateArmor,
+      createWeapon: FTLNomadCharacterSheet.#onCreateWeapon,
+      createBond: FTLNomadCharacterSheet.#onCreateBond,
+      createInjury: FTLNomadCharacterSheet.#onCreateInjury,
+      createMentalDisorder: FTLNomadCharacterSheet.#onCreateMentalDisorder,
+      createMotivation: FTLNomadCharacterSheet.#onCreateMotivation,
+      createSkill: FTLNomadCharacterSheet.#onCreateSkill,
+      createRitual: FTLNomadCharacterSheet.#onCreateRitual,
+      createTome: FTLNomadCharacterSheet.#onCreateTome,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-ftl-nomad/templates/protagonist-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-ftl-nomad/templates/protagonist-skills.hbs",
+    },
+    status: {
+      template: "systems/fvtt-ftl-nomad/templates/protagonist-status.hbs",
+    },
+    equipment: {
+      template: "systems/fvtt-ftl-nomad/templates/protagonist-equipment.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-ftl-nomad/templates/protagonist-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: "FTLNOMAD.Label.skills" },
+      status: { id: "status", group: "sheet", icon: "fa-solid fa-file-waveform", label: "FTLNOMAD.Label.status" },
+      equipment: { id: "equipment", group: "sheet", icon: "fa-solid fa-shapes", label: "FTLNOMAD.Label.equipment" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "FTLNOMAD.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 })
+    
+    context.tooltipsCharacteristic = {
+      str: game.i18n.localize("FTLNOMAD.Characteristic.Str"),
+      dex: game.i18n.localize("FTLNOMAD.Characteristic.Dex"),
+      con: game.i18n.localize("FTLNOMAD.Characteristic.Con"),
+      int: game.i18n.localize("FTLNOMAD.Characteristic.Int"),
+      pow: game.i18n.localize("FTLNOMAD.Characteristic.Pow"),
+      cha: game.i18n.localize("FTLNOMAD.Characteristic.Cha")
+    }
+
+    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.skills.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.gears = doc.itemTypes.gear
+        context.gears.sort((a, b) => a.name.localeCompare(b.name))
+        context.rituals = doc.itemTypes.ritual
+        context.rituals.sort((a, b) => a.name.localeCompare(b.name))
+        context.tomes = doc.itemTypes.tome
+        context.tomes.sort((a, b) => a.name.localeCompare(b.name))
+        break
+      case "status":
+        context.tab = context.tabs.status
+        context.injuries = doc.itemTypes.injury
+        context.injuries.sort((a, b) => a.name.localeCompare(b.name))
+        context.mentaldisorders = doc.itemTypes.mentaldisorder
+        context.mentaldisorders.sort((a, b) => a.name.localeCompare(b.name))
+        context.motivations = doc.itemTypes.motivation
+        context.motivations.sort((a, b) => a.name.localeCompare(b.name))
+        context.bonds = doc.itemTypes.bond
+        context.bonds.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 #onSetBP(event, target) {
+    this.document.system.setBP()
+  }
+  
+  static #onCreateGear(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newGear"), type: "gear" }])
+  }
+
+  static #onCreateWeapon(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newWeapon"), type: "weapon" }])
+  }
+
+  static #onCreateArmor(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newArmor"), type: "armor" }])
+  }
+
+  static #onCreateBond(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newBond"), type: "bond" }])
+  }
+
+  static #onCreateInjury(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newInjury"), type: "injury" }])
+  }
+
+  static #onCreateMentalDisorder(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newMentalDisorder"), type: "mentaldisorder" }])
+  }
+
+  static #onCreateMotivation(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newMotivation"), type: "motivation" }])
+  }
+
+  static #onCreateSkill(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newSkill"), type: "skill" }])
+  }
+
+  static #onCreateRitual(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newRitual"), type: "ritual" }])
+  }
+
+  static #onCreateTome(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newTome"), type: "tome" }])
+  }
+
+  /**
+   * 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
+    // Debug : console.log(">>>>", event, target, rollType)
+    // Deprecated : if (this.isEditMode) return
+    switch (rollType) {
+      case "resource": 
+        item = foundry.utils.duplicate(this.actor.system.resources)
+        item.name = game.i18n.localize(`FTLNOMAD.Label.Resources`)
+        item.targetScore = item.permanentRating
+        break
+      case "char":
+        let charId = $(event.currentTarget).data("char-id")
+        item = foundry.utils.duplicate(this.actor.system.characteristics[charId])
+        item.name = game.i18n.localize(`FTLNOMAD.Label.${charId}Long`)
+        item.targetScore = item.value * 5
+        break
+      case "skill":
+        li = $(event.currentTarget).parents(".item");
+        item = this.actor.items.get(li.data("item-id"));
+        break
+      case "weapon":
+      case "damage":
+        li = $(event.currentTarget).parents(".item");
+        item = this.actor.items.get(li.data("item-id"));
+        item.damageBonus = this.actor.system.damageBonus
+        break
+      case "san": 
+        item = foundry.utils.duplicate(this.actor.system.san)
+        item.name = game.i18n.localize("FTLNOMAD.Label.SAN")
+        item.targetScore = item.value
+        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)
+    }
+  }
+
+}
--- a/module/applications/sheets/equipment-sheet.mjs
+++ b/module/applications/sheets/equipment-sheet.mjs
@@ -0,0 +1,27 @@
+import FTLNomadItemSheet from "./base-item-sheet.mjs"
+
+export default class FTLNomadEquipmentSheet extends FTLNomadItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["equipment"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["equipment-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/equipment.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}
--- a/module/applications/sheets/language-sheet.mjs
+++ b/module/applications/sheets/language-sheet.mjs
@@ -0,0 +1,28 @@
+import FTLNomadItemSheet from "./base-item-sheet.mjs"
+
+export default class FTLNomadLanguageSheet extends FTLNomadItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["language"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["language-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/language.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}
--- a/module/applications/sheets/npc.mjs
+++ b/module/applications/sheets/npc.mjs
@@ -0,0 +1,166 @@
+import FTLNomadActorSheet from "./base-actor-sheet.mjs"
+
+export default class FTLNomadNPCSheet extends FTLNomadActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["npc"],
+    position: {
+      width: 860,
+      height: 620,
+    },
+    window: {
+      contentClasses: ["npc-content"],
+    },
+    actions: {
+      createArmor: FTLNomadNPCSheet.#onCreateArmor,
+      createWeapon: FTLNomadNPCSheet.#onCreateWeapon,
+      createSkill: FTLNomadNPCSheet.#onCreateSkill,
+
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/npc-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    skills: {
+      template: "systems/fvtt-cthulhu-eternal/templates/npc-skills.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-cthulhu-eternal/templates/npc-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: "FTLNOMAD.Label.skills" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "FTLNOMAD.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 "skills":
+        context.tab = context.tabs.skills
+        context.skills = doc.itemTypes.skill
+        context.skills.sort((a, b) => a.name.localeCompare(b.name))
+        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))
+        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 #onCreateWeapon(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newWeapon"), type: "weapon" }])
+  }
+
+  static #onCreateArmor(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newArmor"), type: "armor" }])
+  }
+
+  static #onCreateSkill(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("FTLNOMAD.Label.newSkill"), type: "skill" }])
+  }
+
+  /**
+   * 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
+    // Debug : console.log(">>>>", event, target, rollType)
+    // Deprecated : if (this.isEditMode) return
+    switch (rollType) {
+      case "char":
+        let charId = $(event.currentTarget).data("char-id")
+        item = foundry.utils.duplicate(this.actor.system.characteristics[charId])
+        item.name = game.i18n.localize(`FTLNOMAD.Label.${charId}Long`)
+        item.targetScore = item.value * 5
+        break
+      case "skill":
+        li = $(event.currentTarget).parents(".item");
+        item = this.actor.items.get(li.data("item-id"));
+        break
+      case "weapon":
+      case "damage":
+        li = $(event.currentTarget).parents(".item");
+        item = this.actor.items.get(li.data("item-id"));
+        item.damageBonus = this.actor.system.damageBonus
+        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)
+    }
+  }
+
+}
--- a/module/applications/sheets/psionic-sheet.mjs
+++ b/module/applications/sheets/psionic-sheet.mjs
@@ -0,0 +1,28 @@
+import FTLNomadItemSheet from "./base-item-sheet.mjs"
+
+export default class FTLNomadPsionicSheet extends FTLNomadItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["psionic"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["psionic-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/psionic.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}
--- a/module/applications/sheets/talent-sheet.mjs
+++ b/module/applications/sheets/talent-sheet.mjs
@@ -0,0 +1,28 @@
+import FTLNomadItemSheet from "./base-item-sheet.mjs"
+
+export default class FTLNomadTalentSheet extends FTLNomadItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["talent"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["talent-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/talent.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}
--- a/module/applications/sheets/vehicle-sheet.mjs
+++ b/module/applications/sheets/vehicle-sheet.mjs
@@ -0,0 +1,117 @@
+import FTLNomadActorSheet from "./base-actor-sheet.mjs"
+
+export default class FTLNomadVehicleSheet extends FTLNomadActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["vehicle"],
+    position: {
+      width: 680,
+      height: 540,
+    },
+    window: {
+      contentClasses: ["vehicle-content"],
+    },
+    actions: {
+      createGear: CthulhuEternalVehicleSheet.#onCreateGear,
+      createWeapon: CthulhuEternalVehicleSheet.#onCreateWeapon,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/vehicle-main.hbs",
+    },
+    tabs: {
+      template: "templates/generic/tab-navigation.hbs",
+    },
+    equipment: {
+      template: "systems/fvtt-cthulhu-eternal/templates/vehicle-equipment.hbs",
+    },
+    description: {
+      template: "systems/fvtt-cthulhu-eternal/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: "CTHULHUETERNAL.Label.equipment" },
+      description: { id: "description", group: "sheet", icon: "fa-solid fa-book", label: "CTHULHUETERNAL.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.gears = doc.itemTypes.gear
+        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 #onCreateGear(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("CTHULHUETERNAL.Label.newGear"), type: "gear" }])
+  }
+
+  static #onCreateWeapon(event, target) {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("CTHULHUETERNAL.Label.newWeapon"), type: "weapon" }])
+  }
+
+
+  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)
+    }
+  }
+
+}
--- a/module/applications/sheets/weapon-sheet.mjs
+++ b/module/applications/sheets/weapon-sheet.mjs
@@ -0,0 +1,21 @@
+import FTLNomadItemSheet from "./base-item-sheet.mjs"
+
+export default class FTLNomadWeaponSheet extends FTLNomadItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/weapon.hbs",
+    },
+  }
+}
--- a/module/config/system.mjs
+++ b/module/config/system.mjs
@@ -0,0 +1,33 @@
+export const SYSTEM_ID = "fvtt-ftl-nomad"
+
+export const ASCII = `
+▄████▄  ▄▄▄█████▓ ██░ ██  █    ██  ██▓     ██░ ██  █    ██    ▓█████▄▄▄█████▓▓█████  ██▀███   ███▄    █  ▄▄▄       ██▓    
+▒██▀ ▀█  ▓  ██▒ ▓▒▓██░ ██▒ ██  ▓██▒▓██▒    ▓██░ ██▒ ██  ▓██▒   ▓█   ▀▓  ██▒ ▓▒▓█   ▀ ▓██ ▒ ██▒ ██ ▀█   █ ▒████▄    ▓██▒    
+▒▓█    ▄ ▒ ▓██░ ▒░▒██▀▀██░▓██  ▒██░▒██░    ▒██▀▀██░▓██  ▒██░   ▒███  ▒ ▓██░ ▒░▒███   ▓██ ░▄█ ▒▓██  ▀█ ██▒▒██  ▀█▄  ▒██░    
+▒▓▓▄ ▄██▒░ ▓██▓ ░ ░▓█ ░██ ▓▓█  ░██░▒██░    ░▓█ ░██ ▓▓█  ░██░   ▒▓█  ▄░ ▓██▓ ░ ▒▓█  ▄ ▒██▀▀█▄  ▓██▒  ▐▌██▒░██▄▄▄▄██ ▒██░    
+▒ ▓███▀ ░  ▒██▒ ░ ░▓█▒░██▓▒▒█████▓ ░██████▒░▓█▒░██▓▒▒█████▓    ░▒████▒ ▒██▒ ░ ░▒████▒░██▓ ▒██▒▒██░   ▓██░ ▓█   ▓██▒░██████▒
+░ ░▒ ▒  ░  ▒ ░░    ▒ ░░▒░▒░▒▓▒ ▒ ▒ ░ ▒░▓  ░ ▒ ░░▒░▒░▒▓▒ ▒ ▒    ░░ ▒░ ░ ▒ ░░   ░░ ▒░ ░░ ▒▓ ░▒▓░░ ▒░   ▒ ▒  ▒▒   ▓▒█░░ ▒░▓  ░
+  ░  ▒       ░     ▒ ░▒░ ░░░▒░ ░ ░ ░ ░ ▒  ░ ▒ ░▒░ ░░░▒░ ░ ░     ░ ░  ░   ░     ░ ░  ░  ░▒ ░ ▒░░ ░░   ░ ▒░  ▒   ▒▒ ░░ ░ ▒  ░
+░          ░       ░  ░░ ░ ░░░ ░ ░   ░ ░    ░  ░░ ░ ░░░ ░ ░       ░    ░         ░     ░░   ░    ░   ░ ░   ░   ▒     ░ ░   
+░ ░                ░  ░  ░   ░         ░  ░ ░  ░  ░   ░           ░  ░           ░  ░   ░              ░       ░  ░    ░  ░
+░                                                                                                                          
+`
+export const SKILLS = {
+  "combat": { id: "combat", label: "FTLNOMAD.Skill.Combat" },
+  "knowledge": { id: "knowledge", label: "FTLNOMAD.Skill.Knowledge" },
+  "social": { id: "social", label: "FTLNOMAD.Skill.Social" },
+  "physical": { id: "physical", label: "FTLNOMAD.Skill.Physical" },
+  "stealth": { id: "stealth", label: "FTLNOMAD.Skill.Stealth" },
+  "vehicles": { id: "vehicle", label: "FTLNOMAD.Skill.Vehicles" },
+  "technology": { id: "technology", label: "FTLNOMAD.Skill.Technology" }
+}
+
+/**
+ * Include all constant definitions within the SYSTEM global export
+ * @type {Object}
+ */
+export const SYSTEM = {
+  id: SYSTEM_ID,
+  SKILLS: SKILLS,
+  ASCII
+}
--- a/module/documents/_module.mjs
+++ b/module/documents/_module.mjs
@@ -0,0 +1,4 @@
+export { default as CthulhuEternalActor } from "./actor.mjs"
+export { default as CthulhuEternalItem } from "./item.mjs"
+export { default as CthulhuEternalRoll } from "./roll.mjs"
+export { default as CthulhuEternalChatMessage } from "./chat-message.mjs"
--- a/module/documents/actor.mjs
+++ b/module/documents/actor.mjs
@@ -0,0 +1,86 @@
+import CthulhuEternalUtils from "../utils.mjs"
+
+export default class CthulhuEternalActor extends Actor {
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type === 'protagonist') {
+      let era = game.settings.get("fvtt-cthulhu-eternal", "settings-era")
+      const skills = await CthulhuEternalUtils.loadCompendium("fvtt-cthulhu-eternal.skills")
+      data.items = data.items || []
+      for (let skill of skills) {
+        if (skill.system.settings === era) {
+          data.items.push(skill.toObject())
+        }
+      }
+      data.items.push({ type:"weapon", img: "systems/fvtt-cthulhu-eternal/assets/icons/icon_fist.svg",
+        name: game.i18n.localize("CTHULHUETERNAL.Label.Unarmed"), system: { damage: "1d4-1", weaponType: "unarmed" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  _onUpdate(changed, options, userId) {
+    // DEBUG : console.log("CthulhuEternalActor.update", changed, options, userId)
+    if (changed?.system?.wp?.exhausted) {
+      ChatMessage.create({
+        user: userId,
+        speaker: { alias: this.name },
+        rollMode: "selfroll",
+        content: game.i18n.localize("CTHULHUETERNAL.ChatMessage.exhausted"),
+        type: CONST.CHAT_MESSAGE_STYLES.OTHER
+      })
+    }
+    return super._onUpdate(changed, options, userId)
+  }
+
+  async createEmbeddedDocuments(embeddedName, data, operation) {
+    let newData = []
+    if (embeddedName === "Item") {
+      for (let i of data) {
+        if (i.type === "skill") {
+          if (this.items.find(item => item.name.toLowerCase() === i.name.toLowerCase())) {
+            ui.notifications.warn(game.i18n.localize("CTHULHUETERNAL.Notifications.skillAlreadyExists"))
+            continue
+          }
+        }
+        if (i.type === "bond") {
+          if (i.system.bondType === "individual") {
+            i.system.value = this.system.characteristics.cha.value
+          } else {
+            i.system.value = Math.floor(this.system.resources.permanentRating / 2)
+          }
+        }
+        newData.push(i)
+      }
+      return super.createEmbeddedDocuments(embeddedName, newData, operation)
+    }
+    return super.createEmbeddedDocuments(embeddedName, data, operation)
+  }
+
+  async _preCreate(data, options, user) {
+  await super._preCreate(data, options, user)
+
+  // Configure prototype token settings
+  const prototypeToken = {}
+  if (this.type === "protagonist") {
+    Object.assign(prototypeToken, {
+      sight: { enabled: true },
+      actorLink: true,
+      disposition: CONST.TOKEN_DISPOSITIONS.FRIENDLY,
+    })
+    this.updateSource({ prototypeToken })
+  }
+}
+
+}
--- a/module/documents/chat-message.mjs
+++ b/module/documents/chat-message.mjs
@@ -0,0 +1,21 @@
+import CthulhuEternalRoll from "./roll.mjs"
+
+export default class CthulhuEternalChatMessage extends ChatMessage {
+  async _renderRollContent(messageData) {
+    const data = messageData.message
+    if (this.rolls[0] instanceof CthulhuEternalRoll) {
+      const isPrivate = !this.isContentVisible
+      // _renderRollHTML va appeler render sur tous les rolls
+      const rollHTML = await this._renderRollHTML(isPrivate)
+      if (isPrivate) {
+        data.flavor = game.i18n.format("CHAT.PrivateRollContent", { user: this.user.name })
+        messageData.isWhisper = false
+        messageData.alias = this.user.name
+      }
+      data.content = `<section class="dice-rolls">${rollHTML}</section>`
+      return
+    }
+
+    return super._renderRollContent(messageData)
+  }
+}
--- a/module/documents/item.mjs
+++ b/module/documents/item.mjs
@@ -0,0 +1,23 @@
+export const defaultItemImg = {
+  weapon: "systems/fvtt-cthulhu-eternal/assets/icons/icon_weapon.svg",
+  armor: "systems/fvtt-cthulhu-eternal/assets/icons/icon_armor.svg",
+  gear: "systems/fvtt-cthulhu-eternal/assets/icons/icon_equipment.svg",
+  skill: "systems/fvtt-cthulhu-eternal/assets/icons/icon_skill.svg",
+  archetype: "systems/fvtt-cthulhu-eternal/assets/icons/icon_archetype.svg",
+  bond: "systems/fvtt-cthulhu-eternal/assets/icons/icon_bond.svg",
+  mentaldisorder: "systems/fvtt-cthulhu-eternal/assets/icons/icon_mental_disorder.svg",
+  arcane: "systems/fvtt-cthulhu-eternal/assets/icons/icon_arcane.svg",
+  injury: "systems/fvtt-cthulhu-eternal/assets/icons/icon_injury.svg",
+  motivation: "systems/fvtt-cthulhu-eternal/assets/icons/icon_motivation.svg",
+  ritual: "systems/fvtt-cthulhu-eternal/assets/icons/icon_ritual.svg",
+  tome: "systems/fvtt-cthulhu-eternal/assets/icons/icon_tome.svg",
+}
+
+export default class CthulhuEternalItem extends Item {
+  constructor(data, context) {
+    if (!data.img) {
+      data.img = defaultItemImg[data.type];
+    }
+    super(data, context);
+  }
+}
--- a/module/documents/roll.mjs
+++ b/module/documents/roll.mjs
@@ -0,0 +1,455 @@
+
+import { SYSTEM } from "../config/system.mjs"
+
+export default class CthulhuEternalRoll extends Roll {
+  /**
+   * The HTML template path used to render dice checks of this type
+   * @type {string}
+   */
+  static CHAT_TEMPLATE = "systems/fvtt-cthulhu-eternal/templates/chat-message.hbs"
+
+  get type() {
+    return this.options.type
+  }
+
+  get isDamage() {
+    return this.type === ROLL_TYPE.DAMAGE
+  }
+
+  get target() {
+    return this.options.target
+  }
+
+  get value() {
+    return this.options.value
+  }
+
+  get actorId() {
+    return this.options.actorId
+  }
+
+  get actorName() {
+    return this.options.actorName
+  }
+
+  get actorImage() {
+    return this.options.actorImage
+  }
+
+  get help() {
+    return this.options.help
+  }
+
+  get gene() {
+    return this.options.gene
+  }
+
+  get modifier() {
+    return this.options.modifier
+  }
+
+  get resultType() {
+    return this.options.resultType
+  }
+
+  get isFailure() {
+    return this.resultType === "failure"
+  }
+
+  get hasTarget() {
+    return this.options.hasTarget
+  }
+
+  get realDamage() {
+    return this.options.realDamage
+  }
+
+  get weapon() {
+    return this.options.weapon
+  }
+
+  get isLowWP() {
+    return this.options.isLowWP
+  }
+
+  get isZeroWP() {
+    return this.options.isZeroWP
+  }
+
+  get isExhausted() {
+    return this.options.isExhausted
+  }
+
+  get isNudgedRoll() {
+    return this.options.isNudgedRoll
+  }
+
+  get wpCost()  {
+    return this.options.wpCost
+  }
+
+  static updateResourceDialog(options) {
+    let rating = 0
+    if (options.rollItem.enableHand) {
+      rating += options.rollItem.hand
+    }
+    if (options.rollItem.enableStowed) {
+      rating += options.rollItem.stowed
+    }
+    if (options.rollItem.enableStorage) {
+      rating += options.rollItem.storage
+    }
+    let multiplier = Number($(`.roll-skill-multiplier`).val())
+    options.initialScore = rating
+    options.percentScore = rating * multiplier
+    $(".resource-score").text(`${rating} (${options.percentScore}%)`)
+  }
+
+  /**
+   * Prompt the user with a dialog to configure and execute a roll.
+   *
+   * @param {Object} options Configuration options for the roll.
+   * @param {string} options.rollType The type of roll being performed.
+   * @param {string} options.rollTarget The target of the roll.
+   * @param {string} options.actorId The ID of the actor performing the roll.
+   * @param {string} options.actorName The name of the actor performing the roll.
+   * @param {string} options.actorImage The image of the actor performing the roll.
+   * @param {boolean} options.hasTarget Whether the roll has a target.
+   * @param {Object} options.data Additional data for the roll.
+   *
+   * @returns {Promise<Object|null>} The roll result or null if the dialog was cancelled.
+   */
+  static async prompt(options = {}) {
+    let formula = "1d100"
+    let hasModifier = true
+    let hasMultiplier = false
+    options.isNudge = true
+
+    switch (options.rollType) {
+      case "skill":
+        console.log(options.rollItem)
+        options.initialScore = options.rollItem.system.computeScore()
+        break
+      case "san":
+      case "char":
+        options.initialScore = options.rollItem.targetScore
+        options.isNudge = (options.rollType !== "san")
+        break
+      case "resource":
+        hasModifier = false
+        hasMultiplier = true
+        options.initialScore = options.rollItem.targetScore
+        options.totalRating = options.rollItem.targetScore
+        options.percentScore = options.rollItem.targetScore * 5
+        options.rollItem.enableHand = true
+        options.rollItem.enableStowed = true
+        options.rollItem.enableStorage = true
+        options.isNudge = false
+        break
+      case "damage":
+        let formula = options.rollItem.system.damage
+        if ( options.rollItem.system.weaponType === "melee" || options.rollItem.system.weaponType === "unarmed") {
+          formula += ` + ${options.rollItem.damageBonus}`
+        }
+        let damageRoll = new Roll(formula)
+        await damageRoll.evaluate()
+        await damageRoll.toMessage({
+          flavor: `${options.rollItem.name} - Damage Roll`
+        });
+        let isLethal = false
+        options.isNudge = false
+        if (options.rollItem.system.lethality > 0) {
+          let lethalityRoll = new Roll("1d100")
+          await lethalityRoll.evaluate()
+          isLethal = (lethalityRoll.total <= options.rollItem.system.lethality)
+          await lethalityRoll.toMessage({
+            flavor: `${options.rollItem.name} - Lethality Roll : ${lethalityRoll.total} <= ${options.rollItem.system.lethality} => ${isLethal}`
+          });
+        }
+        return
+      case "weapon":
+        let era = game.settings.get("fvtt-cthulhu-eternal", "settings-era")
+        if (era !== options.rollItem.system.settings) {
+          ui.notifications.error(game.i18n.localize("CTHULHUETERNAL.Notifications.WrongEra"))
+          console.log("WP Wrong Era", era, options.rollItem.system.weaponType)
+          return
+        }
+        if (!SYSTEM.WEAPON_SKILL_MAPPING[era] || !SYSTEM.WEAPON_SKILL_MAPPING[era][options.rollItem.system.weaponType]) {
+          ui.notifications.error(game.i18n.localize("CTHULHUETERNAL.Notifications.NoWeaponType"))
+          console.log("WP Not found", era, options.rollItem.system.weaponType)
+          return
+        }
+        options.weapon = options.rollItem
+        if (options.rollItem.system.hasDirectSkill) {
+          let skillName = options.rollItem.name
+          options.rollItem = {type: "skill", name: skillName, system: {base: 0, bonus:  options.weapon.system.directSkillValue} }
+          options.initialScore = options.weapon.system.directSkillValue
+        } else {
+          let skillName = game.i18n.localize(SYSTEM.WEAPON_SKILL_MAPPING[era][options.rollItem.system.weaponType])
+          let actor = game.actors.get(options.actorId)          
+          options.rollItem = actor.items.find(i => i.type === "skill" && i.name.toLowerCase() === skillName.toLowerCase())
+          if (!options.rollItem) {
+            ui.notifications.error(game.i18n.localize("CTHULHUETERNAL.Notifications.NoWeaponSkill"))
+            return
+          }
+          options.initialScore = options.rollItem.system.computeScore()
+          console.log("WEAPON", skillName, era, options.rollItem)
+        }
+        break
+      default:
+        options.initialScore = 50
+        break
+    }
+
+    const rollModes = Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const fieldRollMode = new foundry.data.fields.StringField({
+      choices: rollModes,
+      blank: false,
+      default: "public",
+    })
+
+    const choiceModifier = SYSTEM.MODIFIER_CHOICES
+    const choiceMultiplier = SYSTEM.MULTIPLIER_CHOICES
+
+    let modifier = "+0"
+    let multiplier = "5"
+
+    let dialogContext = {
+      rollType: options.rollType,
+      rollItem: foundry.utils.duplicate(options.rollItem), // Object only, no class
+      weapon: options?.weapon,
+      initialScore: options.initialScore,
+      targetScore: options.initialScore,
+      isLowWP: options.isLowWP,
+      isZeroWP: options.isZeroWP,
+      isExhausted: options.isExhausted,
+      enableHand: options.rollItem.enableHand,
+      enableStowed: options.rollItem.enableStowed,
+      enableStorage: options.rollItem.enableStorage,
+      rollModes,
+      fieldRollMode,
+      choiceModifier,
+      choiceMultiplier,
+      formula,
+      hasTarget: options.hasTarget,
+      hasModifier,
+      hasMultiplier,
+      modifier,
+      multiplier
+    }
+    const content = await renderTemplate("systems/fvtt-cthulhu-eternal/templates/roll-dialog.hbs", dialogContext)
+
+    const title = CthulhuEternalRoll.createTitle(options.rollType, options.rollTarget)
+    const label = game.i18n.localize("CTHULHUETERNAL.Roll.roll")
+    const rollContext = await foundry.applications.api.DialogV2.wait({
+      window: { title: title },
+      classes: ["fvtt-cthulhu-eternal"],
+      content,
+      buttons: [
+        {
+          label: label,
+          callback: (event, button, dialog) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      actions: {
+        "selectHand": (event, button, dialog) => {
+          options.rollItem.enableHand = !options.rollItem.enableHand
+          this.updateResourceDialog(options)
+        },
+        "selectStowed": (event, button, dialog) => {
+          options.rollItem.enableStowed = !options.rollItem.enableStowed
+          this.updateResourceDialog(options)
+        },
+        "selectStorage": (event, button, dialog) => {
+          options.rollItem.enableStorage = !options.rollItem.enableStorage
+          this.updateResourceDialog(options)
+        }
+      },
+      rejectClose: false, // Click on Close button will not launch an error
+      render: (event, dialog) => {
+        $(".roll-skill-multiplier").change(event => {
+          options.multiplier = Number(event.target.value)
+          this.updateResourceDialog(options)
+        })
+      }
+    })
+
+    // If the user cancels the dialog, exit
+    if (rollContext === null) return
+
+    let rollData = foundry.utils.mergeObject(foundry.utils.duplicate(options), rollContext)
+    rollData.rollMode = rollContext.visibility
+
+    // Update target score
+    console.log("Rolldata", rollData, options)
+    if (options.rollType === "resource") {
+      rollData.targetScore = options.initialScore * Number(rollContext.multiplier)
+    } else {
+      rollData.targetScore = Math.min(Math.max(options.initialScore + Number(rollData.modifier), 0), 100)
+      if (rollData.isLowWP || rollData.isExhausted) {
+        rollData.targetScore -= 20
+      }
+      if (rollData.isZeroWP) {
+        rollData.targetScore = 0
+      }
+      rollData.targetScore = Math.min(Math.max(rollData.targetScore, 0), 100)
+    }
+
+    if (Hooks.call("fvtt-cthulhu-eternal.preRoll", options, rollData) === false) return
+
+    const roll = new this(formula, options.data, rollData)
+    await roll.evaluate()
+
+    roll.displayRollResult(roll, options, rollData)
+
+    if (Hooks.call("fvtt-cthulhu-eternal.Roll", options, rollData, roll) === false) return
+
+    return roll
+  }
+
+  displayRollResult(formula, options, rollData) {
+
+    // Compute the result quality
+    let resultType = "failure"
+    let dec = Math.floor(this.total / 10)
+    let unit = this.total - (dec * 10)
+    if (this.total <= rollData.targetScore) {
+      resultType = "success"
+      // Detect if decimal == unit in the dire total result 
+      if (dec === unit || this.total === 1) {
+        resultType = "successCritical"
+      }
+    } else {
+      // Detect if decimal == unit in the dire total result 
+      if (dec === unit || this.total === 100) {
+        resultType = "failureCritical"
+      }
+    }
+
+    this.options.resultType = resultType
+    if (this.options.isNudgedRoll) { 
+      this.options.isSuccess = resultType === "success" || resultType === "successCritical"
+      this.options.isFailure = resultType === "failure" || resultType === "failureCritical"
+      this.options.isCritical = false
+    } else {
+      this.options.isSuccess = resultType === "success" || resultType === "successCritical"
+      this.options.isFailure = resultType === "failure" || resultType === "failureCritical"
+      this.options.isCritical = resultType === "successCritical" || resultType === "failureCritical"
+    }
+    this.options.isLowWP = rollData.isLowWP
+    this.options.isZeroWP = rollData.isZeroWP
+    this.options.isExhausted = rollData.isExhausted
+    this.options.rollData = foundry.utils.duplicate(rollData)
+  }
+
+  /**
+   * Creates a title based on the given type.
+   *
+   * @param {string} type The type of the roll.
+   * @param {string} target The target of the roll.
+   * @returns {string} The generated title.
+   */
+  static createTitle(type, target) {
+    switch (type) {
+      case "skill":
+        return `${game.i18n.localize("CTHULHUETERNAL.Label.titleSkill")}`
+      case "weapon":
+        return `${game.i18n.localize("CTHULHUETERNAL.Label.titleWeapon")}`
+      case "char":
+        return `${game.i18n.localize("CTHULHUETERNAL.Label.titleCharacteristic")}`
+      case "san":
+        return `${game.i18n.localize("CTHULHUETERNAL.Label.titleSAN")}`
+      default:
+        return game.i18n.localize("CTHULHUETERNAL.Label.titleStandard")
+    }
+  }
+
+  /** @override */
+  async render(chatOptions = {}) {
+    let chatData = await this._getChatCardData(chatOptions.isPrivate)
+    return await renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
+  }
+
+  /**
+   * Generates the data required for rendering a roll chat card.
+   *
+   * @param {boolean} isPrivate Indicates if the chat card is private.
+   * @returns {Promise<Object>} A promise that resolves to an object containing the chat card data.
+   * @property {Array<string>} css - CSS classes for the chat card.
+   * @property {Object} data - The data associated with the roll.
+   * @property {number} diceTotal - The total value of the dice rolled.
+   * @property {boolean} isGM - Indicates if the user is a Game Master.
+   * @property {string} formula - The formula used for the roll.
+   * @property {number} total - The total result of the roll.
+   * @property {boolean} isFailure - Indicates if the roll is a failure.
+   * @property {string} actorId - The ID of the actor performing the roll.
+   * @property {string} actingCharName - The name of the character performing the roll.
+   * @property {string} actingCharImg - The image of the character performing the roll.
+   * @property {string} resultType - The type of result (e.g., success, failure).
+   * @property {boolean} hasTarget - Indicates if the roll has a target.
+   * @property {string} targetName - The name of the target.
+   * @property {number} targetArmor - The armor value of the target.
+   * @property {number} realDamage - The real damage dealt.
+   * @property {boolean} isPrivate - Indicates if the chat card is private.
+   * @property {string} cssClass - The combined CSS classes as a single string.
+   * @property {string} tooltip - The tooltip text for the chat card.
+   */
+  async _getChatCardData(isPrivate) {
+    let cardData = foundry.utils.duplicate(this.options)
+    cardData.css = [SYSTEM.id, "dice-roll"]
+    cardData.data = this.data
+    cardData.diceTotal = this.dice.reduce((t, d) => t + d.total, 0)
+    cardData.isGM = game.user.isGM
+    cardData.formula = this.formula
+    cardData.total = this.total
+    cardData.actorId = this.actorId
+    cardData.actingCharName = this.actorName
+    cardData.actingCharImg = this.actorImage
+    cardData.resultType = this.resultType
+    cardData.hasTarget = this.hasTarget
+    cardData.targetName = this.targetName
+    cardData.targetArmor = this.targetArmor
+    cardData.realDamage = this.realDamage
+    cardData.isPrivate = isPrivate
+    cardData.weapon = this.weapon
+    cardData.isLowWP = this.isLowWP
+    cardData.isZeroWP = this.isZeroWP
+    cardData.isExhausted = this.isExhausted
+    cardData.isNudgedRoll = this.isNudgedRoll
+    cardData.wpCost = this.wpCost
+
+    cardData.cssClass = cardData.css.join(" ")
+    cardData.tooltip = isPrivate ? "" : await this.getTooltip()
+    return cardData
+  }
+
+  /**
+   * Converts the roll result to a chat message.
+   *
+   * @param {Object} [messageData={}] Additional data to include in the message.
+   * @param {Object} options Options for message creation.
+   * @param {string} options.rollMode The mode of the roll (e.g., public, private).
+   * @param {boolean} [options.create=true] Whether to create the message.
+   * @returns {Promise} - A promise that resolves when the message is created.
+   */
+  async toMessage(messageData = {}, { rollMode, create = true } = {}) {
+    super.toMessage(
+      {
+        isFailure: this.resultType === "failure",
+        actingCharName: this.actorName,
+        actingCharImg: this.actorImage,
+        hasTarget: this.hasTarget,
+        realDamage: this.realDamage,
+        ...messageData,
+      },
+      { rollMode: rollMode },
+    )
+  }
+
+}
--- a/module/models/_module.mjs
+++ b/module/models/_module.mjs
@@ -0,0 +1,10 @@
+export { default as FTLNomadWeapon } from "./weapon.mjs"
+export { default as FTLNomadPsionic } from "./psionic.mjs"
+export { default as FTLNomadLanguage } from "./language.mjs"
+export { default as FTLNomadTalent } from "./talent.mjs"
+export { default as FTLNomadArmor } from "./armor.mjs"
+export { default as FTLNomadNPC } from "./npc.mjs"
+export { default as FTLNomadVehicle } from "./vehicle.mjs"
+export { default as FTLNomadCharacter } from "./character.mjs"
+export { default as FTLNomadEquipment } from "./equipment.mjs"
+
--- a/module/models/armor.mjs
+++ b/module/models/armor.mjs
@@ -0,0 +1,21 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class FTLNomadArmor extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    
+    let setting = game.settings.get("fvtt-cthulhu-eternal", "settings-era") || "modern"
+    schema.settings = new fields.StringField({ required: true, initial: setting, choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.protection = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.Armor"]
+}
--- a/module/models/character.mjs
+++ b/module/models/character.mjs
@@ -0,0 +1,232 @@
+import { SYSTEM } from "../config/system.mjs"
+import FTLNomadRoll from "../documents/roll.mjs"
+
+export default class FTLNomadProtagonist extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.notes = new fields.HTMLField({ required: true, textSearch: true })
+    schema.name = new fields.StringField({ required: true, nullable: false, initial: "" })
+    schema.concept = new fields.StringField({ required: true, nullable: false, initial: "" })
+    schema.species = new fields.StringField({ required: true, nullable: false, initial: "" })
+    schema.archetype = new fields.StringField({ required: true, nullable: false, initial: "" })
+
+    // Carac
+    const skillField = (label) => {
+      const schema = {
+        value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      }
+      return new fields.SchemaField(schema, { label })
+    }
+
+    schema.skills = new fields.SchemaField(
+      Object.values(SYSTEM.SKILLS).reduce((obj, characteristic) => {
+        obj[characteristic.id] = skillField(characteristic.label)
+        return obj
+      }, {}),
+    )
+
+    schema.wp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 3, min: 0 }),
+      exhausted: new fields.BooleanField({ required: true, initial: false })
+    })
+
+    schema.hp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      stunned: new fields.BooleanField({ required: true, initial: false })
+    })
+
+    schema.san = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      recovery: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      violence:  new fields.ArrayField(new fields.BooleanField(), { required: true, initial: [false, false, false], min:3, max:3}),
+      helplessness: new fields.ArrayField(new fields.BooleanField(), { required: true, initial: [false, false, false], min:3, max:3 }),
+      breakingPoint: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      insanity: new fields.StringField({ required: true, nullable: false, initial: "none", choices:SYSTEM.INSANITY }),
+    })
+
+    schema.damageBonus = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+
+    schema.resources = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }), // Unused but kept for compatibility
+      permanentRating: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      hand: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      currentHand: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      stowed: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      currentStowed: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      storage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      currentStorage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      checks: new fields.ArrayField(new fields.BooleanField(), { required: true, initial: [false, false, false], min:3, max:3 }),
+      nbValidChecks: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+
+    schema.biodata = new fields.SchemaField({
+      age: new fields.NumberField({ ...requiredInteger, initial: 15, min: 6 }),
+      archetype: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      height: new fields.NumberField({ ...requiredInteger, initial: 170, min: 50 }),
+      gender: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      home: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      birthplace: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      eyes: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      hair: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      harshness: new fields.StringField({ required: true, nullable: false, initial: "normal", choices:SYSTEM.HARSHNESS }),
+      adaptedToViolence: new fields.BooleanField({ required: true, initial: false }),
+      adaptedToHelplessness: new fields.BooleanField({ required: true, initial: false })
+    })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.Protagonist"]
+
+  prepareDerivedData() {
+    super.prepareDerivedData();
+
+    let updates = {}
+    if ( this.wp.max !== this.characteristics.pow.value) {
+      updates[`system.wp.max`] = this.characteristics.pow.value
+    }
+    let hpMax = Math.round((this.characteristics.con.value + this.characteristics.str.value) / 2)
+    if ( this.hp.max !== hpMax) {
+      updates[`system.hp.max`] = hpMax
+    }
+    
+    // Get Unnatural skill for MAX SAN
+    let unnatural = this.parent.items.find(i => i.type === "skill" && i.name.toLowerCase() === game.i18n.localize("CTHULHUETERNAL.Skill.Unnatural").toLowerCase())
+    let minus = 0
+    if (unnatural) {
+      minus = unnatural.system.skillTotal
+    }
+    let maxSan = Math.max(99 - minus, 0)
+    if ( this.san.max !== maxSan) {
+      updates[`system.san.max`] = maxSan
+    }
+
+    let recoverySan = this.characteristics.pow.value * 5
+    if (recoverySan > this.san.max) {
+      recoverySan = this.san.max
+    }
+    if ( this.san.recovery !== recoverySan) {
+      updates[`system.san.recovery`] = recoverySan 
+    }
+
+    let dmgBonus = 0
+    if (this.characteristics.str.value <= 4) {
+      dmgBonus = -2
+    } else if (this.characteristics.str.value <= 8) {
+      dmgBonus = -1
+    } else if (this.characteristics.str.value <= 12) {
+      dmgBonus = 0
+    } else if (this.characteristics.str.value <= 16) {
+      dmgBonus = 1
+    } else if (this.characteristics.str.value <= 20) {
+      dmgBonus = 2
+    }
+    if ( this.damageBonus !== dmgBonus) {
+      updates[`system.damageBonus`] = dmgBonus
+    }
+
+    // Sanity check
+    if (this.san.value > this.san.max) {
+      updates[`system.san.value`] = this.san.max
+    }
+    if (this.wp.value > this.wp.max) {
+      updates[`system.wp.value`] = this.wp.max
+    }
+    if (this.hp.value > this.hp.max) {
+      updates[`system.hp.value`] = this.hp.max
+    }
+
+    if (this.resources.permanentRating < 0) {
+      updates[`system.resources.permanentRating`] = 0
+    }
+    
+    let resourceIndex = Math.max(Math.min(this.resources.permanentRating, 20), 0)
+    let breakdown = SYSTEM.RESOURCE_BREAKDOWN[resourceIndex] 
+    if (this.resources.hand !== breakdown.hand) {
+      updates[`system.resources.hand`] = breakdown.hand
+    }
+    if (this.resources.stowed !== breakdown.stowed) {
+      updates[`system.resources.stowed`] = breakdown.stowed
+    }
+    if (this.resources.storage !== breakdown.storage) {
+      updates[`system.resources.storage`] = breakdown.storage + (this.resources.permanentRating - resourceIndex)
+    }
+    if (this.resources.nbValidChecks !== breakdown.checks) {
+      updates[`system.resources.nbValidChecks`] = breakdown.checks
+    }
+    
+    if (Object.keys(updates).length > 0) {
+      this.parent.update(updates)
+    }
+  }
+
+  isLowWP() {
+    return this.wp.value <= 2
+  }
+
+  isZeroWP() {
+    return this.wp.value === 0
+  }
+
+  isExhausted() { 
+    return this.wp.exhausted
+  }
+
+  modifyWP(value) {
+    let updates = {}
+    let wp = Math.max(Math.min(this.wp.value + value, this.wp.max), 0)
+    if ( this.wp.value !== wp) {
+      updates[`system.wp.value`] = wp
+    }
+    if (Object.keys(updates).length > 0) {
+      this.parent.update(updates)
+    }
+  }
+
+  setBP() {
+    let updates = {}
+    let bp = Math.max(this.san.value - this.characteristics.pow.value, 0)
+    if ( this.san.breakingPoint !== bp) {
+      updates[`system.san.breakingPoint`] = bp
+    }
+    if (Object.keys(updates).length > 0) {
+      this.parent.update(updates)
+    }
+  }
+  
+  /** */
+  /**
+   * Rolls a dice for a character.
+   * @param {("save"|"resource|damage")} rollType The type of the roll.
+   * @param {number} rollItem The target value for the roll. Which caracteristic or resource. If the roll is a damage roll, this is the id of the item.
+   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
+   */
+  async roll(rollType, rollItem) {
+    let opponentTarget
+    const hasTarget = opponentTarget !== undefined
+
+    let roll = await CthulhuEternalRoll.prompt({
+      rollType,
+      rollItem,
+      isLowWP: this.isLowWP(),
+      isZeroWP: this.isZeroWP(),
+      isExhausted: this.isExhausted(),
+      actorId: this.parent.id,
+      actorName: this.parent.name,
+      actorImage: this.parent.img,
+      hasTarget,
+      target: opponentTarget
+    })
+    if (!roll) return null
+
+    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+  }
+}
--- a/module/models/equipment.mjs
+++ b/module/models/equipment.mjs
@@ -0,0 +1,23 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class FTLNomadEquipment extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    
+    let setting = game.settings.get("fvtt-cthulhu-eternal", "settings-era") || "modern"
+    schema.settings = new fields.StringField({ required: true, initial: setting, choices: SYSTEM.AVAILABLE_SETTINGS })
+    
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    schema.state = new fields.StringField({ required: true, initial: "pristine", choices: SYSTEM.EQUIPMENT_STATES })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.Equipment"]
+
+}
--- a/module/models/language.mjs
+++ b/module/models/language.mjs
@@ -0,0 +1,20 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class FTLNomadLanguage extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({
+      required: false,
+      blank: true,
+      initial: "",
+      textSearch: true,
+    })
+  
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.Language"]
+}
--- a/module/models/npc.mjs
+++ b/module/models/npc.mjs
@@ -0,0 +1,80 @@
+import { SYSTEM } from "../config/system.mjs"
+import FTLNomadRoll from "../documents/roll.mjs"
+
+export default class FTLNomadNPC extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    // Carac
+    const characteristicField = (label) => {
+      const schema = {
+        value: new fields.NumberField({ ...requiredInteger, initial: 3, min: 0 }),
+        feature: new fields.StringField({ required: true, nullable: false, initial: "" })
+      }
+      return new fields.SchemaField(schema, { label })
+    }
+
+    schema.characteristics = new fields.SchemaField(
+      Object.values(SYSTEM.CHARACTERISTICS).reduce((obj, characteristic) => {
+        obj[characteristic.id] = characteristicField(characteristic.label)
+        return obj
+      }, {}),
+    )
+
+    schema.wp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 3, min: 0 }),
+      exhausted: new fields.BooleanField({ required: true, initial: false })
+    })
+
+    schema.hp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 })
+    })
+    schema.movement = new fields.StringField({ required: true, initial: "" })
+    schema.sanLoss = new fields.StringField({ required: true, initial: "1/1D6" })
+
+    schema.armor = new fields.StringField({ required: true, initial: "" })
+    schema.size = new fields.StringField({ required: true, initial: "medium", choices: SYSTEM.CREATURE_SIZE })
+    schema.damageBonus = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.notes = new fields.HTMLField({ required: true, textSearch: true })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.NPC"]
+
+    /** */
+    /**
+     * Rolls a dice for a character.
+     * @param {("save"|"resource|damage")} rollType The type of the roll.
+     * @param {number} rollItem The target value for the roll. Which caracteristic or resource. If the roll is a damage roll, this is the id of the item.
+     * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
+     */
+    async roll(rollType, rollItem) {
+      let opponentTarget
+      const hasTarget = opponentTarget !== undefined
+  
+      let roll = await CthulhuEternalRoll.prompt({
+        rollType,
+        rollItem,
+        isLowWP: false,
+        isZeroWP: false,
+        isExhausted: false,
+        actorId: this.parent.id,
+        actorName: this.parent.name,
+        actorImage: this.parent.img,
+        hasTarget,
+        target: opponentTarget
+      })
+      if (!roll) return null
+  
+      await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    }
+  
+}
--- a/module/models/psionic.mjs
+++ b/module/models/psionic.mjs
@@ -0,0 +1,26 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class FTLNomadPsionic extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+
+    let setting = game.settings.get("fvtt-cthulhu-eternal", "settings-era") || "modern"
+    schema.settings = new fields.StringField({ required: true, initial: setting, choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.base = new fields.StringField({ required: true, initial: "0" })
+    schema.bonus = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.diceEvolved = new fields.BooleanField({ required: true, initial: true })
+    schema.rollFailed = new fields.BooleanField({ required: true, initial: false })
+    schema.isAdversary = new fields.BooleanField({ required: true, initial: false })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.Psionic"]
+
+}
--- a/module/models/talent.mjs
+++ b/module/models/talent.mjs
@@ -0,0 +1,64 @@
+import { SYSTEM } from "../config/system.mjs";
+
+export default class FTLNomadTalent extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields;
+    const schema = {};
+
+    let setting = game.settings.get("fvtt-cthulhu-eternal", "settings-era") || "modern"
+    schema.minimumEra = new fields.StringField({ required: true, initial: setting, choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.creationDate = new fields.StringField({
+      required: true,
+      initial: "",
+      textSearch: true
+    });
+
+    // Language field
+    schema.language = new fields.StringField({
+      required: true,
+      initial: "Latin",
+      textSearch: true
+    });
+
+    // studyTime field
+    schema.studyTime = new fields.StringField({
+      required: true,
+      initial: "X days",
+      textSearch: true
+    });
+
+    // SAN loss field
+    schema.sanLoss = new fields.StringField({
+      required: true,
+      initial: "1d4",
+      textSearch: true
+    });
+
+    // Unnatural skill field
+    schema.unnaturalSkill = new fields.StringField({
+      required: true,
+      initial: "1d4",
+      textSearch: true
+    });
+
+    schema.rituals = new fields.StringField({
+      required: true,
+      initial: "",
+      textSearch: true
+    });
+
+    schema.otherBenefits = new fields.StringField({
+      required: true,
+      initial: "",
+      textSearch: true
+    });
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+
+    return schema;
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNomad.Talent"];
+}
--- a/module/models/vehicle.mjs
+++ b/module/models/vehicle.mjs
@@ -0,0 +1,35 @@
+import { SYSTEM } from "../config/system.mjs"
+import FTLNomadRoll from "../documents/roll.mjs"
+
+export default class CthulhuEternalVehicle extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    let setting = game.settings.get("fvtt-cthulhu-eternal", "settings-era") || "modern"
+    schema.settings = new fields.StringField({ required: true, initial: setting, choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.hp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 })
+    })
+
+    schema.armor = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    schema.surfaceSpeed = new fields.StringField({ required: true, initial: "slow", choices: SYSTEM.VEHICLE_SPEED })
+    schema.airSpeed = new fields.StringField({ required: true, initial: "none", choices: SYSTEM.VEHICLE_SPEED })
+    schema.state = new fields.StringField({ required: true, initial: "pristine", choices: SYSTEM.EQUIPMENT_STATES })
+    
+    schema.crew = new fields.ArrayField(new fields.StringField(), { required: false, initial: [], min:0 })
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.notes = new fields.HTMLField({ required: true, textSearch: true })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNomad.Vehicle"]
+
+}
--- a/module/models/weapon.mjs
+++ b/module/models/weapon.mjs
@@ -0,0 +1,35 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class FTLNomadWeapon extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+
+    let setting = game.settings.get("fvtt-cthulhu-eternal", "settings-era") || "modern"
+    schema.settings = new fields.StringField({ required: true, initial: setting, choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.weaponType = new fields.StringField({ required: true, initial: "melee", choices: SYSTEM.WEAPON_TYPE })
+    schema.hasDirectSkill = new fields.BooleanField({ required: true, initial: false })
+    schema.directSkillValue = new fields.NumberField({ required: true, initial: 0, min: 0, max:99 })
+    
+    schema.damage = new fields.StringField({required: true, initial: "1d6"})  
+    schema.baseRange = new fields.StringField({required: true, initial: ""})
+    schema.rangeUnit = new fields.StringField({ required: true, initial: "yard", choices: SYSTEM.WEAPON_RANGE_UNIT })
+    schema.lethality = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    schema.killRadius = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    schema.armorPiercing = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    schema.weaponSubtype = new fields.StringField({ required: true, initial: "basicfirearm", choices: SYSTEM.WEAPON_SUBTYPE })  
+    schema.state = new fields.StringField({ required: true, initial: "pristine", choices: SYSTEM.EQUIPMENT_STATES })
+
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["FTLNOMAD.Weapon"]
+
+}
--- a/module/socket.mjs
+++ b/module/socket.mjs
@@ -0,0 +1,13 @@
+
+/**
+ * Handles socket events based on the provided action.
+ *
+ * @param {Object} [params={}] The parameters for the socket event.
+ * @param {string|null} [params.action=null] The action to be performed.
+ * @param {Object} [params.data={}] The data associated with the action.
+ * @returns {*} The result of the action handler, if applicable.
+ */
+export function handleSocketEvent({ action = null, data = {} } = {}) {
+  console.debug("handleSocketEvent", action, data)
+}
+
--- a/module/utils.mjs
+++ b/module/utils.mjs
@@ -0,0 +1,200 @@
+
+import CthulhuEternalRoll from "./documents/roll.mjs"
+import { SystemManager } from './applications/hud/system-manager.js'
+import { SYSTEM } from "./config/system.mjs"
+
+export default class FTLNomadUtils {
+
+  static registerSettings() {
+    game.settings.register("fvtt-ftl-nomad", "settings-era", {
+      name: game.i18n.localize("FTLNOMAD.Settings.era"),
+      hint: game.i18n.localize("FTLNOMAD.Settings.eraHint"),
+      default: "jazz",
+      scope: "world",
+      type: String,
+      choices: SYSTEM.AVAILABLE_SETTINGS,
+      config: true,
+      onChange: _ => window.location.reload()
+    });
+  }
+
+  static async loadCompendiumData(compendium) {
+    const pack = game.packs.get(compendium)
+    return await pack?.getDocuments() ?? []
+  }
+
+  static async loadCompendium(compendium, filter = item => true) {
+    let compendiumData = await FTLNomadUtils.loadCompendiumData(compendium)
+    return compendiumData.filter(filter)
+  }
+
+  static registerHandlebarsHelpers() {
+
+    Handlebars.registerHelper('isNull', function (val) {
+      return val == null;
+    });
+
+    Handlebars.registerHelper('exists', function (val) {
+      return val != null && val !== undefined;
+    });
+
+    Handlebars.registerHelper('isEmpty', function (list) {
+      if (list) return list.length === 0;
+      else return false;
+    });
+
+    Handlebars.registerHelper('notEmpty', function (list) {
+      return list.length > 0;
+    });
+
+    Handlebars.registerHelper('isNegativeOrNull', function (val) {
+      return val <= 0;
+    });
+
+    Handlebars.registerHelper('isNegative', function (val) {
+      return val < 0;
+    });
+
+    Handlebars.registerHelper('isPositive', function (val) {
+      return val > 0;
+    });
+
+    Handlebars.registerHelper('equals', function (val1, val2) {
+      return val1 === val2;
+    });
+
+    Handlebars.registerHelper('neq', function (val1, val2) {
+      return val1 !== val2;
+    });
+
+    Handlebars.registerHelper('gt', function (val1, val2) {
+      return val1 > val2;
+    })
+
+    Handlebars.registerHelper('lt', function (val1, val2) {
+      return val1 < val2;
+    })
+
+    Handlebars.registerHelper('gte', function (val1, val2) {
+      return val1 >= val2;
+    })
+
+    Handlebars.registerHelper('lte', function (val1, val2) {
+      return val1 <= val2;
+    })
+    Handlebars.registerHelper('and', function (val1, val2) {
+      return val1 && val2;
+    })
+    Handlebars.registerHelper('or', function (val1, val2) {
+      return val1 || val2;
+    })
+
+    Handlebars.registerHelper('or3', function (val1, val2, val3) {
+      return val1 || val2 || val3;
+    })
+
+    Handlebars.registerHelper('for', function (from, to, incr, block) {
+      let accum = '';
+      for (let i = from; i < to; i += incr)
+        accum += block.fn(i);
+      return accum;
+    })
+
+    Handlebars.registerHelper('not', function (cond) {
+      return !cond;
+    })
+    Handlebars.registerHelper('count', function (list) {
+      return list.length;
+    })
+    Handlebars.registerHelper('countKeys', function (obj) {
+      return Object.keys(obj).length;
+    })
+
+    Handlebars.registerHelper('isEnabled', function (configKey) {
+      return game.settings.get("bol", configKey);
+    })
+    Handlebars.registerHelper('split', function (str, separator, keep) {
+      return str.split(separator)[keep];
+    })
+
+    // If you need to add Handlebars helpers, here are a few useful examples:
+    Handlebars.registerHelper('concat', function () {
+      let outStr = '';
+      for (let arg in arguments) {
+        if (typeof arguments[arg] != 'object') {
+          outStr += arguments[arg];
+        }
+      }
+      return outStr;
+    })
+
+    Handlebars.registerHelper('add', function (a, b) {
+      return parseInt(a) + parseInt(b);
+    });
+    Handlebars.registerHelper('mul', function (a, b) {
+      return parseInt(a) * parseInt(b);
+    })
+    Handlebars.registerHelper('sub', function (a, b) {
+      return parseInt(a) - parseInt(b);
+    })
+    Handlebars.registerHelper('abbrev2', function (a) {
+      return a.substring(0, 2);
+    })
+    Handlebars.registerHelper('abbrev3', function (a) {
+      return a.substring(0, 3);
+    })
+    Handlebars.registerHelper('valueAtIndex', function (arr, idx) {
+      return arr[idx];
+    })
+    Handlebars.registerHelper('includesKey', function (items, type, key) {
+      return items.filter(i => i.type === type).map(i => i.system.key).includes(key);
+    })
+    Handlebars.registerHelper('includes', function (array, val) {
+      return array.includes(val);
+    })
+    Handlebars.registerHelper('eval', function (expr) {
+      return eval(expr);
+    })
+    Handlebars.registerHelper('isOwnerOrGM', function (actor) {
+      console.log("Testing actor", actor.isOwner, game.userId)
+      return actor.isOwner || game.isGM;
+    })
+    Handlebars.registerHelper('upperFirst', function (text) {
+      if (typeof text !== 'string') return text
+      return text.charAt(0).toUpperCase() + text.slice(1)
+    })
+    Handlebars.registerHelper('upperFirstOnly', function (text) {
+      if (typeof text !== 'string') return text
+      return text.charAt(0).toUpperCase()
+    })
+    Handlebars.registerHelper('isCreature', function (key) {
+      return key === "creature" || key === "daemon";
+    })
+
+    // Handle v12 removal of this helper
+    Handlebars.registerHelper('select', function (selected, options) {
+      const escapedValue = RegExp.escape(Handlebars.escapeExpression(selected));
+      const rgx = new RegExp(' value=[\"\']' + escapedValue + '[\"\']');
+      const html = options.fn(this);
+      return html.replace(rgx, "$& selected");
+    });
+
+  }
+
+  static setupCSSRootVariables() {
+    const era = game.settings.get("fvtt-cthulhu-eternal", "settings-era")
+
+    let eraCSS = SYSTEM.ERA_CSS[era];
+    if (!eraCSS) eraCSS = SYSTEM.ERA_CSS["jazz"];
+
+    document.documentElement.style.setProperty('--font-size-standard', eraCSS.baseFontSize);
+    document.documentElement.style.setProperty('--font-size-title', eraCSS.titleFontSize);
+    document.documentElement.style.setProperty('--font-size-result', eraCSS.titleFontSize);
+    document.documentElement.style.setProperty('--font-primary', eraCSS.primaryFont);
+    document.documentElement.style.setProperty('--font-secondary', eraCSS.secondaryFont);
+    document.documentElement.style.setProperty('--font-title', eraCSS.titleFont);
+    document.documentElement.style.setProperty('--img-icon-color-filter', eraCSS.imgFilter);
+    document.documentElement.style.setProperty('--background-image-base', `linear-gradient(rgba(255, 255, 255, 0.8), rgba(255, 255, 255, 0.8)), url("../assets/ui/${era}_background_main.webp")`);
+  }
+
+}