Nombreuses corrections sur les fiches settlement/NPC

2026-03-22 21:35:47 +01:00
parent ec291e9c60
commit b46c6d804c
51 changed files with 2892 additions and 227 deletions
--- a/module/applications/sheets/base-item-sheet.mjs
+++ b/module/applications/sheets/base-item-sheet.mjs
@@ -1,5 +1,5 @@
 const { HandlebarsApplicationMixin } = foundry.applications.api
-import { ARMOR_TYPE_CHOICES, WEAPON_PROFICIENCY_GROUPS } from "../../config/system.mjs"
+import { ARMOR_TYPE_CHOICES, CLASS_RESTRICTION_CHOICES, SYSTEM, WEAPON_PROFICIENCY_GROUPS } from "../../config/system.mjs"
 import { rollRarityCheck } from "../../rolls.mjs"

 export default class OathHammerItemSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
@@ -57,6 +57,10 @@ export default class OathHammerItemSheet extends HandlebarsApplicationMixin(foun
    if (this.document.system.description !== undefined) {
      context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.description ?? "", { async: true })
    }
+    if (this.document.system.magicEffect !== undefined) {
+      context.enrichedMagicEffect = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.magicEffect ?? "", { async: true })
+    }
+    context.classRestrictionChoices = CLASS_RESTRICTION_CHOICES
    // Armor-specific numeric selects
    context.armorValueChoices = Object.fromEntries(
      Array.from({ length: 13 }, (_, i) => [i, String(i)])
@@ -71,6 +75,13 @@ export default class OathHammerItemSheet extends HandlebarsApplicationMixin(foun
    context.apChoices = Object.fromEntries(
      Array.from({ length: 7 }, (_, i) => [i, String(i)])
    )
+    // Skill choices for weapon skill override (empty = auto-detect)
+    context.skillChoices = {
+      "": `— ${game.i18n.localize("OATHHAMMER.Weapon.SkillOverrideAuto")} —`,
+      ...Object.fromEntries(
+        Object.entries(SYSTEM.SKILLS).map(([k, v]) => [k, game.i18n.localize(v.label)])
+      )
+    }
    // Class proficiency choices (for class-sheet checkboxes)
    context.armorTypeChoices  = ARMOR_TYPE_CHOICES
    context.weaponGroupChoices = WEAPON_PROFICIENCY_GROUPS
--- a/module/applications/sheets/character-sheet.mjs
+++ b/module/applications/sheets/character-sheet.mjs
@@ -118,7 +118,6 @@ export default class OathHammerCharacterSheet extends OathHammerActorSheet {
            _descTooltip: _stripHtml(parts.join(" "))
          }
        })
-        context.enrichedBackground = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.background ?? "", { async: true })
        break
      case "skills": {
        context.tab = context.tabs.skills
@@ -149,7 +148,7 @@ export default class OathHammerCharacterSheet extends OathHammerActorSheet {
              modifierName: `system.skills.${skillKey}.modifier`,
              colorDiceName: `system.skills.${skillKey}.colorDice`,
              colorDiceTypeName: `system.skills.${skillKey}.colorDiceType`,
-              rankOptions: [0,1,2,3,4].map(v => ({ value: v, label: String(v), selected: v === sk.rank })),
+              rankOptions: [0,1,2,3,4,5,6].map(v => ({ value: v, label: String(v), selected: v === sk.rank })),
              total: attrRanks[attr] + sk.rank,
              // legacy - kept for formInput compatibility
              name: `system.skills.${skillKey}.rank`,
@@ -232,6 +231,7 @@ export default class OathHammerCharacterSheet extends OathHammerActorSheet {
        break
      case "notes":
        context.tab = context.tabs.notes
+        context.enrichedBackground = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.background ?? "", { async: true })
        context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.description ?? "", { async: true })
        context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes ?? "", { async: true })
        break
--- a/module/applications/sheets/npc-sheet.mjs
+++ b/module/applications/sheets/npc-sheet.mjs
@@ -1,50 +1,56 @@
 import OathHammerActorSheet from "./base-actor-sheet.mjs"
