First adaptation pass

2025-11-06 00:01:59 +01:00
parent 5b1fd847c2
commit 6b883f8126
112 changed files with 44142 additions and 953 deletions
@@ -7,8 +7,21 @@ export default class PrismRPGArmor extends foundry.abstract.TypeDataModel {

    schema.description = new fields.HTMLField({ required: true, textSearch: true })
    schema.armorType = new fields.StringField({ required: true, initial: "light", choices: SYSTEM.ARMOR_TYPE })
+
+    // MRR - Movement Rating Reduction (reduced by Vigor sub-attribute)
+    schema.mrr = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0, label: "Movement Rating Reduction" })
+
+    // Armor Passive - the passive ability of this armor piece
+    schema.passive = new fields.StringField({ required: false, initial: "", label: "Armor Passive" })
+    schema.passiveDescription = new fields.HTMLField({ required: false, textSearch: true, label: "Passive Description" })
+
+    // Armor Augment - the Withstand action effect (requires augment from class feature)
+    schema.augment = new fields.StringField({ required: false, initial: "", label: "Armor Augment" })
+    schema.augmentDescription = new fields.HTMLField({ required: false, textSearch: true, label: "Augment Description" })
+
+    // Legacy fields for compatibility
    schema.defense = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: -50 })
-    schema.maximumMovement = new fields.StringField({ ...requiredInteger, required: true, initial: "" })
+    schema.maximumMovement = new fields.StringField({ required: false, initial: "" })
    schema.hp = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
    schema.damageReduction = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })

@@ -18,7 +31,7 @@ export default class PrismRPGArmor extends foundry.abstract.TypeDataModel {

    schema.cost = new fields.NumberField({ required: true, initial: 0, min: 0 })
    schema.money = new fields.StringField({ required: true, initial: "tinbit", choices: SYSTEM.MONEY })
-    
+
    return schema
  }

@@ -168,6 +168,21 @@ export default class PrismRPGCharacter extends foundry.abstract.TypeDataModel {
      }, {}),
    )

+    // Core Skill system (Prism RPG)
+    schema.coreSkill = new fields.SchemaField({
+      skill: new fields.StringField({
+        required: true,
+        initial: "",
+        choices: Object.keys(SYSTEM.CORE_SKILLS || {}),
+        label: "Selected Core Skill"
+      }),
+      attributeChoice: new fields.StringField({
+        required: true,
+        initial: "",
+        label: "Attribute Choice for +2 Bonus"
+      })
+    })
+
    return schema
  }

@@ -1,4 +1,5 @@
 import { SYSTEM } from "../config/system.mjs"
