changelog.md

@@ -1,12 +1,4 @@
 # 12.0
-## 12.0.42 - Les errements d'Astrobazzarh
-- Correction de différentes automatisations de combat incorrectes
-- Correction des jets `@roll[vue/-2]` qui tentaient de chercher une compétence -2 (à cause des armes à 1/2 mains)
-
-## 12.0.41 - La loupe d'Astrobazzarh
-- On peut de nouveau effectuer des tirages cachés
-- Le stress transformé est bien diminué lorsqu'on met le stress dans une compétence
-
 ## 12.0.40 - Les mains d'Astrobazzarh
 - correction des attaques particulières en combat
 - correction de message sur les min/max liés aux modificateurs de races (s'applique uniquement sur la taille)

module/actor-sheet.js

@@ -237,11 +237,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
 
     this.html.find('.carac-xp-augmenter').click(async event => await this.actor.updateCaracXPAuto(event.currentTarget.name.replace("augmenter.", "")))
     this.html.find('.competence-xp-augmenter').click(async event => await this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event)))
-    this.html.find('.competence-stress-augmenter').click(async event =>{
+    this.html.find('.competence-stress-augmenter').click(async event => await this.actor.updateCompetenceStress(RdDSheetUtility.getItemId(event)))
-      await this.actor.updateCompetenceStress(RdDSheetUtility.getItemId(event))
-      this.render(true)
-    } 
-  )
 
     if (this.options.vueDetaillee) {
       // On carac change

module/actor.js

@@ -736,7 +736,7 @@ export class RdDActor extends RdDBaseActorSang {
       await competence.update({
         "system.xp": toXp,
         "system.niveau": toNiveau,
-      }, { render: false })
+      });
       await ExperienceLog.add(this, XP_TOPIC.XP, fromXp, toXp, competence.name);
       await ExperienceLog.add(this, XP_TOPIC.NIVEAU, fromNiveau, toNiveau, competence.name);
     }
@@ -767,7 +767,7 @@ export class RdDActor extends RdDBaseActorSang {
     await competence.update({
       "system.xp": newXp,
       "system.niveau": toNiveau,
-    }, { render: false })
+    });
     const toXpStress = Math.max(0, fromXpStress - xpUtilise);
     await this.update({ "system.compteurs.experience.value": toXpStress });
 
@@ -783,7 +783,7 @@ export class RdDActor extends RdDBaseActorSang {
       const toNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie, competence.getCategories());
       this.notifyCompetencesTronc(competence, toNiveau);
       const fromNiveau = competence.system.niveau;
-      await competence.update({ 'system.niveau': toNiveau }, { render: false })
+      await competence.update({ 'system.niveau': toNiveau });
       await ExperienceLog.add(this, XP_TOPIC.NIVEAU, fromNiveau, toNiveau, competence.name, true);
     }
   }
