@series-inc/rundot-syncplay 5.26.0-beta.4 → 5.26.0-beta.6

package/dist/movement3d.js

@@ -409,12 +409,34 @@ const KCC_GROUND_CLEARANCE = 1e-4;
  * instead of the skyward fling an epsilon probe would give. Per axis it takes
  * the steeper of forward/backward so a sample straddling an edge cannot
  * average its way to an under-lift and back into the freeze.
+ *
+ * A sample that lands outside the selected body's own footprint falls back to
+ * the highest neighbouring static surface at that point. Without this a
+ * capsule straddling the seam between two abutting bodies (two heightfield
+ * chunks) is lifted only for the chunk under its centre: crossing a CONVEX
+ * crease downhill, the shallow chunk's lift collapses while the bottom sphere
+ * is still riding the steep chunk behind, the capsule is snapped down into
+ * that chunk, and the slide reverts the move — frozen exactly at the seam.
+ * Only undefined samples consult the fallback, so a single unbroken body (or
+ * a capsule beside a raised prop on continuous ground) behaves as before.
+ *
+ * The fallback is gated on continuity at the shared edge (see
+ * continuousNeighbourTopAt): streamed chunks meet their neighbours there, a
+ * wall or prop abutting the ground does not. Without the gate such a prop
+ * reads as an extreme slope and the lift snaps the capsule up its side.
  */
