Update Healer Man server

scripts/dungeon-pipeline/recast-mesh-adapter.test.mjs

@@ -0,0 +1,105 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { getPositionsAndIndices } from "@recast-navigation/three";
+import {
+  BufferAttribute,
+  BufferGeometry,
+  InterleavedBuffer,
+  InterleavedBufferAttribute,
+  Mesh,
+  Object3D,
+  Vector3,
+} from "three";
+import { unpackMeshesForRecast } from "./recast-mesh-adapter.mjs";
+
+test("Recast adapter decodes interleaved positions, indices, normalized positions, and parent transforms", () => {
+  const parent = new Object3D();
+  parent.position.set(10, 2, -4);
+  parent.rotation.y = Math.PI / 2;
+  parent.scale.set(2, 3, 4);
+
+  const interleavedGeometry = new BufferGeometry();
+  const interleavedData = new InterleavedBuffer(new Float32Array([
+    0, 0, 0, 91, 1,
+    1, 0, 0, 92, 2,
+    0, 0, 1, 93, 3,
+  ]), 5);
+  interleavedGeometry.setAttribute("position", new InterleavedBufferAttribute(interleavedData, 3, 0));
+  interleavedGeometry.setIndex(new BufferAttribute(new Uint16Array([0, 1, 2]), 1));
+  const interleavedMesh = new Mesh(interleavedGeometry);
+  interleavedMesh.name = "interleaved";
+  interleavedMesh.position.set(1, 0, 2);
+  parent.add(interleavedMesh);
+
+  const normalizedGeometry = new BufferGeometry();
+  normalizedGeometry.setAttribute("position", new BufferAttribute(new Uint16Array([
+    0, 0, 0,
+    65535, 0, 0,
+    0, 65535, 0,
+  ]), 3, true));
+  const normalizedMesh = new Mesh(normalizedGeometry);
+  normalizedMesh.name = "normalized";
+  normalizedMesh.position.set(-3, 5, 7);
+  parent.add(normalizedMesh);
+  parent.updateMatrixWorld(true);
+
+  const originalInterleaved = Array.from(interleavedData.array);
+  const originalNormalized = Array.from(normalizedGeometry.getAttribute("position").array);
+  const result = unpackMeshesForRecast([interleavedMesh, normalizedMesh]);
+  assert.deepEqual(result.report, {
+    adapter: "decoded-three-buffer-attributes-v1",
+    sourceMeshCount: 2,
+    unpackedPositionAccessorCount: 2,
+    interleavedPositionAttributeCount: 1,
+    normalizedPositionAttributeCount: 1,
+    nonFloatPositionAttributeCount: 1,
+    decodedIndexAccessorCount: 1,
+  });
+  for (const [index, sourceMesh] of [interleavedMesh, normalizedMesh].entries()) {
+    assert.deepEqual(
+      result.meshes[index].matrixWorld.toArray(),
+      sourceMesh.matrixWorld.toArray(),
+      "inspection and generator transforms must agree before generator mutation",
+    );
+  }
+
+  const [positions, indices] = getPositionsAndIndices(result.meshes);
+  const expectedWorld = [];
+  const expectedIndices = [];
+  for (const [sourceMeshIndex, sourceMesh] of [interleavedMesh, normalizedMesh].entries()) {
+    const attr = sourceMesh.geometry.getAttribute("position");
+    for (let i = 0; i < attr.count; i += 1) {
+      const point = new Vector3(attr.getX(i), attr.getY(i), attr.getZ(i))
+        .applyMatrix4(sourceMesh.matrixWorld);
+      expectedWorld.push(point.x, point.y, point.z);
+      if (sourceMeshIndex === 1) expectedIndices.push(3 + i);
+    }
+    if (sourceMeshIndex === 0) expectedIndices.push(0, 1, 2);
+  }
+
+  assert.equal(positions.length, expectedWorld.length);
+  for (let i = 0; i < expectedWorld.length; i += 1) {
+    assert.ok(Math.abs(positions[i] - expectedWorld[i]) < 1e-5, `world position component ${i}`);
+  }
+  assert.deepEqual(Array.from(indices), expectedIndices);
+  assert.deepEqual(Array.from(interleavedData.array), originalInterleaved);
+  assert.deepEqual(Array.from(normalizedGeometry.getAttribute("position").array), originalNormalized);
+  assert.equal(result.meshes[0].geometry.getAttribute("position").array.length, 9);
+  assert.equal(result.meshes[1].geometry.getAttribute("position").array.length, 9);
+});
+
+test("Recast adapter rejects malformed indices before Uint32 conversion can truncate them", () => {
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(new Float32Array([
+    0, 0, 0,
+    1, 0, 0,
+    0, 0, 1,
+  ]), 3));
+  geometry.setIndex(new BufferAttribute(new Float32Array([0, 1.5, 2]), 1));
+  const mesh = new Mesh(geometry);
+  mesh.name = "malformed-index-fixture";
+  assert.throws(
+    () => unpackMeshesForRecast([mesh]),
+    /malformed-index-fixture: index 1 references invalid position 1\.5/,
+  );
+});