+
 export default class PrismRPGMiracle extends foundry.abstract.TypeDataModel {
  static defineSchema() {
    const fields = foundry.data.fields
@@ -11,30 +12,120 @@ export default class PrismRPGMiracle extends foundry.abstract.TypeDataModel {
      initial: "",
      textSearch: true,
    })
+
+    // Miracle level (1-7+)
    schema.level = new fields.NumberField({
      ...requiredInteger,
      initial: 1,
      min: 1,
      max: 25,
    })
-    schema.components = new fields.SchemaField({
-      verbal: new fields.BooleanField(),
-      somatic: new fields.BooleanField(),
-      material: new fields.BooleanField(),
-      catalyst: new fields.BooleanField(),
-      religious: new fields.BooleanField()
-    })
-    schema.prayerTime = new fields.StringField({ required: true, initial: "" })
-    schema.miracleRange = new fields.StringField({ required: true, initial: "" })
-    schema.areaAffected = new fields.StringField({ required: true, initial: "" })
-    schema.duration = new fields.StringField({ required: true, initial: "" })
-    schema.savingThrow = new fields.StringField({ required: true, initial: "" })
-    schema.materialComponent = new fields.StringField({ required: true, initial: "" })
-    schema.catalyst = new fields.StringField({ required: true, initial: "" })
-    schema.miracleType = new fields.StringField({ required: true, initial: "combat", choices: SYSTEM.MIRACLE_TYPES })

-    schema.attackRoll = new fields.StringField({ required: true, initial: "" })
-    schema.powerRoll = new fields.StringField({ required: true, initial: "" })
+    // Miracle type
+    schema.miracleType = new fields.StringField({
+      required: true,
+      initial: "combat",
+      choices: SYSTEM.MIRACLE_TYPES
+    })
+
+    // APC to pray
+    schema.apc = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 1,
+      min: 0,
+      label: "Action Point Cost"
+    })
+
+    // Faith cost (if applicable in Prism RPG)
+    schema.faithCost = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      min: 0,
+      label: "Faith Cost"
+    })
+
+    // Divine favor required
+    schema.divineFavor = new fields.StringField({
+      required: true,
+      initial: "",
+      label: "Divine Favor"
+    })
+
+    // Components (Miracles have 'religious' component)
+    schema.components = new fields.SchemaField({
+      verbal: new fields.BooleanField({ initial: false }),
+      somatic: new fields.BooleanField({ initial: false }),
+      material: new fields.BooleanField({ initial: false }),
+      catalyst: new fields.BooleanField({ initial: false }),
+      religious: new fields.BooleanField({ initial: true })
+    })
+
+    schema.materialComponent = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.catalyst = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    // Prayer parameters
+    schema.prayerTime = new fields.StringField({
+      required: true,
+      initial: "1 action"
+    })
+
+    schema.miracleRange = new fields.StringField({
+      required: true,
+      initial: "Touch"
+    })
+
+    schema.areaAffected = new fields.StringField({
+      required: true,
+      initial: "Single target"
+    })
+
+    schema.duration = new fields.StringField({
+      required: true,
+      initial: "Instantaneous"
+    })
+
+    schema.savingThrow = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    // Attack and power
+    schema.attackRoll = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.powerRoll = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    // Keywords
+    schema.keywords = new fields.ArrayField(
+      new fields.StringField()
+    )
+
+    // Miracle augment (if applicable)
+    schema.augment = new fields.StringField({
+      required: true,
+      initial: "",
+      label: "Miracle Augment"
+    })
+
+    schema.augmentDescription = new fields.HTMLField({
+      required: true,
+      initial: "",
+      label: "Augment Description"
+    })

    return schema
  }
@@ -1,4 +1,5 @@
 import { SYSTEM } from "../config/system.mjs"
+
 export default class PrismRPGShield extends foundry.abstract.TypeDataModel {
  static defineSchema() {
    const fields = foundry.data.fields
@@ -6,14 +7,81 @@ export default class PrismRPGShield extends foundry.abstract.TypeDataModel {
    const requiredInteger = { required: true, nullable: false, integer: true }

    schema.description = new fields.HTMLField({ required: true, textSearch: true })
-    schema.defense = new fields.StringField({required: true, initial: "d4", choices: SYSTEM.SHIELD_DEFENSE_DICE})
-    schema.movementreduction = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
-    schema.hascover = new fields.BooleanField({ required: true, initial: false })
+
+    // Prism RPG shield properties
+    schema.shieldType = new fields.StringField({
+      required: true,
+      initial: "buckler",
+      choices: Object.keys(SYSTEM.SHIELD_TYPE || {})
+    })
+
+    // APC (Action Point Cost) for Block action
+    schema.apc = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 1,
+      min: 1,
+      max: 4,
+      label: "Block APC"
+    })
+
+    // Shield Rating (SR) - damage prevention dice (e.g., "1d4", "1d8", "1d12", "3d6")
+    schema.sr = new fields.StringField({
+      required: true,
+      initial: "1d4",
+      label: "Shield Rating (SR)"
+    })
+
+    // Block Augment - passive ability when using Block action
+    schema.blockAugment = new fields.StringField({
+      required: true,
+      initial: "",
+      label: "Block Augment"
+    })
+
+    schema.blockAugmentDescription = new fields.HTMLField({
+      required: true,
+      initial: "",
+      label: "Block Augment Description"
+    })
+
+    // Augment effects (for equipment progression)
+    schema.augment = new fields.StringField({
+      required: true,
+      initial: "",
+      label: "Shield Augment"
+    })
+
+    schema.augmentDescription = new fields.HTMLField({
+      required: true,
+      initial: "",
+      label: "Augment Description"
+    })
+
+    // Legacy properties (kept for backward compatibility)
+    schema.defense = new fields.StringField({
+      required: true,
+      initial: "d4",
+      choices: SYSTEM.SHIELD_DEFENSE_DICE
+    })
+
+    schema.movementreduction = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      min: 0
+    })
+
+    schema.hascover = new fields.BooleanField({
+      required: true,
+      initial: false
+    })

    schema.standing = new fields.SchemaField({
      min: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
      max: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
    })
