@jgengine/core 0.18.0 → 0.19.0

package/dist/multiplayer/poseSyncGate.js

@@ -17,7 +17,15 @@ function poseChanged(a, b, tuning) {
         || Math.abs(a.rotationPitch - b.rotationPitch) > tuning.rotationEpsilon
         || appearanceChanged(a.appearance, b.appearance));
 }
-export function createPoseSyncGate(tuning) {
+/** Default ten-hertz client pose gate with a five-second heartbeat. */
+export const DEFAULT_POSE_SYNC_TUNING = {
+    minIntervalMs: 100,
+    heartbeatMs: 5_000,
+    positionEpsilon: 0.01,
+    verticalEpsilon: 0.01,
+    rotationEpsilon: 0.01,
+};
+export function createPoseSyncGate(tuning = DEFAULT_POSE_SYNC_TUNING) {
     let lastSentPose = null;
     let lastSentAt = 0;
     return {

package/dist/multiplayer/presenceContract.d.ts

@@ -16,6 +16,12 @@ export interface PresencePose {
 export interface PresenceSession<TGameId extends string = string> {
     homeGameId: TGameId;
     externalId: string;
+    viewerChunkKey?: string;
+}
+/** Resident identity used to suppress offline actors while their owner is online. */
+export interface PresenceResidentRow {
+    actorExternalId: string;
+    ownerActorId?: string;
 }
 export interface EnsurePresenceArgs<TGameId extends string = string> {
     gameId: TGameId;

package/dist/multiplayer/presenceModel.d.ts

@@ -22,6 +22,8 @@ export interface IncomingPose {
 export interface PoseSyncRules {
     /** Speed cap (units/sec) for client-authoritative movement. */
     maxSpeed: number;
+    /** Minimum time between accepted pose writes. Defaults to 100 ms. */
+    minIntervalMs?: number;
     /** Vertical offset clamp above floorY (e.g. peak jump height). */
     maxVerticalOffset: number;
     /** World-floor Y used as the base of the jump band. Defaults to 0. */

package/dist/multiplayer/presenceModel.js

@@ -1,6 +1,7 @@
 /** Canonical client-authoritative pose-sync tuning shared by every host transport (WS, Convex). */
 export const DEFAULT_POSE_SYNC_RULES = {
     maxSpeed: 12,
+    minIntervalMs: 100,
     maxVerticalOffset: 3,
     minElapsedSec: 0.05,
     maxElapsedSec: 0.5,
@@ -29,6 +30,16 @@ export function spawnPresenceState(origin = DEFAULT_SPAWN_ORIGIN, nowMs, rules)
 }
 /** @internal */
 export function decidePoseSync(current, incoming, rules, nowMs, floorY) {
+    if (current.lastSeenAtMs !== undefined && nowMs - current.lastSeenAtMs < (rules.minIntervalMs ?? 100)) {
+        return {
+            position: { ...current.position },
+            rotationY: current.rotationY,
+            rotationPitch: current.rotationPitch ?? 0,
+            appearance: current.appearance,
+            changed: false,
+            refreshKeepAlive: false,
+        };
+    }
     const rawElapsedSec = Math.max(0, (nowMs - (current.lastSeenAtMs ?? nowMs)) / 1000);
     const elapsedSec = Math.min(rules.maxElapsedSec, rawElapsedSec);
     const maxDist = rules.maxSpeed * elapsedSec;

package/dist/nav/navFromEnvironment.d.ts

@@ -1,11 +1,17 @@
 import type { EnvironmentWorldFeature } from "../world/features.js";
 import type { Aabb } from "../world/geometry.js";
+import { type WorldSolids } from "../world/worldSolids.js";
 export interface NavObstacleGrid {
     blockAabb(aabb: Aabb): void;
 }
 /**
- * Expands every structure descriptor on an environment world feature into its
- * generated buildings and blocks their footprints on `grid`. Returns the
- * number of buildings blocked.
+ * Blocks the footprint of every solid building an environment feature's `structures` generate — the
+ * same set `ctx.world.solids` holds for it. Returns the number of buildings blocked.
  */
 export declare function populateNavGridFromEnvironment(grid: NavObstacleGrid, world: EnvironmentWorldFeature): number;
+/**
+ * Blocks the XZ footprint of every solid in `solids` (usually `ctx.world.solids`) on `grid`, so NPC
+ * paths avoid exactly what movement and physics collide with. Returns the number of solids blocked.
+ * @capability nav-from-solids block world solids on a nav grid
+ */
+export declare function populateNavGridFromSolids(grid: NavObstacleGrid, solids: Pick<WorldSolids, "all">): number;

package/dist/nav/navFromEnvironment.js

@@ -1,16 +1,22 @@
-import { resolveStructureBuildings } from "../world/environmentSummary.js";
+import { structureSolids, worldSolidFootprint } from "../world/worldSolids.js";
 /**
- * Expands every structure descriptor on an environment world feature into its
- * generated buildings and blocks their footprints on `grid`. Returns the
- * number of buildings blocked.
+ * Blocks the footprint of every solid building an environment feature's `structures` generate — the
+ * same set `ctx.world.solids` holds for it. Returns the number of buildings blocked.
  */
 export function populateNavGridFromEnvironment(grid, world) {
-    let blocked = 0;
-    for (const descriptor of world.structures ?? []) {
-        for (const building of resolveStructureBuildings(descriptor)) {
-            grid.blockAabb(building.bounds);
-            blocked += 1;
-        }
-    }
-    return blocked;
+    const solids = structureSolids(world);
+    for (const solid of solids)
+        grid.blockAabb(worldSolidFootprint(solid));
+    return solids.length;
+}
+/**
+ * Blocks the XZ footprint of every solid in `solids` (usually `ctx.world.solids`) on `grid`, so NPC
+ * paths avoid exactly what movement and physics collide with. Returns the number of solids blocked.
+ * @capability nav-from-solids block world solids on a nav grid
+ */
+export function populateNavGridFromSolids(grid, solids) {
+    const all = solids.all();
+    for (const solid of all)
+        grid.blockAabb(worldSolidFootprint(solid));
+    return all.length;
 }

package/dist/nav/navMesh.d.ts

@@ -0,0 +1,74 @@
+import type { Vec3 } from "../world/geometry.js";
+/** Explicit traversable connection between two navigation polygons. */
+export interface NavMeshLink {
+    from: number;
+    to: number;
+    cost?: number;
+    /** Where the link leaves `from`; defaults to that polygon's center. */
+    start?: Vec3;
+    /** Where the link lands in `to`; defaults to that polygon's center. */
+    end?: Vec3;
+}
+/** Serializable polygon navigation mesh data. Treat it as immutable once queried; queries cache derived geometry per object. */
+export interface NavMeshData {
+    /** Flat xyz vertex coordinates. Polygon indices refer to triples in this array. */
+    verts: number[];
+    /** Convex polygons as vertex index lists. */
+    polys: number[][];
+    links: NavMeshLink[];
+    /** Area id per polygon, priced by {@link NavMeshQueryOptions.areaCosts}. */
+    areas?: number[];
+}
+/** Neighbor relationship for one navigation polygon. */
+export interface NavMeshAdjacency {
+    neighbors: number[];
+    cost: number;
+}
+/** Route points and polygons selected through a navigation mesh. */
+export interface NavMeshPath {
+    points: Vec3[];
+    polys: number[];
+    /** True when the search budget ran out and the route ends at the polygon nearest the goal. */
+    partial?: boolean;
+}
+/** Tunable pricing and bounds for a {@link NavMeshQuery}. */
+export interface NavMeshQueryOptions {
+    /** Cost multiplier per area id; unlisted areas cost 1, and a negative or non-finite cost blocks the area. */
+    areaCosts?: Readonly<Record<number, number>>;
+    /** Most polygons one path search may expand before returning a partial path. Default 2048. */
+    maxNodes?: number;
+}
+/** Serializable tuning of a {@link NavMeshQuery}. */
+export interface NavMeshQuerySnapshot {
+    areaCosts: Record<number, number>;
+    maxNodes: number;
+}
+/** Cached, allocation-light queries over one {@link NavMeshData}. */
+export interface NavMeshQuery {
+    readonly mesh: NavMeshData;
+    /** Polygon nearest the point in 3D, so stacked floors resolve by height; null for an empty mesh. */
+    findPolygon(point: Vec3): number | null;
+    /** Closest point on the mesh surface, or null for an empty mesh. */
+    closestPoint(point: Vec3): Vec3 | null;
+    /** Cheapest polygon corridor by A*, straightened with a portal funnel. */
+    findPath(from: Vec3, to: Vec3): NavMeshPath | null;
+    /** True when the straight segment stays on walkable, unblocked polygons. */
+    raycast(from: Vec3, to: Vec3): boolean;
+    retune(patch: NavMeshQueryOptions): void;
+    snapshot(): NavMeshQuerySnapshot;
+    restore(next: NavMeshQuerySnapshot): void;
+}
+/** Build polygon adjacency from shared edges and explicit off-mesh links. */
+export declare function buildNavAdjacency(mesh: NavMeshData): NavMeshAdjacency[];
+/**
+ * Create a cached query over a nav mesh: height-aware polygon lookup through a uniform grid, binary-heap A*
+ * priced by area costs and bounded by `maxNodes`, portal-funnel path straightening, and edge-walking raycasts.
+ * @capability navmesh-query route, snap, and raycast on a polygon navmesh with retunable area costs and a bounded search
+ */
+export declare function createNavMeshQuery(mesh: NavMeshData, options?: NavMeshQueryOptions): NavMeshQuery;
+/** Return the closest point on the mesh surface, or null for an empty mesh. */
+export declare function closestPoint(mesh: NavMeshData, point: Vec3): Vec3 | null;
+/** A* over polygon portals with default area costs, straightened by a portal funnel. Use {@link createNavMeshQuery} to price areas. */
+export declare function findPath(mesh: NavMeshData, from: Vec3, to: Vec3): NavMeshPath | null;
+/** True when the segment remains over walkable polygons. */
+export declare function raycastNav(mesh: NavMeshData, from: Vec3, to: Vec3): boolean;