-function kccSlopeClearance(body, x, z, top, geometry) {
+function kccSlopeClearance(body, x, z, top, geometry, neighbourTopAt) {
     const step = geometry.radius + geometry.skinWidth;
+    const sampleTopAt = (sampleX, sampleZ) => {
+        const own = groundContactTopAt(body, sampleX, sampleZ);
+        if (own !== undefined || neighbourTopAt === undefined) {
+            return own;
+        }
+        return continuousNeighbourTopAt(body, x, z, sampleX, sampleZ, neighbourTopAt);
+    };
     const axisGradient = (deltaX, deltaZ) => {
-        const ahead = groundContactTopAt(body, x + deltaX, z + deltaZ);
-        const behind = groundContactTopAt(body, x - deltaX, z - deltaZ);
+        const ahead = sampleTopAt(x + deltaX, z + deltaZ);
+        const behind = sampleTopAt(x - deltaX, z - deltaZ);
         const forward = ahead === undefined ? 0 : Math.abs(ahead - top) / step;
         const backward = behind === undefined ? 0 : Math.abs(top - behind) / step;
         return Math.max(forward, backward);
@@ -428,6 +450,55 @@ function kccSlopeClearance(body, x, z, top, geometry) {
     // radius + skinWidth is the bottom-sphere radius physicsOverlapsKcc probes with.
     return (geometry.radius + geometry.skinWidth) * (solverSqrt(1 + gradientSq) - 1);
 }
+/**
+ * How far two abutting bodies' surfaces may differ at their shared edge before
+ * the neighbour stops counting as walkable continuation. Fixed rather than
+ * derived from skinWidth (which defaults to 0): it only has to swallow
+ * triangulation and bisection noise at a streamed-terrain seam — millimetres
+ * at any sane gradient — while staying well under anything a game would call
+ * a step (`world.stepHeight`, typically 0.5+).
+ */
+const KCC_SEAM_CONTINUITY_TOLERANCE = 0.05;
+/** Ray-bisection resolution for the footprint edge: 8 halvings of a sample step. */
+const KCC_SEAM_EDGE_BISECTIONS = 8;
+/**
+ * Neighbour surface at a sample point off the selected body's footprint, or
+ * undefined when no neighbour CONTINUES the selected surface there.
+ *
+ * Continuity is judged at the shared edge, not by extrapolating the selected
+ * surface — at a crease the two gradients differ by design, so any
+ * extrapolation test rejects exactly the seams this exists for. Bisect the
+ * centre→sample ray for the footprint edge, then compare the selected surface
+ * just inside it with the neighbour surface just outside: streamed chunks
+ * from one source interpolate the same shared edge row, so they match to
+ * float noise at ANY gradient, while a wall, prop, or cliff abutting the edge
+ * misses by its full height and is rejected. Fixed iteration count and plain
+ * double arithmetic keep it bit-identical on every peer.
+ */
+function continuousNeighbourTopAt(body, x, z, sampleX, sampleZ, neighbourTopAt) {
+    // The centre is on the selected body (its top is what kccSlopeClearance was
+    // given) and the sample is off it, so the ray crosses a footprint edge.
+    let inside = 0;
+    let outside = 1;
+    for (let i = 0; i < KCC_SEAM_EDGE_BISECTIONS; i += 1) {
+        const mid = (inside + outside) / 2;
+        if (groundContactTopAt(body, x + (sampleX - x) * mid, z + (sampleZ - z) * mid) === undefined) {
+            outside = mid;
+        }
+        else {
+            inside = mid;
+        }
+    }
+    const innerTop = groundContactTopAt(body, x + (sampleX - x) * inside, z + (sampleZ - z) * inside);
+    const outerTop = neighbourTopAt(x + (sampleX - x) * outside, z + (sampleZ - z) * outside);
+    if (innerTop === undefined || outerTop === undefined) {
+        return undefined;
+    }
+    if (Math.abs(innerTop - outerTop) > KCC_SEAM_CONTINUITY_TOLERANCE) {
+        return undefined;
+    }
+    return neighbourTopAt(sampleX, sampleZ);
+}
 /**
  * Distance from the capsule's centre to the bottom of its collision shape.
  * A capsule's vertical extent is halfHeight + radius (see primitiveHalfExtent),
@@ -461,13 +532,29 @@ function staticGroundUnderKcc(physics, x, y, z, previousFeetY, geometry, ignored
         hitKinematics: false,
     };
     const hitIds = new Set(overlapDeterministicPhysics3D(physics, probe));
-    const grounds = physics.bodies
-        .filter((body) => body.kind === 'static' && hitIds.has(body.id) && !ignoredBodyIds.has(body.id))
+    const hitBodies = physics.bodies
+        .filter((body) => body.kind === 'static' && hitIds.has(body.id) && !ignoredBodyIds.has(body.id));
+    const grounds = hitBodies
         .map((body) => ({ body, top: groundContactTopAt(body, x, z) }))
         .filter((candidate) => candidate.top !== undefined)
         .map((candidate) => ({
         ...candidate,
-        lift: kccSlopeClearance(candidate.body, x, z, candidate.top, geometry),
+        // Where the selected body has no surface (a sample past its edge), read
+        // the highest neighbouring static surface instead — abutting terrain
+        // chunks share an edge, and the bottom sphere rides BOTH across a seam.
+        lift: kccSlopeClearance(candidate.body, x, z, candidate.top, geometry, (sampleX, sampleZ) => {
+            let neighbourTop;
+            for (const neighbour of hitBodies) {
+                if (neighbour.id === candidate.body.id) {
+                    continue;
+                }
+                const top = groundContactTopAt(neighbour, sampleX, sampleZ);
+                if (top !== undefined) {
+                    neighbourTop = neighbourTop === undefined ? top : Math.max(neighbourTop, top);
+                }
+            }
+            return neighbourTop;
+        }),
     }))
         // The band is measured from where the capsule actually STANDS, so a slope
         // lift bigger than snapDistance cannot drop it out of its own ground the

package/dist/physics3d.js

@@ -761,7 +761,11 @@ export function raycastDeterministicPhysics3DDetailed(world, query) {
  */
 function bodyOverlapsQueryShape(body, shape, x, y, z, queryBounds) {
     if (body.shape.type === 'heightfield') {
-        return bodyOverlapsQueryShape({ ...body, shape: heightfieldMeshShape(body.shape, localBoundsForHeightfield(body, queryBounds)) }, shape, x, y, z, queryBounds);
+        const mesh = heightfieldMeshShape(body.shape, localBoundsForHeightfield(body, queryBounds));
+        if (mesh.vertices.length === 0) {
+            return false;
+        }
+        return bodyOverlapsQueryShape({ ...body, shape: mesh }, shape, x, y, z, queryBounds);
     }
     if (shape.type === 'heightfield') {
         return bodyOverlapsQueryShape(body, heightfieldMeshShape(shape), x, y, z, queryBounds);
@@ -3100,6 +3104,9 @@ function rayBodyDistance(body, query) {
     }
     if (body.shape.type === 'heightfield') {
         const mesh = heightfieldMeshShape(body.shape, localBoundsForHeightfield(body, raySweepBounds(query)));
+        if (mesh.vertices.length === 0) {
+            return undefined;
+        }
         return rayMeshDistance(meshPose({ ...bodyPose(body), shape: mesh }, mesh), query);
     }
     if (body.shape.type === 'hull') {
@@ -3163,6 +3170,9 @@ function shapeCastBodyDistance(body, query) {
         }
         if (body.shape.type === 'heightfield') {
             const mesh = heightfieldMeshShape(body.shape, localBoundsForHeightfield(body, shapeCastSweepBounds(query)));
+            if (mesh.vertices.length === 0) {
+                return undefined;
+            }
             return rayExpandedMeshDistance(meshPose({ ...bodyPose(body), shape: mesh }, mesh), query, query.shape.radius);
         }
         if (body.shape.type === 'sphere') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/rundot-syncplay",
-  "version": "5.26.0-beta.4",
+  "version": "5.26.0-beta.6",
   "description": "Kinetix orchestration, rollback, replay, late-join, and deterministic networking for RUN.game",
   "repository": {
     "type": "git",