-import { rollInitiativeCheck } from "../../rolls.mjs"
+import { SYSTEM } from "../../config/system.mjs"
+import { rollInitiativeCheck, rollNPCSkill, rollNPCArmor, rollNPCSpell, rollNPCMiracle, rollNPCAttackDamage } from "../../rolls.mjs"

 export default class OathHammerNPCSheet extends OathHammerActorSheet {
-  /** @override */
  static DEFAULT_OPTIONS = {
    classes: ["npc"],
-    position: {
-      width: 720,
-      height: "auto",
-    },
-    window: {
-      contentClasses: ["npc-content"],
-    },
+    position: { width: 720, height: "auto" },
+    window: { contentClasses: ["npc-content"] },
    actions: {
-      rollInitiative: OathHammerNPCSheet.#onRollInitiative,
+      rollInitiative:  OathHammerNPCSheet.#onRollInitiative,
+      adjustGrit:      OathHammerNPCSheet.#onAdjustGrit,
+      rollSkillNPC:    OathHammerNPCSheet.#onRollSkillNPC,
+      rollArmor:       OathHammerNPCSheet.#onRollArmor,
+      createSpell:     OathHammerNPCSheet.#onCreateSpell,
+      createMiracle:   OathHammerNPCSheet.#onCreateMiracle,
+      castNPCSpell:    OathHammerNPCSheet.#onCastNPCSpell,
+      castNPCMiracle:  OathHammerNPCSheet.#onCastNPCMiracle,
+      createNpcAttack: OathHammerNPCSheet.#onCreateNpcAttack,
+      rollNpcAttack:   OathHammerNPCSheet.#onRollNpcAttack,
    },
  }

-  /** @override */
  static PARTS = {
-    main: {
-      template: "systems/fvtt-oath-hammer/templates/actor/npc-sheet.hbs",
-    },
-    tabs: {
-      template: "templates/generic/tab-navigation.hbs",
-    },
-    combat: {
-      template: "systems/fvtt-oath-hammer/templates/actor/npc-combat.hbs",
-    },
-    notes: {
-      template: "systems/fvtt-oath-hammer/templates/actor/npc-notes.hbs",
-    },
+    main:      { template: "systems/fvtt-oath-hammer/templates/actor/npc-sheet.hbs" },
+    tabs:      { template: "templates/generic/tab-navigation.hbs" },
+    skills:    { template: "systems/fvtt-oath-hammer/templates/actor/npc-skills.hbs" },
+    combat:    { template: "systems/fvtt-oath-hammer/templates/actor/npc-combat.hbs" },
+    traits:    { template: "systems/fvtt-oath-hammer/templates/actor/npc-traits.hbs" },
+    magic:     { template: "systems/fvtt-oath-hammer/templates/actor/npc-magic.hbs" },
+    equipment: { template: "systems/fvtt-oath-hammer/templates/actor/npc-equipment.hbs" },
+    notes:     { template: "systems/fvtt-oath-hammer/templates/actor/npc-notes.hbs" },
  }

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

  #getTabs() {
+    const isNPC = this.document.system.subtype === "npc"
+    const hasMagic = this.document.items.some(i => i.type === "spell" || i.type === "miracle")
    const tabs = {
-      combat: { id: "combat", group: "sheet", icon: "fa-solid fa-swords", label: "OATHHAMMER.Tab.Combat" },
-      notes: { id: "notes", group: "sheet", icon: "fa-solid fa-book", label: "OATHHAMMER.Tab.Notes" },
+      skills: { id: "skills",    group: "sheet", icon: "fa-solid fa-dice-d6",        label: "OATHHAMMER.Tab.Skills" },
+      combat: { id: "combat",    group: "sheet", icon: "fa-solid fa-swords",          label: "OATHHAMMER.Tab.Combat" },
+      traits: { id: "traits",    group: "sheet", icon: "fa-solid fa-star",            label: "OATHHAMMER.Tab.Traits" },
+      notes:  { id: "notes",     group: "sheet", icon: "fa-solid fa-book",            label: "OATHHAMMER.Tab.Notes" },
+    }
+    if (isNPC) {
+      tabs.equipment = { id: "equipment", group: "sheet", icon: "fa-solid fa-backpack",     label: "OATHHAMMER.Tab.Equipment" }
+    }
+    if (hasMagic || !this.isPlayMode) {
+      tabs.magic = { id: "magic", group: "sheet", icon: "fa-solid fa-wand-sparkles", label: "OATHHAMMER.Tab.Magic" }
    }
    for (const v of Object.values(tabs)) {
-      v.active = this.tabGroups[v.group] === v.id
+      v.active   = this.tabGroups[v.group] === v.id
      v.cssClass = v.active ? "active" : ""
    }
    return tabs
@@ -54,6 +60,23 @@ export default class OathHammerNPCSheet extends OathHammerActorSheet {
  async _prepareContext() {
    const context = await super._prepareContext()
    context.tabs = this.#getTabs()
+
+    context.subtypeChoices = Object.fromEntries(
+      Object.entries(SYSTEM.NPC_SUBTYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    context.subtypeLabels = context.subtypeChoices
+
+    const armorColor = this.document.system.armorDice?.colorDiceType ?? "white"
+    context.armorDiceEmoji = armorColor === "black" ? "⬛" : armorColor === "red" ? "🔴" : "⬜"
+
+    context.colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+
+    context.traitTypeLabels = Object.fromEntries(
+      Object.entries(SYSTEM.TRAIT_TYPE_CHOICES).map(([k, v]) => [k, v])
+    )
+
    return context
  }

@@ -61,29 +84,265 @@ export default class OathHammerNPCSheet extends OathHammerActorSheet {
  async _preparePartContext(partId, context) {
    const doc = this.document
    switch (partId) {
-      case "main":
+      case "skills":
+        context.tab = context.tabs.skills
+        context.skills = (doc.itemTypes.skillnpc ?? []).slice().sort((a, b) => a.name.localeCompare(b.name))
        break
      case "combat":
        context.tab = context.tabs.combat
-        context.weapons = doc.itemTypes.weapon
+        context.npcAttacks  = (doc.itemTypes.npcattack ?? []).map(a => ({
+          id: a.id, uuid: a.uuid, img: a.img, name: a.name, system: a.system,
+          _descTooltip: a.system.description?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
+        }))
        context.combatantInitiative = game.combat?.combatants.find(c => c.actor?.id === doc.id)?.initiative ?? null
        break
+      case "traits":
+        context.tab = context.tabs.traits
+        context.traits = (doc.itemTypes.trait ?? []).slice().sort((a, b) => a.name.localeCompare(b.name)).map(t => ({
+          id: t.id, uuid: t.uuid, img: t.img, name: t.name, system: t.system,
+          _descTooltip: t.system.description?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
+        }))
+        break
+      case "magic":
+        context.tab = context.tabs.magic
+        context.spells   = (doc.itemTypes.spell ?? []).map(s => ({
+          id: s.id, uuid: s.uuid, img: s.img, name: s.name, system: s.system,
+          _descTooltip: s.system.effect?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
+        }))
+        context.miracles = (doc.itemTypes.miracle ?? []).map(m => ({
+          id: m.id, uuid: m.uuid, img: m.img, name: m.name, system: m.system,
+          _descTooltip: m.system.effect?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
+        }))
+        break
+      case "equipment":
+        context.tab = context.tabs.equipment
+        context.armors    = doc.itemTypes.armor ?? []
+        context.equipment = doc.itemTypes.equipment ?? []
+        break
      case "notes":
        context.tab = context.tabs.notes
        context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.description, { async: true })
-        context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes, { async: true })
+        context.enrichedNotes       = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes, { async: true })
        break
    }
    return context
  }

+  /** @override */
  async _onDrop(event) {
    if (!this.isEditable || !this.isEditMode) return
    const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)
-    if (data.type === "Item") {
-      const item = await fromUuid(data.uuid)
-      return this._onDropItem(item)
-    }
+    if (data.type !== "Item") return
+    const item = await fromUuid(data.uuid)
+    if (!item) return
+    const ALLOWED = new Set(["skillnpc", "npcattack", "trait", "armor", "equipment", "spell", "miracle"])
+    if (!ALLOWED.has(item.type)) return
+    return this._onDropItem(item)
+  }
+
+  static async #onAdjustGrit(event, target) {
+    const delta   = parseInt(target.dataset.delta, 10)
+    const current = this.document.system.grit?.value ?? 0
+    const max     = this.document.system.grit?.max ?? current
+    await this.document.update({ "system.grit.value": Math.max(0, Math.min(max, current + delta)) })
+  }
+
+  static #onCreateNpcAttack() {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("OATHHAMMER.NewItem.NpcAttack"), type: "npcattack" }])
+  }
+
+  static async #onRollNpcAttack(event, target) {
+    const attack = this.document.items.get(target.dataset.itemId)
+    if (!attack) return
+
+    const bonusOptions = Array.from({ length: 13 }, (_, i) => {
+      const v = i - 6
+      return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
+    })
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-oath-hammer/templates/npc-skill-dialog.hbs",
+      {
+        skillName:   attack.name,
+        skillImg:    attack.img,
+        dicePool:    attack.system.damageDice,
+        colorEmoji:  attack.system.colorEmoji,
+        colorType:   attack.system.colorDiceType,
+        threshold:   attack.system.threshold,
+        bonusOptions,
+        colorChoices: Object.fromEntries(
+          Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+        ),
+        rollModes:   foundry.utils.duplicate(CONFIG.Dice.rollModes),
+        visibility:  game.settings.get("core", "rollMode"),
+      }
+    )
+
+    const result = await foundry.applications.api.DialogV2.prompt({
+      window:   { title: attack.name, resizable: true },
+      classes:  ["fvtt-oath-hammer"],
+      position: { width: 420 },
+      content,
+      ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-burst" },
+    })
+    if (!result) return
+
+    const form = new DOMParser().parseFromString(result, "text/html")
+    const getValue = name => form.querySelector(`[name="${name}"]`)?.value
+
+    await rollNPCAttackDamage(this.document, attack, {
+      bonus:      parseInt(getValue("bonus")) || 0,
+      visibility: getValue("visibility"),
+    })
+  }
+
+  static #onCreateSpell() {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("OATHHAMMER.NewItem.Spell"), type: "spell" }])
+  }
+
+  static #onCreateMiracle() {
+    this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("OATHHAMMER.NewItem.Miracle"), type: "miracle" }])
+  }
+
+  static async #onCastNPCSpell(event, target) {
+    const spell = this.document.items.get(target.dataset.itemId)
+    if (!spell) return
+
+    const colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    const poolOptions = Array.from({ length: 10 }, (_, i) => {
+      const v = i + 1
+      return { value: v, label: String(v), selected: v === 3 }
+    })
+    const bonusOptions = Array.from({ length: 13 }, (_, i) => {
+      const v = i - 6
+      return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
+    })
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-oath-hammer/templates/npc-magic-dialog.hbs",
+      {
+        itemName: spell.name, itemImg: spell.img,
+        dv: spell.system.difficultyValue,
+        poolOptions, bonusOptions, colorChoices, showColor: true,
+        rollModes:  foundry.utils.duplicate(CONFIG.Dice.rollModes),
+        visibility: game.settings.get("core", "rollMode"),
+      }
+    )
+
+    const result = await foundry.applications.api.DialogV2.prompt({
+      window:   { title: spell.name, resizable: true },
+      classes:  ["fvtt-oath-hammer"],
+      position: { width: 420 },
+      content,
+      ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-wand-sparkles" },
+    })
+    if (!result) return
+
+    const form = new DOMParser().parseFromString(result, "text/html")
+    const getValue = name => form.querySelector(`[name="${name}"]`)?.value
+
+    await rollNPCSpell(this.document, spell, {
+      dicePool:      parseInt(getValue("dicePool")) || 3,
+      bonus:         parseInt(getValue("bonus")) || 0,
+      colorOverride: getValue("colorOverride") || null,
+      visibility:    getValue("visibility"),
+    })
+  }
+
+  static async #onCastNPCMiracle(event, target) {
+    const miracle = this.document.items.get(target.dataset.itemId)
+    if (!miracle) return
+
+    const poolOptions = Array.from({ length: 10 }, (_, i) => {
+      const v = i + 1
+      return { value: v, label: String(v), selected: v === 3 }
+    })
+    const bonusOptions = Array.from({ length: 13 }, (_, i) => {
+      const v = i - 6
+      return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
+    })
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-oath-hammer/templates/npc-magic-dialog.hbs",
+      {
+        itemName: miracle.name, itemImg: miracle.img,
+        dv: null, showColor: false,
+        poolOptions, bonusOptions,
+        rollModes:  foundry.utils.duplicate(CONFIG.Dice.rollModes),
+        visibility: game.settings.get("core", "rollMode"),
+      }
+    )
+
+    const result = await foundry.applications.api.DialogV2.prompt({
+      window:   { title: miracle.name, resizable: true },
+      classes:  ["fvtt-oath-hammer"],
+      position: { width: 420 },
+      content,
+      ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-hands-praying" },
+    })
+    if (!result) return
+
+    const form = new DOMParser().parseFromString(result, "text/html")
+    const getValue = name => form.querySelector(`[name="${name}"]`)?.value
+
+    await rollNPCMiracle(this.document, miracle, {
+      dicePool:   parseInt(getValue("dicePool")) || 3,
+      bonus:      parseInt(getValue("bonus")) || 0,
+      visibility: getValue("visibility"),
+    })
+  }
+
+  static async #onRollArmor() {
+    const actor = this.document
+    const sys = actor.system
+    const colorType  = sys.armorDice?.colorDiceType || "white"
+    const threshold  = colorType === "black" ? 2 : colorType === "red" ? 3 : 4
+    const colorEmoji = colorType === "black" ? "⬛" : colorType === "red" ? "🔴" : "⬜"
+    const dicePool   = sys.armorDice?.value ?? 0
+
+    const colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    const bonusOptions = Array.from({ length: 13 }, (_, i) => {
+      const v = i - 6
+      return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
+    })
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-oath-hammer/templates/npc-skill-dialog.hbs",
+      {
+        skillName:   game.i18n.localize("OATHHAMMER.Label.ArmorDice"),
+        skillImg:    actor.img,
+        dicePool,
+        colorEmoji,
+        colorType,
+        threshold,
+        bonusOptions,
+        colorChoices,
+        rollModes:   foundry.utils.duplicate(CONFIG.Dice.rollModes),
+        visibility:  game.settings.get("core", "rollMode"),
+      }
+    )
+
+    const result = await foundry.applications.api.DialogV2.prompt({
+      window:   { title: game.i18n.localize("OATHHAMMER.Label.ArmorDice"), resizable: true },
+      classes:  ["fvtt-oath-hammer"],
+      position: { width: 420 },
+      content,
+      ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-dice-d6" },
+    })
+    if (!result) return
+
+    const form = new DOMParser().parseFromString(result, "text/html")
+    const getValue = name => form.querySelector(`[name="${name}"]`)?.value
+
+    await rollNPCArmor(actor, {
+      bonus:         parseInt(getValue("bonus")) || 0,
+      colorOverride: getValue("colorOverride") || null,
+      visibility:    getValue("visibility"),
+    })
  }

  static async #onRollInitiative() {
