changelog.md

@@ -1,4 +1,19 @@
 # 12.0
+## 12.0.34 - la tête d'Astrobazzarh
+- on peut ajouter des liens "jet de dés" dans les journaux texte
+- on peut ajouter des liens "jet de dés" dans les descriptions, notes, ...
+- les liens "jet de dés" peuvent être utilisés pour un acteur, ou les items de l'acteurs
+- les liens "jet avec caractéristiques" s'appliquent:
+  - à tous les tokens sélectionnés
+  - sinon, à l'acteur propriétaire d'un Item
+  - sinon, au personnage du joueur
+
+- gestion des blocs secrets dans les descriptions
+- on peut ajouter des liens "jet de dés" pour appeler une formule dés de foundry
+- les liens "manipulation alchimiques" peuvent être dans les descriptions, notes, ...
+- les "manipulation alchimiques" fonctionnent comme tous les autres jets
+
+
 ## 12.0.33 - la vieillesse d'Astrobazzarh
 - retour de l'expérience pour les joueurs
 - suppression du message "Pas de caractéristique" sur les jets d'odorat-goût

module/actor-sheet.js

@@ -19,6 +19,7 @@ import { RdDBaseActorSangSheet } from "./actor/base-actor-sang-sheet.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js";
 import { RdDItemRace } from "./item/race.js";
+import { RdDTextEditor } from "./apps/rdd-text-roll.js";
 
 /* -------------------------------------------- */
 /**
@@ -44,8 +45,8 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
       cssClass: this.isEditable ? "editable" : "locked",
       limited: this.actor.limited,
       owner: this.actor.isOwner,
-      biographie: await TextEditor.enrichHTML(this.actor.system.biographie, { async: true }),
+      biographie: await RdDTextEditor.enrichHTML(this.actor.system.biographie, this.actor),
-      notes: await TextEditor.enrichHTML(this.actor.system.notes, { async: true }),
+      notes: await RdDTextEditor.enrichHTML(this.actor.system.notes, this.actor),
     });
     foundry.utils.mergeObject(formData.calc, {
       surenc: this.actor.computeMalusSurEncombrement(),
@@ -221,7 +222,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     }
 
     // Points de reve actuel
-    this.html.find('.roll-reve-actuel').click(async event => this.actor.rollCarac('reve-actuel', true))
+    this.html.find('.roll-reve-actuel').click(async event => this.actor.rollCarac('reve-actuel', {resistance:true}))
     this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
 
     this.html.find('.roll-arme').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event)), 'competence'))

module/actor.js

@@ -17,7 +17,7 @@ import { RdDItemSigneDraconique } from "./item/signedraconique.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { Draconique } from "./tmr/draconique.js";
-import { LIST_CARAC, RdDCarac } from "./rdd-carac.js";
+import { LIST_CARAC_PERSONNAGE, RdDCarac } from "./rdd-carac.js";
 import { DialogConsommer } from "./dialog-item-consommer.js";
 import { DialogFabriquerPotion } from "./dialog-fabriquer-potion.js";
 import { RollDataAjustements } from "./rolldata-ajustements.js";
@@ -662,15 +662,15 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async updateCarac(caracName, to) {
     to = Number(to)
-    if (!RdDItemRace.checkRacialMax(this, caracName, to)){
+    if (!RdDItemRace.checkRacialMax(this, caracName, to)) {
       return
     }
-    if (caracName == LIST_CARAC.reve.code) {
+    if (caracName == LIST_CARAC_PERSONNAGE.reve.code) {
       if (to > Misc.toInt(this.system.reve.seuil.value)) {
         this.setPointsDeSeuil(to);
       }
     }
-    if (caracName == LIST_CARAC.chance.code) {
+    if (caracName == LIST_CARAC_PERSONNAGE.chance.code) {
       if (to > Misc.toInt(this.system.compteurs.chance.value)) {
         this.setPointsDeChance(to);
       }
@@ -1387,7 +1387,7 @@ export class RdDActor extends RdDBaseActorSang {
     }
 
     await RdDResolutionTable.rollData(ethylismeData.jetVie);
-    this._gererExperience(ethylismeData.jetVie);
+    this.gererExperience(ethylismeData.jetVie);
     RollDataAjustements.calcul(ethylismeData.jetVie, this);
     if (ethylismeData.jetVie.rolled.isSuccess) {
       ethylisme.nb_doses++;
@@ -1419,7 +1419,7 @@ export class RdDActor extends RdDBaseActorSang {
           finalLevel: Number(ethylisme.value) + Number(this.system.compteurs.moral.value)
         }
         await RdDResolutionTable.rollData(ethylismeData.jetVolonte);
-        this._gererExperience(ethylismeData.jetVolonte);
+        this.gererExperience(ethylismeData.jetVolonte);
         RollDataAjustements.calcul(ethylismeData.jetVolonte, this);
       }
     }
@@ -1799,38 +1799,8 @@ export class RdDActor extends RdDBaseActorSang {
     }
   }
 
-  /**
-   * Méthode pour faire un jet prédéterminer sans ouvrir la fenêtre de dialogue
-   * @param {*} caracName 
-   * @param {*} compName 
-   * @param {*} diff 
-   * @param {*} options 
-   * @returns 
-   */
-  async doRollCaracCompetence(caracName, compName, diff, options = { title: "" }) {
-    const carac = this.getCaracByName(caracName);
-    if (!carac) {
-      ui.notifications.warn(`${this.name} n'a pas de caractéristique correspondant à ${caracName}`)
-      return;
-    }
-    const competence = this.getCompetence(compName);
-    let rollData = {
-      alias: this.getAlias(),
-      caracValue: Number(carac.value),
-      selectedCarac: carac,
-      competence: competence,
-      diffLibre: diff,
-      show: { title: options?.title ?? '' }
-    };
-    RollDataAjustements.calcul(rollData, this);
-    await RdDResolutionTable.rollData(rollData);
-    this._gererExperience(rollData);
-    await RdDResolutionTable.displayRollData(rollData, this)
-    return rollData.rolled;
-  }
-
   /* -------------------------------------------- */
-  _gererExperience(rollData) {
+  gererExperience(rollData) {
     const callback = this.createCallbackExperience();
     if (callback.condition(rollData)) {
       callback.action(rollData);

module/actor/base-actor-reve-sheet.js

@@ -1,3 +1,4 @@
+import { RdDTextEditor } from "../apps/rdd-text-roll.js";
 import { Grammar } from "../grammar.js";
 import { ITEM_TYPES } from "../item.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
@@ -27,7 +28,7 @@ export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
 
     this.html.find('.button-encaissement').click(async event => this.actor.encaisser())
     this.html.find('.roll-carac').click(async event => {
-      this.actor.rollCarac(Grammar.toLowerCaseNoAccent(event.currentTarget.attributes['data-carac-name'].value))});
+      this.actor.rollCarac(Grammar.toLowerCaseNoAccent(event.currentTarget.attributes['data-carac-name'].value))})
     this.html.find('.roll-competence').click(async event => this.actor.rollCompetence(RdDSheetUtility.getItemId(event)));
     this.html.find('.endurance-plus').click(async event => this.actor.santeIncDec("endurance", 1));
     this.html.find('.endurance-moins').click(async event => this.actor.santeIncDec("endurance", -1));
@@ -47,6 +48,7 @@ export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
         }
       }], { renderSheet: true })
     )
+    this.html.find('.roll-text').click(async event => await RdDTextEditor.rollText(event, this.actor))
 
     if (this.options.vueDetaillee) {
       // On carac change

module/actor/base-actor-reve.js

@@ -22,6 +22,7 @@ import { RdDCombat } from "../rdd-combat.js";
 import { RdDEmpoignade } from "../rdd-empoignade.js";
 import { RdDPossession } from "../rdd-possession.js";
 import { BASE_CORPS_A_CORPS, BASE_ESQUIVE, POSSESSION_SANS_DRACONIC } from "../item/base-items.js";
+import { RollDataAjustements } from "../rolldata-ajustements.js";
 
 /**
  * Classe de base pour les acteurs disposant de rêve (donc, pas des objets)
@@ -293,6 +294,38 @@ export class RdDBaseActorReve extends RdDBaseActor {
   createCallbackAppelAuMoral() { return this.createEmptyCallback(); }
   async _onCloseRollDialog(html) { }
 
+  /**
+   * Méthode pour faire un jet prédéterminer sans ouvrir la fenêtre de dialogue
+   * @param {*} caracName code ou label de la caractéristique. On peut utiliser 'intel' pour Intellect.
+   * @param {*} compName nom de compétence ou nom abrégé.
+   * @param {*} diff difficulté (0 si undefined)
+   * @param {*} options
+   * @returns le jet effectué
+   */
+  async doRollCaracCompetence(caracName, compName, diff, options = { title: "" }) {
+    const carac = this.getCaracByName(caracName);
+    if (!carac) {
+      ui.notifications.warn(`${this.name} n'a pas de caractéristique correspondant à ${caracName}`)
+      return
+    }
+    const competence = this.getCompetence(compName);
+    let rollData = {
+      alias: this.getAlias(),
+      caracValue: Number(carac.value),
+      selectedCarac: carac,
+      competence: competence,
+      diffLibre: diff ?? 0,
+      show: { title: options?.title ?? '' }
+    }
+    RollDataAjustements.calcul(rollData, this);
+    await RdDResolutionTable.rollData(rollData);
+    this.gererExperience(rollData);
+    await RdDResolutionTable.displayRollData(rollData, this)
+    return rollData.rolled;
+  }
+
+  gererExperience(rollData) { }
+
   /* -------------------------------------------- */
   async roll() {
     RdDEmpoignade.checkEmpoignadeEnCours(this)
@@ -311,14 +344,14 @@ export class RdDBaseActorReve extends RdDBaseActor {
         competences: this.itemTypes['competence']
       },
       callbackAction: r => this.$onRollCaracResult(r)
-    });
+    })
   }
-
   /* -------------------------------------------- */
