Update Healer Man server

scripts/dungeon-pipeline/detour-topology.mjs

@@ -0,0 +1,219 @@
+import { createHash } from "node:crypto";
+
+const NULL_LINK_VALUES = new Set([-1, 0xffffffff]);
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]),
+  );
+}
+
+export function stableSha256(value) {
+  const bytes = typeof value === "string" ? value : JSON.stringify(canonicalize(value));
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+export function buildDetourGeometryRanges(polygonCount, trianglePolygonIds) {
+  const starts = new Int32Array(polygonCount).fill(-1);
+  const counts = new Uint32Array(polygonCount);
+  let previousPolygonId = -1;
+  for (let triangleIndex = 0; triangleIndex < trianglePolygonIds.length; triangleIndex += 1) {
+    const polygonId = trianglePolygonIds[triangleIndex];
+    if (!Number.isInteger(polygonId) || polygonId < 0 || polygonId >= polygonCount) {
+      throw new Error(`Exported triangle ${triangleIndex} references invalid Detour polygon ${polygonId}.`);
+    }
+    if (polygonId < previousPolygonId) {
+      throw new Error("Exported Detour triangles are not in stable polygon order.");
+    }
+    previousPolygonId = polygonId;
+    if (counts[polygonId] === 0) starts[polygonId] = triangleIndex;
+    counts[polygonId] += 1;
+  }
+  return Array.from({ length: polygonCount }, (_, polygonId) => [
+    starts[polygonId],
+    counts[polygonId],
+  ]);
+}
+
+function findComponents(nodeCount, links) {
+  const parents = new Int32Array(nodeCount);
+  const sizes = new Int32Array(nodeCount);
+  for (let id = 0; id < nodeCount; id += 1) {
+    parents[id] = id;
+    sizes[id] = 1;
+  }
+  const rootOf = (node) => {
+    let root = node;
+    while (parents[root] !== root) root = parents[root];
+    while (parents[node] !== node) {
+      const next = parents[node];
+      parents[node] = root;
+      node = next;
+    }
+    return root;
+  };
+
+  for (const [from, to] of links) {
+    const left = rootOf(from);
+    const right = rootOf(to);
+    if (left === right) continue;
+    if (sizes[left] < sizes[right]) {
+      parents[left] = right;
+      sizes[right] += sizes[left];
+    } else {
+      parents[right] = left;
+      sizes[left] += sizes[right];
+    }
+  }
+
+  const components = new Map();
+  for (let id = 0; id < nodeCount; id += 1) {
+    const root = rootOf(id);
+    components.set(root, (components.get(root) ?? 0) + 1);
+  }
+  const sizesByDescending = [...components.values()].sort((left, right) => right - left);
+  return {
+    count: sizesByDescending.length,
+    largestPolygonCount: sizesByDescending[0] ?? 0,
+    polygonCounts: sizesByDescending,
+  };
+}
+
+/**
+ * Copies the source Detour surface-polygon order and directed link chain into
+ * compact, stable-ID records. Triangle ranges follow NavMeshHelper's emitted
+ * tile/polygon/detail-triangle iteration order; links are only actual Detour
+ * links and never inferred from near-coincident geometry.
+ */
+export function extractDetourTopology(navMesh, {
+  sourceCollisionSha256,
+  settingsSha256,
+} = {}) {
+  if (!navMesh || typeof navMesh.getMaxTiles !== "function") {
+    throw new Error("Detour topology requires a populated NavMesh.");
+  }
+
+  const polygons = [];
+  const polygonIdByReference = new Map();
+  let triangleCount = 0;
+  let polygonFanTriangleCount = 0;
+  let tileCount = 0;
+  let offMeshPolygonCount = 0;
+
+  for (let tileIndex = 0; tileIndex < navMesh.getMaxTiles(); tileIndex += 1) {
+    const tile = navMesh.getTile(tileIndex);
+    const header = tile.header();
+    if (!header || header.polyCount() === 0) continue;
+    tileCount += 1;
+    const polyRefBase = navMesh.getPolyRefBase(tile);
+
+    for (let polygonIndex = 0; polygonIndex < header.polyCount(); polygonIndex += 1) {
+      const polygon = tile.polys(polygonIndex);
+      if (polygon.getType() !== 0) {
+        offMeshPolygonCount += 1;
+        continue;
+      }
+      const detail = tile.detailMeshes(polygonIndex);
+      const triangleCountForPolygon = detail.triCount();
+      const polygonVertexCount = polygon.vertCount();
+      const id = polygons.length;
+      polygons.push([
+        id,
+        tileIndex,
+        header.x(),
+        header.y(),
+        header.layer(),
+        polygonIndex,
+        triangleCount,
+        triangleCountForPolygon,
+        polygonVertexCount,
+      ]);
+      triangleCount += triangleCountForPolygon;
+      polygonFanTriangleCount += Math.max(0, polygonVertexCount - 2);
+      polygonIdByReference.set(polyRefBase + polygonIndex, id);
+    }
+  }
+
+  const links = [];
+  let unrepresentedLinkCount = 0;
+  for (const polygonRecord of polygons) {
+    const [fromId, tileIndex, , , , polygonIndex] = polygonRecord;
+    const tile = navMesh.getTile(tileIndex);
+    const polygon = tile.polys(polygonIndex);
+    const header = tile.header();
+    const maxLinkCount = header.maxLinkCount();
+    let linkIndex = polygon.firstLink();
+    let traversed = 0;
+    while (!NULL_LINK_VALUES.has(linkIndex)) {
+      if (!Number.isInteger(linkIndex) || linkIndex < 0 || linkIndex >= maxLinkCount) {
+        throw new Error(
+          `Detour polygon ${tileIndex}:${polygonIndex} has invalid link index ${linkIndex}.`,
+        );
+      }
+      if (traversed >= maxLinkCount) {
+        throw new Error(`Detour polygon ${tileIndex}:${polygonIndex} contains a link cycle.`);
+      }
+      traversed += 1;
+      const link = tile.links(linkIndex);
+      const toId = polygonIdByReference.get(link.ref());
+      if (toId === undefined) {
+        unrepresentedLinkCount += 1;
+      } else {
+        const edgeIndex = link.edge();
+        const polygonVertexCount = polygon.vertCount();
+        if (edgeIndex < 0 || edgeIndex >= polygonVertexCount) {
+          throw new Error(
+            `Detour polygon ${tileIndex}:${polygonIndex} has invalid linked edge ${edgeIndex}.`,
+          );
+        }
+        const edgeStartVertex = polygon.verts(edgeIndex);
+        const edgeEndVertex = polygon.verts((edgeIndex + 1) % polygonVertexCount);
+        const edgeStartOffset = edgeStartVertex * 3;
+        const edgeEndOffset = edgeEndVertex * 3;
+        links.push([
+          fromId,
+          toId,
+          edgeIndex,
+          link.side(),
+          link.bmin(),
+          link.bmax(),
+          edgeStartVertex,
+          edgeEndVertex,
+          tile.verts(edgeStartOffset),
+          tile.verts(edgeStartOffset + 1),
+          tile.verts(edgeStartOffset + 2),
+          tile.verts(edgeEndOffset),
+          tile.verts(edgeEndOffset + 1),
+          tile.verts(edgeEndOffset + 2),
+        ]);
+      }
+      linkIndex = link.next();
+    }
+  }
+
+  const weakComponents = findComponents(polygons.length, links.map(([from, to]) => [from, to]));
+  return {
+    schemaVersion: 1,
+    kind: "recast-detour-surface-links",
+    coordinateSpace: "GLB navigation POSITION coordinates (meters, Three.js Y-up)",
+    encoding: {
+      polygons: "[id,tileIndex,tileX,tileY,tileLayer,tilePolygonIndex,firstGeometryTriangle,geometryTriangleCount,vertexCount]",
+      links: "[fromPolygonId,toPolygonId,fromEdge,side,bmin,bmax,fromEdgeStartVertex,fromEdgeEndVertex,startX,startY,startZ,endX,endY,endZ] (directed Detour link records)",
+    },
+    sourceCollisionSha256: sourceCollisionSha256 ?? null,
+    settingsSha256: settingsSha256 ?? null,
+    tileCount,
+    polygonCount: polygons.length,
+    detailTriangleCount: triangleCount,
+    polygonFanTriangleCount,
+    geometryTriangleCount: null,
+    directedLinkCount: links.length,
+    unrepresentedLinkCount,
+    offMeshPolygonCount,
+    weakComponents,
+    polygons,
+    links,
+  };
+}