Actor sheet

2025-03-05 22:15:32 +01:00
parent da9a69b916
commit 9013229c20
24 changed files with 958 additions and 682 deletions
--- a/module/documents/roll.mjs
+++ b/module/documents/roll.mjs
@@ -40,14 +40,6 @@ export default class FTLNomadRoll extends Roll {
    return this.options.help
  }

-  get gene() {
-    return this.options.gene
-  }
-
-  get modifier() {
-    return this.options.modifier
-  }
-
  get resultType() {
    return this.options.resultType
  }
@@ -68,41 +60,15 @@ export default class FTLNomadRoll extends Roll {
    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
+  static updateFullFormula(options) {
+    let fullFormula
+    if ( options.numericModifier >= 0) {
+      fullFormula = `${options.formula} + ${options.rollItem.value} + ${options.numericModifier}D` 
+    } else {
+      fullFormula = `${options.formula} + ${options.rollItem.value} - ${Math.abs(options.numericModifier)}D`
    }
-    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}%)`)
+    $('#roll-dialog-full-formula').text(fullFormula)
+    options.fullFormula = fullFormula
  }

  /**
@@ -120,84 +86,25 @@ export default class FTLNomadRoll extends 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
+    let formula = "2d6"

    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-ftl-nomad", "settings-era")
-        if (era !== options.rollItem.system.settings) {
-          ui.notifications.error(game.i18n.localize("FTLNOMAD.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("FTLNOMAD.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("FTLNOMAD.Notifications.NoWeaponSkill"))
-            return
-          }
-          options.initialScore = options.rollItem.system.computeScore()
-          console.log("WEAPON", skillName, era, options.rollItem)
-        }
+        let actor = game.actors.get(options.actorId)          
+        options.weapon = foundry.utils.duplicate(options.rollItem)
+        options.rollItem = actor.system.skills.combat
        break
      default:
-        options.initialScore = 50
        break
    }

@@ -209,37 +116,53 @@ export default class FTLNomadRoll extends Roll {
    })

    const choiceModifier = SYSTEM.MODIFIER_CHOICES
-    const choiceMultiplier = SYSTEM.MULTIPLIER_CHOICES
+    let choiceRangeModifier = {}
+    let rangeModifier = 0
+    if ( options.weapon) {
+      // Build the range modifiers
+      let range = SYSTEM.WEAPON_RANGE[options.weapon.system.rangeType]
+      for (let [key, value] of Object.entries(range.range)) {
+        choiceRangeModifier[key] = { label: `${key} (${value}D)`, value: value }
+        if (!rangeModifier && value) {
+          rangeModifier = value
+        } 
+      }
+    }

-    let modifier = "+0"
-    let multiplier = "5"
+    let modifier = "0"
+    options.numericModifier = rangeModifier
+    let fullFormula = `${formula} + ${options.rollItem.value}`
+    if (options.isEncumbered) {
+      options.numericModifier += -1
+      fullFormula += ` - ${options.numericModifier}D`
+    } else {
+      options.numericModifier += 0
+      fullFormula += ` + ${options.numericModifier}D`
+    }
+    options.fullFormula = fullFormula
+    options.formula = formula

    let dialogContext = {
+      actorId: options.actorId,
+      actorName: options.actorName,
      rollType: options.rollType,
      rollItem: foundry.utils.duplicate(options.rollItem), // Object only, no class
+      fullFormula,
      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,
+      isEncumbered: options.isEncumbered,
+      talents: options.talents,
      rollModes,
      fieldRollMode,
      choiceModifier,
-      choiceMultiplier,
+      choiceRangeModifier,
+      rangeModifier,
      formula,
      hasTarget: options.hasTarget,
-      hasModifier,
-      hasMultiplier,
      modifier,
-      multiplier
    }
    const content = await renderTemplate("systems/fvtt-ftl-nomad/templates/roll-dialog.hbs", dialogContext)

-    const title = CthulhuEternalRoll.createTitle(options.rollType, options.rollTarget)
+    const title = FTLNomadRoll.createTitle(options.rollType, options.rollTarget)
    const label = game.i18n.localize("FTLNOMAD.Roll.roll")
    const rollContext = await foundry.applications.api.DialogV2.wait({
      window: { title: title },
@@ -258,24 +181,27 @@ export default class FTLNomadRoll extends Roll {
        },
      ],
      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)
+        $(".roll-skill-modifier").change(event => {
+          options.numericModifier += Number(event.target.value)
+          FTLNomadRoll.updateFullFormula(options)
+        })
+        $(".roll-skill-range-modifier").change(event => {
+          options.numericModifier += Number(event.target.value)
+          FTLNomadRoll.updateFullFormula(options)
+        })
+        $(".select-combat-option").change(event => {
+          console.log(event)
+          let field = $(event.target).data("field")
+          let modifier = SYSTEM.ATTACK_MODIFIERS[field]
+          if ( event.target.checked) {
+            options.numericModifier += modifier
+          } else {
+            options.numericModifier -= modifier
+          }
+          FTLNomadRoll.updateFullFormula(options)
        })
      }
    })
@@ -285,25 +211,19 @@ export default class FTLNomadRoll extends Roll {

    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)
-    }
+    rollData.targetScore = 8

    if (Hooks.call("fvtt-ftl-nomad.preRoll", options, rollData) === false) return
+    
+    let diceFormula = `${2+Math.abs(options.numericModifier)}D6`
+    if ( options.numericModifier > 0 ) {
+      diceFormula += `kh2 + ${options.rollItem.value}`
+    } else {
+      diceFormula += `kl2 + ${options.rollItem.value}`
+    }

-    const roll = new this(formula, options.data, rollData)
+    const roll = new this(diceFormula, options.data, rollData)
    await roll.evaluate()

    roll.displayRollResult(roll, options, rollData)
@@ -317,34 +237,15 @@ export default class FTLNomadRoll extends Roll {

    // 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) {
+    if (this.total >= 8) {
      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.isSuccess = resultType === "success" 
+    this.options.isFailure = resultType === "failure" 
+    this.options.isEncumbered = rollData.isEncumbered
    this.options.rollData = foundry.utils.duplicate(rollData)
  }

@@ -361,10 +262,6 @@ export default class FTLNomadRoll extends Roll {
        return `${game.i18n.localize("FTLNOMAD.Label.titleSkill")}`
      case "weapon":
        return `${game.i18n.localize("FTLNOMAD.Label.titleWeapon")}`
-      case "char":
-        return `${game.i18n.localize("FTLNOMAD.Label.titleCharacteristic")}`
-      case "san":
-        return `${game.i18n.localize("FTLNOMAD.Label.titleSAN")}`
      default:
        return game.i18n.localize("FTLNOMAD.Label.titleStandard")
    }
@@ -407,6 +304,8 @@ export default class FTLNomadRoll extends Roll {
    cardData.diceTotal = this.dice.reduce((t, d) => t + d.total, 0)
    cardData.isGM = game.user.isGM
    cardData.formula = this.formula
+    cardData.fullFormula = this.options.fullFormula
+    cardData.numericModifier = this.options.numericModifier
    cardData.total = this.total
    cardData.actorId = this.actorId
    cardData.actingCharName = this.actorName
@@ -418,11 +317,7 @@ export default class FTLNomadRoll extends Roll {
    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.isEncumbered = this.isEncumbered

    cardData.cssClass = cardData.css.join(" ")
    cardData.tooltip = isPrivate ? "" : await this.getTooltip()