-  async rollCarac(caracName, jetResistance = undefined) {
+  async rollCarac(caracName, options = {}) {
     if (Grammar.equalsInsensitive(caracName, 'taille')) {
       return
     }
+    foundry.utils.mergeObject(options, { resistance: false, diff: 0 }, { overwrite: false })
     RdDEmpoignade.checkEmpoignadeEnCours(this)
     let selectedCarac = this.getCaracByName(caracName)
     console.log("selectedCarac", selectedCarac)
@@ -329,7 +362,8 @@ export class RdDBaseActorReve extends RdDBaseActor {
       rollData: {
         selectedCarac: selectedCarac,
         competences: this.itemTypes['competence'],
-        jetResistance: jetResistance ? caracName : undefined
+        diffLibre: options.diff ?? 0,
+        jetResistance: options.resistance ? caracName : undefined
       },
       callbackAction: r => this.$onRollCaracResult(r)
     });

module/actor/base-actor-sheet.js

@@ -5,6 +5,7 @@ import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { Monnaie } from "../item-monnaie.js";
 import { RdDItem, ITEM_TYPES } from "../item.js";
 import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
+import { RdDTextEditor } from "../apps/rdd-text-roll.js";
 
 /* -------------------------------------------- */
 /**
@@ -35,8 +36,8 @@ export class RdDBaseActorSheet extends ActorSheet {
       img: this.actor.img,
       name: this.actor.name,
       system: this.actor.system,
-      description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
+      description: await RdDTextEditor.enrichHTML(this.actor.system.description, this.actor),
-      notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
+      notesmj: await RdDTextEditor.enrichHTML(this.actor.system.notesmj, this.actor),
       options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable),
       effects: this.actor.effects
     }

module/actor/base-actor.js

@@ -81,7 +81,6 @@ export class RdDBaseActor extends Actor {
     }
   }
 
-
   static getRealActor(actorId, tokenId) {
     if (tokenId) {
       let token = canvas.tokens.get(tokenId)
@@ -161,8 +160,11 @@ export class RdDBaseActor extends Actor {
     return RdDBaseActor.$findCaracByName(carac, name);
   }
 
+  mapCarac(caracCode) { return caracCode }
+
   getCaracByName(name) {
-    switch (Grammar.toLowerCaseNoAccent(name)) {
+    name = this.mapCarac(Grammar.toLowerCaseNoAccent(name))
+    switch (name) {
       case 'reve-actuel': case 'reve actuel':
         return this.getCaracReveActuel();
       case 'chance-actuelle': case 'chance-actuelle':

module/actor/creature.js

@@ -1,4 +1,6 @@
+import { Grammar } from "../grammar.js";
 import { ITEM_TYPES } from "../item.js";
+import { LIST_CARAC_AUTRES } from "../rdd-carac.js";
 import { RdDBaseActorSang } from "./base-actor-sang.js";
 
 export class RdDCreature extends RdDBaseActorSang {
@@ -32,4 +34,14 @@ export class RdDCreature extends RdDBaseActorSang {
     }
   }
 
+  mapCarac(caracCode) {
+    switch (caracCode) {
+      case 'vue': case 'ouie':
+      case 'odoratgout':
+      case 'empathie':
+        return 'perception'
+    }
+    return caracCode
+  }
+
 }

module/actor/entite.js

@@ -117,4 +117,13 @@ export class RdDEntite extends RdDBaseActorReve {
       super.setEntiteReveAccordee(actor)
     }
   }
+
+  mapCarac(caracCode) {
+    switch (caracCode) {
+      case 'taille':
+        return caracCode
+    }
+    return 'reve'
+  }
+
 }

module/apps/rdd-import-stats.js

@@ -34,7 +34,6 @@ const XREGEXP_WEAPON_MANIEMENT = "(?<maniement>(" + Misc.join(Object.keys(MANIEM
 
 const XREGEXP_SORT_VOIE = "(?<voies>[OHNT](\\/[OHNT])*)"
 const XREGEXP_SORT_NAME = "(?<name>[^\\(]+)"
-// const XREGEXP_SORT_CASE = "(?<coord>([A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+|[A-M]\\d{1,2})+)"
 const XREGEXP_SORT_CASE = "(?<coord>([A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+|[A-M]\\d{1,2}))"
 
 const XREGEXP_SORT = "(" + XREGEXP_SORT_VOIE

module/apps/rdd-text-roll.js

@@ -0,0 +1,224 @@
+import "./xregexp-all.js";
+import { RdDCarac } from "../rdd-carac.js";
+import { SystemCompendiums } from "../settings/system-compendiums.js";
+import { RdDItemCompetence } from "../item-competence.js";
+import { ACTOR_TYPES, ITEM_TYPES } from "../item.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { Misc } from "../misc.js";
+import { RdDAlchimie } from "../rdd-alchimie.js";
+
+const REGEX_ALCHIMIE_TERMES = "(?<termes>(\\w|-)+)"
+const REGEX_ALCHIMIE_MANIP = "(?<manip>(couleur|consistance))"
+const XREGEXP_ROLL_ALCHIMIE = XRegExp("@roll\\[" + REGEX_ALCHIMIE_MANIP + "\\s+" + REGEX_ALCHIMIE_TERMES + "\\]", 'giu')
+const XREGEXP_ROLL_ALCHIMIE_MANIP = XRegExp("@" + REGEX_ALCHIMIE_MANIP + "\\{" + REGEX_ALCHIMIE_TERMES + "\\}", 'giu')
+
+const REGEXP_ROLL_CARAC_COMP = "(?<carac>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+)(\\/(?<competence>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+))?(/(?<diff>[\\+\\-]?\\d+))?"
+const XREGEXP_ROLL_CARAC_COMP = XRegExp("@roll\\[" + REGEXP_ROLL_CARAC_COMP + "\\]", 'giu')
+
+const REGEXP_ROLL_FORMULA = "(?<formula>[^\\[\\]]+)"
+const XREGEXP_ROLL_FORMULA = XRegExp("@roll\\[" + REGEXP_ROLL_FORMULA + "\\]", 'giu')
+
+
+/**
+ * classe pour gérer les jets d'alchimie
+ */
+class TextRollAlchimie {
+  static async onRollText(event, actor) {
+    actor = TextRollAlchimie.getSelectedActor(actor)
+    if (actor) {
+      const recetteId = event.currentTarget.attributes['data-recette-id']?.value
+      const manip = event.currentTarget.attributes['data-manip'].value
+      const termes = event.currentTarget.attributes['data-termes'].value
+      if (recetteId) {
+        await actor.effectuerTacheAlchimie(recetteId, manip, termes)
+      }
+      else {
+        const carac = RdDCarac.caracDetails(RdDAlchimie.getCaracTache(manip))
+        const diff = RdDAlchimie.getDifficulte(termes)
+        await actor.rollCaracCompetence(carac.code, 'Alchimie', diff)
+      }
+    }
+  }
+
+  static getSelectedActor(actor) {
+    actor = actor ?? RdDUtility.getSelectedActor()
+    if (actor && actor.type == ACTOR_TYPES.personnage) {
+      return actor
+    }
+    return undefined
+  }
+
+  static async onReplaceRoll(context) {
+    const handler = new TextRollAlchimie(context)
+    context.text = await handler.replaceManipulationAlchimie()
+  }
+
+  constructor(context) {
+    this.context = context
+  }
+
+  async replaceManipulationAlchimie() {
+    await XRegExp.forEach(this.context.text, XREGEXP_ROLL_ALCHIMIE, async (rollMatch, i) => await this._replaceOneAlchimie(rollMatch, i))
+    await XRegExp.forEach(this.context.text, XREGEXP_ROLL_ALCHIMIE_MANIP, async (rollMatch, i) => await this._replaceOneAlchimie(rollMatch, i))
+    return this.context.text
+  }
+
+  async _replaceOneAlchimie(rollMatch, i) {
+    if (rollMatch.termes && rollMatch.manip) {
+      const manip = rollMatch.manip
+      await this._replaceManip(manip, rollMatch, i)
+    }
+  }
+
+  async _replaceManip(manip, rollMatch, i) {
+    const termes = rollMatch.termes
+    const carac = RdDCarac.caracDetails(RdDAlchimie.getCaracTache(manip))
+    const diff = RdDAlchimie.getDifficulte(termes)
+    const recette = (this.context.object instanceof Item && this.context.object.type == ITEM_TYPES.recettealchimique) ? this.context.object : undefined
+    const replacement = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/apps/link-text-roll-alchimie.hbs`, {
+      manip,
+      termes,
+      recette,
+      carac,
+      diff
+    })
+    this.context.text = this.context.text.replace(rollMatch[0], replacement);
+  }
+}
+
+/**
+ * classe pour gérer les jets de caractéristique/compétence depuis
+ * les journaux/descriptions
+ */
+class TextRollCaracCompetence {
+
+  static async onRollText(event, actor) {
+    const caracCode = event.currentTarget.attributes['data-carac-code']?.value
+    if (caracCode) {
+      const competence = event.currentTarget.attributes['data-competence']?.value
+      const diff = event.currentTarget.attributes['data-diff']?.value
+      const actors = TextRollCaracCompetence.getSelectedActors(actor)
+      actors.forEach(async it => await TextRollCaracCompetence.doRoll(it, caracCode, competence, diff))
+    }
+  }
+  static async doRoll(actor, caracCode, competence, diff) {
+    caracCode = actor.mapCarac(caracCode)
+    if (competence) {
+      if (actor.type == ACTOR_TYPES.personnage) {
+        await actor.rollCaracCompetence(caracCode, competence, diff)
+      }
+      else {
+        await actor.doRollCaracCompetence(caracCode, competence, diff)
+      }
+    }
+    else {
+      await actor.rollCarac(caracCode, { diff })
+    }
+  }
+
+  static async onReplaceRoll(context) {
+    const handler = new TextRollCaracCompetence(context)
+    context.text = await handler.replaceRollCaracCompetence()
+  }
+
+  static getSelectedActors(actor) {
+    const selected = canvas.tokens.controlled.map(it => it.actor).filter(it => it)
+    if (selected.length > 0) {
+      return selected
+    }
+    actor = actor ?? RdDUtility.getSelectedActor()
+    if (actor) {
+      return [actor]
+    }
+    return []
+  }
+
+  constructor(context) {
+    this.context = context
+  }
+
+  async replaceRollCaracCompetence() {
+    await XRegExp.forEach(this.context.text, XREGEXP_ROLL_CARAC_COMP, async (rollMatch, i) => await this._replaceOne(rollMatch, i))
+    return this.context.text
+  }
+
+  async _replaceOne(rollMatch, i) {
+    const carac = RdDCarac.caracDetails(rollMatch.carac)
+    if (carac) {
+      const competence = rollMatch.competence ? RdDItemCompetence.findCompetence(this.context.competences, rollMatch.competence) : undefined
+      const replacement = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/apps/link-text-roll-carac-competence.hbs`, {
+        carac: carac,
+        competence: competence?.name,
+        diff: rollMatch.diff
+      })
+      this.context.text = this.context.text.replace(rollMatch[0], replacement)
+    }
+  }
+}
+
+/**
+ * classe pour gérer les jets de dés (formules Foundry)
+ */
+class TextRollFoundry {
+
+  static async onReplaceRoll(context) {
+    const handler = new TextRollFoundry(context.text)
+    context.text = await handler.replaceRolls()
+  }
+
+  static async onRollText(event, actor) {
+    const rollFoundry = event.currentTarget.attributes['data-roll-foundry']?.value
+    if (rollFoundry) {
+      const roll = new Roll(rollFoundry)
+      await roll.evaluate()
+      await roll.toMessage()
+    }
+  }
+
+  constructor(text) {
+    this.text = text
+  }
+
+  async replaceRolls() {
+    await XRegExp.forEach(this.text, XREGEXP_ROLL_FORMULA, async (rollMatch, i) => await this._replaceOne(rollMatch, i))
+    return this.text
+  }
+
+  async _replaceOne(rollMatch, i) {
+    if (rollMatch.formula) {
+      const replacement = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/apps/link-text-roll-foundry.hbs`, {
+        formula: rollMatch.formula,
+      })
+      this.text = this.text.replace(rollMatch[0], replacement)
+    }
+  }
+}
+
+export class RdDTextEditor {
+
+  static async enrichHTML(text, object) {
+    const competences = await SystemCompendiums.getCompetences(ACTOR_TYPES.personnage);
+    const context = { text, competences, object }
+    await TextRollAlchimie.onReplaceRoll(context)
+    await TextRollCaracCompetence.onReplaceRoll(context)
+    await TextRollFoundry.onReplaceRoll(context)
+    return await TextEditor.enrichHTML(context.text, {
+      relativeTo: object,
+      secrets: object?.isOwner,
+      async: true
+    })
+  }
+
+  static async rollText(event, actor) {
+    const rollMode = event.currentTarget.attributes['data-roll-mode']?.value;
+    switch (rollMode) {
+      case 'foundry':
+        return await TextRollFoundry.onRollText(event, actor)
+      case 'carac':
+        return await TextRollCaracCompetence.onRollText(event, actor)
+      case 'alchimie':
+        return await TextRollAlchimie.onRollText(event, actor)
+    }
+  }
+
+}

module/apps/xregexp-all.js

@@ -2002,7 +2002,7 @@ XRegExp.exec = function (str, regex, pos, sticky) {
  */
 
 
-XRegExp.forEach = function (str, regex, callback) {
+XRegExp.forEach = async function (str, regex, callback) {
   var pos = 0;
   var i = -1;
   var match;
@@ -2014,7 +2014,7 @@ XRegExp.forEach = function (str, regex, callback) {
     // at least. Actually, because of the way `XRegExp.exec` caches globalized versions of
     // regexes, mutating the regex will not have any effect on the iteration or matched strings,
     // which is a nice side effect that brings extra safety.
-    callback(match, ++i, str, regex);
+    await callback(match, ++i, str, regex);
     pos = match.index + (match[0].length || 1);
   }
 };

module/constants.js

@@ -1,13 +1,13 @@
-export const SYSTEM_RDD = 'foundryvtt-reve-de-dragon';
+export const SYSTEM_RDD = 'foundryvtt-reve-de-dragon'
-export const SYSTEM_SOCKET_ID = 'system.foundryvtt-reve-de-dragon';
+export const SYSTEM_SOCKET_ID = 'system.foundryvtt-reve-de-dragon'
-export const LOG_HEAD = 'RdD | ';
+export const LOG_HEAD = 'RdD | '
 
-export const HIDE_DICE = 'hide';
+export const HIDE_DICE = 'hide'
-export const SHOW_DICE = 'show';
+export const SHOW_DICE = 'show'
 
-export const ENTITE_INCARNE = 'incarne';
+export const ENTITE_INCARNE = 'incarne'
-export const ENTITE_NONINCARNE = 'nonincarne';
+export const ENTITE_NONINCARNE = 'nonincarne'
-export const ENTITE_BLURETTE = 'blurette';
+export const ENTITE_BLURETTE = 'blurette'
 
 export const RDD_CONFIG = {
   niveauEthylisme : [

module/item-sheet.js

@@ -1,6 +1,5 @@
 import { RdDItemSort } from "./item-sort.js";
 import { RdDUtility } from "./rdd-utility.js";
-import { RdDAlchimie } from "./rdd-alchimie.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { RdDHerbes } from "./rdd-herbes.js";
 import { RdDGemme } from "./rdd-gemme.js";
@@ -12,8 +11,9 @@ import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { Misc } from "./misc.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
-import { ITEM_TYPES, RdDItem } from "./item.js";
+import { ACTOR_TYPES, ITEM_TYPES, RdDItem } from "./item.js";
 import { FLEUVE_COORD, TMRUtility } from "./tmr-utility.js";
+import { RdDTextEditor } from "./apps/rdd-text-roll.js";
 
 /**
  * Extend the basic ItemSheet for RdD specific items
@@ -97,11 +97,11 @@ export class RdDItemSheet extends ItemSheet {
       name: this.item.name,
       system: this.item.system,
       actorId: this.actor?.id,
-      description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
+      description: await RdDTextEditor.enrichHTML(this.item.system.description, this.item),
-      descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
+      descriptionmj: await RdDTextEditor.enrichHTML(this.item.system.descriptionmj, this.item),
       isComestible: this.item.getUtilisationCuisine(),
       options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable),
-      competences: await SystemCompendiums.getCompetences('personnage'),
+      competences: await SystemCompendiums.getCompetences(ACTOR_TYPES.personnage),
       categories: RdDItem.getCategories(this.item.type),
     }
 
@@ -120,18 +120,17 @@ export class RdDItemSheet extends ItemSheet {
       formData.competences = formData.competences.filter(it => it.isCompetenceArme())
     }
     if (this.item.type == ITEM_TYPES.recettecuisine) {
-      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
+      formData.ingredients = await RdDTextEditor.enrichHTML(this.item.system.ingredients, this.item)
     }
     if (this.item.type == ITEM_TYPES.extraitpoetique) {
-      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, { async: true })
+      formData.extrait = await RdDTextEditor.enrichHTML(this.item.system.extrait, this.item)
-      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, { async: true })
+      formData.texte = await RdDTextEditor.enrichHTML(this.item.system.texte, this.item)
     }
     if (this.item.type == ITEM_TYPES.recettealchimique) {
-      RdDAlchimie.processManipulation(this.item, this.actor?.id);
+      formData.manipulation = await RdDTextEditor.enrichHTML(this.item.system.manipulation, this.item)
-      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, { async: true })
+      formData.utilisation = await RdDTextEditor.enrichHTML(this.item.system.utilisation, this.item)
-      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
+      formData.enchantement = await RdDTextEditor.enrichHTML(this.item.system.enchantement, this.item)
-      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
+      formData.sureffet = await RdDTextEditor.enrichHTML(this.item.system.sureffet, this.item)
-      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
     }
     if (this.item.type == ITEM_TYPES.gemme) {
       formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
@@ -207,17 +206,7 @@ export class RdDItemSheet extends ItemSheet {
     this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).actionHerbe(this.item));
     this.html.find('input[name="system.cacher_points_de_tache"]').change(async event => await this.item.update({ 'system.cacher_points_de_tache': event.currentTarget.checked }));
 
-    this.html.find('.alchimie-tache a').click((event) => {
+    this.html.find('.roll-text').click(async event => await RdDTextEditor.rollText(event, this.actor))
-      let actor = this._getEventActor(event);
-      if (actor) {
-        let recetteId = event.currentTarget.attributes['data-recette-id'].value;
-        let tacheName = event.currentTarget.attributes['data-alchimie-tache'].value;
-        let tacheData = event.currentTarget.attributes['data-alchimie-data'].value;
-        actor.effectuerTacheAlchimie(recetteId, tacheName, tacheData);
-      } else {
-        ui.notifications.info("Impossible trouver un acteur pour réaliser cette tache Alchimique.");
-      }
-    });
 
     if (this.actor) {
       this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
@@ -272,7 +261,7 @@ export class RdDItemSheet extends ItemSheet {
     }
   }
 
-  async supprimerBonusCase(deleteCoord){
+  async supprimerBonusCase(deleteCoord) {
     if (this.item.type == ITEM_TYPES.sort) {
       const oldList = RdDItemSort.getBonusCaseList(this.item)
       const newList = oldList.filter(it => it.case != deleteCoord);

module/item/race.js

@@ -1,6 +1,6 @@
 import { ITEM_TYPES, RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
-import { LIST_CARAC, RdDCarac } from "../rdd-carac.js";
+import { LIST_CARAC_PERSONNAGE, RdDCarac } from "../rdd-carac.js";
 
 export class RdDItemRace extends RdDItem {
 
@@ -12,7 +12,7 @@ export class RdDItemRace extends RdDItem {
 
   static checkRacialMax(actor, code, value) {
     const race = RdDItemRace.getRace(actor)
-    if (code == LIST_CARAC.force.code) {
+    if (code == LIST_CARAC_PERSONNAGE.force.code) {
       if (!race.isForceValid(actor, value)) {
         ui.notifications.warn(race.system.carac.force.limitmessage)
         return false
@@ -55,7 +55,7 @@ export class RdDItemRace extends RdDItem {
     if (value == undefined) {
       value = path ? foundry.utils.getProperty(actor, path) : 0
     }
-    if (code == LIST_CARAC.force.code) {
+    if (code == LIST_CARAC_PERSONNAGE.force.code) {
       return value >= this.getForceMax(actor)
     }
     const max = foundry.utils.getProperty(this, path) ?? -1

module/journal/journal-sheet.js

@@ -0,0 +1,28 @@
+import { RdDTextEditor } from "../apps/rdd-text-roll.js";
+import { SYSTEM_RDD } from "../constants.js";
+import { Misc } from "../misc.js";
+
+
+export class RdDJournalSheet extends JournalTextPageSheet {
+  static register() {
+    DocumentSheetConfig.unregisterSheet(JournalEntryPage, "core", JournalTextPageSheet)
+    DocumentSheetConfig.registerSheet(JournalEntryPage,
+      SYSTEM_RDD,
+      RdDJournalSheet, {
+      types: ["text"],
+      makeDefault: true,
+    });
+  }
+
+  async getData(options) {
+    const journalData = await super.getData(options);
+    journalData.editor.content = await RdDTextEditor.enrichHTML(journalData.document.text.content, this.object)
+    return journalData
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    html.find('.roll-text').click(async event => await RdDTextEditor.rollText(event, this.actor))
+  }
+}

module/rdd-alchimie.js

@@ -1,48 +1,8 @@
-/* -------------------------------------------- */
 import { Misc } from "./misc.js";
 
-const matchOperations = new RegExp(/@(\w*){([\w\-]+)}/ig);
-const matchOperationTerms = new RegExp(/@(\w*){([\w\-]+)}/i);
-/* -------------------------------------------- */
 export class RdDAlchimie {
-
+  static getDifficulte(termes) {
-  /* -------------------------------------------- */
+    let elements = termes.split('-');
-  static processManipulation(recette, actorId = undefined) {
-    let manip = recette.system.manipulation;
-    let matchArray = manip.match(matchOperations);
-    if (matchArray) {
-      for (let matchStr of matchArray) {
-        let result = matchStr.match(matchOperationTerms);
-        if (result[1] && result[2]) {
-          let commande = Misc.upperFirst(result[1]);
-          let replacement = this[`_alchimie${commande}`](recette, result[2], actorId);
-          manip = manip.replace(result[0], replacement);
-        }
-      }
-    }
-    recette.system.manipulation_update = manip;
-  }
-
-  /* -------------------------------------------- */
-  static _alchimieCouleur(recette, couleurs, actorId) {
-    return RdDAlchimie._alchimieLink(recette, couleurs, actorId,  'couleur',  'Température');
-  }
-
-  /* -------------------------------------------- */
-  static _alchimieConsistance(recette, consistances, actorId) {
-    return RdDAlchimie._alchimieLink(recette, consistances, actorId,  'consistance',  'Consistance');
-  }
-
-  static _alchimieLink(recette, termes, actorId, tacheAlchimie, labelTache) {
-    const difficulte = RdDAlchimie.getDifficulte(termes);
-    const link = actorId ? ` <a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="${tacheAlchimie}" data-alchimie-data="${termes}">` : '';
-    const endLink = actorId ? '</a>' : '';
-    return `<span class="alchimie-tache">${link}${labelTache} ${termes} (${difficulte})${endLink}</span>`;
-  }
-
-  /* -------------------------------------------- */
-  static getDifficulte(aspects) {
-    let elements = aspects.split('-');
     let composantes = elements.length;
     let distincts = Object.keys(Misc.classifyFirst(elements, it => it)).length;
     if (distincts == 1) {
@@ -58,5 +18,4 @@ export class RdDAlchimie {
     }
     return 'intellect';
   }
-
 }

module/rdd-carac.js

@@ -37,7 +37,7 @@ const TABLE_CARACTERISTIQUES_DERIVEES = {
   32: { xp: 180, niveau: 11, poids: "1501-2000", poidsMin: 1501, poidsMax: 2000, plusdom: +11, sconst: 10, sust: 17 }
 };
 
-export const LIST_CARAC = {
+export const LIST_CARAC_PERSONNAGE = {
   'taille': { code: 'taille', label: 'Taille', isCarac: true, path: 'system.carac.taille.value' },
   'apparence': { code: 'apparence', label: 'Apparence', isCarac: true, path: 'system.carac.apparence.value' },
   'constitution': { code: 'constitution', label: 'Constitution', isCarac: true, path: 'system.carac.constitution.value' },
@@ -56,18 +56,43 @@ export const LIST_CARAC = {
   'beaute': { code: 'beaute', label: 'Beauté', isCarac: false, path: 'system.background.beaute.value' }
 }
 
+export const LIST_CARAC_AUTRES = {
+  'perception': { code: 'perception', label: 'Perception',  path: 'system.carac.perception.value' },
+}
+
+const LIST_CARAC_DERIVEE = {
+  'melee': { code: "melee", label: 'Mêlée', path: 'system.carac.melee.value' },
+  'tir': { code: "tir", label: 'Tir', path: 'system.carac.tir.value' },
+  'lancer': { code: "lancer", label: 'Lancer', path: 'system.carac.lancer.value' },
+  'derobee': { code: "derobee", label: 'Dérobée', path: 'system.carac.derobee.value' },
+  'chance-actuelle': { code: "chance-actuelle", label: 'Chance actuelle', path: 'system.carac.lancer.value' },
+  'reve-actuel': { code: "reve-actuel", label: 'Rêve actuel', path: 'system.reve.reve.value' },
+}
+
+const LIST_CARAC_ROLL = Object.values(LIST_CARAC_PERSONNAGE).filter(it => it.isCarac && it.code != 'taille')
+  .concat(Object.values(LIST_CARAC_AUTRES))
+  .concat(Object.values(LIST_CARAC_DERIVEE))
+
 export class RdDCarac {
 
+  static caracDetails(name) {
+    let entry = Misc.findFirstLike(name, LIST_CARAC_ROLL, { mapper: it => it.code, description: 'caractéristique', onMessage: m => { } })
+    if (entry) {
+      return entry
+    }
+    return Misc.findFirstLike(name, LIST_CARAC_ROLL, { mapper: it => it.label, description: 'caractéristique' })
+  }
+
   static carac(code) {
-    return LIST_CARAC[code]
+    return LIST_CARAC_PERSONNAGE[code]
   }
 
   static label(code) {
-    return  RdDCarac.carac(code)?.label ?? '---'
+    return RdDCarac.carac(code)?.label ?? '---'
-  }  
+  }
 
   static caracs(filter = it => it.isCarac) {
-    return Object.values(LIST_CARAC).filter(filter)
+    return Object.values(LIST_CARAC_PERSONNAGE).filter(filter)
   }
 
   static isAgiliteOuDerobee(selectedCarac) {

module/rdd-main.js

@@ -75,6 +75,8 @@ import { ExportScriptarium } from "./actor/export-scriptarium/export-scriptarium
 import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js"
 import { RdDActorExportSheet } from "./actor/export-scriptarium/actor-encart-sheet.js"
 import { RdDStatBlockParser } from "./apps/rdd-import-stats.js"
+import { RdDJournalSheet } from "./journal/journal-sheet.js"
+import { RdDTextEditor } from "./apps/rdd-text-roll.js"
 
 /**
  * RdD system
@@ -128,7 +130,7 @@ export class SystemReveDeDragon {
     console.log(`Initializing Reve de Dragon System Settings`)
 
     // preload handlebars templates
-    RdDUtility.preloadHandlebarsTemplates()
+    await RdDUtility.preloadHandlebarsTemplates()
     AppPersonnageAleatoire.preloadHandlebars()
     RdDItemSort.preloadHandlebars()
 
@@ -196,6 +198,7 @@ export class SystemReveDeDragon {
     RdDItemSheet.register(RdDIngredientItemSheet)
     RdDItemSheet.register(RdDServiceItemSheet)
     RdDItemSheet.register(RdDBlessureItemSheet)
+    RdDJournalSheet.register()
 
     Items.registerSheet(SYSTEM_RDD, RdDItemInventaireSheet, {
       types: [

module/rdd-roll.js

@@ -173,7 +173,7 @@ export class RdDRoll extends Dialog {
       this.updateRollResult(html);
       this.html.find("[name='diffLibre']").val(this.rollData.diffLibre);
     });
-    this.html.find('.roll-carac-competence').change((event) => {
+    this.html.find('.roll-text').change((event) => {
       const competence = event.currentTarget.value
       this.rollData.competence = this.rollData.competences.find(it => Grammar.equalsInsensitive(it.name, competence))
       this.updateRollResult(html);

module/rdd-utility.js

@@ -339,7 +339,7 @@ export class RdDUtility {
     Handlebars.registerHelper('typeTmr-name', type => TMRUtility.typeTmrName(type));
     Handlebars.registerHelper('effetRencontre-name', coord => TMRUtility.typeTmrName(coord));
 
-    return loadTemplates(templatePaths);
+    await loadTemplates(templatePaths);
   }
 
   static getItem(itemId, actorId = undefined) {

packs_src/animaux/creature_Chrasme_yL1XStIKWxGnhKvR.yml

@@ -184,16 +184,16 @@ system:
       value: '+0'
       label: +dom
       derivee: true
-    vitesse:
-      type: string
-      value: 12/28
-      label: Vitesse
-      derivee: true
     encombrement:
       type: number
       value: 0
       label: Encombrement
       derivee: false
+    vitesse:
+      type: string
+      value: 12/28
+      label: Vitesse
+      derivee: true
     protection:
       type: number
       value: 4
@@ -207,28 +207,19 @@ system:
       value: 0
       label: Sur-encombrement
   description: >-
-    <h1>Description</h1>
+    <h1>Description</h1><p>Description Le chrasme (prononcer krasme) est une
-
+    sorte de cafard géant à carapace de crabe aux jointures poilues. Il mesure
-    <p>Description Le chrasme (prononcer krasme) est une sorte de cafard
+    en moyenne 1 m de haut sur 1m50 de long, et peut peser jusqu’à 50 kg. Doté
-    g&eacute;ant &agrave; carapace de crabe aux jointures poilues. Il mesure en
+    de mandibules acérées et puissantes, il est redouté pour son venin
-    moyenne 1 m de haut sur 1m50 de long, et peut peser jusqu&rsquo;&agrave; 50
+    mortel.</p><h1>Mœurs</h1><p>Le chrasme vit dans les lieux sombres, cavernes
-    kg. Dot&eacute; de mandibules ac&eacute;r&eacute;es et puissantes, il est
+    et souterrains, où il se nourrit de tout. Paranos le Moindre affirme qu’à
-    redout&eacute; pour son venin mortel.</p>
+    défaut d’une meilleure chère, il peut même se sustenter de cailloux. Il
-
+    déteste la lumière comme son cousin de petite taille, mais a toutefois un
-    <h1>M&oelig;urs</h1>
+    comportement différent: au lieu de fuir, il entre dans une rage féroce et se
-
+    rue sur le porteur de lumière pour le réduire en charpie. Savez-vous, cher
-    <p>Le chrasme vit dans les lieux sombres, cavernes et souterrains, o&ugrave;
+    Paranos, que vous nous faites un peu peur
-    il se nourrit de tout. Paranos le Moindre affirme qu&rsquo;&agrave;
+    ?</p><h1>Venin</h1><p>@UUID[Compendium.foundryvtt-reve-de-dragon.maladies-et-poisons.Item.cFMUtU6LZG0mKeDl]{Venin
-    d&eacute;faut d&rsquo;une meilleure ch&egrave;re, il peut m&ecirc;me se
+    de chrasme}</p><p></p>
-    sustenter de cailloux. Il d&eacute;teste la lumi&egrave;re comme son cousin
-    de petite taille, mais a toutefois un comportement diff&eacute;rent: au lieu
-    de fuir, il entre dans une rage f&eacute;roce et se rue sur le porteur de
-    lumi&egrave;re pour le r&eacute;duire en charpie. Savez-vous, cher Paranos,
-    que vous nous faites un peu peur ?</p>
-
-    <h1>Venin</h1>
-    <p>@UUID[Compendium.foundryvtt-reve-de-dragon.maladies-et-poisons.Item.cFMUtU6LZG0mKeDl]{Venin
-    de chrasme}</p> <p></p>
   race: ''
   notesmj: ''
 ownership:
@@ -311,7 +302,13 @@ prototypeToken:
       texture: null
 _stats:
   systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  systemVersion: 12.0.32
   coreVersion: '12.331'
+  createdTime: null
+  modifiedTime: 1736537299708
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+  compendiumSource: null
+  duplicateSource: null
+flags: {}
 _key: '!actors!yL1XStIKWxGnhKvR'
 

packs_src/animaux/creature_Drakkule_kPDswxsWVnSYitfL.yml

@@ -203,10 +203,10 @@ system:
 
     <p>En combat, quand un drakkule r&eacute;ussit une particuli&egrave;re et
     cause au moins une blessure l&eacute;g&egrave;re, il reste accroch&eacute;
-    &agrave; sa victime qui perd alors automatiquement 1d6 points
+    &agrave; sa victime qui perd alors automatiquement @roll[1d6] points
     d&rsquo;endurance par round sous l&rsquo;effet de la saign&eacute;e. Quand
     l&rsquo;endurance tombe &agrave; z&eacute;ro, le drakkule continue &agrave;
-    la vider de son sang &agrave; raison de 1d6 points de vie par round. Le
+    la vider de son sang &agrave; raison de @roll[1d6] points de vie par round. Le
     drakkule ne se d&eacute;tache que <em>bless&eacute; gravement </em>ou
     <em>sonn&eacute;</em>. Pour se d&eacute;gager, la victime ne peut utiliser
     que Corps &agrave; corps (totaliser 2 points d&rsquo;empoignade) ou une

packs_src/animaux/creature_Grincette_VCRmWnhzCF9tJTD0.yml

@@ -137,7 +137,7 @@ system:
     elles-mêmes, leur grincement involontaire est une torture. Toute
     personne se trouvant dans un rayon de 10m doit manquer un jet
     d’OUÏE à +5. Si le jet réussit, perte de 1 point
-    d’endurance, puis jet de VOLONTÉ à -5. Si le jet de
+    d’endurance, puis jet de @roll[volonté/-5]. Si le jet de
     VOLONTÉ échoue, le personnage est sonné
     jusqu&rsquo;&agrave; la fin du round suivant.</p>
 

packs_src/animaux/creature_Harpie_BgXjyfnolHRQNWCj.yml

@@ -174,8 +174,8 @@ system:
     agressivité s’appliquant aux humanoïdes. S’agissant
     d’un pouvoir inné, elles n’ont ni à monter dans
     les TMR, ni à dépenser de points de rêve. La victime
-    doit jouer un jet de résistance standard, r-8, et en cas
+    doit jouer un jet de résistance standard, @roll[reve-actuel/-8], et en cas
-    d’échec, réussir un jet de VOLONTÉ à -3
+    d’échec, réussir un jet de @roll[Volonté/-3]
     pour pouvoir attaquer la harpie. Le JR n’est à jouer
     qu’une seule fois, tandis qu’en cas d’échec, le jet
     de VOLONTÉ est à jouer tous les rounds. La non

packs_src/animaux/creature_Sir_ne_NZfwIplunfOuuzuD.yml

@@ -201,7 +201,7 @@ system:
 
     <p>La sir&egrave;ne a un chant attractif pouvant porter jusqu&rsquo;&agrave;
     50 m. Toute personne, homme ou femme, percevant ce chant, m&ecirc;me faible
-    et lointain, doit tenter un jet de VOLONT&Eacute; &agrave; -3. Sur toute
+    et lointain, doit tenter un jet de  @roll[Volonté/-3]. Sur toute
     r&eacute;ussite, le personnage est libre de sa d&eacute;cision"; sur tout
     &eacute;chec, il est irr&eacute;sistiblement attir&eacute; vers la source du
     chant. Quand plusieurs sir&egrave;nes chantent simultan&eacute;ment, le jet
@@ -220,7 +220,7 @@ system:
     corps, m&ecirc;me visage. Certaines sir&egrave;nes, plus rarement, donnent
     des illusions d&rsquo;hommes. Contrairement aux illusions des Yeux
     d&rsquo;Hypnos, l&rsquo;illusion des sir&egrave;nes donne lieu &agrave; un
-    jet de r&eacute;sistance (standard, r-8). Comme pour les chants, ce JR est
+    jet de r&eacute;sistance (standard, @roll[reve-actuel/-8]). Comme pour les chants, ce JR est
     global : s&rsquo;il r&eacute;ussit, toutes les sir&egrave;nes apparaissent
     sous leur v&eacute;ritable apparence; s&rsquo;il &eacute;choue, toutes sont
     per&ccedil;ues sous leur apparence illusoire.</p>

packs_src/animaux/creature_Tournedent_e4KXDpAj4seWov6A.yml

@@ -228,8 +228,8 @@ system:
     désolations et autres lieux où Thanatos a laissé son
     empreinte. Ils possèdent le même pouvoir de non
     agressivité s’appliquant aux humanoïdes que la harpie. La
-    victime doit jouer un jet de résistance standard, r-8, et en cas
+    victime doit jouer un jet de résistance standard, @roll[reve-actuel/-8], et en cas
-    d’échec, réussir un jet de VOLONTÉ à -3
+    d’échec, réussir un jet de @roll[Volonté/-3]
     pour pouvoir attaquer le tournedent. Le JR n’est à jouer
     qu’une seule fois, et en cas d’échec, le jet de
     VOLONTÉ est à jouer tous les rounds. La non agressivité

packs_src/arts-et-divertissements/jeu_Le_tisonnier_mRzHzrubRkyqHUTC.yml

@@ -17,9 +17,8 @@ system:
     à long terme, mais tout autant de l’empathie pour bluffer lors
     des surench&egrave;res.</p>
 
-    <p>Pour simuler une partie, jouer un jet de CHANCE &agrave; z&eacute;ro
+    <p>Pour simuler une partie, jouer un jet de @roll[chance/0]
-    (ajust&eacute; astrologiquement), suivi d&rsquo;un jet d&rsquo;EMPATHIE/Jeu
+    (ajust&eacute; astrologiquement), suivi d&rsquo;un jet d&rsquo;@roll[EMPATHIE/Jeu/0], et additionner les points de t&acirc;che obtenus par
-    &agrave; z&eacute;ro, et additionner les points de t&acirc;che obtenus par
     les deux jets. Le vainqueur est celui qui en totalise le plus.</p>
   descriptionmj: ''
   type: carte

packs_src/entites-de-cauchemar/entite_Haine_TBvcGbyEzW0Eoctf.yml

@@ -104,7 +104,7 @@ system:
     Dès qu’il se sent lésé, offensé, victime
     d’un tort même insignifiant, il faut qu’il se venge
     et que sa vengeance soit mortelle. Il peut jouer un jet de
-    VOLONTÉ/ moral à zéro. Si le jet réussit, il
+    @roll[Volonté/0] (avec moral). Si le jet réussit, il
     peut encore laisser couver sa haine ; s’il échoue, il doit agir
     immédiatement. Il est conseillé que le gardien des rêves
     prenne alors le contrôle du personnage s’il s’agit

packs_src/entites-de-cauchemar/entite_Peur_M6cQoL6oeAX5IOYa.yml

@@ -104,7 +104,7 @@ system:
     pareille. Son moral tombe directement à -3 et ne pourra pas remonter
     tant que durera la possession. Chaque fois qu’une action dangereuse se
     présente, incluant toute action de combat y compris l’esquive,
-    la victime doit jouer un jet de VOLONTÉ/moral à zéro.
+    la victime doit jouer un jet de @roll[Volonté/0] avec moral.
     Si ce jet échoue, la victime ne fait rien que trembler et claquer des
     dents.</p>
   race: ''

packs_src/entites-de-cauchemar/entite_Porte_poisse_wcHy6fiEWUnLBSUv.yml

@@ -132,8 +132,8 @@ system:
     les désolations et les ruines. Il combat avec son bec
     acéré. Outre les dommages qu’il cause (+dom +1), chaque
     fois qu’il porte un coup, même une simple
-    contusion-éraflure, sa victime doit réussir un jet de points
+    contusion-éraflure, sa victime doit réussir un jet de @roll[reve-actuel]
-    de rêve actuels ajusté négativement au niveau de
+    ajusté négativement au niveau de
     l’entité, ou perdre 1 point de chance. Les points de chance
     ainsi perdus peuvent être regagnés selon la règle
     normale. Détruite, l’entité ne laisse pour tout vestige

packs_src/entites-de-cauchemar/entite_Quauquemaire_47YUryMgpq1UnLuB.yml

@@ -158,8 +158,8 @@ system:
     <p>Les quauquemaires hantent les endroits lugubres et d&eacute;sol&eacute;s,
     les ruines principalement. Ils chantent au coucher du soleil, et leur chant
     est si lugubre, prometteur d&rsquo;angoisse et de cauchemar, que quiconque
-    l&rsquo;entend et manque un jet de points de r&ecirc;ve actuels
+    l&rsquo;entend et manque un jet de points de @roll[reve-actuel] ajust&eacute;
-    ajust&eacute; n&eacute;gativement au niveau de l&rsquo;entit&eacute;, ne
+    n&eacute;gativement au niveau de l&rsquo;entit&eacute;, ne
     fait que des cauchemars hideux au cours de sa prochaine nuit de sommeil. En
     termes de r&egrave;gles, cela signifie : pas de souvenir de
     l&rsquo;arch&eacute;type et donc pas de jet de stress au matin ; pas de

packs_src/entites-de-cauchemar/entite_Squelette_Fl95F6S0OrCbqQbY.yml

@@ -134,8 +134,8 @@ system:
     nécropoles, catacombes et autres lieux de sépulture. Comme les
     autres entités, leur raison d’être est de
     détruire. Le spectacle d’un squelette est d’une horreur
-    tellement contre nature qu’il demande un jet de VOLONTÉ
+    tellement contre nature qu’il demande un jet de @roll[Volonté/-3].
-    à -3. En cas d’échec, le personnage est frappé
+    En cas d’échec, le personnage est frappé
     d’effroi. En termes de règles, il est en demi- surprise
     jusqu’à la fin du round suivant. Une fois détruit, les
     ossements constitutifs du squelette s’éparpillent sur le sol,

packs_src/faune-flore-mineraux/herbe_Herbe_de_lune_x4wGXTdmrzaOn8Sh.yml

@@ -19,8 +19,8 @@ system:
     dans une pipe ou préparée en décoction. Dans les deux
     cas, une dose doit être composée de 7 brins. Dès la dose
     absorbée (bue ou fumée), le consommateur doit jouer un JR
-    r-force, c’est-à-dire un jet de points de rêve
+    r-force, c’est-à-dire un jet de @roll[reve-actuel] ajusté
-    ajusté négativement à la force de l’herbe. Si le
+     négativement à la force de l’herbe. Si le
     JR réussit, aucun effet ne se produit"; s’il échoue, le
     consommateur gagne immédiatement un nombre de points de rêve
     égal à la force de l’herbe, puis en échange,

packs_src/invocations/personnage_Marmiton_de_Pavois_kB7OSWKvd6m9v0dB.yml

@@ -506,8 +506,8 @@ system:
     <p style="box-sizing: border-box; user-select: text; color: #191813;
     font-family: CaslonAntique; font-size: 16px; letter-spacing: 1px;
     text-align: justify; background-color: #f5f5f0;"><strong style="box-sizing:
-    border-box; user-select: text;">VOLONT&Eacute;/moral &agrave; -
+    border-box; user-select: text;">@roll[Volonté/Cuisibe] (avec moral) &agrave; -
-    (degr&eacute; d&rsquo;exotisme) + (Cuisine)</strong></p>
+    (degr&eacute; d&rsquo;exotisme) </strong></p>
 
     <p style="box-sizing: border-box; user-select: text; color: #191813;
     font-family: CaslonAntique; font-size: 16px; letter-spacing: 1px;

packs_src/maladies-et-poisons/maladie_Fi_vre_brune_nyruCPiWDd8Scv44.yml

@@ -23,31 +23,29 @@ system:
 
     <p>Les points de VUE perdus ne peuvent &ecirc;tre regagn&eacute;s que quand
     la maladie est enti&egrave;rement gu&eacute;rie. &Agrave; chaque point de
-    vie regagn&eacute;, jouer un jet de CONSTITUTION ajust&eacute;
+    vie regagn&eacute;, jouer un jet de @roll[Constitution] ajust&eacute;
     n&eacute;gativement par les points de vie toujours manquants. Puis selon le
     r&eacute;sultat:</p>
 
     <ul>
 
-    <li><strong><em>Particuli&egrave;re&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;
+    <li><strong><em>Particuli&egrave;re</em></strong>&nbsp; Regain de 2 points
-    &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;
+    de VUE</li>
-    </em></strong>Regain de 2 points de VUE</li>
 
-    <li><strong><em>Normale et significative</em></strong>&nbsp; &nbsp; &nbsp;
+    <li><strong><em>Normale et significative</em></strong>&nbsp; Regain de 1
-    Regain de 1 point de VUE</li>
+    point de VUE</li>
 
-    <li><strong><em>&Eacute;chec et &Eacute;chec particulier</em></strong>&nbsp;
+    <li><strong><em>&Eacute;chec et &Eacute;chec particulier</em></strong>&nbsp; 
     Aucun regain</li>
 
-    <li><strong><em>&Eacute;chec total</em>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;
+    <li><strong><em>&Eacute;chec total</em></strong>&nbsp; Aggravation,
-    &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;
+    re-perte d&rsquo;un point de VUE</li>
-    </strong>Aggravation, re-perte d&rsquo;un point de VUE</li>
 
     </ul>
 
     <p>Si tous les points de vie ont &eacute;t&eacute; regagn&eacute;s et
     qu&rsquo;il manque toujours un ou plusieurs points de VUE, jouer un jet de
-    CONSTITUTION &agrave; z&eacute;ro toutes les 12 heures, et appliquer les
+    @roll[Constitution/0] toutes les 12 heures, et appliquer les
     m&ecirc;mes r&eacute;sultats que ci-dessus.</p>
 
     <p>Une potion d&rsquo;herbes de soin enchant&eacute;e peut faire regagner

packs_src/recettes-alchimiques/recettealchimique_Potion_de_Dext_rit__47Wrb4HZnXprP43E.yml

@@ -16,10 +16,10 @@ system:
 
     <p>Il conf&egrave;re un bonus de +5 &agrave; tous les jets de
     DEXT&Eacute;RIT&Eacute;, de Tir et de Lancer, et est suivi d&rsquo;une perte
-    de 1d6 points d&rsquo;endurance.</p>
+    de @roll[1d6] points d&rsquo;endurance.</p>
   enchantement: >-
     <p>Si la potion est enchant&eacute;e, l&rsquo;effet magique n&rsquo;a lieu
-    que si un jet de r&eacute;sistance standard est &eacute;chou&eacute;.</p>
+    que si un jet de r&eacute;sistance standard @roll[reve-actuel] est &eacute;chou&eacute;.</p>
 
     <p>L&rsquo;effet se produit alors dans le round cons&eacute;cutif au jet de
     r&eacute;sistance (au lieu de 2 minutes) et voit sa dur&eacute;e
@@ -32,8 +32,8 @@ system:
     sur-effet se produise &nbsp;: la perte totale du go&ucirc;t et de
     l&rsquo;odorat (ODORAT-GO&Ucirc;T tombe &agrave; z&eacute;ro).</p>
 
-    <p>Pour le regain, jouer tous les matins un jet d&rsquo;ODORAT- GO&Ucirc;T
+    <p>Pour le regain, jouer tous les matins un jet 
-    (originel) &agrave; z&eacute;ro et regagner selon le bar&egrave;me des
+    @roll[odorat-gout] (originel)et regagner selon le bar&egrave;me des
     points de t&acirc;che.</p>
   manipulation: >-
     <ul><li>Piler à froid <strong>2 doigts de graisse de carpe</strong> et

packs_src/recettes-alchimiques/recettealchimique_Potion_de_Force_lGGUyONSD7vJpxsb.yml

@@ -23,7 +23,8 @@ system:
     points d&rsquo;endurance.</p>
   enchantement: >-
     <p>Si la potion est enchant&eacute;e, l&rsquo;effet magique n&rsquo;a lieu
-    que si un jet de r&eacute;sistance standard est &eacute;chou&eacute;.</p>
+    que si un jet de r&eacute;sistance standard @roll[reve-actuel] est
+    &eacute;chou&eacute;.</p>
 
     <p>L&rsquo;effet se produit alors dans le round cons&eacute;cutif au jet de
     r&eacute;sistance (au lieu de 2 minutes) et voit sa dur&eacute;e

packs_src/sorts-hypnos/sort_D_rision_7q0zFbBhxYdf6OZ2.yml

@@ -18,8 +18,8 @@ system:
 
     <p>Si un personnage ainsi rendu dérisoire participe à un combat, il peut
     tenter une fois par round de lancer une plaisanterie en guise d’attaque
-    (tout en esquivant/parant normalement). Il joue pour cela APPARENCE/ Comédie
+    (tout en esquivant/parant normalement). Il joue pour cela @roll[APPARENCE/Comédie]
-    à -1d4 (ce d4 résume les conditions ponctuelles plus ou moins propices, et
+    à -@roll[1d4] (ce d4 résume les conditions ponctuelles plus ou moins propices, et
     il est en fait soustrait du bonus de +4 conféré par le sort). Puis selon la
     réussite, on obtient un ajustement :</p>
 
@@ -56,10 +56,10 @@ system:
     </table>
 
     <p>Tous les autres engagés dans la mêlée capables de comprendre la blague, y
-    compris les compagnons du plaisantin, jouent alors VOLONTÉ/<em>moins
+    compris les compagnons du plaisantin, jouent alors @roll[Volonté] <em>moins
     </em>moral à + (ajustement) + (Comédie facultativement). Tout échec provoque
     un état de demi-surprise pour la fin du round et tout le round suivant. En
-    cas d’échec total à son jet d’APPARENCE/Comédie, le plaisantin est le seul à
+    cas d’échec total à son jet d’@roll[Apparence/Comédie], le plaisantin est le seul à
     rire de sa blague, et entre automatiquement en demi-surprise jusqu’à la fin
     du round suivant.</p>
   descriptionmj: ''

packs_src/sorts-hypnos/sort_Fatigue_2lsRjTYEef4HdQDB.yml

@@ -7,7 +7,7 @@ system:
   description: >-
     <p>Ce sort provoque l’illusion d’une grande fatigue, qui est interprétée
     comme une fatigue réelle. La victime marque instantanément 6 cases de
-    fatigue, puis joue un jet de VOLONTÉ à -5 avec un éventuel bonus de +1 par
+    fatigue, puis joue un jet de @roll[Volonté/-5] avec un éventuel bonus de +1 par
     point de CONSTITUTION au-dessus de 15. Si le jet de VOLONTÉ réussit, il n’y
     a pas d’autre conséquence que les cases de fatigue. Si le jet échoue, tout
     dépend alors de l’activité actuelle de la cible. Si elle est en condition de

packs_src/sorts-hypnos/sort_Fou_rire_ze53LdwhuqUFMvqw.yml

@@ -9,7 +9,7 @@ system:
     humanoïdes. La suggestion d’une idée drolatique plonge la
     cible dans un irrépressible fou-rire, automatique le premier round.
     Puis pour les rounds suivants, la cible doit réussir un jet de
-    VOLONT&Eacute;/ <em>moins </em>moral &agrave; -5, ou continuer &agrave;
+    @roll[Volonté/-5] <em>moins </em>moral, ou continuer &agrave;
     rire. Tant que la cible rit, elle est consid&eacute;r&eacute;e en
     <em>demi-surprise</em>.</p>
   descriptionmj: ''

packs_src/sorts-hypnos/sort_Marmitons_de_Pavois_CRLUPWjMpBxO5jkV.yml

@@ -25,7 +25,7 @@ system:
     pouvant aller de 0 à 7 (1d8-1). Pour en supporter le goût "étrange et venu
     d’ailleurs", les convives doivent réussir un jet de :</p>
 
-    <p><strong>VOLONTÉ/moral à - (degré d’exotisme) + (Cuisine)</strong></p>
+    <p><strong>@roll[Volonté/Cuisine] (avec moral) à - (degré d’exotisme)</strong></p>
 
     <p>Si le jet est réussi, le personnage n’est pas choqué par l’exotisme et
     peut même en apprécier la gastronomie. Pour tout échec, le personnage est

packs_src/sorts-hypnos/sort_Peur_KnyfTatO8GmV5wtt.yml

@@ -7,7 +7,7 @@ system:
   description: >-
     <p>L’effet de Peur ne s’applique qu’aux humanoïdes. La suggestion d’une
     horreur intense cause une peur réelle. La victime doit réussir un jet de
-    VOLONTÉ à -5 ou être sonnée en cas d’échec. Le jet de VOLONTÉ doit être
+    @roll[Volonté/-5] ou être sonnée en cas d’échec. Le jet de VOLONTÉ doit être
     renouvelé de round en round jusqu’à ce qu’il réussisse. Tant qu’il échoue,
     la victime reste en <em>demi-surprise</em>.</p>
   descriptionmj: ''

packs_src/sorts-hypnos/sort_Transfiguration_ktFI49xqZ0mGfTzt.yml

@@ -18,7 +18,7 @@ system:
     impossible d’obtenir le sosie parfait de quelqu’un, tout comme il est
     difficile à un peintre d’obtenir un portrait parfaitement ressemblant. Si un
     haut-rêvant désire donner à sa cible la même apparence que quelqu’un
-    d’autre, il doit jouer un jet de VUE à -8, et obtiendra une ressemblance
+    d’autre, il doit jouer un jet de @roll[Vue/-8], et obtiendra une ressemblance
     plus ou moins approchante selon son genre de résultat. Inventer un humanoïde
     anonyme quoique doté de traits spécifiques (blond, gros nez, une verrue au
     menton, etc.) s’obtient sans problème. Comme toujours en ce qui concerne

packs_src/sorts-hypnos/sort_Tympan_d_Hypnos_D9eSbTGp3i5gdbc5.yml

@@ -18,7 +18,7 @@ system:
     @UUID[Compendium.foundryvtt-reve-de-dragon.rappel-des-regles.JournalEntry.ZmMoOtUdgjMd4cNs]{Conflit
     de sens}. Le cri illusoire d’un animal doit être le cri d’un animal connu,
     et vouloir donner à un humanoïde la même voix que quelqu’un d’autre demande
-    un jet d’OUÏE à -8, avec les mêmes remarques que pour Transfiguration. Noter
+    un jet d’@roll[Ouie/-8], avec les mêmes remarques que pour Transfiguration. Noter
     que seule la voix est changée, sans affecter en rien le contenu du discours.
     Enfin, de même que la taille reste la même pour les illusions visuelles, le
     volume sonore de l’illusion auditive est celui de la cible. Une souris ne

packs_src/sorts-narcos/sort__caille_d_activit____sEBhR48HagKNbkob.yml

@@ -37,9 +37,9 @@ system:
     créateur de l'objet et non de l'utilisateur, et quand le sort a une durée
     HN, c'est également l'heure de naissance du créateur. Le seul paramétrage
     inutile est l'heure de naissance de la cible en prévision du jet de
-    résistance. Quand un JR est possible, il est toujours r-8, quelle que soit
+    résistance. Quand un JR est possible, il est toujours @roll[reve-actuel/-8],
-    la cible. S'il réussit, le sort se dissipe aussitôt sans revenir vers
+    quelle que soit la cible. S'il réussit, le sort se dissipe aussitôt sans
-    l'utilisateur.</p>
+    revenir vers l'utilisateur.</p>
 
     <p>L'objet réussit son lancer, sans jet de dés. Lancer un sort via un objet
     magique n'est pas plus économique en points de rêve que de la lancer

packs_src/sorts-oniros/sort_Brouillard_3JPK8LhnK2RpKoeF.yml

@@ -12,9 +12,9 @@ system:
     arrêtant totalement la vue. De l’intérieur, il est
     pareillement impossible de voir ce qui se passe à
     l’extérieur"; on peut seulement tenter de voir ce qui se passe
-    à l’intérieur en réussissant un jet de VUE
+    à l’intérieur en réussissant un jet de
-    ajusté négativement par le nombre de points de rêve
+    @roll[Vue] ajusté négativement par le nombre de points de
-    d&eacute;pens&eacute;s.</p>
+    r&ecirc;ve d&eacute;pens&eacute;s.</p>
   descriptionmj: ''
   draconic: Oniros
   duree: HN

packs_src/sorts-thanatos/sort_Animer_un_squelette_O1QllxIvIkWxntmO.yml

@@ -19,7 +19,7 @@ system:
     zombis, et contrairement aux entités de cauchemar incarnées qui peuvent
     dépasser cette limite, la caractéristique RÊVE d'un squelette invoqué ne
     peut jamais dépasser sa caractéristique TAILLE. Sa hideur est telle que
-    quiconque l'aperçoit doit réussir un jet de VOLONTÉ à -3 ou être en
+    quiconque l'aperçoit doit réussir un jet de @roll[VOLONTÉ/-3] ou être en
     demi-surprise jusqu'à la fin du round suivant.</p>
 
     <p>Un squelette invoqué est aux ordres de son invocateur et n'agit qu'aux

packs_src/sorts-thanatos/sort_Fletrissement_2Bf9INN5L1WSTrnf.yml

@@ -13,7 +13,7 @@ system:
     à zéro) ou subir en retour l'effet de son sort.</p>
 
     <p>Le flétrissement n'est pas définitif. Chaque jour, à lextrême fin du
-    Château Dormant, la victime peur jouer un jet d'APPARENCE à zéro en prenant
+    Château Dormant, la victime peur jouer un jet d'@roll[APPARENCE/0] en prenant
     non pas son APPARENCE actuelle, mais son APPARENCE initiale. Toute réussite
     : regain de 1 point en APPARENCE et de 2 points de Beauté. Tout échec : pas
     de regain pour aujourd'hui. Dans tous les cas, ni l'APPARENCE ni la Beauté

packs_src/sorts-thanatos/sort_Griffe_de_Thanatos___gZHrkEnR88mEv67I.yml

@@ -10,7 +10,7 @@ system:
     maîtrise. Cette dernière est automatique, comme avec les écailles de Narcos,
     mais au lieu de coûter des points de rêve, elle coûte un nombre de
     <em>points de vie</em> égal au nombre de griffes, chaque point de vie perdu
-    s'accompagnant d'une perte d'1d6 points d'endurance. Il n'y a pas de jet de
+    s'accompagnant d'une perte d'@roll[1d6] points d'endurance. Il n'y a pas de jet de
     résistance. La maîtrise (et la perte de points de vie) a lieu au moment où
     l'objet contenant la griffe est utilisé selon sa fonction : arme frappant,
     bague au doigt, bracelet au poignet, etc. Si l'objet n'a pas de fonction

packs_src/sorts-thanatos/sort_Griffe_morbide_de_Thanatos___qaCjZ5V874ZImf9l.yml

@@ -8,7 +8,7 @@ system:
     <p>Le principe de fonctionnement de la griffe morbide de Thanatos est
     analogue à celui de la simple griffe. C'en est une variante plus mortelle.
     La maîtrise ayant lieu, la victime perd autant de points de vie qu'il y a de
-    griffes morbides, ainsi que 1d6 points d'endurance par point de vie perdu,
+    griffes morbides, ainsi que @roll[1d6] points d'endurance par point de vie perdu,
     puis joue une JR standard r-8. JR réussi, l'effet s'arrête là ; JR échoué,
     le mal s'est implanté en elle. Tous les jours, à l'extrême fin du Château
     Dormant, la victime de la griffe morbide doit tenter un jet de Vie et en

packs_src/souffles-de-dragon/souffle_Vieillissement_instantan__dArTQtFwTssAyl90.yml

@@ -4,7 +4,7 @@ type: souffle
 img: systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp
 system:
   description: >-
-    <p>Le vieillissement est de 1d7 ans. Jouer un jet de Constitution ajusté
+    <p>Le vieillissement est de 1d7 ans. Jouer un jet de @roll[Constitution] ajusté
     négativement au nombre d’années perdues. En cas d’échec, perte définitive
     d’un point en Constitution.</p>
   descriptionmj: ''

packs_src/tetes-de-dragon-pour-haut-revants/tete_Pr_sent_des_cit_s_E4a4O1IdrgbNGpVy.yml

@@ -10,7 +10,8 @@ system:
     rêves, soit un Passeur, soit un Messager, dès qu’elle est visitée par le
     demi-rêve du haut-rêvant. Il n’y a pas de d7 à tirer, le haut-rêvant choisit
     librement ce qu’il préfère, et la rencontre est considérée automatiquement
-    maîtrisée, Fleurs, Messagers et Passeurs ayant une force de 2d6 points. Dès
+    maîtrisée, Fleurs, Messagers et Passeurs ayant une force de @roll[2d6]
+    points. Dès
     qu’elle a offert son présent, la cité redevient normale en ce qui concerne
     le tirage des rencontres; il n’y a qu’un seul présent par cité. La tête de
     Dragon prend fin dès que toutes les cités (22) ont été visitées; entretemps,

packs_src/tetes-de-dragon-pour-tous-personnages/tete_Don_d_apprivoiser_les_animaux_wlbbh75GZWks3Ehb.yml

@@ -5,13 +5,13 @@ flags: {}
 img: systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp
 system:
   description: >-
-    <p>Un jet d’Empathie à zéro permet de rendre amical un animal non agressif
+    <p>Un jet d’@roll[empathie/0] permet de rendre amical un animal non agressif
-    ou de rendre neutre un animal agressif. Les animaux restent neutres\amicaux
+    ou de rendre neutre un animal agressif. Les animaux restent neutres/amicaux
     jusqu’à ce qu’un événement significatif, agression ou autre, vienne tout
     remettre en question. Ce n’est pas un lien magique. Un seul jet par animal.
     Un animal rendu neutre par ce don ne peut pas ensuite être rendu amical par
-    un second jet. Enfin l’étendue de la neutralité\ amitié de l’animal dépend
+    un second jet. Enfin l’étendue de la neutralité/amitié de l’animal dépend de
-    de chaque espèce et est à décider dans chaque cas particulier par le gardien
+    chaque espèce et est à décider dans chaque cas particulier par le gardien
     des rêves. Cumulable.</p>
   descriptionmj: ''
   frequence: 6
@@ -24,7 +24,12 @@ folder: null
 sort: 0
 _stats:
   systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  systemVersion: 12.0.33
   coreVersion: '12.331'
+  createdTime: null
+  modifiedTime: 1736617623199
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+  compendiumSource: null
+  duplicateSource: null
 _key: '!items!wlbbh75GZWks3Ehb'
 

packs_src/tetes-de-dragon-pour-tous-personnages/tete_Don_d_orientation_slnKVCfHbLwbXi4Z.yml

@@ -5,9 +5,9 @@ flags: {}
 img: systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp
 system:
   description: >-
-    <p>Un jet d’Empathie à zéro permet de deviner la direction du nord, et d’une
+    <p>Un jet d’@roll[empathie/0] permet de deviner la direction du nord, et
-    manière générale de retrouver une certaine direction quand on est perdu ou
+    d’une manière générale de retrouver une certaine direction quand on est
-    par manque de visibilité (nuit, brouillard, souterrain, etc.).
+    perdu ou par manque de visibilité (nuit, brouillard, souterrain, etc.).
     Cumulable.</p>
   descriptionmj: ''
   frequence: 6
@@ -20,7 +20,12 @@ folder: null
 sort: 0
 _stats:
   systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  systemVersion: 12.0.33
   coreVersion: '12.331'
+  createdTime: null
+  modifiedTime: 1736617654367
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+  compendiumSource: null
+  duplicateSource: null
 _key: '!items!slnKVCfHbLwbXi4Z'
 

packs_src/tetes-de-dragon-pour-tous-personnages/tete_Don_de_contr_ler_son_sommeil_N6guZDGzzZjt9GrR.yml

@@ -5,10 +5,10 @@ flags: {}
 img: systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp
 system:
   description: >-
-    <p>Un jet de Volonté à zéro permet de s’endormir instantanément et de dormir
+    <p>Un jet de @roll[Volonté/0] permet de s’endormir instantanément et de
-    au moins jusqu’à la fin de la prochaine heure, même sans aucun point de
+    dormir au moins jusqu’à la fin de la prochaine heure, même sans aucun point
-    fatigue. Permet également de se réveiller au bout d’un laps de temps donné,
+    de fatigue. Permet également de se réveiller au bout d’un laps de temps
-    "programmé" au moment de s’endormir. Cumulable.</p>
+    donné, "programmé" au moment de s’endormir. Cumulable.</p>
   descriptionmj: ''
   frequence: 6
   hautrevant: false
@@ -20,7 +20,12 @@ folder: null
 sort: 0
 _stats:
   systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  systemVersion: 12.0.33
   coreVersion: '12.331'
+  createdTime: null
+  modifiedTime: 1736617674311
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+  compendiumSource: null
+  duplicateSource: null
 _key: '!items!N6guZDGzzZjt9GrR'
 

packs_src/tetes-de-dragon-pour-tous-personnages/tete_Don_de_sentir_le_mensonge_OZZbiBiLlM6Y8lEY.yml

@@ -5,8 +5,8 @@ flags: {}
 img: systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp
 system:
   description: >-
-    <p>Un jet d’Empathie à zéro permet de deviner que l’on vous ment, sans pour
+    <p>Un jet d’@roll[empathie/0] permet de deviner que l’on vous ment, sans
-    autant connaître la teneur du mensonge. Ne s’applique qu’au mensonge
+    pour autant connaître la teneur du mensonge. Ne s’applique qu’au mensonge
     volontaire, pas au mensonge par omission ni par ignorance. Cumulable.</p>
   descriptionmj: ''
   frequence: 6
@@ -19,7 +19,12 @@ folder: null
 sort: 0
 _stats:
   systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  systemVersion: 12.0.33
   coreVersion: '12.331'
+  createdTime: null
+  modifiedTime: 1736617720094
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+  compendiumSource: null
+  duplicateSource: null
 _key: '!items!OZZbiBiLlM6Y8lEY'
 

packs_src/tetes-de-dragon-pour-tous-personnages/tete_Don_de_voir_la_magie_QWouooLkM7pE2yG1.yml

@@ -5,10 +5,10 @@ flags: {}
 img: systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp
 system:
   description: >-
-    <p>Un jet de VUE à zéro permet de distinguer une aura bleutée délimitant les
+    <p>Un jet de @roll[vue/0] permet de distinguer une aura bleutée délimitant
-    zones magiques d’Oniros ou entourant les objets enchantés ou les créatures
+    les zones magiques d’Oniros ou entourant les objets enchantés ou les
-    soumises à l’effet d’un sort ou d’un rituel. Un seul essai par zone, objet
+    créatures soumises à l’effet d’un sort ou d’un rituel. Un seul essai par
-    ou personnage. Cumulable.</p>
+    zone, objet ou personnage. Cumulable.</p>
   descriptionmj: ''
   frequence: 6
   hautrevant: false
@@ -20,7 +20,12 @@ folder: null
 sort: 0
 _stats:
   systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  systemVersion: 12.0.33
   coreVersion: '12.331'
+  createdTime: null
+  modifiedTime: 1736617743760
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+  compendiumSource: null
+  duplicateSource: null
 _key: '!items!QWouooLkM7pE2yG1'
 

styles/simple.css

@@ -1067,12 +1067,13 @@ li label.compteur {
   max-width: 90%;
 }
 
-.alchimie-tache {
+a.roll-text.content-link {
+  color: hsla(300, 70%, 40%, 0.5);
   font-weight: bold;
-  background: rgb(182, 180, 179);
+  border: 1px solid var(--color-border-dark-tertiary);
-  border: 1px solid rgba(72, 46, 28, 1);
   border-radius: 0.25rem;
-  color: rgba(212, 27, 27, 0.5);
+  white-space: nowrap;
+  word-break: break-all;
 }
 
 .window-app.sheet .window-content .tooltip:hover .tooltiptext {

template.json

@@ -3,9 +3,9 @@
     "types": ["personnage", "creature", "entite", "commerce", "vehicule"],
     "templates": {
       "description": {
-        "description": "Description ...",
+        "description": "",
         "race": "",
-        "notesmj": "Notes du MJ"
+        "notesmj": ""
       },
       "subacteurs": {
         "subacteurs": {

templates/apps/link-text-roll-alchimie.hbs

@@ -0,0 +1,8 @@
+<span><a class="roll-text content-link"
+    data-roll-mode="alchimie"
+    {{#if recette}}data-recette-id="{{recette.id}}"{{/if}}
+    data-manip="{{manip}}"
+    data-termes="{{termes}}"
+    data-tooltip="{{upperFirst carac.label}}/Alchimie à {{diff}}">
+{{~manip}} {{termes~}}
+</a></span>

templates/apps/link-text-roll-carac-competence.hbs

@@ -0,0 +1,9 @@
+<span><a class="roll-text content-link"
+    data-roll-mode="carac"
+    {{#if competence}}data-competence="{{competence}}"{{/if~}}
+    {{#if diff}}data-diff="{{diff}}"{{/if~}}
+    data-carac-code="{{carac.code}}">
+{{~uppercase carac.label~}}
+{{#if competence}} / {{upperFirst competence}}{{/if~}}
+{{#if diff}} à {{diff}}{{/if~}}
+</a></span>

templates/apps/link-text-roll-foundry.hbs

@@ -0,0 +1,5 @@
+<span><a class="roll-text content-link" 
+  data-roll-mode="foundry"
+  data-roll-foundry="{{formula}}">
+{{~formula~}}
+</a></span>

templates/item-recettealchimique-sheet.html

@@ -9,7 +9,7 @@
     <div class="flexcol">
       <span><label class="item-label">Manipulation : </label></span>
       <div class="form-group medium-editor">
-        {{editor manipulation_update target="system.manipulation" button=true owner=options.isOwner editable=options.editable engine="prosemirror"}}
+        {{editor manipulation target="system.manipulation" button=true owner=options.isOwner editable=options.editable engine="prosemirror"}}
       </div>
     </div>
     <div class="flexcol">

templates/partial-roll-competences.html

@@ -1,7 +1,7 @@
 {{#if @root.competences}}
 <div class="form-group">
-  <label for="roll-carac-competence">Compétence</label>
+  <label for="roll-text">Compétence</label>
-  <select name="roll-carac-competence" class="roll-carac-competence" data-dtype="String">
+  <select name="roll-text" class="roll-text" data-dtype="String">
     {{#select ''}}<option value="">Sans compétence</option>
     {{>"systems/foundryvtt-reve-de-dragon/templates/enum-competence.html"}}
     {{/select}}