@flare-engine/pathfinding 0.1.0

package/dist/index.mjs

@@ -0,0 +1,655 @@
+// src/grid.ts
+function createGrid(config) {
+  const { width, height, defaultCost = 1 } = config;
+  if (width <= 0 || height <= 0) {
+    throw new RangeError("Grid dimensions must be positive");
+  }
+  const w = width | 0;
+  const h = height | 0;
+  let data;
+  if (config.data) {
+    if (config.data.length !== w * h) {
+      throw new RangeError(`Grid data length ${config.data.length} does not match ${w}x${h}`);
+    }
+    data = config.data;
+  } else {
+    data = new Uint8Array(w * h);
+    if (defaultCost > 0) {
+      data.fill(defaultCost);
+    }
+  }
+  return { width: w, height: h, data };
+}
+function inBounds(grid, x, y) {
+  return x >= 0 && y >= 0 && x < grid.width && y < grid.height;
+}
+function isWalkable(grid, x, y) {
+  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return false;
+  return grid.data[(y | 0) * grid.width + (x | 0)] > 0;
+}
+function getCost(grid, x, y) {
+  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return 0;
+  return grid.data[(y | 0) * grid.width + (x | 0)];
+}
+function setWalkable(grid, x, y, walkable) {
+  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return;
+  grid.data[(y | 0) * grid.width + (x | 0)] = walkable ? 1 : 0;
+}
+function setCost(grid, x, y, cost) {
+  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return;
+  grid.data[(y | 0) * grid.width + (x | 0)] = cost > 255 ? 255 : cost < 0 ? 0 : cost | 0;
+}
+
+// src/astar.ts
+var SQRT2 = Math.SQRT2;
+function manhattanDistance(ax, ay, bx, by) {
+  return Math.abs(ax - bx) + Math.abs(ay - by);
+}
+function octileDistance(ax, ay, bx, by) {
+  const dx = Math.abs(ax - bx);
+  const dy = Math.abs(ay - by);
+  return dx > dy ? dx + (SQRT2 - 1) * dy : dy + (SQRT2 - 1) * dx;
+}
+function chebyshevDistance(ax, ay, bx, by) {
+  return Math.max(Math.abs(ax - bx), Math.abs(ay - by));
+}
+function euclideanDistance(ax, ay, bx, by) {
+  const dx = ax - bx;
+  const dy = ay - by;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function heapCreate(capacity) {
+  return {
+    f: new Float64Array(capacity),
+    idx: new Int32Array(capacity),
+    size: 0
+  };
+}
+function heapPush(h, f, nodeIdx) {
+  let i = h.size++;
+  h.f[i] = f;
+  h.idx[i] = nodeIdx;
+  while (i > 0) {
+    const parent = i - 1 >> 1;
+    if (h.f[parent] <= h.f[i]) break;
+    const tf = h.f[parent];
+    const ti = h.idx[parent];
+    h.f[parent] = h.f[i];
+    h.idx[parent] = h.idx[i];
+    h.f[i] = tf;
+    h.idx[i] = ti;
+    i = parent;
+  }
+}
+function heapPop(h) {
+  const result = h.idx[0];
+  h.size--;
+  if (h.size > 0) {
+    h.f[0] = h.f[h.size];
+    h.idx[0] = h.idx[h.size];
+    let i = 0;
+    for (; ; ) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < h.size && h.f[left] < h.f[smallest]) smallest = left;
+      if (right < h.size && h.f[right] < h.f[smallest]) smallest = right;
+      if (smallest === i) break;
+      const tf = h.f[i];
+      const ti = h.idx[i];
+      h.f[i] = h.f[smallest];
+      h.idx[i] = h.idx[smallest];
+      h.f[smallest] = tf;
+      h.idx[smallest] = ti;
+      i = smallest;
+    }
+  }
+  return result;
+}
+var DIR4_X = [0, 1, 0, -1];
+var DIR4_Y = [-1, 0, 1, 0];
+var DIR8_X = [0, 1, 1, 1, 0, -1, -1, -1];
+var DIR8_Y = [-1, -1, 0, 1, 1, 1, 0, -1];
+var DIR8_COST = [1, SQRT2, 1, SQRT2, 1, SQRT2, 1, SQRT2];
+function findPath(grid, startX, startY, endX, endY, options) {
+  const sx = startX | 0;
+  const sy = startY | 0;
+  const ex = endX | 0;
+  const ey = endY | 0;
+  if (!isWalkable(grid, sx, sy) || !isWalkable(grid, ex, ey)) return null;
+  if (sx === ex && sy === ey) return { path: [{ x: sx, y: sy }], cost: 0, explored: 0 };
+  const diagonal = options?.diagonal !== false;
+  const maxIter = options?.maxIterations ?? grid.width * grid.height;
+  const heuristic = options?.heuristic ?? (diagonal ? octileDistance : manhattanDistance);
+  const w = grid.width;
+  const total = w * grid.height;
+  const g = new Float64Array(total);
+  g.fill(Number.POSITIVE_INFINITY);
+  const closed = new Uint8Array(total);
+  const cameFrom = new Int32Array(total);
+  cameFrom.fill(-1);
+  const startIdx = sy * w + sx;
+  const endIdx = ey * w + ex;
+  g[startIdx] = 0;
+  const heap = heapCreate(Math.min(total, 4096));
+  heapPush(heap, heuristic(sx, sy, ex, ey), startIdx);
+  const dirX = diagonal ? DIR8_X : DIR4_X;
+  const dirY = diagonal ? DIR8_Y : DIR4_Y;
+  const dirCost = diagonal ? DIR8_COST : null;
+  const dirCount = dirX.length;
+  let explored = 0;
+  while (heap.size > 0 && explored < maxIter) {
+    const currentIdx = heapPop(heap);
+    if (currentIdx === endIdx) {
+      return reconstructPath(cameFrom, w, currentIdx, g[currentIdx], explored);
+    }
+    if (closed[currentIdx]) continue;
+    closed[currentIdx] = 1;
+    explored++;
+    const cx = currentIdx % w;
+    const cy = currentIdx / w | 0;
+    const currentG = g[currentIdx];
+    for (let d = 0; d < dirCount; d++) {
+      const nx = cx + dirX[d];
+      const ny = cy + dirY[d];
+      if (nx < 0 || ny < 0 || nx >= w || ny >= grid.height) continue;
+      const nIdx = ny * w + nx;
+      if (closed[nIdx]) continue;
+      const tileCost = grid.data[nIdx];
+      if (tileCost === 0) continue;
+      if (diagonal && d & 1) {
+        const dx = dirX[d];
+        const dy = dirY[d];
+        if (!isWalkable(grid, cx + dx, cy) || !isWalkable(grid, cx, cy + dy)) continue;
+      }
+      const moveCost = dirCost ? dirCost[d] * tileCost : tileCost;
+      const tentativeG = currentG + moveCost;
+      if (tentativeG < g[nIdx]) {
+        g[nIdx] = tentativeG;
+        cameFrom[nIdx] = currentIdx;
+        const f = tentativeG + heuristic(nx, ny, ex, ey);
+        heapPush(heap, f, nIdx);
+      }
+    }
+  }
+  return null;
+}
+function reconstructPath(cameFrom, w, endIdx, cost, explored) {
+  const path = [];
+  let idx = endIdx;
+  while (idx !== -1) {
+    path.push({ x: idx % w, y: idx / w | 0 });
+    idx = cameFrom[idx];
+  }
+  path.reverse();
+  return { path, cost, explored };
+}
+
+// src/jps.ts
+function heapCreate2(capacity) {
+  return {
+    f: new Float64Array(capacity),
+    idx: new Int32Array(capacity),
+    size: 0
+  };
+}
+function heapPush2(h, f, nodeIdx) {
+  let i = h.size++;
+  h.f[i] = f;
+  h.idx[i] = nodeIdx;
+  while (i > 0) {
+    const parent = i - 1 >> 1;
+    if (h.f[parent] <= h.f[i]) break;
+    const tf = h.f[parent];
+    const ti = h.idx[parent];
+    h.f[parent] = h.f[i];
+    h.idx[parent] = h.idx[i];
+    h.f[i] = tf;
+    h.idx[i] = ti;
+    i = parent;
+  }
+}
+function heapPop2(h) {
+  const result = h.idx[0];
+  h.size--;
+  if (h.size > 0) {
+    h.f[0] = h.f[h.size];
+    h.idx[0] = h.idx[h.size];
+    let i = 0;
+    for (; ; ) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < h.size && h.f[left] < h.f[smallest]) smallest = left;
+      if (right < h.size && h.f[right] < h.f[smallest]) smallest = right;
+      if (smallest === i) break;
+      const tf = h.f[i];
+      const ti = h.idx[i];
+      h.f[i] = h.f[smallest];
+      h.idx[i] = h.idx[smallest];
+      h.f[smallest] = tf;
+      h.idx[smallest] = ti;
+      i = smallest;
+    }
+  }
+  return result;
+}
+var SQRT22 = Math.SQRT2;
+function findPathJPS(grid, startX, startY, endX, endY, options) {
+  const sx = startX | 0;
+  const sy = startY | 0;
+  const ex = endX | 0;
+  const ey = endY | 0;
+  if (!isWalkable(grid, sx, sy) || !isWalkable(grid, ex, ey)) return null;
+  if (sx === ex && sy === ey) return { path: [{ x: sx, y: sy }], cost: 0, explored: 0 };
+  const w = grid.width;
+  const h = grid.height;
+  const total = w * h;
+  const maxIter = options?.maxIterations ?? total;
+  const heuristic = options?.heuristic ?? octileDistance;
+  const g = new Float64Array(total);
+  g.fill(Number.POSITIVE_INFINITY);
+  const closed = new Uint8Array(total);
+  const cameFrom = new Int32Array(total);
+  cameFrom.fill(-1);
+  const startIdx = sy * w + sx;
+  const endIdx = ey * w + ex;
+  g[startIdx] = 0;
+  const heap = heapCreate2(Math.min(total, 4096));
+  heapPush2(heap, heuristic(sx, sy, ex, ey), startIdx);
+  let explored = 0;
+  while (heap.size > 0 && explored < maxIter) {
+    const currentIdx = heapPop2(heap);
+    if (currentIdx === endIdx) {
+      return buildPath(cameFrom, w, currentIdx, g[currentIdx], explored);
+    }
+    if (closed[currentIdx]) continue;
+    closed[currentIdx] = 1;
+    explored++;
+    const cx = currentIdx % w;
+    const cy = currentIdx / w | 0;
+    const neighbors = identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey);
+    for (let i = 0; i < neighbors.length; i += 2) {
+      const nx = neighbors[i];
+      const ny = neighbors[i + 1];
+      const nIdx = ny * w + nx;
+      if (closed[nIdx]) continue;
+      const dx = Math.abs(nx - cx);
+      const dy = Math.abs(ny - cy);
+      const diag = Math.min(dx, dy);
+      const straight = Math.abs(dx - dy);
+      const dist2 = diag * SQRT22 + straight;
+      const tentativeG = g[currentIdx] + dist2;
+      if (tentativeG < g[nIdx]) {
+        g[nIdx] = tentativeG;
+        cameFrom[nIdx] = currentIdx;
+        heapPush2(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+      }
+    }
+  }
+  return null;
+}
+function identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey) {
+  const results = [];
+  const parentIdx = cameFrom[cy * w + cx];
+  if (parentIdx === -1) {
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        if (dx === 0 && dy === 0) continue;
+        const jp = jump(grid, cx, cy, dx, dy, w, h, ex, ey);
+        if (jp !== -1) {
+          results.push(jp % w, jp / w | 0);
+        }
+      }
+    }
+  } else {
+    const px = parentIdx % w;
+    const py = parentIdx / w | 0;
+    const dx = clampDir(cx - px);
+    const dy = clampDir(cy - py);
+    if (dx !== 0 && dy !== 0) {
+      if (isWalkable(grid, cx, cy + dy)) {
+        const jp = jump(grid, cx, cy, 0, dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (isWalkable(grid, cx + dx, cy)) {
+        const jp = jump(grid, cx, cy, dx, 0, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (isWalkable(grid, cx + dx, cy + dy)) {
+        const jp = jump(grid, cx, cy, dx, dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (!isWalkable(grid, cx - dx, cy) && isWalkable(grid, cx - dx, cy + dy)) {
+        const jp = jump(grid, cx, cy, -dx, dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (!isWalkable(grid, cx, cy - dy) && isWalkable(grid, cx + dx, cy - dy)) {
+        const jp = jump(grid, cx, cy, dx, -dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+    } else if (dx !== 0) {
+      if (isWalkable(grid, cx + dx, cy)) {
+        const jp = jump(grid, cx, cy, dx, 0, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (!isWalkable(grid, cx, cy + 1) && isWalkable(grid, cx + dx, cy + 1)) {
+        const jp = jump(grid, cx, cy, dx, 1, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (!isWalkable(grid, cx, cy - 1) && isWalkable(grid, cx + dx, cy - 1)) {
+        const jp = jump(grid, cx, cy, dx, -1, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+    } else {
+      if (isWalkable(grid, cx, cy + dy)) {
+        const jp = jump(grid, cx, cy, 0, dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (!isWalkable(grid, cx + 1, cy) && isWalkable(grid, cx + 1, cy + dy)) {
+        const jp = jump(grid, cx, cy, 1, dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+      if (!isWalkable(grid, cx - 1, cy) && isWalkable(grid, cx - 1, cy + dy)) {
+        const jp = jump(grid, cx, cy, -1, dy, w, h, ex, ey);
+        if (jp !== -1) results.push(jp % w, jp / w | 0);
+      }
+    }
+  }
+  return results;
+}
+function jump(grid, cx, cy, dx, dy, w, h, ex, ey) {
+  const nx = cx + dx;
+  const ny = cy + dy;
+  if (!isWalkable(grid, nx, ny)) return -1;
+  if (nx === ex && ny === ey) return ny * w + nx;
+  if (dx !== 0 && dy !== 0) {
+    if (!isWalkable(grid, nx - dx, ny) && isWalkable(grid, nx - dx, ny + dy) || !isWalkable(grid, nx, ny - dy) && isWalkable(grid, nx + dx, ny - dy)) {
+      return ny * w + nx;
+    }
+    if (jump(grid, nx, ny, dx, 0, w, h, ex, ey) !== -1) return ny * w + nx;
+    if (jump(grid, nx, ny, 0, dy, w, h, ex, ey) !== -1) return ny * w + nx;
+  } else if (dx !== 0) {
+    if (!isWalkable(grid, nx, ny + 1) && isWalkable(grid, nx + dx, ny + 1) || !isWalkable(grid, nx, ny - 1) && isWalkable(grid, nx + dx, ny - 1)) {
+      return ny * w + nx;
+    }
+  } else {
+    if (!isWalkable(grid, nx + 1, ny) && isWalkable(grid, nx + 1, ny + dy) || !isWalkable(grid, nx - 1, ny) && isWalkable(grid, nx - 1, ny + dy)) {
+      return ny * w + nx;
+    }
+  }
+  return jump(grid, nx, ny, dx, dy, w, h, ex, ey);
+}
+function clampDir(v) {
+  return v > 0 ? 1 : v < 0 ? -1 : 0;
+}
+function buildPath(cameFrom, w, endIdx, cost, explored) {
+  const jumpPoints = [];
+  let idx = endIdx;
+  while (idx !== -1) {
+    jumpPoints.push(idx);
+    idx = cameFrom[idx];
+  }
+  jumpPoints.reverse();
+  const path = [];
+  for (let i = 0; i < jumpPoints.length; i++) {
+    const jpIdx = jumpPoints[i];
+    const jx = jpIdx % w;
+    const jy = jpIdx / w | 0;
+    if (i === 0) {
+      path.push({ x: jx, y: jy });
+    } else {
+      const prev = path[path.length - 1];
+      let cx = prev.x;
+      let cy = prev.y;
+      while (cx !== jx || cy !== jy) {
+        if (cx < jx) cx++;
+        else if (cx > jx) cx--;
+        if (cy < jy) cy++;
+        else if (cy > jy) cy--;
+        path.push({ x: cx, y: cy });
+      }
+    }
+  }
+  return { path, cost, explored };
+}
+
+// src/navmesh.ts
+function createNavMesh(polygons) {
+  return { polygons };
+}
+function pointInConvexPolygon(verts, px, py) {
+  const n = verts.length;
+  if (n < 3) return false;
+  let sign = 0;
+  for (let i = 0; i < n; i++) {
+    const a = verts[i];
+    const b = verts[(i + 1) % n];
+    const cross = (b.x - a.x) * (py - a.y) - (b.y - a.y) * (px - a.x);
+    if (cross !== 0) {
+      const s = cross > 0 ? 1 : -1;
+      if (sign === 0) sign = s;
+      else if (sign !== s) return false;
+    }
+  }
+  return true;
+}
+function findPolygonAt(mesh, x, y) {
+  for (let i = 0; i < mesh.polygons.length; i++) {
+    if (pointInConvexPolygon(mesh.polygons[i].vertices, x, y)) {
+      return mesh.polygons[i].id;
+    }
+  }
+  return -1;
+}
+function centroid(verts) {
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < verts.length; i++) {
+    cx += verts[i].x;
+    cy += verts[i].y;
+  }
+  const n = verts.length;
+  return { x: cx / n, y: cy / n };
+}
+function distSq(ax, ay, bx, by) {
+  const dx = ax - bx;
+  const dy = ay - by;
+  return dx * dx + dy * dy;
+}
+function dist(ax, ay, bx, by) {
+  return Math.sqrt(distSq(ax, ay, bx, by));
+}
+function findNavMeshPath(mesh, start, end) {
+  const startPolyId = findPolygonAt(mesh, start.x, start.y);
+  const endPolyId = findPolygonAt(mesh, end.x, end.y);
+  if (startPolyId === -1 || endPolyId === -1) return null;
+  if (startPolyId === endPolyId) {
+    return {
+      path: [
+        { x: start.x, y: start.y },
+        { x: end.x, y: end.y }
+      ],
+      corridor: [startPolyId]
+    };
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < mesh.polygons.length; i++) {
+    const p = mesh.polygons[i];
+    byId.set(p.id, p);
+  }
+  const gScore = /* @__PURE__ */ new Map();
+  const fScore = /* @__PURE__ */ new Map();
+  const cameFrom = /* @__PURE__ */ new Map();
+  gScore.set(startPolyId, 0);
+  const endPoly = byId.get(endPolyId);
+  const endCenter = centroid(endPoly.vertices);
+  const startPoly = byId.get(startPolyId);
+  const startCenter = centroid(startPoly.vertices);
+  fScore.set(startPolyId, dist(startCenter.x, startCenter.y, endCenter.x, endCenter.y));
+  const open = [startPolyId];
+  const inOpen = /* @__PURE__ */ new Set([startPolyId]);
+  const closed = /* @__PURE__ */ new Set();
+  while (open.length > 0) {
+    let bestI = 0;
+    let bestF = fScore.get(open[0]) ?? Number.POSITIVE_INFINITY;
+    for (let i = 1; i < open.length; i++) {
+      const f = fScore.get(open[i]) ?? Number.POSITIVE_INFINITY;
+      if (f < bestF) {
+        bestF = f;
+        bestI = i;
+      }
+    }
+    const currentId = open[bestI];
+    if (currentId === endPolyId) {
+      const corridor = [];
+      let id = endPolyId;
+      while (id !== void 0) {
+        corridor.push(id);
+        id = cameFrom.get(id);
+      }
+      corridor.reverse();
+      const path = funnelSmooth(mesh, byId, corridor, start, end);
+      return { path, corridor };
+    }
+    open[bestI] = open[open.length - 1];
+    open.length--;
+    inOpen.delete(currentId);
+    closed.add(currentId);
+    const current = byId.get(currentId);
+    const currentCenter = centroid(current.vertices);
+    const currentG = gScore.get(currentId);
+    for (let i = 0; i < current.portals.length; i++) {
+      const portal = current.portals[i];
+      const neighborId = portal.neighborId;
+      if (closed.has(neighborId)) continue;
+      const neighbor = byId.get(neighborId);
+      if (!neighbor) continue;
+      const portalMidX = (portal.a.x + portal.b.x) * 0.5;
+      const portalMidY = (portal.a.y + portal.b.y) * 0.5;
+      const tentativeG = currentG + dist(currentCenter.x, currentCenter.y, portalMidX, portalMidY);
+      const prevG = gScore.get(neighborId);
+      if (prevG !== void 0 && tentativeG >= prevG) continue;
+      gScore.set(neighborId, tentativeG);
+      cameFrom.set(neighborId, currentId);
+      const neighborCenter = centroid(neighbor.vertices);
+      fScore.set(
+        neighborId,
+        tentativeG + dist(neighborCenter.x, neighborCenter.y, endCenter.x, endCenter.y)
+      );
+      if (!inOpen.has(neighborId)) {
+        open.push(neighborId);
+        inOpen.add(neighborId);
+      }
+    }
+  }
+  return null;
+}
+function funnelSmooth(_mesh, byId, corridor, start, end) {
+  if (corridor.length <= 1) {
+    return [
+      { x: start.x, y: start.y },
+      { x: end.x, y: end.y }
+    ];
+  }
+  const portalsLeft = [];
+  const portalsRight = [];
+  portalsLeft.push({ x: start.x, y: start.y });
+  portalsRight.push({ x: start.x, y: start.y });
+  for (let i = 0; i < corridor.length - 1; i++) {
+    const poly = byId.get(corridor[i]);
+    const nextId = corridor[i + 1];
+    let found = false;
+    for (let j = 0; j < poly.portals.length; j++) {
+      if (poly.portals[j].neighborId === nextId) {
+        portalsLeft.push(poly.portals[j].a);
+        portalsRight.push(poly.portals[j].b);
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      const c = centroid(poly.vertices);
+      portalsLeft.push(c);
+      portalsRight.push(c);
+    }
+  }
+  portalsLeft.push({ x: end.x, y: end.y });
+  portalsRight.push({ x: end.x, y: end.y });
+  const path = [];
+  let apexPt = portalsLeft[0];
+  let leftPt = portalsLeft[0];
+  let rightPt = portalsRight[0];
+  let apexIdx = 0;
+  let leftIdx = 0;
+  let rightIdx = 0;
+  path.push({ x: apexPt.x, y: apexPt.y });
+  const n = portalsLeft.length;
+  for (let i = 1; i < n; i++) {
+    const pL = portalsLeft[i];
+    const pR = portalsRight[i];
+    if (triArea2(apexPt, rightPt, pR) <= 0) {
+      if (vEqual(apexPt, rightPt) || triArea2(apexPt, leftPt, pR) > 0) {
+        rightPt = pR;
+        rightIdx = i;
+      } else {
+        addUnique(path, leftPt);
+        apexPt = leftPt;
+        apexIdx = leftIdx;
+        leftPt = apexPt;
+        rightPt = apexPt;
+        leftIdx = apexIdx;
+        rightIdx = apexIdx;
+        i = apexIdx;
+        continue;
+      }
+    }
+    if (triArea2(apexPt, leftPt, pL) >= 0) {
+      if (vEqual(apexPt, leftPt) || triArea2(apexPt, rightPt, pL) < 0) {
+        leftPt = pL;
+        leftIdx = i;
+      } else {
+        addUnique(path, rightPt);
+        apexPt = rightPt;
+        apexIdx = rightIdx;
+        leftPt = apexPt;
+        rightPt = apexPt;
+        leftIdx = apexIdx;
+        rightIdx = apexIdx;
+        i = apexIdx;
+      }
+    }
+  }
+  addUnique(path, end);
+  return path;
+}
+function addUnique(path, p) {
+  const last = path[path.length - 1];
+  if (!last || last.x !== p.x || last.y !== p.y) {
+    path.push({ x: p.x, y: p.y });
+  }
+}
+function triArea2(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
+}
+function vEqual(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+export {
+  chebyshevDistance,
+  createGrid,
+  createNavMesh,
+  euclideanDistance,
+  findNavMeshPath,
+  findPath,
+  findPathJPS,
+  findPolygonAt,
+  getCost,
+  inBounds,
+  isWalkable,
+  manhattanDistance,
+  octileDistance,
+  setCost,
+  setWalkable
+};
+//# sourceMappingURL=index.mjs.map