@@ -95,4 +354,53 @@ export default class OathHammerNPCSheet extends OathHammerActorSheet {
      await rollInitiativeCheck(actor)
    }
  }
+
+  static async #onRollSkillNPC(event, target) {
+    const itemId = target.dataset.itemId
+    const item   = this.document.items.get(itemId)
+    if (!item) return
+
+    const colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    const bonusOptions = Array.from({ length: 13 }, (_, i) => {
+      const v = i - 6
+      return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
+    })
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      "systems/fvtt-oath-hammer/templates/npc-skill-dialog.hbs",
+      {
+        skillName:   item.name,
+        skillImg:    item.img,
+        dicePool:    item.system.dicePool,
+        colorEmoji:  item.system.colorEmoji,
+        colorType:   item.system.colorDiceType,
+        threshold:   item.system.threshold,
+        bonusOptions,
+        colorChoices,
+        rollModes:   foundry.utils.duplicate(CONFIG.Dice.rollModes),
+        visibility:  game.settings.get("core", "rollMode"),
+      }
+    )
+
+    const result = await foundry.applications.api.DialogV2.prompt({
+      window:   { title: item.name, resizable: true },
+      classes:  ["fvtt-oath-hammer"],
+      position: { width: 420 },
+      content,
+      ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-dice-d6" },
+    })
+    if (!result) return
+
+    const form = new DOMParser().parseFromString(result, "text/html")
+    const getValue = name => form.querySelector(`[name="${name}"]`)?.value
+
+    await rollNPCSkill(this.document, item, {
+      bonus:         parseInt(getValue("bonus")) || 0,
+      colorOverride: getValue("colorOverride") || null,
+      visibility:    getValue("visibility"),
+    })
+  }
+
 }
