microboard-temp 0.5.75 → 0.5.77

package/dist/esm/index.js

@@ -6902,7 +6902,8 @@ var conf = {
   DECK_VERTICAL_OFFSET: 2,
   CARD_DIMENSIONS: { width: 250, height: 400 },
   DEFAULT_GAME_ITEM_DIMENSIONS: { width: 200, height: 200 },
-  MAX_CARD_SIZE: 500
+  MAX_CARD_SIZE: 500,
+  CONNECTOR_ITEM_OFFSET: 20
 };
 initDefaultI18N();
 
@@ -36507,7 +36508,6 @@ function radiansBetweenPoints(point1, point22) {
 }
 
 // src/Items/Connector/getLine/findOrthogonalPath.ts
-var ITEM_OFFSET = 1;
 function getDirection(from, to) {
   if (!to) {
     return null;
@@ -36548,9 +36548,9 @@ function getNeighbors(node2, grid, obstacles) {
     { x: node2.xGrid, y: node2.yGrid + 1 }
   ];
   for (const pos of potentialNeighbors) {
-    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0) {
+    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0 && grid[pos.x] && grid[pos.x][pos.y]) {
       const newPoint = grid[pos.x][pos.y];
-      if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, ITEM_OFFSET - 1))) {
+      if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, conf.CONNECTOR_ITEM_OFFSET - 1))) {
         neighbors.push({
           point: newPoint,
           costSoFar: 0,
@@ -36578,16 +36578,20 @@ function findCenterLine(grid, start, end, middle) {
   }
   if (width > height) {
     const centerIdx = grid.findIndex((row2) => row2[0].x === middlePoint.x || Math.abs(row2[0].x - middlePoint.x) < 0.01);
-    for (let y = 0;y < grid[0].length && centerIdx !== -1; y++) {
-      if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
-        centerLine.push(grid[centerIdx][y]);
+    if (centerIdx !== -1) {
+      for (let y = 0;y < grid[0].length; y++) {
+        if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
+          centerLine.push(grid[centerIdx][y]);
+        }
       }
     }
   } else {
     const centerIdx = grid[0].findIndex((point5) => point5.y === middlePoint.y || Math.abs(point5.y - middlePoint.y) < 0.01);
-    for (let x = 0;x < grid.length && centerIdx !== -1; x++) {
-      if (grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
-        centerLine.push(grid[x][centerIdx]);
+    if (centerIdx !== -1) {
+      for (let x = 0;x < grid.length; x++) {
+        if (grid[x][centerIdx] && grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
+          centerLine.push(grid[x][centerIdx]);
+        }
       }
     }
   }
@@ -36598,69 +36602,24 @@ function createGrid(start, end, toVisitPoints = []) {
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
   const offsetMap = {
-    top: { x: 0, y: -ITEM_OFFSET },
-    bottom: { x: 0, y: ITEM_OFFSET },
-    right: { x: ITEM_OFFSET, y: 0 },
-    left: { x: -ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
+    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
+    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
+    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  if (start.pointType !== "Board") {
-    const itemMbr = start.item.getMbr();
-    verticalLines.push(itemMbr.left - ITEM_OFFSET, itemMbr.left, itemMbr.right, itemMbr.right + ITEM_OFFSET);
-    horizontalLines.push(itemMbr.top - ITEM_OFFSET, itemMbr.top, itemMbr.bottom, itemMbr.bottom + ITEM_OFFSET);
-  }
-  if (end.pointType !== "Board") {
-    const itemMbr = end.item.getMbr();
-    verticalLines.push(itemMbr.left - ITEM_OFFSET, itemMbr.left, itemMbr.right, itemMbr.right + ITEM_OFFSET);
-    horizontalLines.push(itemMbr.top - ITEM_OFFSET, itemMbr.top, itemMbr.bottom, itemMbr.bottom + ITEM_OFFSET);
-  }
-  const tempStart = start;
-  const tempEnd = end;
-  const middle = new Point((tempStart.x + tempEnd.x) / 2, (tempStart.y + tempEnd.y) / 2);
-  horizontalLines.push(middle.y, tempStart.y, tempEnd.y);
-  verticalLines.push(middle.x, tempStart.x, tempEnd.x);
-  toVisitPoints.forEach((p3) => {
-    horizontalLines.push(p3.y);
-    verticalLines.push(p3.x);
-  });
-  const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
-  const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   let newStart;
   let newEnd;
   const processPoint = (point5, dir2) => {
     const itemMbr = point5.item.getMbr();
-    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
+    const pointOnMbr = mbrFloored.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
     const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
-    if (dir2 === "top") {
-      const currentYIndex = uniqueHorizontalLines.findIndex((y) => Math.abs(y - pointOnMbr.y) < 0.01);
-      const nextYIndex = currentYIndex - 1;
-      if (nextYIndex >= 0) {
-        newPoint.y = uniqueHorizontalLines[nextYIndex];
-        newPoint.x = pointOnMbr.x;
-      }
-    } else if (dir2 === "bottom") {
-      const currentYIndex = uniqueHorizontalLines.findIndex((y) => Math.abs(y - pointOnMbr.y) < 0.01);
-      const nextYIndex = currentYIndex + 1;
-      if (nextYIndex < uniqueHorizontalLines.length) {
-        newPoint.y = uniqueHorizontalLines[nextYIndex];
-        newPoint.x = pointOnMbr.x;
-      }
-    } else if (dir2 === "left") {
-      const currentXIndex = uniqueVerticalLines.findIndex((x) => Math.abs(x - pointOnMbr.x) < 0.01);
-      const nextXIndex = currentXIndex - 1;
-      if (nextXIndex >= 0) {
-        newPoint.x = uniqueVerticalLines[nextXIndex];
-        newPoint.y = pointOnMbr.y;
-      }
-    } else if (dir2 === "right") {
-      const currentXIndex = uniqueVerticalLines.findIndex((x) => Math.abs(x - pointOnMbr.x) < 0.01);
-      const nextXIndex = currentXIndex + 1;
-      if (nextXIndex < uniqueVerticalLines.length) {
-        newPoint.x = uniqueVerticalLines[nextXIndex];
-        newPoint.y = pointOnMbr.y;
-      }
-    }
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
+    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
     return newPoint;
   };
   if (start.pointType !== "Board" && startDir) {
@@ -36669,6 +36628,17 @@ function createGrid(start, end, toVisitPoints = []) {
   if (end.pointType !== "Board" && endDir) {
     newEnd = processPoint(end, endDir);
   }
+  const finalStart = newStart || start;
+  const finalEnd = newEnd || end;
+  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
+  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
+  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
+  toVisitPoints.forEach((p3) => {
+    horizontalLines.push(p3.y);
+    verticalLines.push(p3.x);
+  });
+  const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
+  const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
@@ -36677,18 +36647,27 @@ function createGrid(start, end, toVisitPoints = []) {
     middlePoint: middle
   };
 }
-function findPath(start, end, grid, obstacles, newStart, newEnd) {
-  const startIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
-  const endIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
-  if (startIdx === -1 || endIdx === -1) {
-    throw new Error("Start or end point not found in the grid");
+function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
+  const startRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
+  if (startRowIndex === -1) {
+    throw new Error("Start point not found in the grid row");
+  }
+  const startPointIndex = grid[startRowIndex].findIndex((point5) => point5.barelyEqual(start));
+  if (startPointIndex === -1) {
+    throw new Error("Start point not found in the grid column");
+  }
+  const endRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
+  if (endRowIndex === -1) {
+    throw new Error("End point not found in the grid row");
+  }
+  const endPointIndex = grid[endRowIndex].findIndex((point5) => point5.barelyEqual(end));
+  if (endPointIndex === -1) {
+    throw new Error("End point not found in the grid column");
   }
-  const startPointIdx = grid[startIdx].findIndex((point5) => point5.barelyEqual(start));
-  const endPointIdx = grid[endIdx].findIndex((point5) => point5.barelyEqual(end));
   const endNode = {
     point: end,
-    xGrid: endIdx,
-    yGrid: endPointIdx,
+    xGrid: endRowIndex,
+    yGrid: endPointIndex,
     costSoFar: 0,
     heuristic: 0,
     toFinish: 0
@@ -36696,53 +36675,72 @@ function findPath(start, end, grid, obstacles, newStart, newEnd) {
   const startNode = {
     point: start,
     costSoFar: 0,
-    heuristic: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    toFinish: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    xGrid: startIdx,
-    yGrid: startPointIdx
+    heuristic: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    toFinish: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    xGrid: startRowIndex,
+    yGrid: startPointIndex
   };
   const openSet = [startNode];
   const closedSet = new Set;
   while (openSet.length > 0) {
     openSet.sort((aa, bb) => aa.toFinish - bb.toFinish);
     const current = openSet.shift();
+    const currentKey = `${current.point.x},${current.point.y}`;
     if (current.point.barelyEqual(end)) {
       const path2 = reconstructPath(current);
       return path2;
     }
-    closedSet.add(current.point);
+    closedSet.add(currentKey);
     const neighbors = getNeighbors(current, grid, obstacles);
     for (const neighbor of neighbors) {
-      if (closedSet.has(neighbor.point)) {
+      const neighborKey = `${neighbor.point.x},${neighbor.point.y}`;
+      if (closedSet.has(neighborKey) || existingPath.has(neighborKey) && !neighbor.point.barelyEqual(end)) {
         continue;
       }
       const extraCost = isChangingDirection(current, neighbor, newStart, newEnd);
-      const tentativeCost = current.costSoFar + 1;
-      if (!openSet.some((node2) => node2.point.barelyEqual(neighbor.point) && node2.costSoFar <= tentativeCost)) {
-        neighbor.costSoFar = tentativeCost + extraCost;
-        neighbor.heuristic = heuristic(neighbor, endNode);
-        neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
-        openSet.push(neighbor);
+      const pathOverlapCost = existingPath.has(neighborKey) ? 1000 : 0;
+      const tentativeCost = current.costSoFar + 1 + pathOverlapCost;
+      let existingNodeInOpenSet = openSet.find((node2) => node2.point.barelyEqual(neighbor.point));
+      if (!existingNodeInOpenSet || tentativeCost < existingNodeInOpenSet.costSoFar) {
+        if (existingNodeInOpenSet) {
+          existingNodeInOpenSet.costSoFar = tentativeCost + extraCost;
+          existingNodeInOpenSet.heuristic = heuristic(neighbor, endNode);
+          existingNodeInOpenSet.toFinish = existingNodeInOpenSet.costSoFar + existingNodeInOpenSet.heuristic;
+          existingNodeInOpenSet.parent = current;
+        } else {
+          neighbor.costSoFar = tentativeCost + extraCost;
+          neighbor.heuristic = heuristic(neighbor, endNode);
+          neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
+          openSet.push(neighbor);
+        }
       }
     }
   }
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const pathPoints = [];
+  const finalPath = [];
+  const existingPathSegments = new Set;
+  if (points.length > 0) {
+    finalPath.push(points[0]);
+    const startKey = `${points[0].x},${points[0].y}`;
+    existingPathSegments.add(startKey);
+  }
   for (let i = 0;i < points.length - 1; i += 1) {
-    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, newStart, newEnd);
-    if (segmentPath) {
-      pathPoints.push(...segmentPath.slice(0, -1));
+    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    if (segmentPath && segmentPath.length > 0) {
+      for (let j = 1;j < segmentPath.length; j++) {
+        const point5 = segmentPath[j];
+        const key = `${point5.x},${point5.y}`;
+        finalPath.push(point5);
+        existingPathSegments.add(key);
+      }
     } else {
       points.splice(i + 1, 1);
       i--;
     }
   }
-  if (pathPoints.length !== 0) {
-    pathPoints.push(points[points.length - 1]);
-  }
-  return pathPoints;
+  return finalPath;
 }
 function reducePoints(points) {
   const uniquePoints = new Map;
@@ -36753,6 +36751,12 @@ function reducePoints(points) {
     if (uniquePoints.has(key)) {
       const loopStartIndex = uniquePoints.get(key);
       result.splice(loopStartIndex + 1);
+      const removedPoints = points.slice(loopStartIndex + 1, i + 1);
+      removedPoints.forEach((p3) => {
+        uniquePoints.delete(`${p3.x},${p3.y}`);
+      });
+      uniquePoints.set(key, result.length);
+      result.push(point5);
     } else {
       uniquePoints.set(key, result.length);
       result.push(point5);
@@ -36762,19 +36766,32 @@ function reducePoints(points) {
 }
 function getLines(pathPoints) {
   const lines = [];
+  if (pathPoints.length < 2) {
+    return [];
+  }
   const reducedPoints = reducePoints(pathPoints);
+  if (reducedPoints.length < 2) {
+    return [];
+  }
   let startPoint = reducedPoints[0];
-  for (let i = 1;i < reducedPoints.length - 1; i += 1) {
+  for (let i = 1;i < reducedPoints.length; i += 1) {
     const prevPoint = reducedPoints[i - 1];
     const currPoint = reducedPoints[i];
-    const nextPoint = reducedPoints[i + 1];
-    if (prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
+    const nextPoint = i + 1 < reducedPoints.length ? reducedPoints[i + 1] : null;
+    if (!nextPoint || prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
       lines.push(new Line(startPoint, currPoint));
       startPoint = currPoint;
     }
   }
-  if (lines.length > 0) {
-    lines.push(new Line(startPoint, pathPoints[pathPoints.length - 1]));
+  if (lines.length === 0 && reducedPoints.length > 1) {
+    lines.push(new Line(reducedPoints[0], reducedPoints[reducedPoints.length - 1]));
+  } else if (lines.length > 0) {
+    const lastLine = lines[lines.length - 1];
+    const lastPointInLines = lastLine.getEndPoint();
+    const lastPointInReduced = reducedPoints[reducedPoints.length - 1];
+    if (!lastPointInLines.barelyEqual(lastPointInReduced)) {
+      lines.push(new Line(lastPointInLines, lastPointInReduced));
+    }
   }
   return lines;
 }