Initial import with skill sheet working

module/models/_module.mjs

@@ -0,0 +1,10 @@
+export { default as CthulhuEternalProtagonist } from "./protagonist.mjs"
+export { default as CthulhuEternalWeapon } from "./weapon.mjs"
+export { default as CthulhuEternalArcane } from "./arcane.mjs"
+export { default as CthulhuEternalSkill } from "./skill.mjs"
+export { default as CthulhuEternalArmor } from "./armor.mjs"
+export { default as CthulhuEternalInjury } from "./injury.mjs"
+export { default as CthulhuEternalMentalDisorder } from "./mentaldisorder.mjs"
+export { default as CthulhuEternalBond } from "./bond.mjs"
+export { default as CthulhuEternalGear } from "./gear.mjs"
+export { default as CthulhuEternalMotivation } from "./motivation.mjs"

module/models/arcane.mjs

@@ -0,0 +1,20 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class CthulhuEternalArcane 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 = ["CTHULHUETERNAL.Arcane"]
+}

module/models/armor.mjs

@@ -0,0 +1,18 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class CthulhuEternalArmor 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.settings = new fields.StringField({ required: true, initial: "common", 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 = ["CTHULHUETERNAL.Armor"]
+}

module/models/bond.mjs

@@ -0,0 +1,17 @@
+export default class CthulhuEternalBond 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.bondType = new fields.StringField({ required: true, initial: "individual", choices: SYSTEM.BOND_TYPE })
+    schema.value = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Bond"]
+
+}

module/models/gear.mjs

@@ -0,0 +1,19 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class CthulhuEternalEquipment 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.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Equipment"]
+
+}

module/models/injury.mjs

@@ -0,0 +1,15 @@
+export default class CthulhuEternalInjury 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 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Gift"]
+
+}

module/models/mentaldisorder.mjs

@@ -0,0 +1,15 @@
+export default class CthulhuEternalMentalDisorder 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 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.MentalDisorder"]
+
+}

module/models/motivation.mjs

@@ -0,0 +1,16 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class CthulhuEternalMotivation 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 })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Shield"]
+
+}

module/models/protagonist.mjs

@@ -0,0 +1,120 @@
+import { SYSTEM } from "../config/system.mjs"
+import CthulhuEternalRoll from "../documents/roll.mjs"
+
+export default class CthulhuEternalProtagonist 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 })
+
+    // Carac
+    const characteristicField = (label) => {
+      const schema = {
+        value: new fields.NumberField({ ...requiredInteger, initial: 3, min: 0 }),
+        percent: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 100 }),
+        attackMod: new fields.NumberField({ ...requiredInteger, initial: 0 }),
+        defenseMod: new fields.NumberField({ ...requiredInteger, initial: 0 })
+      }
+      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.hp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+    })
+
+    schema.perception = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      bonus: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+    schema.grit = new fields.SchemaField({
+      earned: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      current: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+    schema.luck = new fields.SchemaField({
+      earned: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      current: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+    schema.movement = new fields.SchemaField({
+      walk: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      jog: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      sprint: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      run: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      armorAdjust: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+    })
+    schema.biodata = new fields.SchemaField({
+      class: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      level: new fields.NumberField({ ...requiredInteger, initial: 1, min: 1 }),
+      mortal: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      alignment: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      age: new fields.NumberField({ ...requiredInteger, initial: 15, min: 6 }),
+      height: new fields.NumberField({ ...requiredInteger, initial: 170, min: 50 }),
+      eyes: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      hair: new fields.StringField({ required: true, nullable: false, initial: "" })
+    })
+    schema.developmentPoints = new fields.SchemaField({
+      total: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      remaining: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Protagonist"]
+
+  /**
+   * Rolls a dice for a character.
+   * @param {("save"|"resource|damage")} rollType The type of the roll.
+   * @param {number} rollTarget The target value for the roll. Which caracteristic or resource. If the roll is a damage roll, this is the id of the item.
+   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
+   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
+   */
+  async roll(rollType, rollTarget, rollAdvantage = "=") {
+    let rollValue
+    let opponentTarget
+    switch (rollType) {
+      default:
+        // Handle other cases or do nothing
+        break
+    }
+    await this._roll(rollType, rollTarget, rollValue, opponentTarget, rollAdvantage)
+  }
+
+  /**
+   * Rolls a dice for a character.
+   * @param {("save"|"resource|damage")} rollType The type of the roll.
+   * @param {number} rollTarget The target value for the roll. Which caracteristic or resource. If the roll is a damage roll, this is the id of the item.
+   * @param {number} rollValue The value of the roll. If the roll is a damage roll, this is the dice to roll.
+   * @param {Token} opponentTarget The target of the roll : used for save rolls to get the oppponent's malus.
+   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
+   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
+   */
+  async _roll(rollType, rollTarget, rollValue, opponentTarget = undefined, rollAdvantage = "=") {
+    const hasTarget = opponentTarget !== undefined
+    let roll = await CthulhuEternalRoll.prompt({
+      rollType,
+      rollTarget,
+      rollValue,
+      actorId: this.parent.id,
+      actorName: this.parent.name,
+      actorImage: this.parent.img,
+      hasTarget,
+      target: opponentTarget,
+      rollAdvantage,
+    })
+    if (!roll) return null
+
+    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+  }
+}

module/models/skill.mjs

@@ -0,0 +1,65 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class LethalFantasySkill 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.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.base = new fields.StringField({ required: true, initial: "WIS" })
+    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 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Skill"]
+
+  
+  prepareDerivedData() {
+    super.prepareDerivedData();
+    this.skillTotal = this.computeBase();
+  }
+
+  computeBase() {
+    let actor = this.parent?.actor;
+    if (!actor) {
+      return `${this.base  } + ${  String(this.bonus)}`;
+    }
+
+    // Split the base value per stat : WIS,DEX,STR,INT,CHA (example)
+    const base = this.base;
+    let baseSplit = base.split(",");
+    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];
+        const statValue = actor.system.characteristics[stat.toLowerCase()]?.value || 0;
+        if (statValue > maxStat) {
+          maxStat = statValue;
+        }
+      }
+      return maxStat;
+    } else {
+      // Split with +  calculate the total
+      baseSplit = base.split("+");
+      baseSplitLength = baseSplit.length;
+      if ( baseSplitLength > 0) {
+        let total = 0;
+        for (let i = 0; i < baseSplitLength; i++) {
+          const stat = baseSplit[i];
+          const statValue = actor.system.characteristics[stat.toLowerCase()]?.value || 0;
+          total += statValue;
+        }
+        return total
+     }
+    }
+    return `${this.base  } + ${  String(this.bonus)}`;
+  }
+}

module/models/weapon.mjs

@@ -0,0 +1,30 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class LethalFantasySkill 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.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.weaponType = new fields.StringField({ required: true, initial: "melee", choices: SYSTEM.WEAPON_TYPE })
+    schema.damage = new fields.StringField({required: true, initial: "1d6"})  
+    schema.baseRange = new fields.StringField({required: true, initial: ""})
+    schema.rangeDistance = 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.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Weapon"]
+
+  get weaponCategory() {
+    return game.i18n.localize(CATEGORY[this.category].label)
+  }
+}