Fix /rdd [carac]

- en cas de carac exact (reve), choisir cette caractéristique
(pas de message par rapport à reve-actuel)
- support /rdd odorat-gout

module/actor.js

@@ -2345,7 +2345,7 @@ export class RdDActor extends Actor {
       }
       if (xpCarac > 0) {
         let carac = duplicate(Misc.templateData(this).carac);
-        let selectedCarac = RdDActor._findCaracByName(carac, caracName);
+        let selectedCarac = RdDCarac.findCarac(carac, caracName);
         if (!selectedCarac.derivee) {
           selectedCarac.xp = Misc.toInt(selectedCarac.xp) + xpCarac;
           await this.update({ "data.carac": carac });
@@ -2392,49 +2392,17 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  getCaracByName(caracName) {
-    switch (caracName) {
-      case 'reve-actuel': case 'Rêve actuel':
-        return {
-          label: 'Rêve actuel',
-          value: this.getReveActuel(),
-          type: "number"
+  getCaracAndActuel() {
+    let caracs = {
+      'reve-actuel': { label: 'Rêve actuel', value: this.getReveActuel(), type: "number" },
+      'chance-actuelle': { label: 'Chance actuelle', value: this.getChanceActuel(), type: "number" }
     };
-      case 'chance-actuelle': case 'Chance actuelle':
-        return {
-          label: 'Chance actuelle',
-          value: this.getChanceActuel(),
-          type: "number"
-        };
-    }
-    return RdDActor._findCaracByName(Misc.templateData(this).carac, caracName);
+    mergeObject(caracs, Misc.templateData(this).carac);
+    return caracs
   }
 
-  /* -------------------------------------------- */
-  static _findCaracByName(carac, name) {
-    name = Grammar.toLowerCaseNoAccent(name);
-    switch (name) {
-      case 'reve-actuel': case 'rêve actuel':
-        return carac.reve;
-      case 'chance-actuelle': case 'chance actuelle':
-        return carac.chance;
-    }
-    const keys = Object.entries(carac)
-      .filter(it => it[0].includes(name) || Grammar.toLowerCaseNoAccent(it[0]).includes(name))
-      .map(it => it[0]);
-    if (keys.length>1){
-      const names = keys.reduce((a, b) => `${a}<br>${b}`);
-      ui.notifications.info(`Plusieurs caractéristiques possibles:<br>${names}<br>La première sera choisie.`);
-    }
-    if (keys.length>0){
-      return carac[keys[0]];
-    }
-    // for (const [key, value] of Object.entries(carac)) {
-    //   if (key.includes(name) || Grammar.toLowerCaseNoAccent(value.label).includes('name')) {
-    //     return carac[key];
-    //   }
-    // }
-    return undefined; // Per default
+  getCaracByName(caracName) {
+    return RdDCarac.findCarac(this.getCaracAndActuel(), caracName);
   }
 
   /* -------------------------------------------- */

module/item-competence.js

@@ -191,14 +191,14 @@ export class RdDItemCompetence extends Item {
       return undefined;
     }
     let competence = competences.find(it => Grammar.toLowerCaseNoAccent(it.name) == name);
-    if (!competence) {
-      competence = competences[0];
+    if (competence) {
+      return competence;
+    }
     if (competences.length>1) {
       const names = competences.map(it => it.name).reduce((a, b) => `${a}<br>${b}`);
-        ui.notifications.info(`Plusieurs compétences possibles:<br>${names}<br>La première sera choisie: ${competence.name}`);
+      ui.notifications.info(`Plusieurs compétences possibles:<br>${names}<br>La première sera choisie: ${competences[0].name}`);
     }
-    }
-    return competence;
+    return competences[0];
   }
 
   /* -------------------------------------------- */

module/rdd-carac.js

@@ -38,6 +38,29 @@ const tableCaracDerivee = {
 
 export class RdDCarac {
 
+  /* -------------------------------------------- */
+  static findCarac(carac, name) {
+
+    const pairs = Object.entries(carac)
+      .filter(([key, value]) => key.includes(name) || Grammar.toLowerCaseNoAccent(value.label).includes(name));
+
+    let c = pairs.find(([key, value]) => key == name || Grammar.toLowerCaseNoAccent(value.label) == name);
+    if (c) {
+      return c[1];
+    }
+
+    pairs.sort((a, b) => a[0].length- b[0].length);
+    if (pairs.length > 0) {
+      c = pairs[0][1];
+      if (pairs.length > 1) {
+        const labels = pairs.map(pair => pair[1].label).reduce((a, b) => `${a}<br>${b}`);
+        ui.notifications.info(`Plusieurs caractéristiques possibles:<br>${labels}<br>La première sera choisie: ${c.label}.`);
+      }
+      return c;
+    }
+    return undefined;
+  }
+
   static isAgiliteOuDerivee(selectedCarac) {
     return selectedCarac?.label.match(/(Agilité|Dérobée)/);
   }