Minor fixes

images/.directory

@@ -0,0 +1,4 @@
+[Dolphin]
+Timestamp=2022,9,12,23,3,3.4699999999999998
+Version=4
+VisibleRoles=Details_text,Details_size,Details_modificationtime,Details_creationtime,CustomizedDetails

images/icons/feats/.directory

@@ -1,6 +1,5 @@
 [Dolphin]
 SortOrder=1
-Timestamp=2022,7,27,18,56,49.607
+Timestamp=2022,9,12,23,4,32.409
 Version=4
-ViewMode=1
 VisibleRoles=Details_text,Details_size,Details_modificationtime,Details_creationtime,CustomizedDetails

modules/crucible-actor-sheet.js

@@ -158,6 +158,9 @@ export class CrucibleActorSheet extends ActorSheet {
     html.find('.roll-shield-die').click((event) => {
       this.actor.rollShieldDie()
     });
+    html.find('.roll-target-die').click((event) => {
+      this.actor.rollDefenseRanged()
+    });
     
     html.find('.roll-save').click((event) => {
       const saveKey = $(event.currentTarget).data("save-key")

modules/crucible-actor.js

@@ -63,6 +63,7 @@ export class CrucibleActor extends Actor {
 
   /* -------------------------------------------- */
   computeHitPoints() {
+    if (this.type == "character") {
       let hp = duplicate(this.system.secondary.hp)
       let max = (this.system.abilities.str.value + this.system.abilities.con.value) * 6
       if (max != hp.max || hp.value > max) {
@@ -71,8 +72,10 @@ export class CrucibleActor extends Actor {
         this.update({ 'system.secondary.hp': hp })
       }
     }
+  }
   /* -------------------------------------------- */
   computeEffortPoints() {
+    if (this.type == "character") {
       let effort = duplicate(this.system.secondary.effort)
       let max = (this.system.abilities.con.value + this.system.abilities.int.value) * 6
       if (max != effort.max || effort.value > max) {
@@ -81,6 +84,7 @@ export class CrucibleActor extends Actor {
         this.update({ 'system.secondary.effort': effort })
       }
     }
+  }
 
   /* -------------------------------------------- */
   prepareDerivedData() {
@@ -329,21 +333,21 @@ export class CrucibleActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  async rollArmor( rollData) {
+  async rollArmor(rollData) {
     let armor = this.getEquippedArmor()
     if (armor) {
 
     }
-    return { armor: "none"}
+    return { armor: "none" }
   }
 
   /* -------------------------------------------- */
-  async incDecHP( formula ) {
-    let dmgRoll = new Roll(formula).roll( {async: false})
+  async incDecHP(formula) {
+    let dmgRoll = new Roll(formula).roll({ async: false })
     await CrucibleUtility.showDiceSoNice(dmgRoll, game.settings.get("core", "rollMode"))
     let hp = duplicate(this.system.secondary.hp)
     hp.value = Number(hp.value) + Number(dmgRoll.total)
-    this.update( {'system.secondary.hp': hp })
+    this.update({ 'system.secondary.hp': hp })
     return Number(dmgRoll.total)
   }
 
@@ -501,38 +505,38 @@ export class CrucibleActor extends Actor {
 
   /* -------------------------------------------- */
   isForcedAdvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.advantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.advantage)
   }
   isForcedDisadvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.disadvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.disadvantage)
   }
   isForcedRollAdvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.rolladvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.rolladvantage)
   }
   isForcedRollDisadvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.rolldisadvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.rolldisadvantage)
   }
   isNoAdvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.noadvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.noadvantage)
   }
   isNoAction() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.noaction)