+
    schema.crouching = new fields.SchemaField({
      min: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
      max: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
@@ -24,6 +92,7 @@ export default class PrismRPGShield extends foundry.abstract.TypeDataModel {
      slashing: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
      piercing: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
    })
+
    schema.autodestruction = new fields.SchemaField({
      bashing: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
      slashing: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
@@ -40,5 +109,4 @@ export default class PrismRPGShield extends foundry.abstract.TypeDataModel {

  /** @override */
  static LOCALIZATION_PREFIXES = ["PRISMRPG.Shield"]
-
 }
@@ -1,29 +1,75 @@
 import { SYSTEM } from "../config/system.mjs"
-import { CATEGORY } from "../config/skill.mjs"
+
+/**
+ * Core Skill data model for Prism RPG
+ *
+ * Core Skills are skills in which the character is particularly proficient.
+ * - Basic skill checks: +5 modifier
+ * - Advanced skill checks: Only accessible with Core Skill
+ * - Core Skill Class: Gives access to a class based on archetype
+ * - Attribute Bonus: +2 to one of 3 associated attributes
+ */
 export default class PrismRPGSkill 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 })
-    schema.category = new fields.StringField({ required: true, initial: "layperson", choices: SYSTEM.SKILL_CATEGORY })
-    schema.base = new fields.StringField({ required: true, initial: "WIS" })
-    schema.bonus = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
-    
-    schema.classesCost = new fields.SchemaField(
-      Object.values(SYSTEM.CHAR_CLASSES_DEFINES).reduce((obj, pcClass) => {
-        obj[pcClass.id] = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
-        return obj
-      }, {}),
-    )    
-    schema.cost = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.description = new fields.HTMLField({
+      required: true,
+      textSearch: true,
+      initial: ""
+    })

-    schema.weaponClass = new fields.StringField({ required: true, initial: "shortblade", choices: SYSTEM.WEAPON_CLASS })
-    schema.weaponBonus = new fields.SchemaField({
-      attack: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      defense: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      damage: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    // Core Skill type (from the 18 available Core Skills)
+    schema.coreSkill = new fields.StringField({
+      required: true,
+      initial: "acrobatics",
+      choices: Object.keys(SYSTEM.CORE_SKILLS || {}),
+      label: "Core Skill"
+    })
+
+    // Is this the character's chosen Core Skill?
+    schema.isCoreSkill = new fields.BooleanField({
+      required: true,
+      initial: false,
+      label: "Is Core Skill"
+    })
+
+    // If Core Skill, which attribute receives the +2 bonus?
+    schema.attributeBonus = new fields.StringField({
+      required: true,
+      initial: "",
+      label: "Attribute Bonus"
+    })
+
+    // Skill modifier (includes Core Skill bonus if applicable)
+    schema.modifier = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      label: "Skill Modifier"
+    })
+
+    // Can perform advanced checks
+    schema.canAdvancedCheck = new fields.BooleanField({
+      required: true,
+      initial: false,
+      label: "Can Perform Advanced Checks"
+    })
+
+    // Associated Core Skill Class (if any)
+    schema.coreSkillClass = new fields.StringField({
+      required: true,
+      initial: "",
+      label: "Core Skill Class"
+    })
+
+    // Notes/Custom description
+    schema.notes = new fields.HTMLField({
+      required: true,
+      initial: "",
+      label: "Notes"
    })

    return schema
@@ -32,83 +78,57 @@ export default class PrismRPGSkill extends foundry.abstract.TypeDataModel {
  /** @override */
  static LOCALIZATION_PREFIXES = ["PRISMRPG.Skill"]

-  get skillCategory() {
-    return game.i18n.localize(CATEGORY[this.category].label)
+  /**
+   * Get the Core Skill definition from SYSTEM
+   */
+  get coreSkillDefinition() {
+    return SYSTEM.CORE_SKILLS?.[this.coreSkill] || null
  }

-  validate(options) {
-    let isError = super.validate(options)
-    let bonus = this._source.weaponBonus.attack + this._source.weaponBonus.defense + this._source.weaponBonus.damage
-    if (bonus > Math.floor(this._source.skillTotal / 10)) {
-      ui.notifications.error(game.i18n.localize("PRISMRPG.Skill.error.weaponBonus"))
-      isError = true
-    }
-    return isError
+  /**
+   * Get the localized Core Skill name
+   */
+  get coreSkillLabel() {
+    const definition = this.coreSkillDefinition
+    return definition ? game.i18n.localize(definition.label) : this.coreSkill
  }

+  /**
+   * Get the available attribute choices for this Core Skill
+   */
+  get attributeChoices() {
+    const definition = this.coreSkillDefinition
+    return definition?.attributeChoices || []
+  }
+
+  /**
+   * Prepare derived data
+   */
  prepareDerivedData() {
-    super.prepareDerivedData();
-    this.skillTotal = this.computeBase();
-    if (this.category === "weapon") {
-      this.totalBonus = this.weaponBonus.attack + this.weaponBonus.defense + this.weaponBonus.damage;
-      if (Number(this.skillTotal)) {
-        this.availableBonus = Math.max(Math.floor(this.skillTotal / 10) - 1, 0)
-      } else {
-        this.availableBonus = "N/A"
-      }
+    super.prepareDerivedData()
+
+    // If this is the character's Core Skill, apply bonuses
+    if (this.isCoreSkill) {
+      this.modifier = SYSTEM.CORE_SKILL_BONUS?.basic || 5
+      this.canAdvancedCheck = true
+    } else {
+      this.modifier = 0
+      this.canAdvancedCheck = false
    }
  }

-  computeBase() {
-    let actor = this.parent?.actor;
-    if (!actor) {
-      return `${this.base} + ${String(this.bonus)}`;
-    }
+  /**
+   * Calculate skill check bonus
+   * @param {string} attributeKey The attribute to use (str, dex, con, int, wis, cha)
+   * @returns {number} Total skill check bonus
+   */
+  getSkillCheckBonus(attributeKey) {
+    let actor = this.parent?.actor
+    if (!actor) return this.modifier

-    if (this.base === "N/A" || this.base === "None") {
-      return this.bonus
-    }
+    const attribute = actor.system.characteristics?.[attributeKey]
+    const attributeMod = attribute?.mod || 0

-    // Split the base value per stat : WIS,DEX,STR,INT,CHA (example)
-    let base = this.base;
-    // Fix errors in the base value
-    base.replace("CHARISMA", "CHA");
-
-    if (base.match(/OR/)) {
-      let baseSplit = base.split("OR");
-      let baseSplitLength = baseSplit.length;
-      if (baseSplitLength > 0) {
-        // Select the max stat value from the parent actor
-        let maxStat = 0;
-        for (let i = 0; i < baseSplitLength; i++) {
-          const stat = baseSplit[i].trim();
-          const statValue = actor.system.characteristics[stat.toLowerCase()]?.value || 0;
-          if (statValue > maxStat) {
-            maxStat = statValue;
-          }
-        }
-        return maxStat + this.bonus
-      }
-    } else {
-      if (base.match(/\+/)) {
-        // Split with +  calculate the total
-        let baseSplit = base.split("+");
-        let baseSplitLength = baseSplit.length;
-        if (baseSplitLength > 0) {
-          let total = 0;
-          for (let i = 0; i < baseSplitLength; i++) {
-            const stat = baseSplit[i].trim();
-            const statValue = actor.system.characteristics[stat.toLowerCase()]?.value || 0;
-            total += statValue;
-          }
-          return total + this.bonus
-        }
-      } else {
-        // Single stat
-        const statValue = actor.system.characteristics[base.trim().toLowerCase()]?.value || 0;
-        return statValue + this.bonus
-      }
-    }
-    return `${this.base} + ${String(this.bonus)}`;
+    return attributeMod + this.modifier
  }
 }
@@ -1,4 +1,5 @@
 import { SYSTEM } from "../config/system.mjs"
+
 export default class PrismRPGSpell extends foundry.abstract.TypeDataModel {
  static defineSchema() {
    const fields = foundry.data.fields
@@ -11,6 +12,8 @@ export default class PrismRPGSpell extends foundry.abstract.TypeDataModel {
      initial: "",
      textSearch: true,
    })
+
+    // Spell level (1-7+)
    schema.level = new fields.NumberField({
      ...requiredInteger,
      initial: 1,
@@ -18,28 +21,146 @@ export default class PrismRPGSpell extends foundry.abstract.TypeDataModel {
      max: 25,
    })

-    schema.cost = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
-    schema.memorized = new fields.BooleanField({ required: true, initial: false })
-    
-    schema.components = new fields.SchemaField({
-      verbal: new fields.BooleanField(),
-      somatic: new fields.BooleanField(),      
-      catalyst: new fields.BooleanField(),
-      material: new fields.BooleanField(),
+    // Mana cost - base cost of the spell
+    schema.manaCost = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 1,
+      min: 0,
+      label: "Mana Cost"
+    })
+
+    // Mana upkeep cost (for sustained spells)
+    schema.manaUpkeep = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      min: 0,
+      label: "Mana Upkeep"
+    })
+
+    // APC to cast
+    schema.apc = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 1,
+      min: 0,
+      label: "Action Point Cost"
+    })
+
+    // Color/Hue of the spell (from the Prism)
+    schema.color = new fields.StringField({
+      required: true,
+      initial: "violet",
+      choices: Object.keys(SYSTEM.SPELL_COLORS || {}),
+      label: "Spell Color"
+    })
+
+    // Color effect description
+    schema.colorEffect = new fields.HTMLField({
+      required: true,
+      initial: "",
+      label: "Color Effect"
+    })
+
+    // Spell Ascension - can be upcast
+    schema.canAscend = new fields.BooleanField({
+      required: true,
+      initial: true,
+      label: "Can Ascend"
+    })
+
+    schema.ascensionEffect = new fields.HTMLField({
+      required: true,
+      initial: "",
+      label: "Ascension Effect"
+    })
+
+    // Memorized (prepared)
+    schema.memorized = new fields.BooleanField({
+      required: true,
+      initial: false
+    })
+
+    // Components
+    schema.components = new fields.SchemaField({
+      verbal: new fields.BooleanField({ initial: false }),
+      somatic: new fields.BooleanField({ initial: false }),
+      catalyst: new fields.BooleanField({ initial: false }),
+      material: new fields.BooleanField({ initial: false }),
+    })
+
+    schema.materialComponent = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.catalyst = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    // Casting parameters
+    schema.castingTime = new fields.StringField({
+      required: true,
+      initial: "1 action"
+    })
+
+    schema.spellRange = new fields.StringField({
+      required: true,
+      initial: "30ft"
+    })
+
+    schema.areaAffected = new fields.StringField({
+      required: true,
+      initial: "Single target"
+    })
+
+    schema.duration = new fields.StringField({
+      required: true,
+      initial: "Instantaneous"
+    })
+
+    schema.savingThrow = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    // Attack and damage
+    schema.attackRoll = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.powerRoll = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    // Keywords
+    schema.keywords = new fields.ArrayField(
+      new fields.StringField()
+    )
+
+    // Legacy fields
+    schema.cost = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      min: 0
+    })
+
+    schema.extraAetherPoints = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.criticalType = new fields.StringField({
+      required: true,
+      initial: "electric",
+      choices: SYSTEM.SPELL_CRITICAL
    })
-    schema.castingTime = new fields.StringField({ required: true, initial: "" })
-    schema.spellRange = new fields.StringField({ required: true, initial: "" })
-    schema.areaAffected = new fields.StringField({ required: true, initial: "" })
-    schema.duration = new fields.StringField({ required: true, initial: "" })
-    schema.savingThrow = new fields.StringField({ required: true, initial: "" })
-    schema.extraAetherPoints = new fields.StringField({ required: true, initial: "" })
-    schema.materialComponent = new fields.StringField({ required: true, initial: "" })
-    schema.catalyst = new fields.StringField({ required: true, initial: "" })
-    schema.criticalType = new fields.StringField({ required: true, initial: "electric", choices : SYSTEM.SPELL_CRITICAL })

-    schema.attackRoll = new fields.StringField({ required: true, initial: "" })
-    schema.powerRoll = new fields.StringField({ required: true, initial: "" })
-  
    return schema
  }

