Fix calculs coordonnées et distances

Utiliser les différents repères de cases:
- coordonnées TMR A5
- oddq pour les coordonnées de case (ligne, colonne)
- axial (q,r) pour effectuer les calculs de distance

utiliser x, y rend la distinction de positions de pixels vs position
dans la grille parfois ardue.

Utilisation des coordonnées axiales pour le calcul de distance.

module/tmr-utility.js

@@ -2,6 +2,7 @@ import { TMRRencontres } from "./tmr-rencontres.js";
 import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";
+import { tmrConstants } from "./tmr-constants.js";
 
 /* -------------------------------------------- */
 const TMRMapping = {
@@ -232,61 +233,14 @@ const caseSpecificModes = ["attache", "trounoir", "debordement", "reserve_extens
 
 /* -------------------------------------------- */
 const tmrRandomMovePatten =
-  [{ name: 'top', x: 0, y: -1 },
-  { name: 'topright', x: 1, y: -1 },
-  { name: 'botright', x: 1, y: 1 },
-  { name: 'bot', x: 0, y: 1 },
-  { name: 'botleft', x: -1, y: 1 },
-  { name: 'topleft', x: -1, y: -1 }
+  [{ name: 'top', col: 0, row: -1 },
+  { name: 'topright', col: 1, row: -1 },
+  { name: 'botright', col: 1, row: 1 },
+  { name: 'bot', col: 0, row: 1 },
+  { name: 'botleft', col: -1, row: 1 },
+  { name: 'topleft', col: -1, row: -1 }
   ]
 
-/* -------------------------------------------- */
-export const tmrConstants = {
-  col1_y: 30,
-  col2_y: 55,
-  cellw: 55,
-  cellh: 55,
-  gridx: 28,
-  gridy: 28,
-  // tailles
-  third: 18,
-  half: 27.5,
-  twoThird: 36,
-  full: 55,
-  // decallages
-  center: { x: 0, y: 0 },
-  top: { x: 0, y: -11.5 },
-  topLeft: { x: -11.5, y: -11.5 },
-  left: { x: -11.5, y: 0 },
-  bottomLeft: { x: -11.5, y: 11.5 },
-  bottom: { x: 0, y: 11.5 },
-  bottomRight: { x: 11.5, y: 11.5 },
-  right: { x: 11.5, y: 0 },
-  topRight: { x: 11.5, y: -11.5 },
-}
-
-// couleurs
-export const tmrColors = {
-  sort: 0xFF8800,
-  tetes: 0xA000FF,
-  souffle: 0x804040,
-  queues: 0xAA4040,
-  trounoir: 0x401060,
-  demireve: 0x00FFEE,
-  rencontre: 0xFF0000,
-  casehumide: 0x1050F0,
-}
-export const tmrTokenZIndex = {
-  sort: 40,
-  tetes: 20,
-  casehumide: 10,
-  conquete: 30,
-  rencontre: 50,
-  trounoir: 60,
-  demireve: 70,
-  tooltip: 100,
-}
-
 /* -------------------------------------------- */
 
 /* -------------------------------------------- */
@@ -295,6 +249,7 @@ export class TMRUtility {
     for (let coord in TMRMapping) {
       const tmr = TMRMapping[coord];
       tmr.coord = coord;
+      tmr.oddq = TMRUtility.coordTMRToOddq(coord);
       tmr.genre = TMRType[tmr.type].genre;
     }
     let tmrByType = Misc.classify(Object.values(TMRMapping));
@@ -303,12 +258,6 @@ export class TMRUtility {
     }
   }
 
-  /* -------------------------------------------- */
-  static convertToTMRCoord(pos) {
-    let letterX = String.fromCharCode(65 + (pos.x));
-    return letterX + (pos.y + 1)
-  }
-
   /* -------------------------------------------- */
   static verifyTMRCoord(coord) {
     let TMRregexp = new RegExp(/([A-M])(\d+)/g);
@@ -321,13 +270,6 @@ export class TMRUtility {
     return false;
   }
 
-  /* -------------------------------------------- */
-  static convertToCellPos(coordTMR) {
-    let x = coordTMR.charCodeAt(0) - 65;
-    let y = coordTMR.substr(1) - 1;
-    return { x: x, y: y }
-  }
-
   /* -------------------------------------------- */
   static getTMR(coord) {
     return TMRMapping[coord];
@@ -400,13 +342,14 @@ export class TMRUtility {
   }
 
   /* -------------------------------------------- */
-  static async deplaceTMRSelonPattern(actor, coord, direction, nTime) {
+  static async deplaceTMRSelonPattern(actor, coordTMR, direction, nTime) {
+    let coord;
     for (let i = 0; i < nTime; i++) {
-      let currentPos = TMRUtility.convertToCellPos(coord);
-      currentPos.x = currentPos.x + direction.x;
-      currentPos.y = currentPos.y + direction.y;
-      if (this._checkTMRCoord(currentPos.x, currentPos.y)) { // Sortie de carte ! Ré-insertion aléatoire
-        coord = TMRUtility.getTMR(TMRUtility.convertToTMRCoord(currentPos));
+      let currentOddq = TMRUtility.coordTMRToOddq(coordTMR);
+      currentOddq.col = currentOddq.col + direction.col;
+      currentOddq.row = currentOddq.row + direction.row;
+      if (this.isOddqInTMR(currentOddq)) { // Sortie de carte ! Ré-insertion aléatoire
+        coord = TMRUtility.getTMR(TMRUtility.oddqToCoordTMR(currentOddq));
       } else {
         coord = await actor.reinsertionAleatoire('Sortie de carte');
       }
@@ -437,22 +380,6 @@ export class TMRUtility {
     return await RdDDice.rollOneOf(TMRUtility.filterTMR(filter))
   }
 
-  /* -------------------------------------------- */
-  static _checkTMRCoord(x, y) {
-    if (x >= 0 && x < 13 && y >= 0 && y < 14) return true;
-    if (x >= 0 && x < 13 && x % 2 == 0 && y == 14) return true;
-    return false;
-  }
-
-  /* -------------------------------------------- */
-  static computeRealPictureCoordinates(coordXY, tmrConstants) {
-    let decallagePairImpair = (coordXY.x % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
-    return {
-      x: tmrConstants.gridx + (coordXY.x * tmrConstants.cellw),
-      y: tmrConstants.gridy + (coordXY.y * tmrConstants.cellh) + decallagePairImpair
-    }
-  }
-
   /* -------------------------------------------- */
   static getSortsReserve(reserveList, coord) {
     // TODO : Gérer les têtes spéciales réserve!
@@ -470,16 +397,15 @@ export class TMRUtility {
    * 
    */
   static getTMRPortee(coord, portee) {
-    let centerPos = this.convertToCellPos(coord);
-    let posPic = this.computeRealPictureCoordinates(centerPos, tmrConstants);
+    let centerOddq = this.coordTMRToOddq(coord);
     let caseList = [];
-    for (let dx = -portee; dx <= portee; dx++) { // Loop thru lines
-      for (let dy = -portee; dy <= portee; 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 dist = this.distancePosTMR(centerPos, currentPos);
+    for (let dcol = -portee; dcol <= portee; dcol++) { // rows
+      for (let drow = -portee; drow <= portee; drow++) { // columns
+        const currentOddq = { col: centerOddq.col + dcol, row: centerOddq.row + drow };
+        if (this.isOddqInTMR(currentOddq)) {
+          let dist = this.distanceOddq(centerOddq, currentOddq);
           if (dist <= portee) {
-            caseList.push(this.convertToTMRCoord(currentPos)); // Inside the area
+            caseList.push(this.oddqToCoordTMR(currentOddq)); // Inside the area
           }
         }
       }
@@ -488,21 +414,93 @@ export class TMRUtility {
   }
 
   /* -------------------------------------------- */
-  static distanceTMR(coord1, coord2) {
-    let pos1 = this.convertToCellPos(coord1);
-    let pos2 = this.convertToCellPos(coord2);
-    return this.distancePosTMR(pos1, pos2);
+  // https://www.redblobgames.com/grids/hexagons/#distances
+  // TMR Letter-row correspond to "odd-q" grid (letter => col, numeric => row )
+
+  /* -------------------------------------------- */
+  static coordTMRToOddq(coordTMR) {
+    let col = coordTMR.charCodeAt(0) - 65;
+    let row = coordTMR.substr(1) - 1;
+    return { col: col, row: row }
   }
 
   /* -------------------------------------------- */
-  static distancePosTMR(pos1, pos2) {
-    const dx = pos2.x - pos1.x;
-    const dy = pos2.y - pos1.y;
-    const abs_dx = Math.abs(dx);
-    const abs_dy = Math.abs(dy);
-    const distance = Math.sign(dx) == Math.sign(dy) ? Math.max(abs_dx, abs_dy) : (abs_dx + abs_dy);
-    return distance;
+  static oddqToCoordTMR(oddq) {
+    let letterX = String.fromCharCode(65 + (oddq.col));
+    return letterX + (oddq.row + 1)
   }
 
-}
+  /* -------------------------------------------- */
+  static isOddqInTMR(oddq) {
+    const col = oddq.col;
+    const row = oddq.row;
+    return (
+      col >= 0 && col < 13 &&
+      row >= 0 &&
+      (row + col % 2 <= 14)
+      );
+    // if (x >= 0 && x < 13 && y >= 0 && y < 14) return true;
+    // if (x >= 0 && x < 13 && x % 2 == 0 && y == 14) return true;
+    // return false;
+  }
 
+
+  /* -------------------------------------------- */
+  static distanceCoordTMR(coord1, coord2) {
+    let oddq1 = this.coordTMRToOddq(coord1);
+    let oddq2 = this.coordTMRToOddq(coord2);
+    return this.distanceOddq(oddq1, oddq2);
+  }
+
+  /* -------------------------------------------- */
+  static distanceOddq(oddq1, oddq2) {
+    const axial1 = TMRUtility.oddqToAxial(oddq1);
+    const axial2 = TMRUtility.oddqToAxial(oddq2);
+    return TMRUtility.distanceAxial(axial1, axial2);
+
+    // const dx = oddq2.col - oddq1.col;
+    // const dy = oddq2.row - oddq1.row;
+    // const abs_dx = Math.abs(dx);
+    // const abs_dy = Math.abs(dy);
+    // const distance = Math.sign(dx) == Math.sign(dy) ? Math.max(abs_dx, abs_dy) : (abs_dx + abs_dy);
+    // return distance;
+  }
+
+  static oddqToAxial(pos) {
+    return {
+      q: pos.col,
+      r: pos.row - (pos.col - (pos.col & 1)) / 2
+    }
+  }
+
+  static distanceAxial(a, b) {
+    const vector = TMRUtility.axial_subtract(a, b)
+    return (Math.abs(vector.q)
+      + Math.abs(vector.q + vector.r)
+      + Math.abs(vector.r)) / 2
+  }
+
+  static axial_subtract(a, b) {
+    return {
+      q: a.q- b.q,
+      r: a.r - b.r
+    };
+  }
+
+  //   function axial_to_cube(hex):
+  //   var q = hex.q
+  // var r = hex.r
+  // var s = -q - r
+  // return Cube(q, r, s)
+  // }
+
+  
+  // /* -------------------------------------------- */
+  // static computeRealPictureCoordinates(coordOddq) {
+  //   let decallagePairImpair = (coordOddq.col % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
+  //   return {
+  //     x: tmrConstants.gridx + (coordOddq.col * tmrConstants.cellw),
+  //     y: tmrConstants.gridy + (coordOddq.row * tmrConstants.cellh) + decallagePairImpair
+  //   }
+  // }
+}