@downdraft/engine 0.1.1 → 0.2.0

package/dist/libraries/navmesh/src/pathfinder.js

@@ -0,0 +1,221 @@
+class MinHeap {
+    data = [];
+    compare;
+    constructor(compare) {
+        this.compare = compare;
+    }
+    get size() {
+        return this.data.length;
+    }
+    push(item) {
+        this.data.push(item);
+        this.siftUp(this.data.length - 1);
+    }
+    pop() {
+        if (this.data.length === 0)
+            return undefined;
+        const top = this.data[0];
+        const last = this.data.pop();
+        if (this.data.length > 0) {
+            this.data[0] = last;
+            this.siftDown(0);
+        }
+        return top;
+    }
+    siftUp(idx) {
+        while (idx > 0) {
+            const parent = (idx - 1) >> 1;
+            if (this.compare(this.data[idx], this.data[parent]) >= 0)
+                break;
+            [this.data[idx], this.data[parent]] = [this.data[parent], this.data[idx]];
+            idx = parent;
+        }
+    }
+    siftDown(idx) {
+        const n = this.data.length;
+        while (true) {
+            let smallest = idx;
+            const left = idx * 2 + 1;
+            const right = idx * 2 + 2;
+            if (left < n && this.compare(this.data[left], this.data[smallest]) < 0)
+                smallest = left;
+            if (right < n && this.compare(this.data[right], this.data[smallest]) < 0)
+                smallest = right;
+            if (smallest === idx)
+                break;
+            [this.data[idx], this.data[smallest]] = [this.data[smallest], this.data[idx]];
+            idx = smallest;
+        }
+    }
+}
+export class Pathfinder {
+    navMesh;
+    constructor(navMesh) {
+        this.navMesh = navMesh;
+    }
+    findPath(start, end) {
+        const startPoly = this.navMesh.findClosestPoly(start);
+        const endPoly = this.navMesh.findClosestPoly(end);
+        if (startPoly < 0 || endPoly < 0)
+            return [];
+        if (startPoly === endPoly)
+            return [start, end];
+        const polyPath = this.aStar(startPoly, endPoly);
+        if (polyPath.length === 0)
+            return [];
+        return this.funnelAlgorithm(start, end, polyPath);
+    }
+    aStar(startPoly, endPoly) {
+        const open = new MinHeap((a, b) => a.f - b.f);
+        const closed = new Set();
+        const allNodes = new Map();
+        const MAX_ITERATIONS = 10000;
+        const startNode = {
+            polyId: startPoly,
+            g: 0,
+            f: 0,
+            parent: null,
+        };
+        const endCenter = this.navMesh.getPolyCenter(endPoly);
+        startNode.f = this.heuristic(this.navMesh.getPolyCenter(startPoly), endCenter);
+        open.push(startNode);
+        allNodes.set(startPoly, startNode);
+        let iterations = 0;
+        while (open.size > 0) {
+            if (iterations++ >= MAX_ITERATIONS) {
+                return [];
+            }
+            const current = open.pop();
+            if (closed.has(current.polyId))
+                continue;
+            const best = allNodes.get(current.polyId);
+            if (best && current.f > best.f)
+                continue;
+            if (current.polyId === endPoly) {
+                return this.reconstructPath(current);
+            }
+            closed.add(current.polyId);
+            const neighbors = this.navMesh.getPolyNeighbors(current.polyId);
+            for (let _i = 0, _it = neighbors, _n = _it.length; _i < _n; _i++) {
+                const neighborId = _it[_i];
+                if (closed.has(neighborId))
+                    continue;
+                const neighborCenter = this.navMesh.getPolyCenter(neighborId);
+                const g = current.g + this.heuristic(this.navMesh.getPolyCenter(current.polyId), neighborCenter);
+                const existing = allNodes.get(neighborId);
+                if (existing && g >= existing.g)
+                    continue;
+                const h = this.heuristic(neighborCenter, endCenter);
+                const node = {
+                    polyId: neighborId,
+                    g,
+                    f: g + h,
+                    parent: current,
+                };
+                allNodes.set(neighborId, node);
+                open.push(node);
+            }
+        }
+        return [];
+    }
+    reconstructPath(node) {
+        const path = [];
+        let current = node;
+        while (current) {
+            path.unshift(current.polyId);
+            current = current.parent;
+        }
+        return path;
+    }
+    heuristic(a, b) {
+        const dx = a[0] - b[0];
+        const dy = a[1] - b[1];
+        const dz = a[2] - b[2];
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    funnelAlgorithm(start, end, polyPath) {
+        if (polyPath.length < 2)
+            return [start, end];
+        const portals = [];
+        for (let i = 0; i < polyPath.length - 1; i++) {
+            const portal = this.navMesh.getPortalEdge(polyPath[i], polyPath[i + 1]);
+            if (portal) {
+                portals.push({ left: portal.left, right: portal.right });
+            }
+            else {
+                const center = this.navMesh.getPolyCenter(polyPath[i]);
+                portals.push({ left: center, right: center });
+            }
+        }
+        const path = [start];
+        let apex = start;
+        let apexIndex = 0;
+        let leftLeg = portals[0].left;
+        let leftIndex = 0;
+        let rightLeg = portals[0].right;
+        let rightIndex = 0;
+        for (let i = 1; i <= portals.length; i++) {
+            if (i === portals.length) {
+                if (!this.vecEqual(apex, end)) {
+                    path.push(end);
+                }
+                break;
+            }
+            const portal = portals[i];
+            const newLeft = portal.left;
+            const newRight = portal.right;
+            if (this.tripleProduct(rightLeg, apex, newRight) >= 0) {
+                if (this.tripleProduct(leftLeg, apex, newRight) > 0 || apexIndex === rightIndex) {
+                    rightLeg = newRight;
+                    rightIndex = i;
+                }
+                else {
+                    apex = leftLeg;
+                    apexIndex = leftIndex;
+                    if (!this.vecEqual(apex, path[path.length - 1])) {
+                        path.push(apex);
+                    }
+                    leftLeg = apex;
+                    leftIndex = apexIndex;
+                    rightLeg = apex;
+                    rightIndex = apexIndex;
+                    i = apexIndex;
+                    continue;
+                }
+            }
+            if (this.tripleProduct(leftLeg, apex, newLeft) <= 0) {
+                if (this.tripleProduct(rightLeg, apex, newLeft) < 0 || apexIndex === leftIndex) {
+                    leftLeg = newLeft;
+                    leftIndex = i;
+                }
+                else {
+                    apex = rightLeg;
+                    apexIndex = rightIndex;
+                    if (!this.vecEqual(apex, path[path.length - 1])) {
+                        path.push(apex);
+                    }
+                    leftLeg = apex;
+                    leftIndex = apexIndex;
+                    rightLeg = apex;
+                    rightIndex = apexIndex;
+                    i = apexIndex;
+                    continue;
+                }
+            }
+        }
+        return path;
+    }
+    tripleProduct(a, b, c) {
+        const abx = b[0] - a[0];
+        const abz = b[2] - a[2];
+        const acx = c[0] - a[0];
+        const acz = c[2] - a[2];
+        return abx * acz - abz * acx;
+    }
+    vecEqual(a, b) {
+        const eps = 0.0001;
+        return Math.abs(a[0] - b[0]) < eps &&
+            Math.abs(a[1] - b[1]) < eps &&
+            Math.abs(a[2] - b[2]) < eps;
+    }
+}

package/dist/libraries/navmesh/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/libraries/networking/src/authority.js

@@ -0,0 +1,107 @@
+export class AuthorityManager {
+    authorities = new Map();
+    localPeerId;
+    isServer;
+    authorityChangeCbs = [];
+    constructor(localPeerId, isServer) {
+        this.localPeerId = localPeerId;
+        this.isServer = isServer;
+    }
+    registerEntity(entityId, authorityLevel = "server") {
+        this.authorities.set(entityId, {
+            entityId,
+            ownerPeerId: authorityLevel === "client" ? this.localPeerId : null,
+            authorityLevel,
+            locked: false,
+        });
+    }
+    unregisterEntity(entityId) {
+        this.authorities.delete(entityId);
+    }
+    requestAuthority(entityId, peerId) {
+        if (!this.isServer)
+            return false;
+        const auth = this.authorities.get(entityId);
+        if (!auth)
+            return false;
+        if (auth.locked)
+            return false;
+        auth.ownerPeerId = peerId;
+        auth.authorityLevel = "client";
+        this.notifyChange(entityId, auth);
+        return true;
+    }
+    grantAuthority(entityId, peerId) {
+        const auth = this.authorities.get(entityId);
+        if (!auth)
+            return;
+        auth.ownerPeerId = peerId;
+        auth.authorityLevel = "client";
+        this.notifyChange(entityId, auth);
+    }
+    revokeAuthority(entityId) {
+        const auth = this.authorities.get(entityId);
+        if (!auth)
+            return;
+        auth.ownerPeerId = null;
+        auth.authorityLevel = "server";
+        this.notifyChange(entityId, auth);
+    }
+    lockAuthority(entityId) {
+        const auth = this.authorities.get(entityId);
+        if (!auth)
+            return;
+        auth.locked = true;
+    }
+    unlockAuthority(entityId) {
+        const auth = this.authorities.get(entityId);
+        if (!auth)
+            return;
+        auth.locked = false;
+    }
+    hasAuthority(entityId) {
+        const auth = this.authorities.get(entityId);
+        if (!auth)
+            return false;
+        if (this.isServer && auth.authorityLevel === "server")
+            return true;
+        if (auth.authorityLevel === "client" && auth.ownerPeerId === this.localPeerId)
+            return true;
+        if (auth.authorityLevel === "shared")
+            return true;
+        return false;
+    }
+    getAuthority(entityId) {
+        return this.authorities.get(entityId);
+    }
+    getOwnedEntities() {
+        const result = [];
+        for (const [entityId, auth] of this.authorities.entries()) {
+            if (auth.ownerPeerId === this.localPeerId) {
+                result.push(entityId);
+            }
+        }
+        return result;
+    }
+    getServerEntities() {
+        const result = [];
+        for (const [entityId, auth] of this.authorities.entries()) {
+            if (auth.authorityLevel === "server") {
+                result.push(entityId);
+            }
+        }
+        return result;
+    }
+    canModify(entityId) {
+        return this.hasAuthority(entityId);
+    }
+    onAuthorityChange(cb) {
+        this.authorityChangeCbs.push(cb);
+    }
+    notifyChange(entityId, auth) {
+        this.authorityChangeCbs.forEach((cb) => cb(entityId, auth));
+    }
+    setLocalPeerId(peerId) {
+        this.localPeerId = peerId;
+    }
+}

package/dist/libraries/networking/src/connection.js

@@ -0,0 +1,107 @@
+export class ConnectionManager {
+    platform;
+    transport;
+    state = "disconnected";
+    peers = new Map();
+    stateChangeCbs = [];
+    peerConnectCbs = [];
+    peerDisconnectCbs = [];
+    reconnectDelay = 1000;
+    maxReconnectDelay = 30000;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    constructor(platform, transport) {
+        this.platform = platform;
+        this.transport = transport ?? null;
+        this.platform.onPeerConnect((peerId) => {
+            this.peers.set(peerId, {
+                peerId,
+                connected: true,
+                rtt: this.platform.getRTT(peerId),
+                lastSeen: Date.now(),
+            });
+            this.peerConnectCbs.forEach((cb) => cb(peerId));
+            if (this.state === "connecting" || this.state === "reconnecting") {
+                this.setState("connected");
+            }
+        });
+        this.platform.onPeerDisconnect((peerId) => {
+            const peer = this.peers.get(peerId);
+            if (peer) {
+                peer.connected = false;
+            }
+            this.peerDisconnectCbs.forEach((cb) => cb(peerId));
+            if (this.peers.size === 0 || ![...this.peers.values()].some((p) => p.connected)) {
+                this.setState("reconnecting");
+            }
+        });
+    }
+    send(peerId, data, reliable = true) {
+        this.platform.sendToPeer(peerId, data, reliable);
+    }
+    broadcast(data, reliable = true) {
+        for (const [peerId] of this.peers.entries()) {
+            this.platform.sendToPeer(peerId, data, reliable);
+        }
+    }
+    getConnectedPeers() {
+        return [...this.peers.values()].filter((p) => p.connected).map((p) => p.peerId);
+    }
+    getPeerInfo(peerId) {
+        return this.peers.get(peerId);
+    }
+    getPeerCount() {
+        return this.peers.size;
+    }
+    getConnectedPeerCount() {
+        return [...this.peers.values()].filter((p) => p.connected).length;
+    }
+    getState() {
+        return this.state;
+    }
+    getAverageRTT() {
+        const connected = [...this.peers.values()].filter((p) => p.connected);
+        if (connected.length === 0)
+            return 0;
+        return connected.reduce((sum, p) => sum + p.rtt, 0) / connected.length;
+    }
+    updatePeerRTTs() {
+        for (const [peerId, peer] of this.peers.entries()) {
+            peer.rtt = this.platform.getRTT(peerId);
+            peer.lastSeen = Date.now();
+        }
+    }
+    shouldReconnect() {
+        return this.state === "reconnecting" && this.reconnectAttempts < this.maxReconnectAttempts;
+    }
+    getReconnectDelay() {
+        const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+        return delay;
+    }
+    incrementReconnectAttempt() {
+        this.reconnectAttempts++;
+    }
+    resetReconnect() {
+        this.reconnectAttempts = 0;
+    }
+    setState(state) {
+        this.state = state;
+        this.stateChangeCbs.forEach((cb) => cb(state));
+    }
+    onStateChange(cb) {
+        this.stateChangeCbs.push(cb);
+    }
+    onPeerConnect(cb) {
+        this.peerConnectCbs.push(cb);
+    }
+    onPeerDisconnect(cb) {
+        this.peerDisconnectCbs.push(cb);
+    }
+    disconnectAll() {
+        for (const peer of this.peers.values()) {
+            peer.connected = false;
+        }
+        this.peers.clear();
+        this.setState("disconnected");
+    }
+}