@@ -1,47 +1,139 @@
 import { SYSTEM } from "../config/system.mjs"

-export default class PrismRPGSkill extends foundry.abstract.TypeDataModel {
+export default class PrismRPGWeapon 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 })
-    schema.weaponType = new fields.StringField({ required: true, initial: "melee", choices: SYSTEM.WEAPON_TYPE })
-    schema.weaponClass = new fields.StringField({ required: true, initial: "shortblade", choices: SYSTEM.WEAPON_CLASS })

+    // Prism RPG weapon properties
+    schema.weaponType = new fields.StringField({
+      required: true,
+      initial: "light",
+      choices: Object.keys(SYSTEM.WEAPON_TYPE || {})
+    })
+
+    schema.weaponGroup = new fields.StringField({
+      required: true,
+      initial: "longsword",
+      choices: Object.keys(SYSTEM.WEAPON_GROUP || {})
+    })
+
+    // APC (Action Point Cost) - determined by weapon type
+    schema.apc = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 1,
+      min: 0,
+      max: 3
+    })
+
+    // Damage dice (e.g., "1d8", "2d6", "1d12")
+    schema.damage = new fields.StringField({
+      required: true,
+      initial: "1d8"
+    })
+
+    // Damage type(s)
    schema.damageType = new fields.SchemaField({
-      typeP: new fields.BooleanField(),
-      typeB: new fields.BooleanField(),
-      typeS: new fields.BooleanField()
-    })
-    schema.damage = new fields.SchemaField({
-      damageS: new fields.StringField({required: true, initial: ""}),
-      damageM: new fields.StringField({required: true, initial: ""})
-    })
-    schema.applyStrengthDamageBonus = new fields.BooleanField({ required: true, initial: true })
-
-    schema.hands = new fields.StringField({ required: true, initial: "1", choices: {"1": "1", "2": "2"} })
-    schema.isAgile = new fields.BooleanField({ required: true, initial: false })
-
-    schema.defenseMax = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
-    schema.secondsToAttack = new fields.StringField({required: true, initial: ""})
-    schema.combatProgressionDice = new fields.StringField({required: true, initial: "d4", choices: SYSTEM.COMBAT_PROGRESSION_DICE})
-
-    schema.speed = new fields.SchemaField({
-      simpleAim: new fields.StringField({required: true, initial: ""}),
-      carefulAim: new fields.StringField({required: true, initial: ""}),
-      focusedAim: new fields.StringField({required: true, initial: ""})
+      piercing: new fields.BooleanField({ initial: false }),
+      bludgeoning: new fields.BooleanField({ initial: false }),
+      slashing: new fields.BooleanField({ initial: false })
    })