+    return this.items.find(cond => cond.type == "condition" && cond.system.noaction)
   }
   isAttackDisadvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.attackdisadvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.attackdisadvantage)
   }
   isDefenseDisadvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.defensedisadvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.defensedisadvantage)
   }
   isAttackerAdvantage() {
-    return this.items.find(cond => cond.type =="condition" && cond.system.targetadvantage)
+    return this.items.find(cond => cond.type == "condition" && cond.system.targetadvantage)
   }
 
   /* -------------------------------------------- */
   getCommonRollData(abilityKey = undefined) {
     let noAction = this.isNoAction()
-    if ( noAction)  {
-      ui.notifications.warn("You can't do any actions du to the condition : " + noAction.name )
+    if (noAction) {
+      ui.notifications.warn("You can't do any actions du to the condition : " + noAction.name)
       return
     }
 
@@ -555,24 +559,24 @@ export class CrucibleActor extends Actor {
     rollData.forceRollAdvantage = this.isForcedRollAdvantage()
     rollData.forceRollDisadvantage = this.isForcedRollDisadvantage()
     rollData.noAdvantage = this.isNoAdvantage()
-    if ( rollData.defenderTokenId) {
+    if (rollData.defenderTokenId) {
       let defenderToken = game.canvas.tokens.get(rollData.defenderTokenId)
       let defender = defenderToken.actor
 
       // Distance management
       let token = this.token
-      if ( !token) {
-        let tokens =this.getActiveTokens()
+      if (!token) {
+        let tokens = this.getActiveTokens()
         token = tokens[0]
       }
-      if ( token ) {
+      if (token) {
         const ray = new Ray(token.object?.center || token.center, defenderToken.center)
-        rollData.tokensDistance = canvas.grid.measureDistances([{ray}], {gridSpaces:false})[0] / canvas.grid.grid.options.dimensions.distance
+        rollData.tokensDistance = canvas.grid.measureDistances([{ ray }], { gridSpaces: false })[0] / canvas.grid.grid.options.dimensions.distance
       } else {
         ui.notifications.info("No token connected to this actor, unable to compute distance.")
         return
       }
-      if (defender ) {
+      if (defender) {
         rollData.forceAdvantage = defender.isAttackerAdvantage()
         rollData.advantageFromTarget = true
       }
@@ -637,7 +641,7 @@ export class CrucibleActor extends Actor {
         rollData.skill = skill
         rollData.weapon = weapon
         rollData.img = weapon.img
-        if ( !rollData.forceDisadvantage) { // This is an attack, check if disadvantaged
+        if (!rollData.forceDisadvantage) { // This is an attack, check if disadvantaged
           rollData.forceDisadvantage = this.isAttackDisadvantage()
         }
         /*if (rollData.weapon.system.isranged && rollData.tokensDistance > CrucibleUtility.getWeaponMaxRange(rollData.weapon) ) {
@@ -669,7 +673,7 @@ export class CrucibleActor extends Actor {
         rollData.skill = skill
         rollData.weapon = weapon
         rollData.img = weapon.img
-        if ( !rollData.forceDisadvantage) { // This is an attack, check if disadvantaged
+        if (!rollData.forceDisadvantage) { // This is an attack, check if disadvantaged
           rollData.forceDisadvantage = this.isDefenseDisadvantage()
         }
 
@@ -687,10 +691,12 @@ export class CrucibleActor extends Actor {
     let rollData = this.getCommonRollData()
     rollData.defenderTokenId = undefined // Cleanup
     rollData.mode = "rangeddefense"
+    if ( attackRollData) {
       rollData.attackRollData = duplicate(attackRollData)
-    rollData.sizeDice = CrucibleUtility.getSizeDice( this.system.biodata.size )
       rollData.effectiveRange = CrucibleUtility.getWeaponRange(attackRollData.weapon)
       rollData.tokensDistance = attackRollData.tokensDistance // QoL copy
+    }
+    rollData.sizeDice = CrucibleUtility.getSizeDice(this.system.biodata.size)
     rollData.distanceBonusDice = 0 //Math.max(0, Math.floor((rollData.tokensDistance - rollData.effectiveRange) + 0.5))
     rollData.hasCover = "none"
     rollData.situational = "none"
@@ -725,51 +731,51 @@ export class CrucibleActor extends Actor {
       let messages = ["Armor applied"]
 
       if (rollData) {
-        if (CrucibleUtility.isArmorLight(armor) && CrucibleUtility.isWeaponPenetrating(rollData.attackRollData.weapon) ) {
+        if (CrucibleUtility.isArmorLight(armor) && CrucibleUtility.isWeaponPenetrating(rollData.attackRollData.weapon)) {
           return { armorIgnored: true, nbSuccess: 0, messages: ["Armor ignored : Penetrating weapons ignore Light Armors."] }
         }
-        if (CrucibleUtility.isWeaponPenetrating(rollData.attackRollData.weapon) ) {
+        if (CrucibleUtility.isWeaponPenetrating(rollData.attackRollData.weapon)) {
           messages.push("Armor reduced by 1 (Penetrating weapon)")
           reduce = 1
         }
-        if (CrucibleUtility.isWeaponLight(rollData.attackRollData.weapon) ) {
+        if (CrucibleUtility.isWeaponLight(rollData.attackRollData.weapon)) {
           messages.push("Armor with advantage (Light weapon)")
           advantage = true
         }
-        if (CrucibleUtility.isWeaponHeavy(rollData.attackRollData.weapon) ) {
+        if (CrucibleUtility.isWeaponHeavy(rollData.attackRollData.weapon)) {
           messages.push("Armor with disadvantage (Heavy weapon)")
           disadvantage = true
         }
-        if (CrucibleUtility.isWeaponHack(rollData.attackRollData.weapon) ) {
+        if (CrucibleUtility.isWeaponHack(rollData.attackRollData.weapon)) {
           messages.push("Armor reduced by 1 (Hack weapon)")
           reduce = 1
         }
-        if (CrucibleUtility.isWeaponUndamaging(rollData.attackRollData.weapon) ) {
+        if (CrucibleUtility.isWeaponUndamaging(rollData.attackRollData.weapon)) {
           messages.push("Armor multiplied by 2 (Undamaging weapon)")
           multiply = 2
         }
       }
       let diceColor = armor.system.absorprionroll
-      let armorResult = await CrucibleUtility.getRollTableFromDiceColor( diceColor, false )
+      let armorResult = await CrucibleUtility.getRollTableFromDiceColor(diceColor, false)
       console.log("Armor log", armorResult)
-      let armorValue = (Number(armorResult.text) + reduce) * multiply
-      if ( advantage || disadvantage) {
-        let armorResult2 = await CrucibleUtility.getRollTableFromDiceColor( diceColor, false )
-        let armorValue2 = (Number(armorResult2.text) + reduce) * multiply
-        if ( advantage) {
+      let armorValue = Math.max(0, (Number(armorResult.text) + reduce) * multiply)
+      if (advantage || disadvantage) {
+        let armorResult2 = await CrucibleUtility.getRollTableFromDiceColor(diceColor, false)
+        let armorValue2 = Math.max(0, (Number(armorResult2.text) + reduce) * multiply)
+        if (advantage) {
           armorValue = (armorValue2 > armorValue) ? armorValue2 : armorValue
           messages.push(`Armor advantage - Roll 1 = ${armorValue} - Roll 2 = ${armorValue2}`)
         }
-        if ( disadvantage) {
+        if (disadvantage) {
           armorValue = (armorValue2 < armorValue) ? armorValue2 : armorValue
           messages.push(`Armor disadvantage - Roll 1 = ${armorValue} - Roll 2 = ${armorValue2}`)
         }
       }
       armorResult.armorValue = armorValue
-      if ( !rollData) {
-        ChatMessage.create( { content: "Armor result : " + armorValue   } )
+      if (!rollData) {
+        ChatMessage.create({ content: "Armor result : " + armorValue })
       }
-      messages.push( "Armor result : " + armorValue)
+      messages.push("Armor result : " + armorValue)
       return { armorIgnored: false, nbSuccess: armorValue, rawArmor: armorResult.text, messages: messages }
     }
     return { armorIgnored: true, nbSuccess: 0, messages: ["No armor equipped."] }

modules/crucible-npc-sheet.js

@@ -157,6 +157,9 @@ export class CrucibleNPCSheet extends ActorSheet {
     html.find('.roll-shield-die').click((event) => {
       this.actor.rollShieldDie()
     });
+    html.find('.roll-target-die').click((event) => {
+      this.actor.rollDefenseRanged()
+    });
 
     html.find('.roll-save').click((event) => {
       const saveKey = $(event.currentTarget).data("save-key")

system.json

@@ -199,15 +199,15 @@
   "styles": [
     "styles/simple.css"
   ],
-  "version": "10.0.10",
+  "version": "10.0.12",
   "compatibility": {
     "minimum": "10",
-    "verified": "10.279",
+    "verified": "10.285",
     "maximum": "10"
   },
   "title": "Crucible RPG",
   "manifest": "https://www.uberwald.me/gitea/public/fvtt-crucible-rpg/raw/master/system.json",
-  "download": "https://www.uberwald.me/gitea/public/fvtt-crucible-rpg/archive/fvtt-crucible-rpg-v10.0.10.zip",
+  "download": "https://www.uberwald.me/gitea/public/fvtt-crucible-rpg/archive/fvtt-crucible-rpg-v10.0.12.zip",
   "url": "https://www.uberwald.me/gitea/public/fvtt-crucible-rpg",
   "background": "images/ui/crucible_welcome_page.webp",
   "id": "fvtt-crucible-rpg"

templates/actor-sheet.html

@@ -59,6 +59,12 @@
                   </span>
                 </li>
                 {{/if}}
+                <li class="item flexrow list-item" data-attr-key="class">              
+                  <img class="sheet-competence-img" src="systems/fvtt-crucible-rpg/images/icons/feats/Marksman (Ballistic).webp" />
+                  <span class="ability-label " name="rollTarget">
+                    <h4 class="ability-text-white ability-margin"><a class="roll-target-die ability-margin">Target Roll</a></h4>
+                  </span>
+                </li>
 
               </ul>
             </div>

templates/npc-sheet.html

@@ -60,6 +60,12 @@
                   </span>
                 </li>
                 {{/if}}
+                <li class="item flexrow list-item" data-attr-key="class">              
+                  <img class="sheet-competence-img" src="systems/fvtt-crucible-rpg/images/icons/feats/Marksman (Ballistic).webp" />
+                  <span class="ability-label " name="rollTarget">
+                    <h4 class="ability-text-white ability-margin"><a class="roll-target-die ability-margin">Target Roll</a></h4>
+                  </span>
+                </li>
 
               </ul>
             </div>

templates/partial-actor-status.html

@@ -3,15 +3,25 @@
     <span class="ability-label " name="hp">
       <h4 class="ability-text-white ability-margin">HP</h4>
     </span>
-    <span class="ability-label ability-margin"><input class="input-numeric-short" name="system.secondary.hp.value" value="{{data.secondary.hp.value}}"></span>
+    <span class="ability-label ability-margin">
+      <input class="input-numeric-short" name="system.secondary.hp.value" value="{{data.secondary.hp.value}}"></span>
+      {{#if (eq type "character")}}
       <span class="ability-label ability-margin"> / {{data.secondary.hp.max}}</span>
+      {{else}}
+      <span class="ability-label ability-margin">/<input class="input-numeric-short" name="system.secondary.hp.max" value="{{data.secondary.hp.max}}"></span>
+    {{/if}}
   </li>
   <li class="item flexrow list-item" data-attr-key="hp">
     <span class="ability-label " name="hp">
       <h4 class="ability-text-white ability-margin">Effort</h4>
     </span>
-    <span class="ability-label ability-margin"><input class="input-numeric-short" name="system.secondary.effort.value" value="{{data.secondary.effort.value}}"></span>
+    <span class="ability-label ability-margin">
+      <input class="input-numeric-short" name="system.secondary.effort.value" value="{{data.secondary.effort.value}}"></span>
+    {{#if (eq type "character")}}
     <span class="ability-label ability-margin"> / {{data.secondary.effort.max}}</span>
+    {{else}}
+    <span class="ability-label ability-margin">/<input class="input-numeric-short" name="system.secondary.effort.max" value="{{data.secondary.effort.max}}"></span>
+    {{/if}}
   </li>
 
   <li>&nbsp;</li>