Update rolls and similar stuff

modules/hawkmoon-actor-sheet.js

@@ -89,6 +89,13 @@ export class HawkmoonActorSheet extends ActorSheet {
       this.actor.editItemField(itemId, itemType, itemField, dataType, value)
     })
 
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+      
     html.find('.quantity-minus').click(event => {
       const li = $(event.currentTarget).parents(".item");
       this.actor.incDecQuantity( li.data("item-id"), -1 );

modules/hawkmoon-actor.js

@@ -56,9 +56,8 @@ export class HawkmoonActor extends Actor {
       arme.system.attrKey = "pui"
       arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
       arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
-      if (arme.system.isdefense) {
-        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.bonusmaniementdef
-      }
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      arme.system.isdefense = true
     }
     if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
       arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
@@ -66,7 +65,7 @@ export class HawkmoonActor extends Actor {
       arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
       arme.system.totalDegats = arme.system.degats
       if (arme.system.isdefense) {
-        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.bonusmaniementdef
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
       }
     }
     return arme
@@ -135,13 +134,26 @@ export class HawkmoonActor extends Actor {
 
   /* -------------------------------------------- */
   getDefenseBase() {
-    return this.system.attributs.tre.value
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.pui.value)
   }
 
   /* -------------------------------------------- */
   getVitesseBase() {
     return 5 + __vitesseBonus[this.system.attributs.adr.value]
   }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for(let armor in this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
 
   /* -------------------------------------------- */
   getCombatValues() {
@@ -153,7 +165,8 @@ export class HawkmoonActor extends Actor {
       vitesseBase: this.getVitesseBase(),
       vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
       defenseBase: this.getDefenseBase(),
-      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus
+      protection : this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite()
     }
     return combat
   }
@@ -171,9 +184,9 @@ export class HawkmoonActor extends Actor {
   prepareDerivedData() {
 
     if (this.type == 'personnage') {
-      let vigueur = Math.floor( (this.system.attributs.pui.value + this.system.attributs.tre.value) / 2)
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2)
       if (vigueur != this.system.sante.vigueur) {
-        this.update( { 'system.sante.vigueur': vigueur})
+        this.update({ 'system.sante.vigueur': vigueur })
       }
     }
 
@@ -220,45 +233,45 @@ export class HawkmoonActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  checkAttribut(attribut, minLevel)  {
-    let attr = this.system.attributs.find( at => at.labelnorm == attribut.toLowerCase() )
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
     if (attr && attr.value >= minLevel) {
-      return {isValid: true, attr: duplicate(attr) }
+      return { isValid: true, attr: duplicate(attr) }
     }
-    return {isValid: false}
+    return { isValid: false }
   }
   /* -------------------------------------------- */
   checkAttributOrCompetenceLevel(compName, minLevel) {
     let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
-    if ( comp) {
-      return {isValid: true, item: duplicate(comp) }
+    if (comp) {
+      return { isValid: true, item: duplicate(comp) }
     } else {
       for (let attrKey in this.system.attributs) {
-        if ( this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel ) {
-          return {isValid: true, item: duplicate(this.system.attributs[attrKey]) }
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: duplicate(this.system.attributs[attrKey]) }
         }
       }
     }
-    return {isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum`}
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
   }
   /* -------------------------------------------- */
   addCompetenceBonus(compName, bonus, baCost) {
     let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
-    if ( comp) {
+    if (comp) {
       comp = duplicate(comp)
       comp.system.bonus = bonus
       comp.system.baCost = baCost
-      return {isValid: true, item: comp }
+      return { isValid: true, item: comp }
     }
-    return {isValid: false, warningMessage: `Compétence ${compName} non trouvée`}
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
   }
   /* -------------------------------------------- */
-  checkIfCompetence( compName ) {
+  checkIfCompetence(compName) {
     let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
-    if ( comp) {
-      return {isValid: true, item: comp}
+    if (comp) {
+      return { isValid: true, item: comp }
     }
-    return {isValid: false }
+    return { isValid: false }
   }
   /* -------------------------------------------- */
   getBonneAventure() {
@@ -305,7 +318,7 @@ export class HawkmoonActor extends Actor {
 
   /* -------------------------------------------- */
   getBonusDegats() {
-    return __degatsBonus[this.system.attributs.pui.value]
+    return 0; 
   }
 
   /* -------------------------------------------- */
@@ -342,11 +355,24 @@ export class HawkmoonActor extends Actor {
     await this.update({ 'system.subactors': newArray });
   }
 
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    this.update({ 'system.adversite': adversite })
+  }
   /* -------------------------------------------- */
   async incDecQuantity(objetId, incDec = 0) {
     let objetQ = this.items.get(objetId)
     if (objetQ) {
-      let newQ = objetQ.system.quantity + incDec;
+      let newQ = objetQ.system.quantity + incDec
+      newQ = Math.max(newQ, 0)
       const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantity': newQ }]); // pdates one EmbeddedEntity
     }
   }
@@ -365,22 +391,22 @@ export class HawkmoonActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  getInitiativeScore( ) {
+  getInitiativeScore() {
     return Number(this.system.attributs.adr.value) + Number(this.system.combat.initbonus)
   }
   /* -------------------------------------------- */
   getBestDefenseValue() {
-    let defenseList = this.items.filter(item => (item.type =="arme" || item.type == "bouclier") && item.system.equipped)
+    let defenseList = this.items.filter(item => (item.type == "arme" || item.type == "bouclier") && item.system.equipped)
     let maxDef = 0
     let bestArme
-    for(let arme of defenseList) {
+    for (let arme of defenseList) {
       if (arme.type == "arme" && arme.system.isdefense) {
         arme = this.prepareArme(arme)
       }
-      if (arme.type == "bouclier" ) {
+      if (arme.type == "bouclier") {
         arme = this.prepareBouclier(arme)
       }
-      if ( arme.system.totalDefensif > maxDef) {
+      if (arme.system.totalDefensif > maxDef) {
         maxDef = arme.system.totalDefensif
         bestArme = duplicate(arme)
       }
@@ -392,15 +418,15 @@ export class HawkmoonActor extends Actor {
   searchRelevantTalents(competence) {
     let talents = []
 
-    for( let talent of this.items) {
+    for (let talent of this.items) {
       if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
         for (let auto of talent.system.automations) {
           if (auto.eventtype === "prepare-roll") {
-            if (auto.competence.toLowerCase() == competence.name.toLowerCase() ) {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
               talent = duplicate(talent)
-              talent.system.bonus  = auto.bonus
+              talent.system.bonus = auto.bonus
               talent.system.baCost = auto.baCost
-              talents.push( talent )
+              talents.push(talent)
             }
           }
         }
@@ -418,24 +444,26 @@ export class HawkmoonActor extends Actor {
     rollData.img = this.img
     rollData.attributs = HawkmoonUtility.getAttributs()
     rollData.maitriseId = "none"
-    rollData.nbEclat  = this.system.eclat.value
+    rollData.nbEclat = this.system.eclat.value
     rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
 
     if (attrKey) {
       rollData.attrKey = attrKey
       if (attrKey != "tochoose") {
-        rollData.actionImg = "systems/fvtt-mournblade-cyd/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.actionImg = "systems/fvtt-hawkmoon-cyd/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
         rollData.attr = duplicate(this.system.attributs[attrKey])
       }
     }
     if (compId) {
       rollData.competence = duplicate(this.items.get(compId) || {})
-      rollData.maitrises = rollData.competence.system.predilections.filter(p => p.maitrise )
+      rollData.maitrises = rollData.competence.system.predilections.filter(p => p.maitrise)
       rollData.actionImg = rollData.competence?.img
-      rollData.talents = this.searchRelevantTalents( rollData.competence)
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
     }
     if (compName) {
-      rollData.competence = duplicate(this.items.find( item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.competence = duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
       rollData.actionImg = rollData.competence?.img
     }
     return rollData
@@ -481,7 +509,8 @@ export class HawkmoonActor extends Actor {
     if (arme.type == "bouclier") {
       arme = this.prepareBouclier(arme)
     }
-    let roll = new Roll(arme.system.totalDegats).roll({ async: false })
+    console.log("DEGATS", arme)
+    let roll = new Roll( "1d10+"+arme.system.totalDegats).roll({ async: false })
     await HawkmoonUtility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
     let rollData = {
       arme: arme,
@@ -492,7 +521,7 @@ export class HawkmoonActor extends Actor {
       actionImg: arme.img,
     }
     HawkmoonUtility.createChatWithRollMode(rollData.alias, {
-      content: await renderTemplate(`systems/fvtt-mournblade/templates/chat-degats-result.html`, rollData)
+      content: await renderTemplate(`systems/fvtt-hawkmoon-cyd/templates/chat-degats-result.html`, rollData)
     })
 
   }

modules/hawkmoon-utility.js

@@ -336,6 +336,8 @@ export class HawkmoonUtility {
       rollData.diceFormula += `+${rollData.attr.value}*2+${rollData.modificateur}`
     }
 
+    // Ajout adversités
+    rollData.diceFormula += `-${rollData.nbAdversites}`
 
     if (rollData.arme && rollData.arme.type == "arme") {
       rollData.diceFormula += `+${rollData.arme.system.bonusmaniementoff}`

system.json

@@ -1,7 +1,7 @@
 {
   "id": "fvtt-hawkmoon-cyd",
   "description": "Hawmoon RPG for FoundryVTT (CYD system - French)",
-  "version": "10.0.8",
+  "version": "10.0.9",
   "authors": [
     {
       "name": "Uberwald/LeRatierBretonnien",
@@ -15,7 +15,7 @@
   "gridUnits": "m",
   "license": "LICENSE.txt",
   "manifest": "https://www.uberwald.me/gitea/public/fvtt-hawkmoon-cyd/raw/branch/master/system.json",
-  "download": "https://www.uberwald.me/gitea/public/fvtt-hawkmoon-cyd/archive/fvtt-hawkmoon-cyd-10.0.8.zip",
+  "download": "https://www.uberwald.me/gitea/public/fvtt-hawkmoon-cyd/archive/fvtt-hawkmoon-cyd-10.0.9.zip",
   "packs": [
     {
       "type": "Item",

templates/actor-sheet.html

@@ -67,7 +67,7 @@
               <img class="item-name-img" src="systems/fvtt-hawkmoon-cyd/assets/icons/{{attr.labelnorm}}.webp">
               <span class="item-name-label competence-name item-field-label-medium"><a
                   class="roll-attribut">{{attr.label}}</a></span>
-              <select class="status-small-label color-class-common item-field-label-short" type="text"
+              <select class="status-small-label color-class-common edit-item-data competence-niveau" type="text"
                 name="system.attributs.{{key}}.value" value="{{attr.value}}" data-dtype="Number">
                 {{#select attr.value}}
                 {{> systems/fvtt-hawkmoon-cyd/templates/partial-list-niveau.html}}
@@ -81,18 +81,16 @@
         <div class="sheet-box color-bg-archetype">
           <h4 class="item-name-label competence-name">Adversité</h4>
           <ul class="item-list alternate-list">
-            <li class="item flexrow">
-              <label class="label-name item-field-label-short">Bleue</label>
-              <label class="label-name item-field-label-short">{{system.adversite.bleue}}</label>
-            </li>
-            <li class="item flexrow">
-              <label class="label-name item-field-label-short">Rouge</label>
-              <label class="label-name item-field-label-short">{{system.adversite.rouge}}</label>
-            </li>
-            <li class="item flexrow">
-              <label class="label-name item-field-label-short">Noire</label>
-              <label class="label-name item-field-label-short">{{system.adversite.noire}}</label>
+            {{#each system.adversite as |adv key|}}
+            <li class="item flexrow" data-adversite="{{key}}">
+              <label class="label-name item-field-label-short">{{upperFirst key}}</label>
+              <label class="label-name item-field-label-short">{{adv}}</label>
+              <span class="status-small-label no-grow">
+                <a class="adversite-modify plus-minus-button" data-adversite-value="1">+</a>
+                <a class="adversite-modify plus-minus-button" data-adversite-value="-1">&nbsp;-</a>
+              </span>        
             </li>
+            {{/each}}
           </ul>
         </div>
 

templates/chat-degats-result.html

@@ -19,7 +19,7 @@
 <div>
   <ul>
     <li>Arme : {{arme.name}} (+{{arme.system.totalDegats}})</li>
-    <li>Dégats : {{finalResult}} {{#if arme.system.nonletaux}}(Non létaux){{else}}(Létaux){{/if}}</li>    
+    <li>Dégats : {{finalResult}}</li>    
   </ul>
 </div>
 

templates/roll-dialog-generic.html

@@ -24,6 +24,13 @@
       {{/if}}
     </div>
 
+    {{#if nbAdversites}}
+    <div class="flexrow">
+      <span class="roll-dialog-label">Malus d'adversités : </span>
+      <span class="small-label">- {{nbAdversites}}</span>
+    </div>
+    {{/if}}
+    
     {{#if competence}}
       <div class="flexrow">
         <span class="roll-dialog-label">{{competence.name}}</span>