-    schema.defense = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
-    schema.weaponRange = new fields.SchemaField({
-      pointBlank: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      short: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      medium: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      long: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      extreme: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      outOfSkill: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    // Group passive (inherited from weapon group)
+    schema.groupPassive = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.groupPassiveDescription = new fields.HTMLField({
+      required: true,
+      initial: ""
+    })
+
+    // Weapon-specific passive ability
+    schema.passive = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.passiveDescription = new fields.HTMLField({
+      required: true,
+      initial: ""
+    })
+
+    // Maneuver(s) available with this weapon
+    schema.maneuver = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.maneuverDescription = new fields.HTMLField({
+      required: true,
+      initial: ""
+    })
+
+    // Augment effects (for equipment progression)
+    schema.augment = new fields.StringField({
+      required: true,
+      initial: ""
+    })
+
+    schema.augmentDescription = new fields.HTMLField({
+      required: true,
+      initial: ""
+    })
+
+    // Projectile-specific properties
+    schema.isProjectile = new fields.BooleanField({
+      required: true,
+      initial: false
+    })
+
+    schema.range = new fields.SchemaField({
+      short: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      medium: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      long: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+
+    schema.reloadAPC = new fields.NumberField({
+      ...requiredInteger,
+      initial: 0,
+      min: 0
+    })
+
+    // Legacy properties (kept for backward compatibility)
+    schema.hands = new fields.StringField({
+      required: true,
+      initial: "1",
+      choices: { "1": "1", "2": "2" }
+    })
+
+    schema.isAgile = new fields.BooleanField({
+      required: true,
+      initial: false
+    })
+
+    schema.applyStrengthDamageBonus = new fields.BooleanField({
+      required: true,
+      initial: true
+    })
+
+    schema.defenseMax = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      min: 0
+    })
+
+    schema.defense = new fields.NumberField({
+      ...requiredInteger,
+      required: true,
+      initial: 0,
+      min: 0
    })

    schema.bonuses = new fields.SchemaField({
@@ -60,9 +152,4 @@ export default class PrismRPGSkill extends foundry.abstract.TypeDataModel {

  /** @override */
  static LOCALIZATION_PREFIXES = ["PRISMRPG.Weapon"]
-
-  get weaponCategory() {
-    return game.i18n.localize(CATEGORY[this.weaponType].label)
-  }
-
 }