@@ -808,7 +808,7 @@ export class RdDActor extends RdDBaseActorSang {
       if (isNaN(toXp) || typeof (toXp) != 'number') toXp = 0;
       const fromXp = competence.system.xp;
       this.checkCompetenceXP(idOrName, toXp);
-      await competence.update({ 'system.xp': toXp }, { render: false })
+      await competence.update({ 'system.xp': toXp });
       await ExperienceLog.add(this, XP_TOPIC.XP, fromXp, toXp, competence.name, true);
       if (toXp > fromXp) {
         RdDUtility.checkThanatosXP(competence)
@@ -822,7 +822,7 @@ export class RdDActor extends RdDBaseActorSang {
     if (competence) {
       if (isNaN(toXpSort) || typeof (toXpSort) != 'number') toXpSort = 0;
       const fromXpSort = competence.system.xp_sort;
-      await competence.update({ 'system.xp_sort': toXpSort }, { render: false })
+      await competence.update({ 'system.xp_sort': toXpSort });
       await ExperienceLog.add(this, XP_TOPIC.XPSORT, fromXpSort, toXpSort, competence.name, true);
       if (toXpSort > fromXpSort) {
         RdDUtility.checkThanatosXP(competence)
@@ -834,7 +834,7 @@ export class RdDActor extends RdDBaseActorSang {
   async updateCompetenceArchetype(idOrName, compValue) {
     let competence = this.getCompetence(idOrName)
     if (competence) {
-      await competence.update({ 'system.niveau_archetype': Math.max(compValue ?? 0, 0) })
+      await competence.update({ 'system.niveau_archetype': Math.max(compValue ?? 0, 0) });
     }
   }
 
@@ -1584,7 +1584,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async _appliquerAppelMoral(rollData) {
-    if (!rollData.use.moral || game.settings.get("core", "rollMode") == 'selfroll') {
+    if (!rollData.use.moral || game.settings.get("core", "rollMode") == 'selfroll'){
       return
     }
     if (rollData.rolled.isEchec ||
@@ -2527,6 +2527,7 @@ export class RdDActor extends RdDBaseActorSang {
       })
     }
     const blessure = this.getItem(blessureId, 'blessure')
+    console.log('TODO update blessure', this, blessureId, rollData, rollData.tache);
     if (blessure && !blessure.system.premierssoins.done) {
       const tache = rollData.tache;
       if (rollData.rolled.isETotal) {
@@ -2643,13 +2644,12 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   /* -------------------------------------------- */
-  async incDecItemUse(itemId, shouldIncrease = true) {
+  async incDecItemUse(itemId, inc = 1) {
-    if (shouldIncrease) {
     const currentItemUse = this.getFlag(SYSTEM_RDD, 'itemUse');
     let itemUse = currentItemUse ? foundry.utils.duplicate(currentItemUse) : {};
-      itemUse[itemId] = (itemUse[itemId] ?? 0) + 1;
+    itemUse[itemId] = (itemUse[itemId] ?? 0) + inc;
     await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse);
-    }
+    console.log("ITEM USE INC", inc, itemUse);
   }
 
   /* -------------------------------------------- */

module/actor/base-actor-reve.js

@@ -277,9 +277,14 @@ export class RdDBaseActorReve extends RdDBaseActor {
     return dialog
   }
 
-  createCallbackExperience() { return { action: r => { } } }
+  createEmptyCallback() {
-  createCallbackAppelAuMoral() { return { action: r => { } } }
+    return {
-
+      condition: r => false,
+      action: r => { }
+    };
+  }
+  createCallbackExperience() { return this.createEmptyCallback(); }
+  createCallbackAppelAuMoral() { return this.createEmptyCallback(); }
   async _onCloseRollDialog(html) { }
 
   async rollCaracCompetence(caracName, compName, diff, options = { title: "" }) {

module/actor/base-actor.js

@@ -244,19 +244,16 @@ export class RdDBaseActor extends Actor {
   async onUpdateActor(update, options, actorId) { }
   async onDeleteItem(item, options, id) {
     if (item.isInventaire()) {
-      await this._removeItemFromConteneur(item)
+      this._removeItemFromConteneur(item)
     }
   }
 
-  async _removeItemFromConteneur(item) {
+  _removeItemFromConteneur(item) {
-    const updates = this.items.filter(it => it.isConteneur() && it.system.contenu.includes(item.id))
+    this.items.filter(it => it.isConteneur() && it.system.contenu.includes(item.id))
-      .map(conteneur => {
+      .forEach(conteneur => {
-        const nouveauContenu = conteneur.system.contenu.filter(id => id != item.id)
+        const nouveauContenu = conteneur.system.contenu.filter(id => id != item.id);
-        return { _id: conteneur.id, 'system.contenu': nouveauContenu }
+        conteneur.update({ 'system.contenu': nouveauContenu });
-      })
+      });
-    if (updates.length > 0) {
-      await this.updateEmbeddedDocuments('Item', updates)
-    }
   }
 
   async onTimeChanging(oldTimestamp, newTimestamp) {
@@ -747,7 +744,7 @@ export class RdDBaseActor extends Actor {
   async jetDeMoral() { this.actionImpossible("jet de moral") }
 
   async resetItemUse() { }
-  async incDecItemUse(itemId, shouldIncrease = true) { }
+  async incDecItemUse(itemId, inc = 1) { }
   getItemUse(itemId) { return 0; }
 
   async finDeRound(options = { terminer: false }) { }

module/apps/textroll/text-roll-carac-competence.js

@@ -5,7 +5,7 @@ import { RdDUtility } from "../../rdd-utility.js";
 import { TextRollManager } from "./text-roll-formatter.js";
 
 const REGECP_CARAC = "(?<carac>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+)"
-const REGEXP_COMP = "(\\/(?<competence>[A-Za-zÀ-ÖØ-öø-ÿ ]+([1-2]?[A-Za-zÀ-ÖØ-öø-ÿ ]+)?))?"
+const REGEXP_COMP = "(\\/(?<competence>[A-Za-z0-9À-ÖØ-öø-ÿ -]+))?"
 const REGEXP_DIFF = "(/(?<diff>[\\+\\-]?\\d+(d\\d+)?))?"
 const REGEXP_ROLL_CARAC_COMP = REGECP_CARAC + REGEXP_COMP + REGEXP_DIFF
 const XREGEXP_ROLL_CARAC_COMP = XRegExp("@roll\\[" + REGEXP_ROLL_CARAC_COMP + "\\]", 'giu')

module/chat-utility.js

@@ -62,6 +62,7 @@ export class ChatUtility {
   }
 
   /* -------------------------------------------- */
+
   static removeMessages(socketData) {
     if (Misc.isFirstConnectedGM()) {
       ChatUtility.onRemoveMessages(socketData);
@@ -96,7 +97,7 @@ export class ChatUtility {
         }
         break
       case "gmroll":
-        messageData.whisper = actor ? ChatUtility.getOwners(actor) : ChatUtility.getUserAndGMs()
+        messageData.whisper = ChatUtility.getOwners(actor)
         break
       case "selfroll":
         messageData.whisper = [game.user]
@@ -107,7 +108,7 @@ export class ChatUtility {
   }
 
   static getOwners(document) {
-    return document ? game.users.filter(it => document.getUserLevel(it) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER) : [game.user]
+    return game.users.filter(it => document.getUserLevel(it) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
   }
 
   static getUserAndGMs() {
@@ -198,7 +199,7 @@ export class ChatUtility {
   static async onCreateChatMessage(chatMessage, options, id) {
     if (chatMessage.isAuthor) {
       await chatMessage.setFlag(SYSTEM_RDD, 'rdd-timestamp', game.system.rdd.calendrier.getTimestamp());
-      await chatMessage.update({ content: await RdDTextEditor.enrichHTML(chatMessage.content, undefined, { showLink: false }) })
+      await chatMessage.update({ content: await RdDTextEditor.enrichHTML(chatMessage.content, undefined, {showLink:false}) })
     }
   }
 }

module/rdd-combat.js

@@ -743,13 +743,23 @@ export class RdDCombat {
           this.attacker.createCallbackExperience(),
           this.attacker.createCallbackAppelAuMoral(),
           { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
-          { action: async r => await this.attacker.incDecItemUse(arme._id, arme && !RdDCombat.isParticuliere(r)) },
+          { action: r => this._increaseItemUse(r, arme) },
-          { action: r => this._onAttaque(r) },
+          { action: r => this._onAttaqueNormale(r) },
+          { action: r => this._onAttaqueParticuliere(r) },
+          { action: r => this._onAttaqueEchec(r) },
+          { action: r => this._onAttaqueEchecTotal(r) },
         ]
       });
     dialog.render(true);
   }
 
+  _increaseItemUse(rollData, arme) {
+    if (!arme || RdDCombat.isParticuliere(rollData)) {
+      return
+    }
+    this.attacker.incDecItemUse(arme._id)
+  }
+
   /* -------------------------------------------- */
   _prepareAttaque(competence, arme) {
     let rollData = {
@@ -780,23 +790,11 @@ export class RdDCombat {
     return rollData;
   }
 
-  async _onAttaque(attackerRoll) {
-    if (RdDCombat.isParticuliere(attackerRoll)) {
-      return await this._onAttaqueParticuliere(attackerRoll)
-    }
-    if (RdDCombat.isReussite(attackerRoll)) {
-      return await this._onAttaqueNormale(attackerRoll)
-    }
-    // if (RdDCombat.isParticuliere(attackerRoll) && attackerRoll.particuliere == undefined) {
-    //   return
-    // }
-    if (RdDCombat.isEchecTotal(attackerRoll)) {
-      return await this._onAttaqueEchecTotal(attackerRoll)
-    }
-    return await this._onAttaqueEchec(attackerRoll)
-  }
   /* -------------------------------------------- */
   async _onAttaqueParticuliere(rollData) {
+    if (!RdDCombat.isParticuliere(rollData)) {
+      return
+    }
     const isMeleeDiffNegative = (rollData.competence.type == 'competencecreature' || rollData.selectedCarac.label == "Mêlée") && rollData.diffLibre < 0;
     // force toujours, sauf empoignade
     // finesse seulement en mélée, pour l'empoignade, ou si la difficulté libre est de -1 minimum
@@ -834,6 +832,12 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async _onAttaqueNormale(attackerRoll) {
+    if (!RdDCombat.isReussite(attackerRoll)) {
+      return
+    }
+    if (RdDCombat.isParticuliere(attackerRoll) && attackerRoll.particuliere == undefined) {
+      return
+    }
     console.log("RdDCombat.onAttaqueNormale >>>", attackerRoll);
 
     attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker, this.defender.isEntite());
@@ -950,6 +954,9 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async _onAttaqueEchecTotal(attackerRoll) {
+    if (!RdDCombat.isEchecTotal(attackerRoll)) {
+      return
+    }
     const choixEchecTotal = await ChatMessage.create({
       whisper: ChatUtility.getOwners(this.attacker),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.hbs', {
@@ -976,16 +983,22 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  async _onAttaqueEchec(attackerRoll) {
+  async _onAttaqueEchec(rollData) {
-    console.log("RdDCombat.onAttaqueEchec >>>", attackerRoll);
+    if (!RdDCombat.isEchec(rollData)) {
-    await RdDRollResult.displayRollData(attackerRoll, this.attacker, 'chat-resultat-attaque.hbs');
+      return
+    }
+    console.log("RdDCombat.onAttaqueEchec >>>", rollData);
+    await RdDRollResult.displayRollData(rollData, this.attacker, 'chat-resultat-attaque.hbs');
+
   }
 
   /* -------------------------------------------- */
   async choixParticuliere(rollData, choix) {
     console.log("RdDCombat.choixParticuliere >>>", rollData, choix);
 
-    await this.attacker.incDecItemUse(rollData.arme.id, choix != "rapidite")
+    if (choix != "rapidite") {
+      this.attacker.incDecItemUse(rollData.arme.id);
+    }
 
     this.removeChatMessageActionsPasseArme(rollData.passeArme);
     rollData.particuliere = choix;
@@ -1013,8 +1026,10 @@ export class RdDCombat {
           this.defender.createCallbackExperience(),
           this.defender.createCallbackAppelAuMoral(),
           { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
-          { action: async r => await this.defender.incDecItemUse(armeParadeId, !RdDCombat.isParticuliere(r)) },
+          { condition: r => !RdDCombat.isParticuliere(r), action: r => this.defender.incDecItemUse(armeParadeId) },
-          { action: r => this._onParade(r) },
+          { condition: RdDCombat.isReussite, action: r => this._onParadeNormale(r) },
+          { condition: RdDCombat.isParticuliere, action: r => this._onParadeParticuliere(r) },
+          { condition: RdDCombat.isEchec, action: r => this._onParadeEchec(r) },
         ]
       });
     dialog.render(true);
@@ -1045,19 +1060,8 @@ export class RdDCombat {
     return defenderRoll;
   }
 
-
-  async _onParade(defenderRoll) {
-    if (RdDCombat.isParticuliere(defenderRoll)) {
-      return await this._onParadeParticuliere(defenderRoll)
-    }
-    if (RdDCombat.isReussite(defenderRoll)) {
-      return await this._onParadeNormale(defenderRoll)
-    }
-    await this._onParadeEchec(defenderRoll)
-  }
-
   /* -------------------------------------------- */
-  async _onParadeParticuliere(defenderRoll) {
+  _onParadeParticuliere(defenderRoll) {
     console.log("RdDCombat._onParadeParticuliere >>>", defenderRoll);
     if (!defenderRoll.attackerRoll.isPart) {
       // TODO: attaquant doit jouer résistance et peut être désarmé p132
@@ -1066,6 +1070,7 @@ export class RdDCombat {
         this.defender)
     }
   }
+
   /* -------------------------------------------- */
   async _onParadeNormale(defenderRoll) {
     console.log("RdDCombat._onParadeNormale >>>", defenderRoll);
@@ -1104,9 +1109,11 @@ export class RdDCombat {
         callbacks: [
           this.defender.createCallbackExperience(),
           this.defender.createCallbackAppelAuMoral(),
-          { action: async r => await this.defender.incDecItemUse(esquive._id, !RdDCombat.isParticuliere(r)) },
+          { condition: r => !RdDCombat.isParticuliere(r), action: r => this.defender.incDecItemUse(esquive._id) },
           { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
-          { action: r => this._onEsquive(r) },
+          { condition: RdDCombat.isReussite, action: r => this._onEsquiveNormale(r) },
+          { condition: RdDCombat.isParticuliere, action: r => this._onEsquiveParticuliere(r) },
+          { condition: RdDCombat.isEchec, action: r => this._onEsquiveEchec(r) },
         ]
       });
     dialog.render(true);
@@ -1134,18 +1141,9 @@ export class RdDCombat {
     return rollData;
   }
 
-  async _onEsquive(defenderRoll) {
-    if (RdDCombat.isParticuliere(defenderRoll)) {
-      return await this._onEsquiveParticuliere(defenderRoll)
-    }
-    if (RdDCombat.isReussite(defenderRoll)) {
-      return await this._onEsquiveNormale(defenderRoll)
-    }
-    return await this._onEsquiveEchec(defenderRoll)
-  }
   /* -------------------------------------------- */
-  async _onEsquiveParticuliere(defenderRoll) {
+  _onEsquiveParticuliere(rollData) {
-    console.log("RdDCombat._onEsquiveParticuliere >>>", defenderRoll);
+    console.log("RdDCombat._onEsquiveParticuliere >>>", rollData);
     ChatUtility.createChatWithRollMode(
       { content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>" },
       this.defender);

module/rdd-resolution-table.js

@@ -1,3 +1,4 @@
+import { ChatUtility } from "./chat-utility.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";

system.json

@@ -1,9 +1,9 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "12.0.42",
+  "version": "12.0.38",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.42/rddsystem.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.38/rddsystem.zip",
-  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.42/system.json",
+  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.38/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
     "minimum": "11",

templates/actor/xp-competences.hbs

@@ -1,18 +1,15 @@
 <div>
   <ul class="item-list">
-    <li class="flexrow">
+    <li class="item flexrow">
       <label class="derivee-label" for="system.compteurs.experience.value">Stress transformé</label>
       {{#if options.vueDetaillee}}
-      <input class="resource-content"
+      <input class="derivee-value" type="number" name="system.compteurs.experience.value" value="{{system.compteurs.experience.value}}" data-dtype="number" size="3"/>
-        type="text" data-dtype="Number" size="3"
-        name="system.compteurs.experience.value"
-        value="{{system.compteurs.experience.value}}"/>
       {{else}}
       <label name="system.compteurs.experience.value">{{system.compteurs.experience.value}}</label>
       {{/if}}
     </li>
     {{#if options.vueDetaillee}}
-    <li class="flexrow">
+    <li class="item flexrow">
       <span class="generic-label">Total XP compétences</span>
       <span class="competence-value">{{calc.competenceXPTotal}}</span>
     </li>

templates/chat-resultat-lecture-signedraconique.hbs

@@ -4,7 +4,7 @@
 <hr>
 <div>
   {{#if rolled.isSuccess}}
-  {{alias}} a gagné {{xpSort}} points d'expérience en sorts en {{competence.name}}.
+  {{alias}} a gagné {{xpSort}} points d'expérience en sorts dans la {{competence.name}}.
   {{else}}
   {{alias}} n'a pas pu interpréter le signe draconique.
   {{/if}}