--- a/module/applications/sheets/npcattack-sheet.mjs
+++ b/module/applications/sheets/npcattack-sheet.mjs
@@ -0,0 +1,28 @@
+import OathHammerItemSheet from "./base-item-sheet.mjs"
+import { SYSTEM } from "../../config/system.mjs"
+
+export default class OathHammerNpcAttackSheet extends OathHammerItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["npcattack"],
+    position: { width: 460 },
+    window: { contentClasses: ["npcattack-content"] },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: { template: "systems/fvtt-oath-hammer/templates/item/npcattack-sheet.hbs" },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.dicePoolChoices = Object.fromEntries(
+      Array.from({ length: 21 }, (_, i) => [i, String(i)])
+    )
+    context.colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    return context
+  }
+}
--- a/module/applications/sheets/regiment-sheet.mjs
+++ b/module/applications/sheets/regiment-sheet.mjs
@@ -0,0 +1,80 @@
+import OathHammerItemSheet from "./base-item-sheet.mjs"
+import { SYSTEM } from "../../config/system.mjs"
+
+export default class OathHammerRegimentSheet extends OathHammerItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["regiment"],
+    position: { width: 560, height: "auto" },
+    window: { contentClasses: ["regiment-content"] },
+    actions: {
+      addSkill:    OathHammerRegimentSheet.#onAddSkill,
+      removeSkill: OathHammerRegimentSheet.#onRemoveSkill,
+      addAttack:   OathHammerRegimentSheet.#onAddAttack,
+      removeAttack:OathHammerRegimentSheet.#onRemoveAttack,
+      addTrait:    OathHammerRegimentSheet.#onAddTrait,
+      removeTrait: OathHammerRegimentSheet.#onRemoveTrait,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: { template: "systems/fvtt-oath-hammer/templates/item/regiment-sheet.hbs" },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    context.dicePoolChoices = Object.fromEntries(
+      Array.from({ length: 21 }, (_, i) => [i, String(i)])
+    )
+    context.apChoices = Object.fromEntries(
+      Array.from({ length: 7 }, (_, i) => [i, String(i)])
+    )
+    return context
+  }
+
+  // ── Array helpers ────────────────────────────────────────────────────────────
+
+  static async #onAddSkill() {
+    const skills = foundry.utils.deepClone(this.document.system.skills ?? [])
+    skills.push({ name: "", value: 2, colorDiceType: "white" })
+    await this.document.update({ "system.skills": skills })
+  }
+
+  static async #onRemoveSkill(event, target) {
+    const idx = parseInt(target.dataset.idx, 10)
+    const skills = foundry.utils.deepClone(this.document.system.skills ?? [])
+    skills.splice(idx, 1)
+    await this.document.update({ "system.skills": skills })
+  }
+
+  static async #onAddAttack() {
+    const attacks = foundry.utils.deepClone(this.document.system.attacks ?? [])
+    attacks.push({ name: "", damageDice: 6, colorDiceType: "white", ap: 0, special: "" })
+    await this.document.update({ "system.attacks": attacks })
+  }
+
+  static async #onRemoveAttack(event, target) {
+    const idx = parseInt(target.dataset.idx, 10)
+    const attacks = foundry.utils.deepClone(this.document.system.attacks ?? [])
+    attacks.splice(idx, 1)
+    await this.document.update({ "system.attacks": attacks })
+  }
+
+  static async #onAddTrait() {
+    const traits = foundry.utils.deepClone(this.document.system.traits ?? [])
+    traits.push({ name: "", description: "" })
+    await this.document.update({ "system.traits": traits })
+  }
+
+  static async #onRemoveTrait(event, target) {
+    const idx = parseInt(target.dataset.idx, 10)
+    const traits = foundry.utils.deepClone(this.document.system.traits ?? [])
+    traits.splice(idx, 1)
+    await this.document.update({ "system.traits": traits })
+  }
+}
--- a/module/applications/sheets/settlement-sheet.mjs
+++ b/module/applications/sheets/settlement-sheet.mjs
@@ -1,6 +1,6 @@
 import OathHammerActorSheet from "./base-actor-sheet.mjs"

