Fixes nombreux sur tmr

- rencontre sur case humide ne causait pas de maîtrise
- détermination de la liste des tmrs par type à l'init (classify)
- tirages aléatoire par type de tmr dans les commandes
- amélioration de messages (nom de case)
- fix expérience case humide
- correction gestion des débordement
- montées très laborieuses multiples
- renommages et extraits méthodes
- distinction de pos (x, y) vs coord (A1)

module/tmr-utility.js

@@ -1,6 +1,7 @@
 import { DeDraconique } from "./de-draconique.js";
 import { TMRRencontres } from "./tmr-rencontres.js";
 import { Grammar } from "./grammar.js";
+import { Misc } from "./misc.js";
 
 /* -------------------------------------------- */
 const TMRMapping = { 
@@ -210,20 +211,20 @@ const TMRMapping = {
     }
 
 export const TMRType = { 
-  cite: "cité",
-  sanctuaire: "sanctuaire",
-  plaines: "plaines",
-  pont: "pont",
-  collines: "collines",
-  foret: "forêt",
-  monts: "monts",
-  desert: "désert",
-  fleuve: "fleuve",
-  lac: "lac",
-  marais: "marais",
-  gouffre: "gouffre",
-  necropole: "nécropole",
-  desolation: "désolation"
+  cite: {name:"cité"},
+  sanctuaire: {name:"sanctuaire"},
+  plaines: {name:"plaines"},
+  pont: {name:"pont"},
+  collines: {name:"collines"},
+  foret: {name:"forêt"},
+  monts: {name:"monts"},
+  desert: {name:"désert"},
+  fleuve: {name:"fleuve"},
+  lac: {name:"lac"},
+  marais: {name:"marais"},
+  gouffre: {name:"gouffre"},
+  necropole: {name:"nécropole"},
+  desolation: {name:"désolation"}
 }
 
 /* -------------------------------------------- */
@@ -257,14 +258,17 @@ export class TMRUtility  {
     for (let coord in TMRMapping) {
       TMRMapping[coord].coord = coord;
     }
+    let tmrByType = Misc.classify(Object.values(TMRMapping));
+    for (const [type, list] of Object.entries(tmrByType)) {
+      TMRType[type].list = list;
+    }
   }
 
   /* -------------------------------------------- */
-  static convertToTMRCoord( x, y )
+  static convertToTMRCoord( pos )
   {
-    y = y + 1
-    let letterX = String.fromCharCode(65+x);
-    return letterX+y
+    let letterX = String.fromCharCode(65+ (pos.x));
+    return letterX + (pos.y +1)
   }
 
   /* -------------------------------------------- */
@@ -280,7 +284,7 @@ export class TMRUtility  {
  }
 
   /* -------------------------------------------- */
-  static convertToCellCoord( coordTMR )
+  static convertToCellPos( coordTMR )
   {
     let x = coordTMR.charCodeAt(0) - 65;
     let y = coordTMR.substr(1) - 1;
@@ -328,13 +332,13 @@ export class TMRUtility  {
   /* -------------------------------------------- */
   static deplaceTMRSelonPattern( coord, direction, nTime ) {
     for (let i=0; i <nTime; i++) {
-      let currentPosXY = TMRUtility.convertToCellCoord(coord);
+      let currentPosXY = TMRUtility.convertToCellPos(coord);
       currentPosXY.x = currentPosXY.x + direction.x;
       currentPosXY.y = currentPosXY.y + direction.y;
       if ( this._checkTMRCoord(currentPosXY.x, currentPosXY.y) ) { // Sortie de carte ! Ré-insertion aléatoire
-        coord = TMRUtility.convertToTMRCoord(currentPosXY.x, currentPosXY.y);
+        coord = TMRUtility.convertToTMRCoord(currentPosXY);
       } else {
-        coord = this.getTMRAleatoire();
+        coord = this.getTMRAleatoire().coord;
       }
       console.log("Nouvelle case iteration !!!", i, coord);
     }
@@ -361,40 +365,17 @@ export class TMRUtility  {
   
   /* -------------------------------------------- */
   static getListTMR(terrain) {
-    let list = [];
-    for (let index in TMRMapping) {
-      if (TMRMapping[index].type == terrain){
-        list.push(TMRMapping[index]);
-      }
-    }
-    return list;
+    return TMRType[terrain].list;
   }
 
   static getListCoordTMR(terrain) {
     return this.getListTMR(terrain).map(it=>it.coord);
   }
 
-  /* -------------------------------------------- */
-  static getTMRAleatoire(terrain=undefined)
-  {
-    if (terrain) {
-      let list = TMRUtility.getListTMR(terrain);
-      let index = new Roll("1d" + list.length).evaluate().total - 1;
-      return list[index];  
-    }
-    let num = new Roll("1d15").roll().total;
-    let letter, letterValue;
-    if ( num == 15) {
-      letterValue = new Roll( "1d7").roll().total;
-      letter = String.fromCharCode( 65 + ((parseInt(letterValue)-1)*2) );
-    } else {
-      letterValue = new Roll( "1d13 + 64" ).roll().total;
-      letter = String.fromCharCode( letterValue );
-    }
-    let caseIndex = letter+num;
-    ChatMessage.create( { content: "Case aléatoire : " + letter+num + " - " + TMRMapping[caseIndex].label , 
-                          whisper: ChatMessage.getWhisperRecipients("GM") } );
-    return caseIndex;
+  static getTMRAleatoire(terrain = undefined) {
+    let list = terrain ? TMRUtility.getListTMR(terrain) : Object.values(TMRMapping);
+    let index = new Roll("1d" + list.length).evaluate().total - 1;
+    return list[index];    
   }
 
   /* -------------------------------------------- */
@@ -432,22 +413,22 @@ export class TMRUtility  {
   /** Returns a list of case inside a given distance
    * 
    */
-  static getTMRPortee(coord, portee) {
-    return TMRUtility.getTMRArea(coord, portee, tmrConstants);
+  static getTMRPortee(centerCoord, portee) {
+    return TMRUtility.getTMRArea(centerCoord, portee, tmrConstants);
   }
 
-  static getTMRArea( coord, distance, tmrConstants ) {
-    let pos = this.convertToCellCoord( coord );    
-    let posPic = this.computeRealPictureCoordinates( pos, tmrConstants );
+  static getTMRArea( centerCoord, distance, tmrConstants ) {
+    let centerPos = this.convertToCellPos( centerCoord );    
+    let posPic = this.computeRealPictureCoordinates( centerPos, tmrConstants );
     let caseList = [];
-    for (let x=pos.x-distance; x<=pos.x+distance; x++ ) { // Loop thru lines
-      for (let y=pos.y-distance; y<=pos.y+distance; y++ ) { // Loop thru lines
-        //console.log("Parsing position", x, y);
-        if ( this._checkTMRCoord(x, y) ) { // Coordinate is valie
-          let posPicNow = this.computeRealPictureCoordinates( {x: x, y: y}, tmrConstants );
+    for (let dx=-distance; dx<=distance; dx++ ) { // Loop thru lines
+      for (let dy=-distance; dy<=distance; dy++ ) { // Loop thru lines
+        const currentPos = { x: centerPos.x+dx, y: centerPos.y+dy };
+        if ( this._checkTMRCoord(currentPos.x, currentPos.y) ) { // Coordinate is valie
+          let posPicNow = this.computeRealPictureCoordinates( currentPos, tmrConstants );
           let dist = Math.sqrt(Math.pow(posPicNow.x - posPic.x,2) + Math.pow(posPicNow.y - posPic.y, 2)) / tmrConstants.cellw;
           if ( dist < distance+0.5) {
-            caseList.push( this.convertToTMRCoord(x, y) ); // Inside the area
+            caseList.push( this.convertToTMRCoord(currentPos) ); // Inside the area
           }
         }
       }