@flare-engine/pathfinding 0.4.8 → 0.4.11

package/dist/index.js

@@ -38,25 +38,8 @@ 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
-const SQRT2$1 = 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 - 1) * dy : dy + (SQRT2$1 - 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$1(capacity) {
+// src/heap.ts
+function heapCreate(capacity) {
 	return {
 		f: new Float64Array(capacity),
 		idx: new Int32Array(capacity),
@@ -73,7 +56,7 @@ function heapCreate$1(capacity) {
 * non-optimal path. Growth is amortized O(1): allocation happens only when
 * capacity is reached, never per push.
 */
-function heapGrow$1(h) {
+function heapGrow(h) {
 	const next = h.f.length === 0 ? 16 : h.f.length * 2;
 	const f = new Float64Array(next);
 	f.set(h.f);
@@ -82,8 +65,8 @@ function heapGrow$1(h) {
 	h.f = f;
 	h.idx = idx;
 }
-function heapPush$1(h, f, nodeIdx) {
-	if (h.size === h.f.length) heapGrow$1(h);
+function heapPush(h, f, nodeIdx) {
+	if (h.size === h.f.length) heapGrow(h);
 	let i = h.size++;
 	h.f[i] = f;
 	h.idx[i] = nodeIdx;
@@ -99,7 +82,7 @@ function heapPush$1(h, f, nodeIdx) {
 		i = parent;
 	}
 }
-function heapPop$1(h) {
+function heapPop(h) {
 	const result = h.idx[0];
 	h.size--;
 	if (h.size > 0) {
@@ -124,6 +107,65 @@ function heapPop$1(h) {
 	}
 	return result;
 }
+// src/scratch.ts
+const MAX_OPEN = 4294967294;
+const scratches = /* @__PURE__ */ new WeakMap();
+function createScratch(total) {
+	return {
+		total,
+		g: new Float64Array(total),
+		cameFrom: new Int32Array(total),
+		stamp: new Uint32Array(total),
+		open: 0,
+		heap: heapCreate(Math.min(total, 4096)),
+		succ: /* @__PURE__ */ new Int32Array(8),
+		inUse: false
+	};
+}
+/**
+* Hand out the scratch for `grid`, ready for a new search: generation advanced
+* (every cell reads as untouched), heap emptied, start cell untouched too — the
+* caller stamps it.
+*
+* A grid whose stored scratch is already in use (a heuristic re-entered a
+* search on the same grid) gets a fresh temporary scratch that is not stored.
+*/
+function acquireScratch(grid) {
+	const total = grid.width * grid.height;
+	let s = scratches.get(grid);
+	if (s === void 0 || s.total !== total) {
+		s = createScratch(total);
+		scratches.set(grid, s);
+	} else if (s.inUse) s = createScratch(total);
+	s.inUse = true;
+	s.heap.size = 0;
+	if (s.open >= MAX_OPEN) {
+		s.stamp.fill(0);
+		s.open = 2;
+	} else s.open += 2;
+	return s;
+}
+function releaseScratch(s) {
+	s.inUse = false;
+}
+// src/astar.ts
+const SQRT2$1 = 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 - 1) * dy : dy + (SQRT2$1 - 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);
+}
 const DIR4_X = [
 	0,
 	1,
@@ -184,53 +226,58 @@ function findPath(grid, startX, startY, endX, endY, options) {
 	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;
+	const scratch = acquireScratch(grid);
+	const { g, cameFrom, stamp, heap } = scratch;
+	const openMark = scratch.open;
+	const closedMark = openMark + 1;
+	stamp[startIdx] = openMark;
 	g[startIdx] = 0;
-	const heap = heapCreate$1(Math.min(total, 4096));
-	heapPush$1(heap, heuristic(sx, sy, ex, ey), startIdx);
+	cameFrom[startIdx] = -1;
 	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$1(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 tentativeG = currentG + (dirCost ? dirCost[d] * tileCost : tileCost);
-			if (tentativeG < g[nIdx]) {
-				g[nIdx] = tentativeG;
-				cameFrom[nIdx] = currentIdx;
-				heapPush$1(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+	try {
+		heapPush(heap, heuristic(sx, sy, ex, ey), startIdx);
+		while (heap.size > 0 && explored < maxIter) {
+			const currentIdx = heapPop(heap);
+			if (currentIdx === endIdx) return reconstructPath(cameFrom, w, currentIdx, g[currentIdx], explored);
+			if (stamp[currentIdx] === closedMark) continue;
+			stamp[currentIdx] = closedMark;
+			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;
+				const nStamp = stamp[nIdx];
+				if (nStamp === closedMark) 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 tentativeG = currentG + (dirCost ? dirCost[d] * tileCost : tileCost);
+				if (nStamp !== openMark || tentativeG < g[nIdx]) {
+					g[nIdx] = tentativeG;
+					cameFrom[nIdx] = currentIdx;
+					stamp[nIdx] = openMark;
+					heapPush(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+				}
 			}
 		}
+		return null;
+	} finally {
+		releaseScratch(scratch);
 	}
-	return null;
 }
 function reconstructPath(cameFrom, w, endIdx, cost, explored) {
 	const path = [];
@@ -250,74 +297,6 @@ function reconstructPath(cameFrom, w, endIdx, cost, explored) {
 	};
 }
 // src/jps.ts
-function heapCreate(capacity) {
-	return {
-		f: new Float64Array(capacity),
-		idx: new Int32Array(capacity),
-		size: 0
-	};
-}
-/**
-* Double the heap's backing arrays.
-*
-* Typed arrays do not throw on an out-of-range write — the store is silently
-* dropped — so without this a push past capacity increments `size`, writes
-* nothing, and every later comparison reads `undefined`. The open set then
-* degrades without any error, and the search returns a valid-looking but
-* non-optimal path. Growth is amortized O(1): allocation happens only when
-* capacity is reached, never per push.
-*/
-function heapGrow(h) {
-	const next = h.f.length === 0 ? 16 : h.f.length * 2;
-	const f = new Float64Array(next);
-	f.set(h.f);
-	const idx = new Int32Array(next);
-	idx.set(h.idx);
-	h.f = f;
-	h.idx = idx;
-}
-function heapPush(h, f, nodeIdx) {
-	if (h.size === h.f.length) heapGrow(h);
-	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;
-}
 const SQRT2 = Math.SQRT2;
 function hasWeightedCost(grid) {
 	const data = grid.data;
@@ -344,56 +323,66 @@ function findPathJPS(grid, startX, startY, endX, endY, options) {
 	});
 	const w = grid.width;
 	const h = grid.height;
-	const total = w * h;
-	const maxIter = options?.maxIterations ?? total;
+	const maxIter = options?.maxIterations ?? w * h;
 	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;
+	const scratch = acquireScratch(grid);
+	const { g, cameFrom, stamp, heap, succ } = scratch;
+	const openMark = scratch.open;
+	const closedMark = openMark + 1;
+	stamp[startIdx] = openMark;
 	g[startIdx] = 0;
-	const heap = heapCreate(Math.min(total, 4096));
-	heapPush(heap, heuristic(sx, sy, ex, ey), startIdx);
+	cameFrom[startIdx] = -1;
 	let explored = 0;
-	while (heap.size > 0 && explored < maxIter) {
-		const currentIdx = heapPop(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 dist = diag * SQRT2 + straight;
-			const tentativeG = g[currentIdx] + dist;
-			if (tentativeG < g[nIdx]) {
-				g[nIdx] = tentativeG;
-				cameFrom[nIdx] = currentIdx;
-				heapPush(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+	try {
+		heapPush(heap, heuristic(sx, sy, ex, ey), startIdx);
+		while (heap.size > 0 && explored < maxIter) {
+			const currentIdx = heapPop(heap);
+			if (currentIdx === endIdx) return buildPath(cameFrom, w, currentIdx, g[currentIdx], explored);
+			if (stamp[currentIdx] === closedMark) continue;
+			stamp[currentIdx] = closedMark;
+			explored++;
+			const cx = currentIdx % w;
+			const cy = currentIdx / w | 0;
+			const count = identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey, succ);
+			for (let i = 0; i < count; i++) {
+				const nIdx = succ[i];
+				const nx = nIdx % w;
+				const ny = nIdx / w | 0;
+				const nStamp = stamp[nIdx];
+				if (nStamp === closedMark) 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 dist = diag * SQRT2 + straight;
+				const tentativeG = g[currentIdx] + dist;
+				if (nStamp !== openMark || tentativeG < g[nIdx]) {
+					g[nIdx] = tentativeG;
+					cameFrom[nIdx] = currentIdx;
+					stamp[nIdx] = openMark;
+					heapPush(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+				}
 			}
 		}
+		return null;
+	} finally {
+		releaseScratch(scratch);
 	}
-	return null;
 }
-function identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey) {
-	const results = [];
+/**
+* Writes the cell index of each jump point reachable from (cx, cy) into `out`
+* and returns how many. At most one per direction tried — 8 from the start
+* node, 5 after a diagonal move, 3 after a cardinal one — so `out` needs 8 slots.
+*/
+function identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey, out) {
+	let n = 0;
 	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);
+		if (jp !== -1) out[n++] = jp;
 	}
 	else {
 		const px = parentIdx % w;
@@ -403,67 +392,70 @@ function identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey) {
 		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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 			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);
+				if (jp !== -1) out[n++] = jp;
 			}
 		} 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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 		} 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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 			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 (jp !== -1) out[n++] = jp;
 			}
 		}
 	}
-	return results;
+	return n;
 }
 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);
+	let nx = cx;
+	let ny = cy;
+	for (;;) {
+		nx += dx;
+		ny += 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;
+	}
 }
 function clampDir(v) {
 	return v > 0 ? 1 : v < 0 ? -1 : 0;
@@ -531,18 +523,56 @@ 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 MAX_GEN = 4294967295;
+const indices = /* @__PURE__ */ new WeakMap();
+/** True when `pos` is exactly the id → position map of the live polygon list. */
+function isCurrent(index, polygons) {
+	if (index.pos.size !== polygons.length) return false;
+	for (let i = 0; i < polygons.length; i++) if (index.pos.get(polygons[i].id) !== i) return false;
+	return true;
+}
+function rebuild(index, polygons) {
+	index.pos.clear();
+	for (let i = 0; i < polygons.length; i++) index.pos.set(polygons[i].id, i);
+	if (index.cx.length < polygons.length) {
+		index.cx = new Float64Array(polygons.length);
+		index.cy = new Float64Array(polygons.length);
+		index.stamp = new Uint32Array(polygons.length);
 	}
-	const n = verts.length;
-	return {
-		x: cx / n,
-		y: cy / n
-	};
+}
+/** The mesh's index, validated against the live polygon list and advanced to a new search generation. */
+function acquireIndex(mesh) {
+	let index = indices.get(mesh);
+	if (index === void 0) {
+		index = {
+			pos: /* @__PURE__ */ new Map(),
+			cx: /* @__PURE__ */ new Float64Array(0),
+			cy: /* @__PURE__ */ new Float64Array(0),
+			stamp: /* @__PURE__ */ new Uint32Array(0),
+			gen: 0
+		};
+		indices.set(mesh, index);
+	}
+	if (!isCurrent(index, mesh.polygons)) rebuild(index, mesh.polygons);
+	if (index.gen === MAX_GEN) {
+		index.stamp.fill(0);
+		index.gen = 1;
+	} else index.gen++;
+	return index;
+}
+/** Makes `cx[i]` / `cy[i]` the centroid of the live polygon at `i`, summing its vertices once per search. */
+function centroidAt(index, polygons, i) {
+	if (index.stamp[i] === index.gen) return;
+	const verts = polygons[i].vertices;
+	let sx = 0;
+	let sy = 0;
+	for (let j = 0; j < verts.length; j++) {
+		sx += verts[j].x;
+		sy += verts[j].y;
+	}
+	index.cx[i] = sx / verts.length;
+	index.cy[i] = sy / verts.length;
+	index.stamp[i] = index.gen;
 }
 function distSq(ax, ay, bx, by) {
 	const dx = ax - bx;
@@ -552,6 +582,12 @@ function distSq(ax, ay, bx, by) {
 function dist(ax, ay, bx, by) {
 	return Math.sqrt(distSq(ax, ay, bx, by));
 }
+/**
+* A* over the polygon graph, then funnel smoothing. Keeps an id index per mesh
+* object (rebuilt when the polygon list changes) and computes each polygon's
+* centroid at most once per search; edits to the mesh between searches are seen
+* by the next one.
+*/
 function findNavMeshPath(mesh, start, end) {
 	const startPolyId = findPolygonAt(mesh, start.x, start.y);
 	const endPolyId = findPolygonAt(mesh, end.x, end.y);
@@ -566,18 +602,20 @@ function findNavMeshPath(mesh, start, end) {
 		}],
 		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 polygons = mesh.polygons;
+	const index = acquireIndex(mesh);
+	const { pos, cx, cy } = index;
 	const gScore = /* @__PURE__ */ new Map();
 	const fScore = /* @__PURE__ */ new Map();
 	const cameFrom = /* @__PURE__ */ new Map();
 	gScore.set(startPolyId, 0);
-	const endCenter = centroid(byId.get(endPolyId).vertices);
-	const startCenter = centroid(byId.get(startPolyId).vertices);
-	fScore.set(startPolyId, dist(startCenter.x, startCenter.y, endCenter.x, endCenter.y));
+	const endPos = pos.get(endPolyId);
+	centroidAt(index, polygons, endPos);
+	const endCx = cx[endPos];
+	const endCy = cy[endPos];
+	const startPos = pos.get(startPolyId);
+	centroidAt(index, polygons, startPos);
+	fScore.set(startPolyId, dist(cx[startPos], cy[startPos], endCx, endCy));
 	const open = [startPolyId];
 	const inOpen = /* @__PURE__ */ new Set([startPolyId]);
 	const closed = /* @__PURE__ */ new Set();
@@ -601,7 +639,7 @@ function findNavMeshPath(mesh, start, end) {
 			}
 			corridor.reverse();
 			return {
-				path: funnelSmooth(mesh, byId, corridor, start, end),
+				path: funnelSmooth(mesh, index, corridor, start, end),
 				corridor
 			};
 		}
@@ -609,24 +647,25 @@ function findNavMeshPath(mesh, start, end) {
 		open.length--;
 		inOpen.delete(currentId);
 		closed.add(currentId);
-		const current = byId.get(currentId);
-		const currentCenter = centroid(current.vertices);
+		const currentPos = pos.get(currentId);
+		const current = polygons[currentPos];
+		centroidAt(index, polygons, currentPos);
+		const currentCx = cx[currentPos];
+		const currentCy = cy[currentPos];
 		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) * .5;
-			const portalMidY = (portal.a.y + portal.b.y) * .5;
-			const tentativeG = currentG + dist(currentCenter.x, currentCenter.y, portalMidX, portalMidY);
+			const neighborPos = pos.get(neighborId);
+			if (neighborPos === void 0) continue;
+			const tentativeG = currentG + dist(currentCx, currentCy, (portal.a.x + portal.b.x) * .5, (portal.a.y + portal.b.y) * .5);
 			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));
+			centroidAt(index, polygons, neighborPos);
+			fScore.set(neighborId, tentativeG + dist(cx[neighborPos], cy[neighborPos], endCx, endCy));
 			if (!inOpen.has(neighborId)) {
 				open.push(neighborId);
 				inOpen.add(neighborId);
@@ -635,7 +674,7 @@ function findNavMeshPath(mesh, start, end) {
 	}
 	return null;
 }
-function funnelSmooth(_mesh, byId, corridor, start, end) {
+function funnelSmooth(mesh, index, corridor, start, end) {
 	if (corridor.length <= 1) return [{
 		x: start.x,
 		y: start.y
@@ -654,7 +693,8 @@ function funnelSmooth(_mesh, byId, corridor, start, end) {
 		y: start.y
 	});
 	for (let i = 0; i < corridor.length - 1; i++) {
-		const poly = byId.get(corridor[i]);
+		const polyPos = index.pos.get(corridor[i]);
+		const poly = mesh.polygons[polyPos];
 		const nextId = corridor[i + 1];
 		let found = false;
 		for (let j = 0; j < poly.portals.length; j++) if (poly.portals[j].neighborId === nextId) {
@@ -664,7 +704,11 @@ function funnelSmooth(_mesh, byId, corridor, start, end) {
 			break;
 		}
 		if (!found) {
-			const c = centroid(poly.vertices);
+			centroidAt(index, mesh.polygons, polyPos);
+			const c = {
+				x: index.cx[polyPos],
+				y: index.cy[polyPos]
+			};
 			portalsLeft.push(c);
 			portalsRight.push(c);
 		}