-const ALLOWED_ITEM_TYPES = new Set(["building", "equipment", "weapon", "armor"])
+const ALLOWED_ITEM_TYPES = new Set(["building", "equipment", "weapon", "armor", "regiment"])

 export default class OathHammerSettlementSheet extends OathHammerActorSheet {
  /** @override */
@@ -14,9 +14,11 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
      contentClasses: ["settlement-content"],
    },
    actions: {
-      adjustCurrency: OathHammerSettlementSheet.#onAdjustCurrency,
-      adjustQty:      OathHammerSettlementSheet.#onAdjustQty,
+      adjustCurrency:    OathHammerSettlementSheet.#onAdjustCurrency,
+      adjustQty:         OathHammerSettlementSheet.#onAdjustQty,
      toggleConstructed: OathHammerSettlementSheet.#onToggleConstructed,
+      createRegiment:    OathHammerSettlementSheet.#onCreateRegiment,
+      collectTaxes:      OathHammerSettlementSheet.#onCollectTaxes,
    },
  }

@@ -37,6 +39,9 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
    inventory: {
      template: "systems/fvtt-oath-hammer/templates/actor/settlement-inventory.hbs",
    },
+    garrison: {
+      template: "systems/fvtt-oath-hammer/templates/actor/settlement-garrison.hbs",
+    },
  }

  /** @override */
