v10.0.28

Version 10.0.28
Fix: Organisation boutons/messages d'équipement
2022-10-14 21:52:38 +02:00 · 2022-10-14 21:47:34 +02:00 · 2022-10-14 00:58:26 +02:00 · 2022-10-14 00:48:05 +02:00 · 2022-10-14 00:46:42 +02:00 · 2022-10-14 00:45:53 +02:00
29 changed files with 770 additions and 475 deletions
--- a/module/actor.js
+++ b/module/actor.js
@ -33,8 +33,9 @@ import { RollDataAjustements } from "./rolldata-ajustements.js";
 import { DialogItemAchat } from "./dialog-item-achat.js";
 import { RdDItem } from "./item.js";
 import { RdDPossession } from "./rdd-possession.js";
-import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { RdDConfirm } from "./rdd-confirm.js";
+import { DialogValidationEncaissement } from "./dialog-validation-encaissement.js";

 const POSSESSION_SANS_DRACONIC = {
  img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
@ -116,17 +117,13 @@ export class RdDActor extends Actor {
    const isPersonnage = actorData.type == "personnage";
    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
    if (actorData.items) {
-      let actor = await super.create(actorData, options);
-      if (isPersonnage) {
-        await actor.checkMonnaiePresence();
-      }
-      return actor;
+      return await super.create(actorData, options);
    }

    if (isPersonnage) {
-      const competences = await RdDUtility.loadCompendium(RdDItemCompetence.actorCompendium(actorData.type));
+      const competences = await RdDUtility.loadItems(it => it.isCompetencePersonnage(), 'foundryvtt-reve-de-dragon.competences');
      actorData.items = competences.map(i => i.toObject());
-      actorData.items = actorData.items.concat(Monnaie.monnaiesData());
+      actorData.items = actorData.items.concat(Monnaie.monnaiesStandard());
    }
    else {
      actorData.items = [];
@ -143,9 +140,9 @@ export class RdDActor extends Actor {

    // Make separate methods for each Actor type (character, npc, etc.) to keep
    // things organized.
-    if (this.type === 'personnage') this._prepareCharacterData(this)
-    if (this.type === 'creature') this._prepareCreatureData(this)
-    if (this.type === 'vehicule') this._prepareVehiculeData(this)
+    if (this.isPersonnage()) this._prepareCharacterData(this)
+    if (this.isCreature()) this._prepareCreatureData(this)
+    if (this.isVehicule()) this._prepareVehiculeData(this)
  }

  /* -------------------------------------------- */
@ -180,8 +177,6 @@ export class RdDActor extends Actor {
    await this.cleanupConteneurs();
    await this.computeEncombrementTotalEtMalusArmure();
    this.computeEtatGeneral();
-    // Sanity check
-    await this.checkMonnaiePresence();
  }

  /* -------------------------------------------- */
@ -194,15 +189,6 @@ export class RdDActor extends Actor {
    }
  }

-  /* -------------------------------------------- */
-  async checkMonnaiePresence() { // Ajout opportuniste si les pièces n'existent pas.
-    if (!this.items) return; // Sanity check during import
-    let manquantes = Monnaie.monnaiesManquantes(this);
-    if (manquantes.length > 0) {
-      await this.createEmbeddedDocuments('Item', manquantes, { renderSheet: false });
-    }
-  }
-
  /* -------------------------------------------- */
  isCreature() {
    return this.type == 'creature' || this.type == 'entite';
@ -211,6 +197,9 @@ export class RdDActor extends Actor {
  isPersonnage() {
    return this.type == 'personnage';
  }
+  isVehicule() {
+    return this.type == 'vehicule';
+  }
  /* -------------------------------------------- */
  isHautRevant() {
    return this.isPersonnage() && this.system.attributs.hautrevant.value != ""
@ -355,7 +344,7 @@ export class RdDActor extends Actor {
  }
  /* -------------------------------------------- */
  getDraconicList() {
-    return this.items.filter(it => it.type == 'competence' && it.system.categorie == 'draconic')
+    return this.items.filter(it => it.isCompetencePersonnage() && it.system.categorie == 'draconic')
  }
  /* -------------------------------------------- */
  getBestDraconic() {
@ -2304,12 +2293,7 @@ export class RdDActor extends Actor {

  /* -------------------------------------------- */
  computeDraconicAndSortIndex(sortList) {
-    let draconicList = this.getDraconicList()
-      .map(it => {
-        it = duplicate(it)
-        it.system.defaut_carac = "reve";
-        return it;
-      });
+    let draconicList = this.getDraconicList();
    for (let sort of sortList) {
      let draconicsSort = this.getDraconicsSort(draconicList, sort).map(it => it.name);
      for (let index = 0; index < draconicList.length && sort.system.listIndex == undefined; index++) {
@ -2329,7 +2313,7 @@ export class RdDActor extends Actor {
      case "detection d'aura":
        return draconicList;
      case "annulation de magie":
-        return draconicList.filter(it => !Grammar.toLowerCaseNoAccent(it.name).includes('thanatos'));
+        return draconicList.filter(it => !RdDItemCompetence.isThanatos(it));
    }
    return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
  }
@ -3342,20 +3326,39 @@ export class RdDActor extends Actor {
  }

  /* -------------------------------------------- */
-  async encaisserDommages(rollData, attacker = undefined, defenderRoll = undefined) {
+  async encaisserDommages(rollData, attacker = undefined, show = undefined) {
    if (attacker && !await attacker.accorder(this, 'avant-encaissement')) {
      return;
    }
+    this.validerEncaissement(rollData, show);
+  }

-    console.log("encaisserDommages", rollData)
+  async validerEncaissement(rollData, show) {
+    if (ReglesOptionelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
+        RdDActor.remoteActorCall({
+          actorId: this.id,
+          method: 'validerEncaissement',
+          args: [rollData, show]
+        });
+        return;
+    }
+    const armure = await this.computeArmure(rollData);
+    if (ReglesOptionelles.isUsing('validation-encaissement-gr')) {
+      DialogValidationEncaissement.validerEncaissement(this, rollData, armure, show, (encaissement, show) => this._appliquerEncaissement(encaissement, show));
+    }
+    else {
+      let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
+      await this._appliquerEncaissement(encaissement, show)
+    }
+  }

+  async _appliquerEncaissement(encaissement, show) {
    let santeOrig = duplicate(this.system.sante);
-    let encaissement = await this.jetEncaissement(rollData);

    this.ajouterBlessure(encaissement); // Will upate the result table
    const perteVie = this.isEntite()
      ? { newValue: 0 }
-      : await this.santeIncDec("vie", - encaissement.vie);
+      : await this.santeIncDec("vie", -encaissement.vie);
    const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, encaissement.critiques > 0);

    this.computeEtatGeneral();
@ -3368,7 +3371,7 @@ export class RdDActor extends Actor {
      jetEndurance: perteEndurance.jetEndurance,
      endurance: santeOrig.endurance.value - perteEndurance.newValue,
      vie: this.isEntite() ? 0 : (santeOrig.vie.value - perteVie.newValue),
-      show: defenderRoll?.show ?? {}
+      show: show ?? {}
    });

    await ChatUtility.createChatWithRollMode(this.name, {
@ -3386,65 +3389,6 @@ export class RdDActor extends Actor {
    }
  }

-  /* -------------------------------------------- */
-  async jetEncaissement(rollData) {
-    let formula = "2d10";
-
-    // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionelles.isUsing('degat-minimum-malus-libre')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        formula += "min" + valeurMin;
-      }
-    }
-    // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionelles.isUsing('degat-ajout-malus-libre')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        formula += "+" + valeurMin;
-      }
-    }
-
-    let roll = await RdDDice.roll(formula);
-
-    // 1 dé fait au minmum la difficulté libre
-    if (ReglesOptionelles.isUsing('degat-minimum-malus-libre-simple')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        if (roll.terms[0].results[0].result < valeurMin) {
-          roll.terms[0].results[0].result = valeurMin;
-        } else if (roll.terms[0].results[1].result < valeurMin) {
-          roll.terms[0].results[1].result = valeurMin;
-        }
-        roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
-      }
-    }
-
-    const armure = await this.computeArmure(rollData);
-    const jetTotal = roll.total + rollData.dmg.total - armure;
-
-    let encaissement = RdDUtility.selectEncaissement(jetTotal, rollData.dmg.mortalite)
-    let over20 = Math.max(jetTotal - 20, 0);
-    encaissement.dmg = rollData.dmg;
-    encaissement.dmg.loc = rollData.dmg.loc ?? await RdDUtility.getLocalisation(this.type);
-    encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;'
-    encaissement.roll = roll;
-    encaissement.armure = armure;
-    encaissement.total = jetTotal;
-    encaissement.vie = await RdDActor._evaluatePerte(encaissement.vie, over20);
-    encaissement.endurance = await RdDActor._evaluatePerte(encaissement.endurance, over20);
-    encaissement.penetration = rollData.arme?.system.penetration ?? 0;
-
-    return encaissement;
-  }
-
-  /* -------------------------------------------- */
-  static async _evaluatePerte(formula, over20) {
-    let perte = new Roll(formula, { over20: over20 });
-    await perte.evaluate({ async: true });
-    return perte.total;
-  }
-
  /* -------------------------------------------- */
  ajouterBlessure(encaissement) {
    if (this.type == 'entite') return; // Une entité n'a pas de blessures
@ -3610,33 +3554,11 @@ export class RdDActor extends Actor {

  /* -------------------------------------------- */
  getFortune() {
-    let monnaies = this.itemTypes['monnaie'];
-    if (monnaies.length < 4) {
-      ui.notifications.error("Problème de monnaies manquantes, impossible de payer correctement!")
-      throw "Problème de monnaies manquantes, impossible de payer correctement!";
-    }
-    return monnaies.map(m => Number(m.system.valeur_deniers) * Number(m.system.quantite))
+    return this.itemTypes['monnaie']
+      .map(m => Number(m.system.valeur_deniers) * Number(m.system.quantite))
      .reduce(Misc.sum(), 0);
  }

-  /* -------------------------------------------- */
-  async optimizeArgent(fortuneTotale) {
-    let monnaies =  this.itemTypes['monnaie'];
-    let parValeur = Misc.classifyFirst(monnaies, it => it.system.valeur_deniers);
-    let nouvelleFortune = {
-      1000: Math.floor(fortuneTotale / 1000), // or
-      100: Math.floor(fortuneTotale / 100) % 10, // argent
-      10: Math.floor(fortuneTotale / 10) % 10, // bronze
-      1: fortuneTotale % 10 // étain
-    }
-    console.log('RdDActor.optimizeArgent', fortuneTotale, 'nouvelleFortune', nouvelleFortune, 'monnaie_par_valeur', parValeur);
-    let updates = [];
-    for (const [valeur, nombre] of Object.entries(nouvelleFortune)) {
-      updates.push({ _id: parValeur[valeur].id, 'system.quantite': nombre });
-    }
-    await this.updateEmbeddedDocuments('Item', updates);
-  }
-
  /* -------------------------------------------- */
  async depenserDeniers(depense, dataObj = undefined, quantite = 1, toActorId) {
    depense = Number(depense);
@ -3653,10 +3575,9 @@ export class RdDActor extends Actor {
    }
    else {
      if (fortune >= depense) {
-        fortune -= depense;
        const toActor = game.actors.get(toActorId)
        await toActor?.ajouterDeniers(depense, this.id);
-        await this.optimizeArgent(fortune);
+        await Monnaie.optimiser(this, fortune - depense);
        msg = `Vous avez payé <strong>${depense} Deniers</strong>${toActor ? " à " + toActor.name : ''}, qui ont été soustraits de votre argent.`;
        RdDAudio.PlayContextAudio("argent"); // Petit son

@ -3679,18 +3600,19 @@ export class RdDActor extends Actor {
  }

  async depenser(depense) {
-    depense = Number(depense);
-    let fortune = this.getFortune();
-    let reste = fortune - depense;
+    let reste = this.getFortune() - Number.parseInt(depense);
    if (reste >= 0) {
-      fortune -= depense;
-      await this.optimizeArgent(fortune);
+      await Monnaie.optimiser(this, reste);
    }
    return reste;
  }

  async ajouterDeniers(gain, fromActorId = undefined) {
    gain = Number.parseInt(gain);
+    if (gain < 0) {
+      ui.notifications.error(`Impossible d'ajouter un gain de ${gain} <0`);
+      return;
+    }
    if (gain == 0) {
      return;
    }
@ -3703,9 +3625,7 @@ export class RdDActor extends Actor {
    }
    else {
      const fromActor = game.actors.get(fromActorId)
-      let fortune = this.getFortune();
-      fortune += gain;
-      await this.optimizeArgent(fortune);
+      await Monnaie.optimiser(this, gain + this.getFortune());

      RdDAudio.PlayContextAudio("argent"); // Petit son
      ChatMessage.create({
@ -3735,8 +3655,7 @@ export class RdDActor extends Actor {
        actorId: achat.vendeurId ?? achat.acheteurId,
        method: 'achatVente',
        args: [achat]
-      },
-      );
+      });
      return;
    }

@ -3744,8 +3663,8 @@ export class RdDActor extends Actor {
    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined;
    const messageVente = game.messages.get(achat.chatMessageIdVente);
    const html = await messageVente.getHTML();
-    const buttonAcheter = html.find(".button-acheter")[0];
-    const vente = DialogItemAchat.prepareVenteData(buttonAcheter, achat.vendeurId, vendeur, acheteur);
+    const button = html.find(".button-acheter")[0];
+    const vente = DialogItemAchat.venteData(button);
    const itemId = vente.item._id;
    const isItemEmpilable = "quantite" in vente.item.system;

@ -4146,7 +4065,7 @@ export class RdDActor extends Actor {

  /* -------------------------------------------- */
  async setEffect(statusId, status) {
-    if (this.isEntite() || this.type == 'vehicule') {
+    if (this.isEntite() || this.isVehicule()) {
      return;
    }
    console.log("setEffect", statusId, status)
@ -4176,7 +4095,7 @@ export class RdDActor extends Actor {

  /* -------------------------------------------- */
  async onPreUpdateItem(item, change, options, id) {
-    if (item.type == 'competence' && item.system.defaut_carac && item.system.xp) {
+    if (item.isCompetencePersonnage() && item.system.defaut_carac && item.system.xp) {
      await this.checkCompetenceXP(item.name, item.system.xp);
    }
  }
--- a/module/chat-utility.js
+++ b/module/chat-utility.js
@ -129,7 +129,7 @@ export class ChatUtility {

  /* -------------------------------------------- */
  static getUsers(filter) {
-    return Misc.getUsers().filter(filter).map(user => user.id);
+    return game.users.filter(filter).map(user => user.id);
  }

  /* -------------------------------------------- */
--- a/module/dialog-item-achat.js
+++ b/module/dialog-item-achat.js
@ -1,34 +1,52 @@

+import { Monnaie } from "./item-monnaie.js";
 import { Misc } from "./misc.js";
 import { RdDUtility } from "./rdd-utility.js";

 export class DialogItemAchat extends Dialog {

-  static async onButtonAcheter(event) {
-    const buttonAcheter = event.currentTarget;
-    if (!buttonAcheter.attributes['data-jsondata']?.value) {
-      ui.notifications.warn("Impossible d'acheter: informations sur l'objet manquantes")
-      return;
-    }
-    const chatMessageIdVente = RdDUtility.findChatMessageId(buttonAcheter);
-
-    const vendeurId = buttonAcheter.attributes['data-vendeurId']?.value;
+  static venteData(button) {
+    const vendeurId = button.attributes['data-vendeurId']?.value;
    const vendeur = vendeurId ? game.actors.get(vendeurId) : undefined;
    const acheteur = RdDUtility.getSelectedActor();
-
+    const json = button.attributes['data-jsondata']?.value;
    if (!acheteur && !vendeur) {
      ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
-      return;
+      return undefined;
+    }
+    if (!json) {
+      ui.notifications.warn("Impossible d'acheter: informations sur l'objet manquantes")
+      return undefined;
    }

-    let venteData = DialogItemAchat.prepareVenteData(buttonAcheter, vendeurId, vendeur, acheteur);
+    const prixLot = Monnaie.arrondiDeniers(button.attributes['data-prixLot']?.value ?? 0);
+    return {
+      item: json ? JSON.parse(json) : undefined,
+      vendeurId: vendeurId,
+      vendeur: vendeur,
+      acheteur: acheteur,
+      tailleLot: parseInt(button.attributes['data-tailleLot']?.value ?? 1),
+      quantiteIllimite: button.attributes['data-quantiteIllimite']?.value == 'true',
+      quantiteNbLots: parseInt(button.attributes['data-quantiteNbLots']?.value),
+      choix: {
+        nombreLots: 1,
+        seForcer: false,
+        supprimerSiZero: true
+      },
+      prixLot: prixLot,
+      prixTotal: prixLot,
+      isVente: prixLot > 0,
+      chatMessageIdVente: RdDUtility.findChatMessageId(button)
+    };
+  }
+  static async onAcheter(venteData) {
    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-achat.html`, venteData);
-    const dialog = new DialogItemAchat(html, vendeur, acheteur, venteData, chatMessageIdVente);
+    const dialog = new DialogItemAchat(html, venteData);
    dialog.render(true);
  }

-  constructor(html, vendeur, acheteur, venteData, chatMessageIdVente) {
-    const isConsommable = venteData.item.type == 'nourritureboisson';
+  constructor(html, venteData) {
+    const isConsommable = venteData.item.type == 'nourritureboisson' && venteData.acheteur?.isPersonnage();
    let options = { classes: ["dialogachat"], width: 400, height: isConsommable ? 450 : 350, 'z-index': 99999 };

    const actionAchat = venteData.prixLot > 0 ? "Acheter" : "Prendre";
@ -47,42 +65,17 @@ export class DialogItemAchat extends Dialog {

    super(conf, options);

-    this.vendeur = vendeur;
-    this.acheteur = acheteur;
-    this.chatMessageIdVente = chatMessageIdVente;
    this.venteData = venteData;
  }

-  static prepareVenteData(buttonAcheter, vendeurId, vendeur, acheteur) {
-    const jsondata = buttonAcheter.attributes['data-jsondata']?.value;
-    const prixLot = parseInt(buttonAcheter.attributes['data-prixLot']?.value ?? 0);
-    return {
-      item: JSON.parse(jsondata),
-      vendeurId: vendeurId,
-      vendeur: vendeur,
-      acheteur: acheteur,
-      tailleLot: parseInt(buttonAcheter.attributes['data-tailleLot']?.value ?? 1),
-      quantiteIllimite: buttonAcheter.attributes['data-quantiteIllimite']?.value == 'true',
-      quantiteNbLots: parseInt(buttonAcheter.attributes['data-quantiteNbLots']?.value),
-      choix: {
-        nombreLots: 1,
-        seForcer: false,
-        supprimerSiZero: true
-      },
-      prixLot: prixLot,
-      prixTotal: prixLot,
-      isVente: prixLot > 0
-    };
-  }
-
  async onAchat() {
    await $(".nombreLots").change();
-    (this.vendeur ?? this.acheteur).achatVente({
+    (this.venteData.vendeur ?? this.venteData.acheteur).achatVente({
      userId: game.user.id,
-      vendeurId: this.vendeur?.id,
-      acheteurId: this.acheteur?.id,
+      vendeurId: this.venteData.vendeur?.id,
+      acheteurId: this.venteData.acheteur?.id,
      prixTotal: this.venteData.prixTotal,
-      chatMessageIdVente: this.chatMessageIdVente,
+      chatMessageIdVente: this.venteData.chatMessageIdVente,
      choix: this.venteData.choix
    });
  }
--- a/module/dialog-item-vente.js
+++ b/module/dialog-item-vente.js
@ -3,7 +3,7 @@ import { Misc } from "./misc.js";

 export class DialogItemVente extends Dialog {

-  static async create(item, callback) {
+  static async display(item, callback) {
    const quantite = item.isConteneur() ? 1 : item.system.quantite;
    const venteData = {
      item: item,
@ -20,7 +20,7 @@ export class DialogItemVente extends Dialog {
      isOwned: item.isOwned,
    };
    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-vente.html`, venteData);
-    return new DialogItemVente(venteData, html, callback);
+    return new DialogItemVente(venteData, html, callback).render(true);
  }

  constructor(venteData, html, callback) {
--- a/module/dialog-validation-encaissement.js
+++ b/module/dialog-validation-encaissement.js
@ -0,0 +1,70 @@
+import { HIDE_DICE, SHOW_DICE } from "./constants.js";
+import { RdDUtility } from "./rdd-utility.js";
+
+/**
+ * Extend the base Dialog entity by defining a custom window to perform roll.
+ * @extends {Dialog}
+ */
+export class DialogValidationEncaissement extends Dialog {
+
+  static async validerEncaissement(actor, rollData, armure, show, onEncaisser) {
+    let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: HIDE_DICE });
+    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-validation-encaissement.html', {
+      actor: actor,
+      rollData: rollData,
+      encaissement: encaissement,
+      show: show
+    });
+    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, onEncaisser);
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  constructor(html, actor, rollData, armure, encaissement, show, onEncaisser) {
+    // Common conf
+    let buttons = {
+      "valider": { label: "Valider", callback: html => this.validerEncaissement() },
+      "annuler": { label: "Annuler", callback: html => { } },
+    };
+
+    let dialogConf = {
+      title: "Validation d'encaissement",
+      content: html,
+      buttons: buttons,
+      default: "valider"
+    }
+
+    let dialogOptions = {
+      classes: ["rdddialog"],
+      width: 350,
+      height: 290
+    }
+
+    // Select proper roll dialog template and stuff
+    super(dialogConf, dialogOptions);
+
+    this.actor = actor
+    this.rollData = rollData;
+    this.armure = armure;
+    this.encaissement = encaissement;
+    this.show = show;
+    this.onEncaisser = onEncaisser;
+    this.forceDiceResult = {total: encaissement.roll.result };
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    html.find('input.encaissement-roll-result').keyup(async event => {
+      this.forceDiceResult.total = event.currentTarget.value;
+      this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: HIDE_DICE, forceDiceResult: this.forceDiceResult});
+      $('label.encaissement-total').text(this.encaissement.total);
+      $('label.encaissement-blessure').text(this.encaissement.blessures)
+    });
+  }
+
+  async validerEncaissement() {
+    this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: SHOW_DICE, forceDiceResult: this.forceDiceResult});
+    this.onEncaisser(this.encaissement, this.show)
+  }
+}
--- a/module/item-competence.js
+++ b/module/item-competence.js
@ -57,8 +57,8 @@ const competence_xp_cumul = _buildCumulXP();
 export class RdDItemCompetence extends Item {

  /* -------------------------------------------- */
-  static actorCompendium(actorType) {
-    return compendiumCompetences[actorType];
+  static actorCompendium(actorType = undefined) {
+    return compendiumCompetences[actorType ?? 'personnage'];
  }

  /* -------------------------------------------- */
@ -84,27 +84,36 @@ export class RdDItemCompetence extends Item {

  /* -------------------------------------------- */
  static getVoieDraconic(competences, voie) {
-    return RdDItemCompetence.findCompetence(competences.filter(it => RdDItemCompetence.isDraconic(it)), voie);
+    return RdDItemCompetence.findFirstItem(competences, voie, {
+       preFilter: it => it.isCompetence() && RdDItemCompetence.isDraconic(it),
+       description: 'Draconic',
+      });
  }

  /* -------------------------------------------- */
  static isCompetenceArme(competence) {
-    switch (competence.system.categorie) {
-      case 'melee':
-        return competence.name != 'Esquive';
-      case 'tir':
-      case 'lancer':
-        return true;
+    if (competence.isCompetence()) {
+      switch (competence.system.categorie) {
+        case 'melee':
+          return !Grammar.toLowerCaseNoAccent(competence.name).includes('esquive');
+        case 'tir':
+        case 'lancer':
+          return true;
+      }
    }
    return false;
  }

  /* -------------------------------------------- */
  static isArmeUneMain(competence) {
-    return competence.name.toLowerCase().includes("1 main");
+    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("1 main");
  }
  static isArme2Main(competence) {
-    return competence.name.toLowerCase().includes("2 main");
+    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("2 main");
+  }
+
+  static isThanatos(competence) {
+    return competence.isCompetencePersonnage() && Grammar.toLowerCaseNoAccent(competence.name).includes('thanatos');
  }

  /* -------------------------------------------- */
@ -133,7 +142,7 @@ export class RdDItemCompetence extends Item {

  /* -------------------------------------------- */
  static computeXP(competence) {
-    const factor = competence.name.includes('Thanatos') ? 2 : 1; // Thanatos compte double !
+    const factor = RdDItemCompetence.isThanatos(competence) ? 2 : 1; // Thanatos compte double !
    const xpNiveau = RdDItemCompetence.computeDeltaXP(competence.system.base, competence.system.niveau ?? competence.system.base);
    const xp = competence.system.xp ?? 0;
    const xpSort = competence.system.xp_sort ?? 0;
@ -213,21 +222,18 @@ export class RdDItemCompetence extends Item {
    if (idOrName == undefined) {
      return undefined;
    }
-    options = mergeObject(options, {
-      preFilter: it => RdDItemCompetence.isCompetence(it),
-      description: 'compétence',
-    });
-    return list.find(it => it.id == idOrName && RdDItemCompetence.isCompetence(it))
-      ?? Misc.findFirstLike(idOrName, list, options);
+    options = mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, {overwrite: false});
+    return RdDItemCompetence.findFirstItem(list, idOrName, options);
  }

  /* -------------------------------------------- */
  static findCompetences(list, name) {
-    return Misc.findAllLike(name, list, { filter: it => RdDItemCompetence.isCompetence(it), description: 'compétence' });
+    return Misc.findAllLike(name, list, { filter: it => it.isCompetence(), description: 'compétence' });
  }

-  static isCompetence(item) {
-    return item.type == 'competence' || item.type == 'competencecreature';
+  static findFirstItem(list, idOrName, options) {
+    return list.find(it => it.id == idOrName && options.preFilter(it))
+      ?? Misc.findFirstLike(idOrName, list, options);
  }

  /* -------------------------------------------- */
--- a/module/item-monnaie.js
+++ b/module/item-monnaie.js
@ -1,44 +1,32 @@
 import { Misc } from "./misc.js";
-import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
+import { LOG_HEAD } from "./constants.js";

-const MONNAIES_STANDARD = [
-  {
-    name: "Etain (1 denier)", type: 'monnaie',
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
-    system: { quantite: 0, valeur_deniers: 1, encombrement: 0.001, description: "" }
-  },
-  {
-    name: "Bronze (10 deniers)", type: 'monnaie',
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_bronze_epees.webp",
-    system: { quantite: 0, valeur_deniers: 10, encombrement: 0.002, description: "" }
-  },
-  {
-    name: "Argent (1 sol)", type: 'monnaie',
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_argent_sol.webp",
-    system: { quantite: 0, valeur_deniers: 100, encombrement: 0.003, description: "" }
-  },
-  {
-    name: "Or (10 sols)", type: 'monnaie',
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
-    system: { quantite: 0, valeur_deniers: 1000, encombrement: 0.004, description: "" }
-  }
-]
-const VALEURS_STANDARDS = MONNAIES_STANDARD.map(it =>it.system.valeur_deniers);
+const MONNAIE_ETAIN = {
+  name: "Etain (1 denier)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
+  system: { quantite: 0, valeur_deniers: 1, encombrement: 0.001, description: "" }
+};
+const MONNAIE_BRONZE = {
+  name: "Bronze (10 deniers)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_bronze_epees.webp",
+  system: { quantite: 0, valeur_deniers: 10, encombrement: 0.002, description: "" }
+};
+const MONNAIE_ARGENT = {
+  name: "Argent (1 sol)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_argent_sol.webp",
+  system: { quantite: 0, valeur_deniers: 100, encombrement: 0.003, description: "" }
+};
+const MONNAIE_OR = {
+  name: "Or (10 sols)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
+  system: { quantite: 0, valeur_deniers: 1000, encombrement: 0.004, description: "" }
+};
+
+const MONNAIES_STANDARD = [MONNAIE_ETAIN, MONNAIE_BRONZE, MONNAIE_ARGENT, MONNAIE_OR];

 export class Monnaie {

-  static isSystemMonnaie(item, items) {
-    if (item.type == 'monnaie')    {
-      const valeur = item.system.valeur_deniers;
-      if (VALEURS_STANDARDS.includes(valeur)) {
-        const monnaiesDeValeur = items.filter(it => it.type == 'monnaie' && it.system.valeur_deniers == valeur)
-        return monnaiesDeValeur.length<=1;
-      }
-    }
-    return false;
-  }
-
-  static monnaiesData() {
+  static monnaiesStandard() {
    return MONNAIES_STANDARD;
  }

@ -56,10 +44,50 @@ export class Monnaie {
  }

  static arrondiDeniers(sols) {
-    return sols.toFixed(2);
+    return Number(sols).toFixed(2);
  }

  static triValeurDenier() {
    return Misc.ascending(item => item.system.valeur_deniers)
  }
+
+  static async creerMonnaiesStandard(actor) {
+    await actor.createEmbeddedDocuments('Item', MONNAIES_STANDARD, { renderSheet: false });
+  }
+
+  static async creerMonnaiesDeniers(actor, fortune) {
+    await actor.createEmbeddedDocuments('Item', [Monnaie.creerDeniers(fortune)], { renderSheet: false });
+  }
+
+  static creerDeniers(fortune) {
+    const deniers = duplicate(MONNAIE_ETAIN);
+    deniers.system.quantite = fortune;
+    return deniers;
+  }
+
+  static async optimiser(actor, fortune) {
+    let reste = fortune;
+    let monnaies = actor.itemTypes['monnaie'];
+    let updates = [];
+    let parValeur = Misc.classifyFirst(monnaies, it => it.system.valeur_deniers);
+    for (let valeur of  [1000, 100, 10, 1]) {
+      const itemPiece = parValeur[valeur];
+      const piecesDeCetteValeur = Math.floor(reste / valeur);
+      if (itemPiece) {
+        if (piecesDeCetteValeur != itemPiece.system.quantite) {
+          updates.push({ _id: parValeur[valeur].id, 'system.quantite': piecesDeCetteValeur });
+        }
+        reste -= piecesDeCetteValeur*valeur;
+      }
+    }
+    console.log('Monnaie.optimiser', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', reste);
+    if (updates.length > 0) {
+      await actor.updateEmbeddedDocuments('Item', updates);
+    }
+    if (reste>0){
+      // créer le reste en deniers fortune en deniers
+      await Monnaie.creerMonnaiesDeniers(actor, reste);
+    }
+  }
+
 }
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@ -90,11 +90,10 @@ export class RdDItemSheet extends ItemSheet {
    if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
      formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
      formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
-      formData.competences = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.competences')
+      formData.competences = await RdDUtility.loadItems(it => it.isCompetencePersonnage(), RdDItemCompetence.actorCompendium(this.actor?.type))
    }
    if (this.item.type == 'arme') {
-      formData.competences = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.competences', it => RdDItemCompetence.isCompetenceArme(it));
-      console.log(formData.competences)
+      formData.competences = await RdDUtility.loadItems(it => RdDItemCompetence.isCompetenceArme(it),  RdDItemCompetence.actorCompendium(this.actor?.type))
    }
    if (this.item.type == 'recettecuisine') {
      formData.ingredients =  await TextEditor.enrichHTML(this.object.system.ingredients, {async: true})
@ -115,7 +114,7 @@ export class RdDItemSheet extends ItemSheet {
        formData.system.prdate = this.dateUpdated;
        this.dateUpdated = undefined;
      }
-      RdDHerbes.updatePotionData(formData);
+      await RdDHerbes.updatePotionData(formData);
    }
    if (formData.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
      formData.isIngredientPotionBase = true;
@ -160,7 +159,7 @@ export class RdDItemSheet extends ItemSheet {
    html.find(".categorie").change(event => this._onSelectCategorie(event));

    html.find('.sheet-competence-xp').change((event) => {
-      if (this.item.type == 'competence') {
+      if (this.item.isCompetencePersonnage()) {
        RdDUtility.checkThanatosXP(this.item.name);
      }
    });
--- a/module/item.js
+++ b/module/item.js
@ -21,7 +21,7 @@ const typesObjetsOeuvres = ["oeuvre", "recettecuisine", "musique", "chant", "dan
 const typesObjetsDraconiques = ["queue", "ombre", "souffle", "tete", "signedraconique", "sortreserve"]
 const typesObjetsConnaissance = ["meditation", "recettealchimique", "sort"]
 const typesObjetsEffet = ["possession", "poison", "maladie"]
-const typesObjetsCompetence = ["competence", "compcreature"]
+const typesObjetsCompetence = ["competence", "competencecreature"]
 const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
 const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
 densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ 
@ -29,7 +29,7 @@ densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierre

 export const defaultItemImg = {
  competence: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
-  compcreature: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
+  competencecreature: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
  arme: "systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_gnome.webp",
  armure: "systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.webp",
  conteneur: "systems/foundryvtt-reve-de-dragon/icons/objets/sac_a_dos.webp",
@ -77,6 +77,9 @@ export class RdDItem extends Item {
    return typesObjetsOeuvres
  }

+  isCompetencePersonnage() {
+    return this.type == 'competence'
+  }
  isCompetence() {
    return typesObjetsCompetence.includes(this.type)
  }
@ -180,8 +183,8 @@ export class RdDItem extends Item {
    this.system.magique = categorie.includes('enchante');
    if (this.system.magique) {
      if (categorie.includes('soin') || categorie.includes('repos')) {
-        // TODO: utiliser calculePointsRepos / calculePointsGuerison
-        this.system.puissance = RdDHerbes.calculePuissancePotion(this);
+        // TODO: utiliser calculPointsRepos / calculPointsGuerison
+        this.system.puissance = RdDHerbes.calculPuissancePotion(this);
      }
    }
  }
@ -268,26 +271,23 @@ export class RdDItem extends Item {
  async proposerVente() {
    console.log(this);
    if (this.isConteneurNonVide()) {
-      ui.notifications.warn(`Votre ${this.name} n'est pas vide, pas possible de le donner ou le vendre`);
+      ui.notifications.warn(`Votre ${this.name} n'est pas vide, pas possible de le proposer`);
      return;
    }
-    const dialog = await DialogItemVente.create(this, (vente) => this._onProposerVente(vente))
-    dialog.render(true);
-  }
-
-  async _onProposerVente(venteData) {
-    venteData["properties"] = this.getProprietes();
-    if (venteData.isOwned) {
-      if (venteData.quantiteNbLots * venteData.tailleLot > venteData.quantiteMax) {
-        ui.notifications.warn(`Vous avez ${venteData.quantiteMax} ${venteData.item.name}, ce n'est pas suffisant pour vendre ${venteData.quantiteNbLots} de ${venteData.tailleLot}`)
-        return;
+    await DialogItemVente.display(this, async (vente) =>  {
+      vente["properties"] = this.getProprietes();
+      if (vente.isOwned) {
+        if (vente.quantiteNbLots * vente.tailleLot > vente.quantiteMax) {
+          ui.notifications.warn(`Vous avez ${vente.quantiteMax} ${vente.item.name}, ce n'est pas suffisant pour vendre ${vente.quantiteNbLots} de ${vente.tailleLot}`)
+          return;
+        }
      }
-    }
-    venteData.jsondata = JSON.stringify(venteData.item);
-
-    console.log(venteData);
-    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', venteData);
-    ChatMessage.create(RdDUtility.chatDataSetup(html));
+      vente.jsondata = JSON.stringify(vente.item);
+  
+      console.log(vente);
+      let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
+      ChatMessage.create(RdDUtility.chatDataSetup(html));
+    });
  }

  /* -------------------------------------------- */
--- a/module/misc.js
+++ b/module/misc.js
@ -105,17 +105,6 @@ export class Misc {
    return params.reduce((a, b) => a + separator + b);
  }

-
-  static getEntityTypeLabel(entity) {
-    const documentName = entity?.documentName
-    const type = entity?.type
-    if (documentName === 'Actor' || documentName === 'Item') {
-      const label = CONFIG[documentName]?.typeLabels?.[type] ?? type;
-      return game.i18n.has(label) ? game.i18n.localize(label) : t;
-    }
-    return type;
-  }
-
  static connectedGMOrUser(ownerId = undefined) {
    if (ownerId && game.user.id == ownerId) {
      return ownerId;
@ -123,16 +112,12 @@ export class Misc {
    return Misc.firstConnectedGM()?.id ?? game.user.id;
  }

-  static getUsers() {
-    return game.version ? game.users : game.users.entities;
-  }
-
  static getActiveUser(id) {
-    return Misc.getUsers().find(u => u.id == id && u.active);
+    return game.users.find(u => u.id == id && u.active);
  }  

  static firstConnectedGM() {
-    return Misc.getUsers().filter(u => u.isGM && u.active).sort(Misc.ascending(u => u.id)).find(u => u.isGM && u.active);
+    return game.users.filter(u => u.isGM && u.active).sort(Misc.ascending(u => u.id)).find(u => u.isGM && u.active);
    
  }

@ -153,7 +138,7 @@ export class Misc {

  /* -------------------------------------------- */
  static findPlayer(name) {
-    return Misc.findFirstLike(name, Misc.getUsers(), { description: 'joueur' });
+    return Misc.findFirstLike(name, game.users, { description: 'joueur' });
  }

  /* -------------------------------------------- */
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@ -1,5 +1,5 @@
 import { ChatUtility } from "./chat-utility.js";
-import { ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetence } from "./item-competence.js";
@ -688,27 +688,81 @@ export class RdDCombat {
  }

  /* -------------------------------------------- */
-  verifierDistance( rollData ) {
-    if ( rollData.competence.system.categorie == "tir" || 
-         rollData.competence.system.categorie == "lancer" ) {
-      const defenderToken = canvas.tokens.get(this.defenderTokenId)
-      let dist = canvas.grid.measureDistances([{ ray: new Ray(_token.center, defenderToken.center) }], { gridSpaces: false })
-      dist = Number(dist).toPrecision(5)
-      //let ray = new Ray( {x: _token.x, y: _token.y}, {x: defenderToken.x, y:defenderToken.y} )
-      let msgPortee = "portée est courte (0)"
-      if (dist > rollData.arme.system.portee_courte && dist <= rollData.arme.system.portee_moyenne) {
-        msgPortee = "portée est moyenne (-3)"      
-      } else if (dist > rollData.arme.system.portee_moyenne && dist <= rollData.arme.system.portee_extreme) {
-        msgPortee = "portée est extrême (-5)" 
-      } else if ( dist > rollData.arme.system.portee_extreme) {
-        msgPortee = "cible est inateignable" 
+  async proposerAjustementTirLancer( rollData ) {
+    if (['tir', 'lancer'].includes(rollData.competence.system.categorie)) {
+      if (this.defender.isEntite([ENTITE_BLURETTE])){
+        ChatMessage.create( {
+          content: `<strong>La cible est une blurette, l'arme à distance sera perdue dans le blurêve`,
+          whisper: ChatMessage.getWhisperRecipients("GM")})
+      }
+      else {
+        const defenderToken = canvas.tokens.get(this.defenderTokenId);
+        const dist = this.distance(_token, defenderToken)
+        const isVisible = this.isVisible(_token, defenderToken)
+        const portee = this._ajustementPortee(dist, rollData.arme)
+        const taille = this._ajustementTaille(this.defender)
+        const activite = this._ajustementMouvement(this.defender)
+        const total = [portee, taille, activite].map(it=>it.diff).filter(d => !Number.isNaN(d)).reduce(Misc.sum(), 0)
+        ChatMessage.create({
+          content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.html', {
+            rollData: rollData,
+            attacker: _token,
+            isVisible: isVisible,
+            defender: defenderToken,
+            distance: dist,
+            portee: portee,
+            taille: taille,
+            activite: activite,
+            total: total
+          }),
+          whisper: ChatMessage.getWhisperRecipients("GM")
+        })
      }
-      ChatMessage.create( { content: `<strong>Indication MJ</strong> : La cible est à une distance indicative de : ${dist} mètres. Pour l'arme ${rollData.arme.name}, la ${msgPortee}.`,                    whisper: ChatMessage.getWhisperRecipients("GM") } )
    }
  }

+  isVisible(token, defenderToken) {
+    return canvas.effects.visibility.testVisibility(defenderToken.center, { object: token })
+  }
+    
+  distance(token, defenderToken) {
+    return Number(canvas.grid.measureDistances([{ ray: new Ray(token.center, defenderToken.center) }], { gridSpaces: false })).toFixed(1);
+  }
+
+  _ajustementPortee(dist, arme) {
+    if (dist <= arme.system.portee_courte) return {msg:"courte", diff:0};
+    if (dist <= arme.system.portee_moyenne) return {msg: "moyenne" , diff: -3};
+    if (dist <= arme.system.portee_extreme) return {msg: "extrême", diff:-5};
+    return {msg: "inatteignable", diff: -10};
+  }
+
+  _ajustementTaille(actor) {
+    if (actor.isVehicule()) return {msg: "véhicule", diff: 0}
+    const taille = actor.getCaracByName('TAILLE')?.value ?? 1;
+    if (taille <= 1) return {msg: "souris", diff: -8};
+    if (taille <= 3) return {msg: "chat", diff: -4};
+    if (taille <= 5) return {msg: "chien", diff: -2};
+    if (taille <= 15) return {msg: "humanoïde", diff: 0};
+    if (taille <= 20) return {msg: "ogre", diff: 2};
+    return {msg: "gigantesque", diff: 4};
+  }
+  _ajustementMouvement(defender) {
+    if (defender.getSurprise(true)) return {msg: "immobile (surprise)", diff: 0};
+    if (game.combat?.combatants.find(it => it.actorId == defender.id)) return {msg: "en mouvement (combat)", diff: -4};
+    return {msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3};
+  }
+
  /* -------------------------------------------- */
  async attaque(competence, arme) {
+    // const nonIncarnee = this.defender.isEntite([ENTITE_NONINCARNE])
+    // const blurette = this.defender.isEntite([ENTITE_BLURETTE])
+    // if (nonIncarnee || blurette) {
+    //   ChatMessage.create( {
+    //     content: `<strong>La cible est ${nonIncarnee ? 'non incarnée' : 'une blurette'}.
+    //       Il est impossible de l'atteindre.`,
+    //     whisper: ChatMessage.getWhisperRecipients("GM")})
+    // }
+
    if (!await this.accorderEntite('avant-attaque')) {
      return;
    }
@ -729,7 +783,7 @@ export class RdDCombat {
    if (arme) {
      this.attacker.verifierForceMin(arme);
    }
-    this.verifierDistance(rollData)
+    await this.proposerAjustementTirLancer(rollData)

    const dialog = await RdDRoll.create(this.attacker, rollData,
      {
@ -824,7 +878,7 @@ export class RdDCombat {
    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntite());
    let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
    attackerRoll.show = {
-      cible: this.target ? this.defender.system.name : 'la cible',
+      cible: this.target ? this.defender.name : 'la cible',
      isRecul: (attackerRoll.particuliere == 'force' || attackerRoll.tactique == 'charge')
    }
    await RdDResolutionTable.displayRollData(attackerRoll, this.attacker, 'chat-resultat-attaque.html');
@ -1249,7 +1303,7 @@ export class RdDCombat {
      attackerRoll.defenderTokenId = defenderTokenId;

      await this.computeRecul(defenderRoll);
-      this.defender.encaisserDommages(attackerRoll, this.attacker, defenderRoll);
+      this.defender.encaisserDommages(attackerRoll, this.attacker, defenderRoll?.show);
    }
    else { // envoi à un GM: les joueurs n'ont pas le droit de modifier les personnages qu'ils ne possèdent pas
      game.socket.emit(SYSTEM_SOCKET_ID, {
--- a/module/rdd-compendium-organiser.js
+++ b/module/rdd-compendium-organiser.js
@ -1,5 +1,4 @@
 import { SYSTEM_RDD } from "./constants.js";
-import { Misc } from "./misc.js";

 export class RddCompendiumOrganiser {
  static init() {
@ -17,7 +16,7 @@ export class RddCompendiumOrganiser {
  }

  static async setEntityTypeName(pack, element) {
-    const label = Misc.getEntityTypeLabel(await pack.getDocument(element.dataset.documentId));
+    const label = RddCompendiumOrganiser.getEntityTypeLabel(await pack.getDocument(element.dataset.documentId));
    RddCompendiumOrganiser.insertEntityType(element, label);
  }

@ -27,4 +26,16 @@ export class RddCompendiumOrganiser {
    }
  }

+  
+  static getEntityTypeLabel(entity) {
+    const documentName = entity?.documentName
+    const type = entity?.type 
+    if (documentName === 'Actor' || documentName === 'Item') {
+      const label = CONFIG[documentName]?.typeLabels?.[type] ?? type;
+      return game.i18n.has(label) ? game.i18n.localize(label) : t;
+    }
+    return type;
+  }
+
+
 }
--- a/module/rdd-dice.js
+++ b/module/rdd-dice.js
@ -132,18 +132,15 @@ export class RdDDice {
    }
  }

-  static async roll(formula, options = { showDice: SHOW_DICE, rollMode: undefined }) {
-    const roll = new Roll(formula);
-    await roll.evaluate({ async: true });
-    if (options.showDice != HIDE_DICE) {
-      await this.showDiceSoNice(roll, options.rollMode ?? game.settings.get("core", "rollMode"));
-    }
-    return roll;
+  static async rollTotal(formula, options = { showDice: HIDE_DICE }) {
+    return (await RdDDice.roll(formula, options)).total;
  }

-  static async rollTotal(formula, options = { showDice: HIDE_DICE}) {
-    const roll = await RdDDice.roll(formula, options);
-    return roll.total;
+  static async roll(formula, options = { showDice: SHOW_DICE, rollMode: undefined }) {
+    const roll = new Roll(RdDDice._formulaOrFake(formula, options));
+    await roll.evaluate({ async: true });
+    await this.showDiceSoNice(roll, options);
+    return roll;
  }

  static async rollOneOf(array) {
@ -160,27 +157,106 @@ export class RdDDice {
  }

  /* -------------------------------------------- */
-  static async showDiceSoNice(roll, rollMode) {
-    if (game.modules.get("dice-so-nice")?.active) {
-      if (game.dice3d) {
-        let whisper = null;
-        let blind = false;
-        rollMode = rollMode ?? game.settings.get("core", "rollMode");
-        switch (rollMode) {
-          case "blindroll": //GM only
-            blind = true;
-          case "gmroll": //GM + rolling player
-            whisper = ChatUtility.getUsers(user => user.isGM);
-            break;
-          case "roll": //everybody
-            whisper = ChatUtility.getUsers(user => user.active);
-            break;
-          case "selfroll":
-            whisper = [game.user.id];
-            break;
-        }
-        await game.dice3d.showForRoll(roll, game.user, true, whisper, blind);
+  static async showDiceSoNice(roll, options) {
+    if (options.showDice == HIDE_DICE || !game.modules.get("dice-so-nice")?.active || !game.dice3d) {
+      return;
+    }
+    
+    let { whisper, blind } = RdDDice._getWhisperBlind(options);
+    if (options.forceDiceResult?.total) {
+      let terms = await RdDDice._getForcedTerms(options);
+      if (terms) {
+        await game.dice3d.show({ throws: [{ dice: terms }] })
+        return;
      }
    }
+    await game.dice3d.showForRoll(roll, game.user, true, whisper, blind);
+  }
+
+  static _formulaOrFake(formula, options) {
+    if (options?.forceDiceResult?.total) {
+      options.forceDiceResult.formula = formula;
+      return options.forceDiceResult.total.toString()
+    }
+    return formula;
+  }
+
+  static async _getForcedTerms(options) {
+    const total = options.forceDiceResult.total;
+    switch (options.forceDiceResult.formula) {
+      case '1d100':
+        return terms1d100(total);
+      case "2d10":
+        return await terms2d10(total);
+    }
+    return undefined;
+
+    function terms1d100(total) {
+      const unites = total % 10;
+      const dizaines = Math.floor(total / 10);
+      return [{
+        resultLabel: dizaines * 10,
+        d100Result: total,
+        result: dizaines,
+        type: "d100",
+        vectors: [],
+        options: {}
+      },
+      {
+        resultLabel: unites,
+        d100Result: total,
+        result: unites,
+        type: "d10",
+        vectors: [],
+        options: {}
+      }];
+    }
+
+    async function terms2d10(total) {
+      if (total>20 || total<2) { return undefined }
+      let first = await RdDDice.d10();
+      let second = Math.min(total-first, 10);
+      first = Math.max(first, total-second);
+      return [{
+        resultLabel:first,
+        result: first,
+        type: "d10",
+        vectors: [],
+        options: {}
+      },
+      {
+        resultLabel: second,
+        result: second,
+        type: "d10",
+        vectors: [],
+        options: {}
+      }];
+    }
+  }
+
+  static async d10() {
+    let roll = new Roll('1d10');
+    await roll.evaluate({ async: true });
+    return roll.total;
+  }
+
+  static _getWhisperBlind(options) {
+    let whisper = null;
+    let blind = false;
+    let rollMode = options.rollMode ?? game.settings.get("core", "rollMode");
+    switch (rollMode) {
+      case "blindroll": //GM only
+        blind = true;
+      case "gmroll": //GM + rolling player
+        whisper = ChatUtility.getUsers(user => user.isGM);
+        break;
+      case "roll": //everybody
+        whisper = ChatUtility.getUsers(user => user.active);
+        break;
+      case "selfroll":
+        whisper = [game.user.id];
+        break;
+    }
+    return { whisper, blind };
  }
 }
--- a/module/rdd-herbes.js
+++ b/module/rdd-herbes.js
@ -1,76 +1,75 @@
 import { RdDUtility } from "./rdd-utility.js";
 import { RdDCalendrier } from "./rdd-calendrier.js";
+import { Grammar } from "./grammar.js";

 /* -------------------------------------------- */
 export class RdDHerbes extends Item {

  /* -------------------------------------------- */
-  static isHerbeSoin( botaniqueItem ) {
-    return botaniqueItem.categorie == 'Soin';
-  }
-  /* -------------------------------------------- */
-  static isHerbeRepos( botaniqueItem ) {
-    return botaniqueItem.categorie == 'Repos';
+  static async initializeHerbes() {
+    this.herbesSoins = await RdDHerbes.listCategorieHerbes('Soin');
+    this.herbesRepos = await RdDHerbes.listCategorieHerbes('Repos');
  }

-  /* -------------------------------------------- */
-  static async initializeHerbes( ) {  
-    this.herbesSoins = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.botanique', item => this.isHerbeSoin(item));
-    this.herbesRepos = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.botanique', item => this.isHerbeRepos(item));
+  static async listCategorieHerbes(categorie) {
+    return await RdDUtility.loadItems(
+      it => it.type == 'herbe' && it.system.categorie.toLowerCase() == categorie.toLowerCase(),
+      'foundryvtt-reve-de-dragon.botanique');
  }

  /* -------------------------------------------- */
  static buildHerbesList(listeHerbes, max) {
    let list = {}
-    for ( let herbe of listeHerbes) {
+    for (let herbe of listeHerbes) {
      let brins = max - herbe.system.niveau;
-      list[herbe.system.name] = `${herbe.system.name} (Bonus: ${herbe.system.niveau}, Brins: ${brins})`;
+      list[herbe.name] = `${herbe.name} (Bonus: ${herbe.system.niveau}, Brins: ${brins})`;
    }
    list['Autre'] = 'Autre (Bonus: variable, Brins: variable)'
    return list;
  }

  /* -------------------------------------------- */
-  static updatePotionData( formData ) {
-    formData.herbesSoins = this.buildHerbesList(this.herbesSoins, 12);
-    formData.herbesRepos = this.buildHerbesList(this.herbesRepos, 7);
+  static async updatePotionData(formData) {
+    formData.isSoins = formData.system.categorie.includes('Soin');
+    formData.isRepos = formData.system.categorie.includes('Repos');
+    if (formData.isSoins) {
+      RdDHerbes.calculBonusHerbe(formData, this.herbesSoins, 12);
+    }
+    if (formData.isRepos) {
+      RdDHerbes.calculBonusHerbe(formData, this.herbesRepos, 7);
+    }
+    formData.herbesSoins = RdDHerbes.buildHerbesList(this.herbesSoins, 12);
+    formData.herbesRepos = RdDHerbes.buildHerbesList(this.herbesRepos, 7);
    formData.jourMoisOptions = RdDCalendrier.buildJoursMois();
    formData.dateActuelle = game.system.rdd.calendrier.getDateFromIndex();
    formData.splitDate = game.system.rdd.calendrier.getNumericDateFromIndex(formData.system.prdate);
-
-    if (formData.system.categorie.includes('Soin') ) {
-      formData.isHerbe = true;
-      this.computeHerbeBonus(formData, this.herbesSoins, 12);
-    } else if (formData.system.categorie.includes('Repos')) {
-      formData.isRepos = true;
-      this.computeHerbeBonus(formData, this.herbesRepos, 7);
-    }
  }

  /* -------------------------------------------- */
-  static calculePuissancePotion( potion ) {
+  static calculPuissancePotion(potion) {
    return potion.system.herbebonus * potion.system.pr;
  }

  /* -------------------------------------------- */
-  static calculePointsRepos( potion ) {
+  static calculPointsRepos(potion) {
    return potion.system.herbebonus * potion.system.pr;
  }

  /* -------------------------------------------- */
-  static calculePointsGuerison( potion ){
+  static calculPointsGuerison(potion) {
    return potion.system.herbebonus * potion.system.pr;
  }

  /* -------------------------------------------- */
-  static computeHerbeBonus( formData, herbesList, max) {
-    if ( Number(formData.system.herbebrins) ) {
-    let herbe = herbesList.find(item => item.name.toLowerCase() == formData.system.herbe.toLowerCase() );
-      if( herbe ) {
-        let brinsBase = max - herbe.system.niveau;
-        formData.system.herbebonus = Math.max(herbe.system.niveau - Math.max(brinsBase - formData.system.herbebrins, 0), 0);
+  static calculBonusHerbe(formData, herbesList, max) {
+    if (Number(formData.system.herbebrins)) {
+      let herbe = herbesList.find(item => item.name.toLowerCase() == formData.system.herbe.toLowerCase());
+      if (herbe) {
+        const brinsRequis = max - herbe.system.niveau;
+        const brinsManquants = Math.max(brinsRequis - formData.system.herbebrins, 0);
+        formData.system.herbebonus = Math.max(herbe.system.niveau - brinsManquants, 0);
      }
    }
-  }  
+  }

 }  
--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@ -150,11 +150,14 @@ Hooks.once("init", async function () {
  /* -------------------------------------------- */
  game.socket.on(SYSTEM_SOCKET_ID, sockmsg => {
    console.log(">>>>> MSG RECV", sockmsg);
-
-    RdDUtility.onSocketMessage(sockmsg);
-    RdDCombat.onSocketMessage(sockmsg);
-    ChatUtility.onSocketMessage(sockmsg);
-    RdDActor.onSocketMessage(sockmsg);
+    try {
+      RdDUtility.onSocketMessage(sockmsg);
+      RdDCombat.onSocketMessage(sockmsg);
+      ChatUtility.onSocketMessage(sockmsg);
+      RdDActor.onSocketMessage(sockmsg);
+    } catch(e) {
+      console.error('game.socket.on(SYSTEM_SOCKET_ID) Exception: ', sockmsg,' => ', e)
+    }
  });

  /* -------------------------------------------- */
--- a/module/rdd-resolution-table.js
+++ b/module/rdd-resolution-table.js
@ -142,10 +142,8 @@ export class RdDResolutionTable {

  /* -------------------------------------------- */
  static async rollChances(chances, diviseur, forceDiceResult = -1) {
-    if (forceDiceResult <= 0 || forceDiceResult > 100) {
-      forceDiceResult = -1;
-    }
-    chances.roll = await RdDDice.rollTotal((forceDiceResult == -1) ? "1d100" : `${forceDiceResult}`, chances);
+    chances.forceDiceResult = forceDiceResult <= 0 || forceDiceResult > 100 ? undefined : {total: forceDiceResult};
+    chances.roll = await RdDDice.rollTotal( "1d100", chances);
    mergeObject(chances, this.computeReussite(chances, chances.roll, diviseur), { overwrite: true });
    return chances;
  }
--- a/module/rdd-roll-encaisser.js
+++ b/module/rdd-roll-encaisser.js
@ -1,4 +1,4 @@
-import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE } from "./constants.js";
+import { ENTITE_BLURETTE, ENTITE_INCARNE} from "./constants.js";

 /**
 * Extend the base Dialog entity by defining a custom window to perform roll.
@ -33,7 +33,7 @@ export class RdDEncaisser extends Dialog {
    let dialogOptions = {
      classes: ["rdddialog"],
      width: 320,
-      height: 240
+      height: 260
    }

    // Select proper roll dialog template and stuff
@ -51,6 +51,7 @@ export class RdDEncaisser extends Dialog {
    this.actor.encaisserDommages({
      dmg: {
        total: Number(this.modifier),
+        ajustement: Number(this.modifier),
        encaisserSpecial: this.encaisserSpecial,
        loc: { result: 0, label: "" },
        mortalite: mortalite
--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@ -144,6 +144,7 @@ export class RdDRoll extends Dialog {

  /* -------------------------------------------- */
  async onAction(action, html) {
+    this.rollData.forceDiceResult = Number.parseInt($('#force-dice-result').val()) ?? -1;
    await RdDResolutionTable.rollData(this.rollData);
    console.log("RdDRoll -=>", this.rollData, this.rollData.rolled);
    this.actor.setRollWindowsOpened(false);
--- a/module/rdd-rolltables.js
+++ b/module/rdd-rolltables.js
@ -2,16 +2,22 @@ export class RdDRollTables {

  /* -------------------------------------------- */
  static async genericGetTableResult(tableName, toChat) {
-    let table = game.tables.find(table => table.name.toLowerCase() == tableName.toLowerCase())
-    if ( !table) {
-      const pack = game.packs.get("foundryvtt-reve-de-dragon.tables-diverses");
-      const index = await pack.getIndex();
-      const entry = index.find(e => e.name === tableName);
-      table = await pack.getDocument(entry._id);
-    }
+    let table = RdDRollTables.getWorldTable(tableName) ?? (await RdDRollTables.getSystemTable(tableName));
    const draw = await table.draw({ displayChat: toChat, rollMode: "gmroll"});
    //console.log("RdDRollTables", tableName, toChat, ":", draw);
    return draw.results.length > 0 ? draw.results[0] : undefined;
+
+  }
+
+  static getWorldTable(tableName) {
+    return game.tables.find(table => table.name.toLowerCase() == tableName.toLowerCase());
+  }
+
+  static async getSystemTable(tableName) {
+    const pack = game.packs.get("foundryvtt-reve-de-dragon.tables-diverses");
+    const index = await pack.getIndex();
+    const entry = index.find(e => e.name === tableName);
+    return await pack.getDocument(entry._id);
  }

  /* -------------------------------------------- */
--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@ -13,6 +13,7 @@ import { Monnaie } from "./item-monnaie.js";
 import { RdDPossession } from "./rdd-possession.js";
 import { RdDNameGen } from "./rdd-namegen.js";
 import { RdDConfirm } from "./rdd-confirm.js";
+import { RdDActor } from "./actor.js";

 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@ -112,7 +113,6 @@ export class RdDUtility {
  static async preloadHandlebarsTemplates() {
    const templatePaths = [
      //Character Sheets
-      'systems/foundryvtt-reve-de-dragon/templates/actor-creation-sheet.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor-creature-sheet.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html',
@ -214,6 +214,7 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html',
      'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-sort.html',
      'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-encaisser.html',
+      'systems/foundryvtt-reve-de-dragon/templates/dialog-validation-encaissement.html',
      'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-meditation.html',
      'systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html',
      'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-alchimie.html',
@ -242,6 +243,7 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-description.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html',
+      'systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-particuliere.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html',
@ -652,7 +654,68 @@ export class RdDUtility {
  }

  /* -------------------------------------------- */
-  static selectEncaissement(degats, mortalite) {
+  static async jetEncaissement(rollData, armure, options = { showDice: HIDE_DICE }) {
+    let formula = "2d10";
+
+    // Chaque dé fait au minmum la difficulté libre
+    if (ReglesOptionelles.isUsing('degat-minimum-malus-libre')) {
+      if (rollData.diffLibre < 0) {
+        let valeurMin = Math.abs(rollData.diffLibre);
+        formula += "min" + valeurMin;
+      }
+    }
+    // Chaque dé fait au minmum la difficulté libre
+    if (ReglesOptionelles.isUsing('degat-ajout-malus-libre')) {
+      if (rollData.diffLibre < 0) {
+        let valeurMin = Math.abs(rollData.diffLibre);
+        formula += "+" + valeurMin;
+      }
+    }
+
+    let roll = await RdDDice.roll(formula, options);
+
+    // 1 dé fait au minmum la difficulté libre
+    if (ReglesOptionelles.isUsing('degat-minimum-malus-libre-simple')) {
+      if (rollData.diffLibre < 0) {
+        let valeurMin = Math.abs(rollData.diffLibre);
+        if (roll.terms[0].results[0].result < valeurMin) {
+          roll.terms[0].results[0].result = valeurMin;
+        } else if (roll.terms[0].results[1].result < valeurMin) {
+          roll.terms[0].results[1].result = valeurMin;
+        }
+        roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
+      }
+    }
+
+    return await RdDUtility.prepareEncaissement(rollData, roll, armure);
+  }
+  
+  /* -------------------------------------------- */
+  static async prepareEncaissement(rollData, roll, armure) {
+    const jetTotal = roll.total + rollData.dmg.total - armure;
+    let encaissement = RdDUtility._selectEncaissement(jetTotal, rollData.dmg.mortalite);
+    let over20 = Math.max(jetTotal - 20, 0);
+    encaissement.dmg = rollData.dmg;
+    encaissement.dmg.loc = rollData.dmg.loc ?? await RdDUtility.getLocalisation(this.type);
+    encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;';
+    encaissement.roll = roll;
+    encaissement.armure = armure;
+    encaissement.total = jetTotal;
+    encaissement.vie = await RdDUtility._evaluatePerte(encaissement.vie, over20);
+    encaissement.endurance = await RdDUtility._evaluatePerte(encaissement.endurance, over20);
+    encaissement.penetration = rollData.arme?.system.penetration ?? 0;
+    encaissement.blessures = (
+      encaissement.critiques> 0 ? "Critique":
+      encaissement.graves> 0 ? "Grave":
+      encaissement.legeres> 0 ? "Légère":
+      encaissement.eraflures>0 ? "Contusions/Eraflures":
+      'Aucune'
+    );
+    return encaissement;
+  }
+
+  /* -------------------------------------------- */
+  static _selectEncaissement(degats, mortalite) {
    const table = definitionsEncaissement[mortalite] === undefined ? definitionsEncaissement["mortel"] : definitionsEncaissement[mortalite];
    for (let encaissement of table) {
      if ((encaissement.minimum === undefined || encaissement.minimum <= degats)
@ -663,6 +726,13 @@ export class RdDUtility {
    return duplicate(table[0]);
  }

+  /* -------------------------------------------- */
+  static async _evaluatePerte(formula, over20) {
+    let perte = new Roll(formula, { over20: over20 });
+    await perte.evaluate({ async: true });
+    return perte.total;
+  }
+
  /* -------------------------------------------- */
  static currentFatigueMalus(value, max) {
    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
@ -683,17 +753,28 @@ export class RdDUtility {
  }

  /* -------------------------------------------- */
-  static async loadCompendiumData(compendium) {
-    const pack = game.packs.get(compendium);
-    return await pack?.getDocuments() ?? [];
+  static async loadItems(filter, compendium) {
+    let items = game.items.filter(filter);
+    if (compendium) {
+      const ids = items.map(it => it.id);
+      const names = items.map(it => it.name.toLowerCase());
+      items = items.concat(await RdDUtility.loadCompendium(compendium, it => !ids.includes(it.id) && !names.includes(it.name.toLowerCase()) && filter(it)));
+    }
+    return items;
  }

  /* -------------------------------------------- */
-  static async loadCompendium(compendium, filter = item => true) {
+  static async loadCompendium(compendium, filter = it => true) {
    let compendiumData = await RdDUtility.loadCompendiumData(compendium);
    return compendiumData.filter(filter);
  }

+  /* -------------------------------------------- */
+  static async loadCompendiumData(compendium) {
+    const pack = game.packs.get(compendium);
+    return await pack?.getDocuments() ?? [];
+  }
+
  /* -------------------------------------------- */
  static async responseNombreAstral(callData) {
    let actor = game.actors.get(callData.id);
@ -750,7 +831,12 @@ export class RdDUtility {
    });

    // gestion bouton tchat Acheter
-    html.on("click", '.button-acheter', event => DialogItemAchat.onButtonAcheter(event));
+    html.on("click", '.button-acheter', event => {
+      const venteData = DialogItemAchat.venteData(event.currentTarget);
+      if (venteData) {
+        DialogItemAchat.onAcheter(venteData);
+      }
+    });
    html.on("click", '.button-creer-acteur', event => RdDNameGen.onCreerActeur(event));

    // Gestion du bouton payer
@ -888,11 +974,6 @@ export class RdDUtility {
  /* -------------------------------------------- */
  static async confirmerSuppressionItem(sheet, item, htmlToDelete) {
    const itemId = item.id;
-    if (Monnaie.isSystemMonnaie(item, sheet.actor.items)) {
-      ui.notifications.warn("Suppression des monnaies de base impossible");
-      return;
-    }
-    
    const confirmationSuppression = {
      settingConfirmer: "confirmation-supprimer-" + item.getItemGroup(),
      content: `<p>Etes vous certain de vouloir supprimer: ${item.name}?</p>`,
--- a/module/regles-optionelles.js
+++ b/module/regles-optionelles.js
@ -2,29 +2,32 @@ import { SYSTEM_RDD } from "./constants.js";
 import { Misc } from "./misc.js";

 const listeReglesOptionelles = [
-  { name: 'recul', group: 'Règles de combat', descr: "Appliquer le recul en cas de particulière en force ou de charge" },
-  { name: 'resistanceArmeParade', group: 'Règles de combat', descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },
-  { name: 'deteriorationArmure', group: 'Règles de combat', descr: "Tenir compte de la détérioration des armures" },
-  { name: 'defenseurDesarme', group: 'Règles de combat', descr: "Le défenseur peut être désarmé en parant une particulière en force ou une charge avec une arme autre qu'un bouclier" },
-  { name: 'categorieParade', group: 'Règles de combat', descr: "Le défenseur doit obtenir une significative en cas de parade avec des armes de catégories différentes" },
-  { name: 'tripleSignificative', group: 'Règles de combat', descr: "En cas de demi-surprise, d'attaque particulière en finesse, et de catégories d'armes différentes, le défenseur doit obtenir 1/8 des chances de succès" },
-  { name: 'degat-minimum-malus-libre-simple', group: 'Règles de combat', descr: "Le malus libre d'attaque remplace une des valeurs de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, si 1 résultat est inférieur à 4, alors il devient 4.", default: false },
-  { name: 'degat-minimum-malus-libre', group: 'Règles de combat', descr: "Le malus libre d'attaque remplace une valeur de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, tout résultat inférieur à 4 devient 4.", default: false },
-  { name: 'degat-ajout-malus-libre', group: 'Règles de combat', descr: "Le malus libre d'attaque s'ajoute au jet d'encaissement et aux autres bonus. Exemple : la difficulté libre de l'attaquant est de -4. Le jet d'encaissement est effectué à 2d10+4, plus les bonus de situation et d'armes.", default: false },
-  { name: 'astrologie', group: 'Règles générales', descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels"},
-  { name: 'afficher-prix-joueurs', group: 'Règles générales', descr: "Afficher le prix de l'équipement des joueurs", uniquementJoueur: true},
-  { name: 'appliquer-fatigue', group: 'Règles générales', descr: "Appliquer les règles de fatigue"},
-  { name: 'afficher-colonnes-reussite', group: 'Règles générales', descr: "Afficher le nombre de colonnes de réussite ou d'échec", default: false },
-  { name: 'confirmation-tmr', group: 'Confirmations', descr: "Confirmer pour monter dans les TMR", scope: "client"},
-  { name: 'confirmation-vider', group: 'Confirmations', descr: "Confirmer pour vider l'équipement", scope: "client"},
-  { name: 'confirmation-supprimer-lien-acteur',  group: 'Confirmations', descr: "Confirmer pour détacher un animal/suivant/véhicule", scope: "client"},
-  { name: 'confirmation-supprimer-equipement',   group: 'Confirmations', descr: "Confirmer la suppression des équipements", scope: "client"},
-  { name: 'confirmation-supprimer-oeuvre',       group: 'Confirmations', descr: "Confirmer la suppression des oeuvres", scope: "client"},
-  { name: 'confirmation-supprimer-connaissance', group: 'Confirmations', descr: "Confirmer la suppression des connaissances", scope: "client"},
-  { name: 'confirmation-supprimer-draconique',   group: 'Confirmations', descr: "Confirmer la suppression des queues, souffles, têtes", scope: "client"},
-  { name: 'confirmation-supprimer-effet',        group: 'Confirmations', descr: "Confirmer la suppression des effets", scope: "client"},
-  { name: 'confirmation-supprimer-competence',   group: 'Confirmations', descr: "Confirmer la suppression des compétences", scope: "client"},
-  { name: 'confirmation-supprimer-autres',       group: 'Confirmations', descr: "Confirmer la suppression des autres types d'Objets", scope: "client"},
+  { group: 'Règles de combat', name: 'recul', descr: "Appliquer le recul en cas de particulière en force ou de charge" },
+  { group: 'Règles de combat', name: 'resistanceArmeParade', descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },
+  { group: 'Règles de combat', name: 'deteriorationArmure', descr: "Tenir compte de la détérioration des armures" },
+  { group: 'Règles de combat', name: 'defenseurDesarme', descr: "Le défenseur peut être désarmé en parant une particulière en force ou une charge avec une arme autre qu'un bouclier" },
+  { group: 'Règles de combat', name: 'categorieParade', descr: "Le défenseur doit obtenir une significative en cas de parade avec des armes de catégories différentes" },
+  { group: 'Règles de combat', name: 'tripleSignificative', descr: "En cas de demi-surprise, d'attaque particulière en finesse, et de catégories d'armes différentes, le défenseur doit obtenir 1/8 des chances de succès" },
+  { group: 'Règles de combat', name: 'degat-minimum-malus-libre-simple', descr: "Le malus libre d'attaque remplace une des valeurs de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, si le plus petit dé est inférieur à 4, alors il devient 4.", default: false },
+  { group: 'Règles de combat', name: 'degat-minimum-malus-libre', descr: "Le malus libre d'attaque remplace une valeur de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, tout résultat inférieur à 4 devient 4.", default: false },
+  { group: 'Règles de combat', name: 'degat-ajout-malus-libre', descr: "Le malus libre d'attaque s'ajoute au jet d'encaissement et aux autres bonus. Exemple : la difficulté libre de l'attaquant est de -4. Le jet d'encaissement est effectué à 2d10+4, plus les bonus de situation et d'armes.", default: false },
+  { group: 'Règles de combat', name: 'validation-encaissement-gr', descr: "Le Gardien des Rêves doit valider les jets d'encaissement et peut les changer.", default: false },
+
+  { group: 'Règles générales', name: 'astrologie', descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels"},
+  { group: 'Règles générales', name: 'afficher-prix-joueurs', descr: "Afficher le prix de l'équipement des joueurs", uniquementJoueur: true},
+  { group: 'Règles générales', name: 'appliquer-fatigue', descr: "Appliquer les règles de fatigue"},
+  { group: 'Règles générales', name: 'afficher-colonnes-reussite', descr: "Afficher le nombre de colonnes de réussite ou d'échec", default: false },
+
+  { group: 'Confirmations', name: 'confirmation-tmr', descr: "Confirmer pour monter dans les TMR", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-vider', descr: "Confirmer pour vider l'équipement", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-lien-acteur',  descr: "Confirmer pour détacher un animal/suivant/véhicule", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-equipement',   descr: "Confirmer la suppression des équipements", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-oeuvre',       descr: "Confirmer la suppression des oeuvres", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-connaissance', descr: "Confirmer la suppression des connaissances", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-draconique',   descr: "Confirmer la suppression des queues, souffles, têtes", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-effet',        descr: "Confirmer la suppression des effets", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-competence',   descr: "Confirmer la suppression des compétences", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-autres',       descr: "Confirmer la suppression des autres types d'Objets", scope: "client"},
 ];

 const uniquementJoueur = listeReglesOptionelles.filter(it => it.uniquementJoueur).map(it=>it.name);
@ -73,7 +76,7 @@ export class ReglesOptionelles extends FormApplication {
    const regles = listeReglesOptionelles.filter(it => game.user.isGM || it.scope == "client").map(it => {
      it = duplicate(it);
      it.id = ReglesOptionelles._getIdRegle(it.name);
-      it.active = ReglesOptionelles.isUsing(it.name);
+      it.active = ReglesOptionelles.isSet(it.name);
      return it;
    });
    formData.regles = regles;
@ -85,11 +88,11 @@ export class ReglesOptionelles extends FormApplication {
    if (game.user.isGM && uniquementJoueur.includes(name)) {
      return true;
    }
-    return game.settings.get(SYSTEM_RDD, ReglesOptionelles._getIdRegle(name));
+    return ReglesOptionelles.isSet(name);
  }

  static isSet(name) {
-    return ReglesOptionelles.isUsing(name);
+    return game.settings.get(SYSTEM_RDD, ReglesOptionelles._getIdRegle(name));
  }

  static set(name, value) {
--- a/system.json
+++ b/system.json
@ -1,6 +1,13 @@
 {
  "id": "foundryvtt-reve-de-dragon",
  "title": "Rêve de Dragon",
+  "version": "10.0.28",
+  "download": "https://www.uberwald.me/gitea/VincentVk/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.0.28.zip",
+  "manifest": "https://www.uberwald.me/gitea/VincentVk/foundryvtt-reve-de-dragon/raw/v10/system.json",
+  "compatibility": {
+    "minimum": "10",
+    "verified": "10.288"
+  },
  "description": "Rêve de Dragon RPG for FoundryVTT",
  "authors": [
    {
@ -34,11 +41,6 @@
  ],
  "url": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/",
  "license": "LICENSE.txt",
-  "version": "10.0.25",
-  "compatibility": {
-    "minimum": "10",
-    "verified": "10.286"
-  },
  "esmodules": [
    "module/rdd-main.js"
  ],
@ -332,8 +334,6 @@
    }
  ],
  "socket": true,
-  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v10/system.json",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.0.25.zip",
  "gridDistance": 1,
  "gridUnits": "m",
  "primaryTokenAttribute": "sante.vie",
--- a/templates/actor/dragon-queues.html
+++ b/templates/actor/dragon-queues.html
@ -4,7 +4,7 @@
  {{#if (and queues.length ombres.length)}} et {{/if}}
  {{#if ombres.length}}Ombres de Thanatos{{/if}}
 </h3>
-<ul class="flex-group-left">
+<ul class="item-list">
  {{#each queues as |queue key|}}
  {{> "systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.html" queue=queue key=key}}
  {{/each}}
--- a/templates/actor/inventaire.html
+++ b/templates/actor/inventaire.html
@ -2,15 +2,15 @@

 <h4>Equipement</h4>
 <span class="item-name">
-  Encombrement: {{numberFormat calc.encTotal decimals=2}} (max: {{system.attributs.encombrement.value}}){{#if calc.surEncombrementMessage}}<b>{{calc.surEncombrementMessage}}</b>{{/if}}
-  {{#if (regle-optionnelle 'afficher-prix-joueurs')}}
-  &hyphen; Valeur: {{numberFormat calc.prixTotalEquipement decimals=2}} Sols
-  {{/if}}
-  &hyphen;
  <a class="chat-card-button creer-un-objet">Nouvel objet</a>
  {{#if options.isGM}}
  <a class="chat-card-button nettoyer-conteneurs">Tout vider</a>
  {{/if}}
+  {{#if calc.surEncombrementMessage}}<b>{{calc.surEncombrementMessage}}</b> &hyphen;{{/if}}
+  Encombrement: {{numberFormat calc.encTotal decimals=2}} (max: {{system.attributs.encombrement.value}})
+  {{#if (regle-optionnelle 'afficher-prix-joueurs')}}
+  &hyphen; Valeur: {{numberFormat calc.prixTotalEquipement decimals=2}} Sols
+  {{/if}}
 </span>
 <ul class="item-list alterne-list">
  <li class="competence-header flexrow">
--- a/templates/chat-info-distance.html
+++ b/templates/chat-info-distance.html
@ -0,0 +1,14 @@
+<img class="chat-icon" src="{{rollData.arme.img}}" alt="{{rollData.arme.name}}" />
+<strong>Ajustement de tir/lancer</strong> proposé de <strong>{{total}}</strong>
+<ul>
+  <li>{{defender.name}} est à une distance indicative de {{distance}} mètres.</li>
+  {{#if isVisible}}
+    <li>Selon les murs et la lumière, la cible {{defender.name}} est visible de {{attacker.name}}.</li>
+  {{else}}
+    <li>Selon les murs et la lumière, la cible {{defender.name}} n'est pas visible de {{attacker.name}}.</li>
+  {{/if}}
+  {{log defender}}
+  <li>Portée {{portee.msg}} pour l'arme {{rollData.arme.name}} : {{portee.diff}}</li>
+  <li>De taille {{taille.msg}}: {{taille.diff}}</li>
+  <li>Mouvement {{activite.msg}}: {{activite.diff}}</li>
+</ul>
--- a/templates/dialog-item-achat.html
+++ b/templates/dialog-item-achat.html
@ -45,38 +45,38 @@
    </div>
  </div>

-  {{#if (eq item.type 'nourritureboisson')}}
-  <p>
-    Si vous souhaitez {{#if item.system.boisson}}boire{{else}}manger{{/if}}:
-  </p>
+  {{#if (and (eq item.type 'nourritureboisson') (eq acheteur.type 'personnage'))}}
+    <p>Si vous souhaitez {{#if item.system.boisson}}boire{{else}}manger{{/if}}:</p>

-  {{#if item.system.sust}}
-   <p>Cette {{#if item.system.boisson}}boisson{{else}}nourriture{{/if}} vous apportera <span
-       class="total-sust">{{totalSust}}</span> de sustantation.</p>
-   {{/if}}
-   {{#if item.system.boisson}}
-   <p>{{#if item.system.alcoolise}}
-     C'est une boisson alcoolisée de force {{item.system.force}}, vous effectuerez un jet d'éthylisme.
-     {{/if}}
-     Cette boisson vous apportera <span class="total-desaltere">{{totalDesaltere}}</span> unités d'eau.
-   </p>
-   {{/if}}
-   {{#if (gt item.system.qualite 0)}}
-   {{#if (gt item.system.qualite cuisine.system.niveau)}}
-   <p>La qualité du plat est telle qu'un jet de Goût/Cuisine à {{numberFormat item.system.qualite decimals=0 sign=true}}
-     vous permettra un jet de moral heureux.</p>
-   {{/if}}
-   {{/if}}
-   
-   {{#if (or (lt item.system.qualite 0) (lt item.system.exotisme 0))}}
-   <p>
-     Pour surmonter {{#if (lt item.system.qualite 0)}}le mauvais goût{{else}}l'exotisme{{/if}}, vous devez effectuer un jet de Volonté/Cuisine à {{numberFormat (min item.system.exotisme item.system.qualite) decimals=0 sign=true}}.
-   <br/>
-     <input class="attribute-value se-forcer" type="checkbox" name="se-forcer" {{#if choix.seForcer}}checked{{/if}}>
-       <label for="se-forcer">En cas d'échec, voulez-vous vous forcer à manger (et subir un jet de moral en situation malheureuse)?</label>
-     </input>
-   </p>
-   {{/if}}
+    {{#if item.system.sust}}
+      <p>Cette {{#if item.system.boisson}}boisson{{else}}nourriture{{/if}} vous apportera
+        <span class="total-sust">{{totalSust}}</span>
+        de sustantation.</p>
+    {{/if}}
+    {{#if item.system.boisson}}
+      <p>
+        {{#if item.system.alcoolise}}
+          C'est une boisson alcoolisée de force {{item.system.force}}, vous effectuerez un jet d'éthylisme.
+        {{/if}}
+        Cette boisson vous apportera <span class="total-desaltere">{{totalDesaltere}}</span> unités d'eau.
+      </p>
+    {{/if}}
+    {{#if (gt item.system.qualite 0)}}
+      {{#if (gt item.system.qualite cuisine.system.niveau)}}
+      <p>La qualité du plat est telle qu'un jet de Goût/Cuisine à {{numberFormat item.system.qualite decimals=0 sign=true}}
+        vous permettra un jet de moral heureux.</p>
+      {{/if}}
+    {{/if}}
+    
+    {{#if (or (lt item.system.qualite 0) (lt item.system.exotisme 0))}}
+      <p>
+        Pour surmonter {{#if (lt item.system.qualite 0)}}le mauvais goût{{else}}l'exotisme{{/if}}, vous devez effectuer un jet de Volonté/Cuisine à {{numberFormat (min item.system.exotisme item.system.qualite) decimals=0 sign=true}}.
+      <br/>
+        <input class="attribute-value se-forcer" type="checkbox" name="se-forcer" {{#if choix.seForcer}}checked{{/if}}>
+          <label for="se-forcer">En cas d'échec, voulez-vous vous forcer à manger (et subir un jet de moral en situation malheureuse)?</label>
+        </input>
+      </p>
+    {{/if}}
  {{/if}}

  {{#if isVente}}
--- a/templates/dialog-roll-encaisser.html
+++ b/templates/dialog-roll-encaisser.html
@ -1,8 +1,8 @@
 <form class="encaisse-roll-dialog">
  <h2 class="encaisserdialog" id="encaisserTitle"></h2>
-  <div class="form-group">
-    <label class="competence-label">Modificateurs aux Dommages:</label>
-    <select class="competence-value" name="modificateurDegats" id="modificateurDegats" data-dtype="number">
+  <div class="flexrow">
+    <label>Modificateurs aux Dommages:</label>
+    <select class="competence-value flex-shrink" name="modificateurDegats" id="modificateurDegats" data-dtype="number">
      {{#select modificateurDegats}}
      {{#each ajustementsEncaissement as |key|}}
      <option value={{key}}>{{numberFormat key decimals=0 sign=true}}</option>
@ -10,9 +10,9 @@
      {{/select}}
    </select>
  </div>
-  <div class="form-group">
-    <label class="competence-label">Cas particuliers:</label>
-    <select class="competence-value" name="encaisserSpecial" id="encaisserSpecial" data-dtype="String">
+  <div class="flexcol">
+    <label >Cas particuliers:</label>
+    <select name="encaisserSpecial" id="encaisserSpecial" data-dtype="String">
      <option value="aucun">Aucun</option>
      <option value="noarmure">Ne pas compter les Armures</option>
      <option value="chute">Chute : Limiter les armures à 2 PA</option>
--- a/templates/dialog-validation-encaissement.html
+++ b/templates/dialog-validation-encaissement.html
@ -0,0 +1,48 @@
+<form class="dialog-validation-encaissement">
+  <div class="flexrow flex-center">
+    <div class="flex-shrink"><img class="chat-icon" src="icons/svg/bones.svg" alt="Encaisser des dommages" /></div>
+    <div><h4>Encaissement de {{actor.name}}</h4></div>
+    <div class="flex-shrink"><img class="chat-icon" src="{{actor.img}}" title="{{actor.name}}" alt="{{actor.name}}" /></div>
+  </div>
+  <ul>
+    <li class="flexrow flex-group-left">
+      <label>Jet d'encaissement</label>
+      <input class="encaissement-roll-result" type="number" value="{{encaissement.roll.result}}" min="2" max="20" data-dtype="Number" />
+    </li>
+    <li class="flexrow flex-group-left">
+      <label>Total</label>
+      <span class="tooltip tooltip-dotted">
+        <label class="encaissement-total">{{encaissement.total}}</label>
+        <div class="tooltiptext ttt-ajustements">
+          <div>Armure: {{encaissement.armure}}</div>
+          {{#if rollData.dmg.penetration}}
+          <div>Pénétration: -{{rollData.dmg.penetration}}</div>
+          {{/if}}
+          <hr>
+          {{#if encaissement.dmg.total}}
+          <div>+dom encaissement: {{numberFormat rollData.dmg.total decimals=0 sign=true}}</div>
+          {{/if}}
+          {{#if rollData.dmg.dmgArme}}
+          <div>+dom arme: {{numberFormat rollData.dmg.dmgArme decimals=0 sign=true}}</div>
+          {{/if}}
+          {{#if rollData.dmg.dmgActor}}
+          <div>+dom attaquant: {{numberFormat rollData.dmg.dmgActor decimals=0 sign=true}}</div>
+          {{/if}}
+          {{#if rollData.dmg.dmgParticuliere}}
+          <div>+dom particulière: {{numberFormat rollData.dmg.dmgParticuliere decimals=0 sign=true}}</div>
+          {{/if}}
+          {{#if rollData.dmg.dmgTactique}}
+          <div>+dom tactique: {{numberFormat rollData.dmg.dmgTactique decimals=0 sign=true}}</div>
+          {{/if}}
+          {{#if rollData.dmg.dmgSurprise}}
+          <div>+dom surprise: {{numberFormat rollData.dmg.dmgSurprise decimals=0 sign=true}}</div>
+          {{/if}}
+        </div>
+      </span>
+    </li>
+    <li class="flexrow flex-group-left">
+      <label>Blessure ({{rollData.dmg.mortalite}})</label>
+      <label class="encaissement-blessure">{{encaissement.blessures}}</label>
+    </li>
+  </ul>
+</form>
--- a/templates/item-potion-sheet.html
+++ b/templates/item-potion-sheet.html
@ -41,7 +41,7 @@
        {{/select}}
      </select>
    </div>
-    {{#if isHerbe}}
+    {{#if isSoins}}
    <div class="form-group">
      <label>Herbe</label>
      <select name="system.herbe" class="herbe" data-dtype="String">
@ -86,7 +86,7 @@
      <label for="xp">Permanente ? </label>
      <input class="attribute-value" type="checkbox" name="system.prpermanent"  {{#if system.prpermanent}}checked{{/if}}/>
    </div>
-    {{#if isHerbe}}
+    {{#if isSoins}}
    <div class="form-group">
      <label for="xp">Points de guérison </label>
      <label for="xp">{{pointsGuerison}}</label>
Author	SHA1	Message	Date
Vincent Vandemeulebrouck	d795968519	v10.0.28	2022-10-14 21:52:38 +02:00
Vincent Vandemeulebrouck	37e5b3c0aa	Version 10.0.28	2022-10-14 21:47:34 +02:00
Vincent Vandemeulebrouck	e1aecb05c3	Fix: Organisation boutons/messages d'équipement Le message de surencombrement rendait la présentation moche	2022-10-14 00:58:26 +02:00
Vincent Vandemeulebrouck	168127d8fe	Fix: tirage dans une table ne fonctionnait plus Régression bête, qui empêchait aussi d'afficher le résultat d'un échec contre un rêve de dragon	2022-10-14 00:48:05 +02:00
Vincent Vandemeulebrouck	21ec043e98	Fix: alignement des queues avec le reste Sans l'onglet Haut rêve, les queues n'étaient pas bien alignées.	2022-10-14 00:46:42 +02:00
Vincent Vandemeulebrouck	00b3b7f9b3	Fix: Affichage ajustement encaissement Pour les encaissements hors combat, rappel de l'ajustement d'encaissement choisi	2022-10-14 00:45:53 +02:00
Vincent Vandemeulebrouck	d1be242791	Minor: optimisation de monnaies pas d'updates pour les monnaies non affectées	2022-10-14 00:43:37 +02:00
Vincent Vandemeulebrouck	fa75828bc1	Fix: régression lancer de sorts A cause du duplicate, les voies n'étaient plus des RdDItem, du coup, la méthode isCompetence de la recherche de compétences ne marche pas... Et le duplicate était inutile de toutes façons.	2022-10-14 00:42:35 +02:00
sladecraven	232f414a62	Ajout distance	2022-10-09 13:44:40 +02:00
uberwald	14e76ac631	Merge pull request 'v10' (#564 ) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10 Reviewed-on: public/foundryvtt-reve-de-dragon#564	2022-10-09 13:43:27 +02:00
Vincent Vandemeulebrouck	43763dbe3a	Jets d'encaissement validés par le MJ * ajout d'une option pour activer la validation par le MJ * lors d'un jet d'encaissement, une fenêtre s'ouvre chez le MJ avec le résultat d'encaissement * le MJ peut changer le jet d'encaissement * si le MJ annule, l'encaissement n'a pas lieu * Attention, si plusieurs MJ, un seul doit valider, sinon encaissements multiples	2022-10-09 02:19:33 +02:00
Vincent Vandemeulebrouck	81ae15a6a2	Simuler les lancers de dés Lorsqu'on force le résultat des dés, on force l'affichage d'un lancer donnant ce résultat avec DiceSoNice	2022-10-08 17:37:39 +02:00
Vincent Vandemeulebrouck	6dc7272ef6	Corrections mineures Plus besoin de vérifier game.versions pour utiliser game.users Plus besoin d'une indirection Misc.getUsers defender.system.name => defender.name	2022-10-08 17:37:32 +02:00
Vincent Vandemeulebrouck	d75eef1926	Correction configuration affichage prix L'option de configuration étaity toujours vrai quand vue par le MJ	2022-10-08 17:37:32 +02:00
Vincent Vandemeulebrouck	18039e905b	Compétences & herbes personalisées * permettre d'ajouter des compétences dans un monde, qui seront ajoutés aux acteurs créés dans ce monde * les herbes de repos/soins du monde sont bien considérées comme des herbes pour les potions	2022-10-08 17:37:32 +02:00
Vincent Vandemeulebrouck	6d0e5321a2	Nommage homogène	2022-10-08 11:56:52 +02:00
sladecraven	3073670afa	Ajout visibilité	2022-10-07 23:46:36 +02:00
uberwald	690dd1f0a2	Merge pull request 'Monnaies et armes à distance' (#563 ) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10 Reviewed-on: public/foundryvtt-reve-de-dragon#563	2022-10-07 23:35:40 +02:00
Vincent Vandemeulebrouck	0dcce5456b	Inatteignable à -10 au lieu de hyphen non affiché	2022-10-07 23:31:57 +02:00
Vincent Vandemeulebrouck	35f1f2437c	Garde fous En cas d'exception dans le traitement d'un message websocket, faire un catch pour être sûr de ne pas réémettre si l'exception revient à l'émetteur (boucle infinie d'envois sinon)	2022-10-07 23:30:06 +02:00
Vincent Vandemeulebrouck	3e17dd9b7e	Ajout d'informations pour armes à distance * prise en compte de la taille de la cible * prise en compte de l'activité * valeur indicative	2022-10-07 23:28:41 +02:00
Vincent Vandemeulebrouck	4f8406360f	Suppression de création de personnage la feuille n'est pas encore prête	2022-10-07 19:07:25 +02:00
Vincent Vandemeulebrouck	d316bba8fa	Déplacement de méthode compendium	2022-10-07 19:07:25 +02:00
Vincent Vandemeulebrouck	9621d72f92	Correction des monnaies * Des deniers sont créés si on n'a rien d'autre * Gagner ou dépenser de l'argent fonctionne même si on n'a pas tous les types de pièces * Tous les acteurs peuvent acheter/vendre s'ils ont de l'argent => Pratique pour créer une auberge! * Seuls les personnages peuvent boire et manger * plus de problèmes de monnaies manquantes	2022-10-07 19:07:25 +02:00