@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/navigation.js

@@ -0,0 +1,338 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+export function cookDeterministicNavigationGraph(source) {
+    const nodes = [...source.nodes].sort(compareNavNodes);
+    const edges = [...expandBidirectionalEdges(source.edges)].sort(compareNavEdges);
+    const regions = [...(source.regions ?? [])].sort(compareNavRegions);
+    const nodeIds = new Set();
+    for (const node of nodes) {
+        if (nodeIds.has(node.id)) {
+            throw new Error(`Duplicate navigation node id ${node.id}`);
+        }
+        nodeIds.add(node.id);
+    }
+    for (const edge of edges) {
+        if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) {
+            throw new Error(`Navigation edge ${edge.from}->${edge.to} references a missing node`);
+        }
+    }
+    const cooked = { id: source.id, nodes, edges, regions };
+    const bytes = canonicalStringify(cooked);
+    return {
+        ...cooked,
+        bytes,
+        hash: defaultChecksum(bytes),
+    };
+}
+export function findDeterministicPath(graph, query) {
+    const nodes = nodeMap(graph);
+    if (!nodes.has(query.start) || !nodes.has(query.goal)) {
+        return emptyPathResult();
+    }
+    const disabledRegions = new Set(query.disabledRegionIds ?? []);
+    const blockedNodes = new Set(query.blockedNodeIds ?? []);
+    if (isNodeBlocked(nodes.get(query.start), disabledRegions, blockedNodes)
+        || isNodeBlocked(nodes.get(query.goal), disabledRegions, blockedNodes)) {
+        return emptyPathResult();
+    }
+    const adjacency = adjacencyMap(graph);
+    const open = [{ id: query.start, f: heuristic(nodes.get(query.start), nodes.get(query.goal)), g: 0, order: 0 }];
+    const cameFrom = new Map();
+    const bestCost = new Map([[query.start, 0]]);
+    const visited = new Set();
+    let pushOrder = 1;
+    while (open.length > 0) {
+        open.sort(compareQueueEntries);
+        const current = open.shift();
+        if (visited.has(current.id)) {
+            continue;
+        }
+        visited.add(current.id);
+        if (current.id === query.goal) {
+            const path = reconstructPath(cameFrom, current.id);
+            return {
+                found: true,
+                nodes: path,
+                cost: current.g,
+                visitedNodeCount: visited.size,
+                offMeshTraversals: countOffMeshTraversals(graph, path),
+                pathHash: defaultChecksum(path),
+            };
+        }
+        const neighbors = [...(adjacency.get(current.id) ?? [])].sort(compareNavEdges);
+        for (const edge of neighbors) {
+            const next = nodes.get(edge.to);
+            if (next === undefined || isNodeBlocked(next, disabledRegions, blockedNodes)) {
+                continue;
+            }
+            const candidateCost = current.g + (edge.cost ?? 1) + (next.cost ?? 1);
+            const knownCost = bestCost.get(edge.to);
+            if (knownCost !== undefined && candidateCost >= knownCost) {
+                continue;
+            }
+            cameFrom.set(edge.to, current.id);
+            bestCost.set(edge.to, candidateCost);
+            open.push({
+                id: edge.to,
+                f: candidateCost + heuristic(next, nodes.get(query.goal)),
+                g: candidateCost,
+                order: pushOrder,
+            });
+            pushOrder += 1;
+        }
+    }
+    return {
+        found: false,
+        nodes: [],
+        cost: 0,
+        visitedNodeCount: visited.size,
+        offMeshTraversals: 0,
+        pathHash: defaultChecksum([]),
+    };
+}
+export function createDeterministicFlowField(graph, goal, options = {}) {
+    const nextByNodeId = {};
+    for (const node of graph.nodes) {
+        const path = findDeterministicPath(graph, {
+            ...options,
+            start: node.id,
+            goal,
+        });
+        if (path.found && path.nodes.length > 1) {
+            nextByNodeId[node.id] = path.nodes[1];
+        }
+    }
+    const stable = Object.fromEntries(Object.entries(nextByNodeId).sort(compareStringEntries));
+    return {
+        goal,
+        nextByNodeId: stable,
+        hash: defaultChecksum(stable),
+    };
+}
+export function smoothDeterministicPath(graph, path) {
+    if (path.length <= 2) {
+        return path;
+    }
+    const nodes = nodeMap(graph);
+    const smoothed = [path[0]];
+    for (let index = 1; index < path.length - 1; index += 1) {
+        const prev = nodes.get(smoothed[smoothed.length - 1]);
+        const current = nodes.get(path[index]);
+        const next = nodes.get(path[index + 1]);
+        if (prev === undefined || current === undefined || next === undefined) {
+            smoothed.push(path[index]);
+            continue;
+        }
+        const collinear = (current.x - prev.x) * (next.y - current.y) === (current.y - prev.y) * (next.x - current.x);
+        if (!collinear || isOffMeshEdge(graph, path[index - 1], path[index]) || isOffMeshEdge(graph, path[index], path[index + 1])) {
+            smoothed.push(path[index]);
+        }
+    }
+    smoothed.push(path[path.length - 1]);
+    return smoothed;
+}
+export function applyDeterministicReciprocalAvoidance(agents) {
+    const occupancy = new Map();
+    for (const agent of [...agents].sort(compareAgents)) {
+        occupancy.set(agent.nodeId, [...(occupancy.get(agent.nodeId) ?? []), agent]);
+    }
+    let corrections = 0;
+    const adjusted = [...agents].sort(compareAgents).map((agent) => {
+        /* istanbul ignore next -- every adjusted agent was inserted into occupancy by nodeId above. */
+        const peers = occupancy.get(agent.nodeId) ?? [];
+        if (peers.length <= 1) {
+            return agent;
+        }
+        const peerIndex = peers.findIndex((peer) => peer.id === agent.id);
+        corrections += peerIndex === 0 ? 0 : 1;
+        return {
+            ...agent,
+            pathIndex: (agent.pathIndex ?? 0) + peerIndex,
+        };
+    });
+    return {
+        agents: cloneCanonical(adjusted),
+        corrections,
+        hash: defaultChecksum(adjusted),
+    };
+}
+export function cookTilemapNavigationGraph(source) {
+    const blocked = new Set(source.blocked ?? []);
+    const nodes = [];
+    const edges = [];
+    for (let y = 0; y < source.height; y += 1) {
+        for (let x = 0; x < source.width; x += 1) {
+            const id = `${x},${y}`;
+            if (blocked.has(id)) {
+                continue;
+            }
+            nodes.push({ id, x, y, cost: source.costs?.[id] ?? 1 });
+            for (const [dx, dy] of [[-1, 0], [0, -1]]) {
+                const neighbor = `${x + dx},${y + dy}`;
+                if (!blocked.has(neighbor) && x + dx >= 0 && y + dy >= 0) {
+                    edges.push({ from: id, to: neighbor, bidirectional: true });
+                }
+            }
+        }
+    }
+    for (const [from, to] of Object.entries(source.portals ?? {}).sort(compareStringEntries)) {
+        edges.push({ from, to, cost: 1, offMesh: true });
+    }
+    return cookDeterministicNavigationGraph({
+        id: source.id,
+        nodes,
+        edges,
+    });
+}
+export function stepDeterministicNavigationAgents(graph, agents, options) {
+    const reserved = new Set();
+    const sortedAgents = [...agents].sort(compareAgents);
+    const nextAgents = [];
+    let replans = 0;
+    let avoidanceCorrections = 0;
+    let reciprocalAvoidanceCorrections = 0;
+    let offMeshTraversals = 0;
+    let visitedNodeCount = 0;
+    for (const agent of sortedAgents) {
+        let path = agent.path ?? [];
+        let pathIndex = agent.pathIndex ?? 0;
+        if (path.length === 0 || path[path.length - 1] !== agent.targetNodeId || options.frame % 31 === 0) {
+            const planned = findDeterministicPath(graph, {
+                start: agent.nodeId,
+                goal: agent.targetNodeId,
+                disabledRegionIds: options.disabledRegionIds,
+                blockedNodeIds: options.blockedNodeIds,
+            });
+            path = planned.nodes;
+            pathIndex = 0;
+            replans += 1;
+            visitedNodeCount += planned.visitedNodeCount;
+        }
+        const candidate = path[pathIndex + 1] ?? agent.nodeId;
+        if (reserved.has(candidate)) {
+            reserved.add(agent.nodeId);
+            nextAgents.push({ ...agent, path, pathIndex });
+            avoidanceCorrections += 1;
+            continue;
+        }
+        const moved = candidate !== agent.nodeId;
+        reserved.add(candidate);
+        if (moved && isOffMeshEdge(graph, agent.nodeId, candidate)) {
+            offMeshTraversals += 1;
+        }
+        nextAgents.push({
+            ...agent,
+            nodeId: candidate,
+            path,
+            pathIndex: moved ? pathIndex + 1 : pathIndex,
+        });
+    }
+    const agentsByInputOrder = nextAgents.sort(compareAgents);
+    const reciprocal = applyDeterministicReciprocalAvoidance(agentsByInputOrder);
+    reciprocalAvoidanceCorrections += reciprocal.corrections;
+    return {
+        agents: reciprocal.agents,
+        replans,
+        avoidanceCorrections,
+        offMeshTraversals,
+        visitedNodeCount,
+        reciprocalAvoidanceCorrections,
+        agentChecksum: defaultChecksum({ agents: reciprocal.agents, reciprocalHash: reciprocal.hash }),
+    };
+}
+function emptyPathResult() {
+    return {
+        found: false,
+        nodes: [],
+        cost: 0,
+        visitedNodeCount: 0,
+        offMeshTraversals: 0,
+        pathHash: defaultChecksum([]),
+    };
+}
+function compareNavNodes(left, right) {
+    return compareStrings(left.id, right.id);
+}
+function compareNavEdges(left, right) {
+    return compareStrings(`${left.from}->${left.to}`, `${right.from}->${right.to}`);
+}
+function compareNavRegions(left, right) {
+    return compareStrings(left.id, right.id);
+}
+function compareAgents(left, right) {
+    return compareStrings(left.id, right.id);
+}
+function compareQueueEntries(left, right) {
+    const fDelta = left.f - right.f;
+    if (fDelta !== 0) {
+        return fDelta;
+    }
+    const gDelta = left.g - right.g;
+    if (gDelta !== 0) {
+        return gDelta;
+    }
+    const idDelta = compareStrings(left.id, right.id);
+    /* istanbul ignore else -- queue ids are unique after f/g tie-breakers in public graph searches. */
+    if (idDelta !== 0) {
+        return idDelta;
+    }
+    /* istanbul ignore next -- queue ids are unique after f/g/id tie-breakers in public graph searches. */
+    return left.order - right.order;
+}
+function compareStringEntries(left, right) {
+    return compareStrings(left[0], right[0]);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function expandBidirectionalEdges(edges) {
+    const expanded = [];
+    for (const edge of edges) {
+        expanded.push(edge);
+        if (edge.bidirectional === true) {
+            expanded.push({
+                from: edge.to,
+                to: edge.from,
+                cost: edge.cost,
+                offMesh: edge.offMesh,
+            });
+        }
+    }
+    return expanded;
+}
+function nodeMap(graph) {
+    return new Map(graph.nodes.map((node) => [node.id, node]));
+}
+function adjacencyMap(graph) {
+    const adjacency = new Map();
+    for (const edge of graph.edges) {
+        adjacency.set(edge.from, [...(adjacency.get(edge.from) ?? []), edge]);
+    }
+    return adjacency;
+}
+function isNodeBlocked(node, disabledRegions, blockedNodes) {
+    return blockedNodes.has(node.id) || (node.region !== undefined && disabledRegions.has(node.region));
+}
+function heuristic(left, right) {
+    return Math.abs(left.x - right.x) + Math.abs(left.y - right.y);
+}
+function reconstructPath(cameFrom, goal) {
+    const path = [goal];
+    let current = goal;
+    while (cameFrom.has(current)) {
+        current = cameFrom.get(current);
+        path.push(current);
+    }
+    return path.reverse();
+}
+function countOffMeshTraversals(graph, path) {
+    let count = 0;
+    for (let index = 1; index < path.length; index += 1) {
+        if (isOffMeshEdge(graph, path[index - 1], path[index])) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function isOffMeshEdge(graph, from, to) {
+    return graph.edges.some((edge) => edge.from === from && edge.to === to && edge.offMesh === true);
+}

package/dist/navmesh.d.ts

@@ -0,0 +1,236 @@
+export interface DeterministicNavmeshPolygon {
+    readonly id: string;
+    readonly vertices: readonly DeterministicNavmeshPoint[];
+    readonly region?: string;
+    readonly cost?: number;
+}
+export interface DeterministicNavmeshPoint {
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number;
+}
+export interface DeterministicNavmeshLink {
+    readonly from: string;
+    readonly to: string;
+    readonly cost?: number;
+    readonly offMesh?: boolean;
+    readonly bidirectional?: boolean;
+}
+export interface DeterministicNavmeshSource {
+    readonly id: string;
+    readonly polygons: readonly DeterministicNavmeshPolygon[];
+    readonly links: readonly DeterministicNavmeshLink[];
+    readonly regions?: readonly {
+        readonly id: string;
+        readonly enabled: boolean;
+    }[];
+}
+export interface DeterministicNavmeshImportSource {
+    readonly id: string;
+    readonly polygons: readonly {
+        readonly id: string;
+        readonly vertices: readonly DeterministicNavmeshPoint[];
+        readonly region?: string;
+        readonly cost?: number;
+    }[];
+    readonly links: readonly {
+        readonly from: string;
+        readonly to: string;
+        readonly cost?: number;
+        readonly offMesh?: boolean;
+        readonly bidirectional?: boolean;
+    }[];
+    readonly regions?: readonly {
+        readonly id: string;
+        readonly enabled: boolean;
+    }[];
+    readonly spawnMarkers?: readonly {
+        readonly id: string;
+        readonly polygonId: string;
+        readonly point: DeterministicNavmeshPoint;
+    }[];
+}
+export interface CookedDeterministicNavmesh {
+    readonly id: string;
+    readonly polygons: readonly DeterministicNavmeshPolygon[];
+    readonly links: readonly DeterministicNavmeshLink[];
+    readonly regions: readonly {
+        readonly id: string;
+        readonly enabled: boolean;
+    }[];
+    readonly portalTable: readonly {
+        readonly from: string;
+        readonly to: string;
+        readonly midpoint: DeterministicNavmeshPoint;
+        readonly offMesh: boolean;
+    }[];
+    readonly spawnMarkers: readonly {
+        readonly id: string;
+        readonly polygonId: string;
+        readonly point: DeterministicNavmeshPoint;
+    }[];
+    readonly bytes: string;
+    readonly hash: string;
+}
+export interface DeterministicNavmeshPath {
+    readonly found: boolean;
+    readonly polygons: readonly string[];
+    readonly points: readonly DeterministicNavmeshPoint[];
+    readonly offMeshTraversals: number;
+    readonly visitedPolygons: number;
+    readonly pathHash: string;
+    readonly startPolygonId?: string;
+    readonly goalPolygonId?: string;
+}
+export interface DeterministicNavmeshAgent {
+    readonly id: string;
+    readonly polygonId: string;
+    readonly targetPolygonId: string;
+    readonly x?: number;
+    readonly y?: number;
+    readonly z?: number;
+    readonly speedPerFrame?: number;
+    readonly updateIntervalFrames?: number;
+    readonly stoppingDistance?: number;
+    readonly corridor?: readonly string[];
+    readonly corridorIndex?: number;
+    readonly avoidancePriority?: number;
+    readonly radius?: number;
+}
+export interface DeterministicNavmeshMovingAvoidanceObstacle {
+    readonly id: string;
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number;
+    readonly vx: number;
+    readonly vy: number;
+    readonly vz?: number;
+    readonly radius: number;
+    readonly predictionFrames?: number;
+    readonly speedReductionPerFrame?: number;
+}
+export interface DeterministicNavmeshAgentStepResult {
+    readonly agents: readonly DeterministicNavmeshAgent[];
+    readonly replans: number;
+    readonly avoidanceCorrections: number;
+    readonly dynamicRegionToggles: number;
+    readonly obstacleCount: number;
+    readonly waypointAdvances: number;
+    readonly radiusAvoidanceCorrections: number;
+    readonly velocityObstacleAvoidanceCorrections: number;
+    readonly agentVelocityObstacleAvoidanceCorrections: number;
+    readonly agentAvoidancePriorityYields: number;
+    readonly avoidanceSpeedReductions: number;
+    readonly agentAvoidanceSpeedReductions: number;
+    readonly checksum: string;
+}
+export interface DeterministicNavmeshOffMeshTraversalState {
+    readonly agentId: string;
+    readonly linkFrom: string;
+    readonly linkTo: string;
+    readonly commandId: string;
+    readonly phase: 'idle' | 'entering' | 'traversing' | 'exiting' | 'complete';
+    readonly elapsedFrames: number;
+    readonly durationFrames: number;
+}
+export interface DeterministicNavmeshOffMeshTraversalStep {
+    readonly state: DeterministicNavmeshOffMeshTraversalState;
+    readonly agent: DeterministicNavmeshAgent;
+    readonly events: readonly string[];
+    readonly checksum: string;
+}
+export interface DeterministicNavmeshImportTraversalFixtureResult {
+    readonly checksum: string;
+    readonly restoredChecksum: string;
+    readonly rollbackEquivalent: boolean;
+    readonly importedHash: string;
+    readonly permutedHash: string;
+    readonly importOrderStable: boolean;
+    readonly portalCount: number;
+    readonly spawnMarkerCount: number;
+    readonly missingRegionRejected: boolean;
+    readonly missingLinkRejected: boolean;
+    readonly missingSpawnRejected: boolean;
+    readonly offMeshEnterEvents: number;
+    readonly offMeshTraverseEvents: number;
+    readonly offMeshExitEvents: number;
+    readonly offMeshCompleteEvents: number;
+    readonly offMeshCommandIdStable: boolean;
+    readonly offMeshTraversalFrames: number;
+    readonly pointPathFound: boolean;
+    readonly pointPathHash: string;
+}
+export interface DeterministicNavmeshLayered3DFixtureResult {
+    readonly checksum: string;
+    readonly restoredChecksum: string;
+    readonly rollbackEquivalent: boolean;
+    readonly cookedHash: string;
+    readonly permutedHash: string;
+    readonly cookOrderStable: boolean;
+    readonly lowerLookupId: string;
+    readonly upperLookupId: string;
+    readonly lowerPathHash: string;
+    readonly upperPathHash: string;
+    readonly verticalOffMeshTraversals: number;
+    readonly stackedOverlapAccepted: boolean;
+    readonly sameLayerOverlapRejected: boolean;
+    readonly layerDisambiguationStable: boolean;
+    readonly upperAgentZ: number;
+}
+export interface DeterministicNavmeshVelocityObstacleFixtureResult {
+    readonly checksum: string;
+    readonly restoredChecksum: string;
+    readonly rollbackEquivalent: boolean;
+    readonly movingObstacleSpeedReduction: boolean;
+    readonly predictedFuturePositionAvoided: boolean;
+    readonly authoredSpeedRestored: boolean;
+    readonly obstacleOrderStable: boolean;
+    readonly obstacleValidationRejected: boolean;
+    readonly velocityObstacleAvoidanceCorrections: number;
+    readonly avoidanceSpeedReductions: number;
+}
+export declare function cookDeterministicNavmesh(source: DeterministicNavmeshSource): CookedDeterministicNavmesh;
+export declare function cookImportedDeterministicNavmesh(source: DeterministicNavmeshImportSource): CookedDeterministicNavmesh;
+export declare function findDeterministicNavmeshPath(navmesh: CookedDeterministicNavmesh, query: {
+    readonly start: string;
+    readonly goal: string;
+    readonly disabledRegions?: readonly string[];
+    readonly blockedPolygons?: readonly string[];
+}): DeterministicNavmeshPath;
+export declare function findDeterministicNavmeshPointPath(navmesh: CookedDeterministicNavmesh, query: {
+    readonly start: DeterministicNavmeshPoint;
+    readonly goal: DeterministicNavmeshPoint;
+    readonly disabledRegions?: readonly string[];
+    readonly blockedPolygons?: readonly string[];
+}): DeterministicNavmeshPath;
+export declare function locateDeterministicNavmeshPolygon(navmesh: CookedDeterministicNavmesh, point: DeterministicNavmeshPoint, disabledRegions?: readonly string[], blockedPolygons?: readonly string[]): DeterministicNavmeshPolygon | undefined;
+export declare function smoothDeterministicNavmeshPath(navmesh: CookedDeterministicNavmesh, polygonIds: readonly string[]): readonly DeterministicNavmeshPoint[];
+export declare function stepDeterministicNavmeshAgents(navmesh: CookedDeterministicNavmesh, agents: readonly DeterministicNavmeshAgent[], options?: {
+    readonly frame?: number;
+    readonly disabledRegions?: readonly string[];
+    readonly movingObstaclePolygons?: readonly string[];
+    readonly movingAvoidanceObstacles?: readonly DeterministicNavmeshMovingAvoidanceObstacle[];
+}): DeterministicNavmeshAgentStepResult;
+export declare function stepDeterministicNavmeshOffMeshTraversal(navmesh: CookedDeterministicNavmesh, agent: DeterministicNavmeshAgent, state: DeterministicNavmeshOffMeshTraversalState): DeterministicNavmeshOffMeshTraversalStep;
+export declare function runDeterministicNavmeshStress(agents: number, frames: number): {
+    readonly checksum: string;
+    readonly agents: number;
+    readonly frames: number;
+    readonly replans: number;
+    readonly avoidanceCorrections: number;
+    readonly waypointAdvances: number;
+    readonly radiusAvoidanceCorrections: number;
+    readonly velocityObstacleAvoidanceCorrections: number;
+    readonly agentVelocityObstacleAvoidanceCorrections: number;
+    readonly agentAvoidancePriorityYields: number;
+    readonly avoidanceSpeedReductions: number;
+    readonly agentAvoidanceSpeedReductions: number;
+    readonly pathHash: string;
+    readonly pointPathHash: string;
+    readonly pointPathFound: boolean;
+    readonly pointLookupStable: boolean;
+    readonly rollbackEquivalent: boolean;
+};
+export declare function runDeterministicNavmeshVelocityObstacleFixture(): DeterministicNavmeshVelocityObstacleFixtureResult;
+export declare function runDeterministicNavmeshImportTraversalFixture(): DeterministicNavmeshImportTraversalFixtureResult;
+export declare function runDeterministicNavmeshLayered3DFixture(): DeterministicNavmeshLayered3DFixtureResult;