@@ -46,9 +51,10 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {

  #getTabs() {
    const tabs = {
-      overview:  { id: "overview",  group: "sheet", icon: "fa-solid fa-city",        label: "OATHHAMMER.Tab.Overview" },
-      buildings: { id: "buildings", group: "sheet", icon: "fa-solid fa-building",     label: "OATHHAMMER.Tab.Buildings" },
-      inventory: { id: "inventory", group: "sheet", icon: "fa-solid fa-boxes-stacked", label: "OATHHAMMER.Tab.Inventory" },
+      overview:  { id: "overview",  group: "sheet", icon: "fa-solid fa-city",          label: "OATHHAMMER.Tab.Overview" },
+      buildings: { id: "buildings", group: "sheet", icon: "fa-solid fa-building",       label: "OATHHAMMER.Tab.Buildings" },
+      inventory: { id: "inventory", group: "sheet", icon: "fa-solid fa-boxes-stacked",  label: "OATHHAMMER.Tab.Inventory" },
+      garrison:  { id: "garrison",  group: "sheet", icon: "fa-solid fa-shield-halved",  label: "OATHHAMMER.Tab.Garrison" },
    }
    for (const v of Object.values(tabs)) {
      v.active   = this.tabGroups[v.group] === v.id
@@ -81,7 +87,11 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
        break
      case "buildings":
        context.tab = context.tabs.buildings
-        context.buildings = doc.itemTypes.building
+        context.buildings = doc.itemTypes.building.map(b => ({
+          id: b.id, uuid: b.uuid, img: b.img, name: b.name, system: b.system,
+          _descTooltip: b.system.description?.replace(/<[^>]+>/g, "").trim().slice(0, 400) ?? ""
+        }))
+        context.hasTaxBuildings = doc.itemTypes.building.some(b => b.system.constructed && b.system.taxRevenue?.trim())
        break
      case "inventory": {
        context.tab = context.tabs.inventory
@@ -90,6 +100,10 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
        context.equipments = doc.itemTypes.equipment
        break
      }
+      case "garrison":
+        context.tab = context.tabs.garrison
+        context.regiments = doc.itemTypes.regiment ?? []
+        break
    }
    return context
  }
