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

package/dist/cjs/navigation.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookDeterministicNavigationGraph = cookDeterministicNavigationGraph;
+exports.findDeterministicPath = findDeterministicPath;
+exports.createDeterministicFlowField = createDeterministicFlowField;
+exports.smoothDeterministicPath = smoothDeterministicPath;
+exports.applyDeterministicReciprocalAvoidance = applyDeterministicReciprocalAvoidance;
+exports.cookTilemapNavigationGraph = cookTilemapNavigationGraph;
+exports.stepDeterministicNavigationAgents = stepDeterministicNavigationAgents;
+const canonical_js_1 = require("./canonical.js");
+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 = (0, canonical_js_1.canonicalStringify)(cooked);
+    return {
+        ...cooked,
+        bytes,
+        hash: (0, canonical_js_1.defaultChecksum)(bytes),
+    };
+}
+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: (0, canonical_js_1.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: (0, canonical_js_1.defaultChecksum)([]),
+    };
+}
+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: (0, canonical_js_1.defaultChecksum)(stable),
+    };
+}
+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;
+}
+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: (0, canonical_js_1.cloneCanonical)(adjusted),
+        corrections,
+        hash: (0, canonical_js_1.defaultChecksum)(adjusted),
+    };
+}
+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,
+    });
+}
+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: (0, canonical_js_1.defaultChecksum)({ agents: reciprocal.agents, reciprocalHash: reciprocal.hash }),
+    };
+}
+function emptyPathResult() {
+    return {
+        found: false,
+        nodes: [],
+        cost: 0,
+        visitedNodeCount: 0,
+        offMeshTraversals: 0,
+        pathHash: (0, canonical_js_1.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);
+}