@@ -129,4 +143,59 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
    if (!item) return
    await item.update({ "system.constructed": !item.system.constructed })
  }
+
+  static async #onCreateRegiment() {
+    await this.document.createEmbeddedDocuments("Item", [{
+      name: game.i18n.localize("OATHHAMMER.NewItem.Regiment"),
+      type: "regiment",
+    }])
+  }
+
+  static async #onCollectTaxes() {
+    const actor = this.document
+    // Only constructed buildings with a non-empty taxRevenue formula
+    const taxBuildings = actor.itemTypes.building.filter(
+      b => b.system.constructed && b.system.taxRevenue?.trim()
+    )
+    if (!taxBuildings.length) {
+      ui.notifications.warn(game.i18n.localize("OATHHAMMER.Settlement.NoTaxRevenue"))
+      return
+    }
+
+    // Roll each building's formula individually, sum totals
+    const rolls = []
+    const lines = []
+    let total = 0
+    for (const b of taxBuildings) {
+      const r = new Roll(b.system.taxRevenue.trim())
+      await r.evaluate()
+      rolls.push(r)
+      total += r.total
+      lines.push(`<li><strong>${b.name}</strong> — ${b.system.taxRevenue} = <em>${r.total} gp</em></li>`)
+    }
+
+    const content = `
+      <div class="oh-roll-card oh-weapon-card">
+        <div class="oh-roll-header">
+          <span class="oh-roll-title">🏛 ${actor.name}</span>
+          <span class="oh-roll-subtitle">${game.i18n.localize("OATHHAMMER.Settlement.CollectTaxes")}</span>
+        </div>
+        <div class="oh-roll-info">
+          <ul style="margin:4px 0;padding-left:1.2em;">${lines.join("")}</ul>
+        </div>
+        <div class="oh-roll-result">
+          <span class="oh-roll-successes">${total} gp</span>
+          <span class="oh-roll-verdict">${game.i18n.localize("OATHHAMMER.Settlement.TotalRevenue")}</span>
+        </div>
+      </div>`
+
+    const msgData = {
+      speaker: ChatMessage.getSpeaker({ actor }),
+      content,
+      rolls,
+      sound: CONFIG.sounds.dice,
+    }
+    ChatMessage.applyRollMode(msgData, game.settings.get("core", "rollMode"))
+    await ChatMessage.create(msgData)
+  }
 }
--- a/module/applications/sheets/skillnpc-sheet.mjs
+++ b/module/applications/sheets/skillnpc-sheet.mjs
@@ -0,0 +1,37 @@
+import OathHammerItemSheet from "./base-item-sheet.mjs"
+import { SYSTEM } from "../../config/system.mjs"
+
+export default class OathHammerSkillNPCSheet extends OathHammerItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["skillnpc"],
+    position: { width: 460 },
+    window: { contentClasses: ["skillnpc-content"] },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: { template: "systems/fvtt-oath-hammer/templates/item/skillnpc-sheet.hbs" },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    // Build dicePool selector (0–20)
+    context.dicePoolChoices = Object.fromEntries(
+      Array.from({ length: 21 }, (_, i) => [i, String(i)])
+    )
+    // Color choices (localized labels)
+    context.colorChoices = Object.fromEntries(
+      Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
+    )
+    // Skill reference choices (optional)
+    context.skillRefChoices = {
+      "": `— ${game.i18n.localize("OATHHAMMER.Label.None")} —`,
+      ...Object.fromEntries(
+        Object.entries(SYSTEM.SKILLS).map(([k, v]) => [k, game.i18n.localize(v.label)])
+      )
+    }
+    return context
+  }
+}