@downdraft/engine 0.1.0 → 0.1.2-alpha.5

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

@@ -0,0 +1,156 @@
+import { WebRTCTransport } from "./webrtc.js";
+export class MockTransport {
+    type = "mock";
+    connected = false;
+    msgHandlers = [];
+    connectHandlers = [];
+    disconnectHandlers = [];
+    rtt = 0;
+    packetLoss = 0;
+    peer = null;
+    async connect(_url) {
+        this.connected = true;
+        this.connectHandlers.forEach((h) => h());
+    }
+    async disconnect() {
+        this.connected = false;
+        this.disconnectHandlers.forEach((h) => h());
+    }
+    send(msg) {
+        if (!this.connected || !this.peer)
+            return;
+        this.peer.msgHandlers.forEach((h) => h(msg));
+    }
+    onMessage(handler) { this.msgHandlers.push(handler); }
+    onConnect(handler) { this.connectHandlers.push(handler); }
+    onDisconnect(handler) { this.disconnectHandlers.push(handler); }
+    isConnected() { return this.connected; }
+    getRTT() { return this.rtt; }
+    getPacketLoss() { return this.packetLoss; }
+    link(other) {
+        this.peer = other;
+        other.peer = this;
+    }
+    setRTT(rtt) { this.rtt = rtt; }
+    setPacketLoss(loss) { this.packetLoss = loss; }
+}
+export class WebSocketTransport {
+    type = "websocket";
+    ws = null;
+    connected = false;
+    msgHandlers = [];
+    connectHandlers = [];
+    disconnectHandlers = [];
+    rtt = 0;
+    packetLoss = 0;
+    lastPing = 0;
+    pingInterval = null;
+    connectingPromise = null;
+    async connect(url) {
+        if (this.connected) {
+            throw new Error("connect() already in progress or connected");
+        }
+        if (this.connectingPromise) {
+            return this.connectingPromise;
+        }
+        this.connectingPromise = new Promise((resolve, reject) => {
+            this.ws = new WebSocket(url);
+            this.ws.binaryType = "arraybuffer";
+            this.ws.onopen = () => {
+                this.connected = true;
+                this.connectingPromise = null;
+                this.connectHandlers.forEach((h) => h());
+                this.startPing();
+                resolve();
+            };
+            this.ws.onerror = (e) => {
+                if (!this.connected) {
+                    this.connectingPromise = null;
+                    reject(e);
+                }
+            };
+            this.ws.onclose = () => {
+                this.connected = false;
+                this.connectingPromise = null;
+                this.stopPing();
+                this.disconnectHandlers.forEach((h) => h());
+            };
+            this.ws.onmessage = (e) => {
+                const data = new Uint8Array(e.data);
+                const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+                if (data.length > MAX_MESSAGE_SIZE) {
+                    this.ws?.close(1009, "message too large");
+                    return;
+                }
+                if (data.length < 4)
+                    return;
+                const type = (data[0] << 8) | data[1];
+                const channel = data[2];
+                const reliable = (data[3] & 1) !== 0;
+                const ordered = (data[3] & 2) !== 0;
+                const payload = data.slice(4);
+                if (type === 0xFFFF) {
+                    // Ping/pong
+                    this.rtt = performance.now() - this.lastPing;
+                    return;
+                }
+                this.msgHandlers.forEach((h) => h({
+                    type, data: payload, reliable, ordered, channel,
+                }));
+            };
+        });
+    }
+    async disconnect() {
+        this.stopPing();
+        this.ws?.close();
+        this.ws = null;
+        this.connected = false;
+        this.connectingPromise = null;
+        this.disconnectHandlers.forEach((h) => h());
+    }
+    send(msg) {
+        if (!this.ws || !this.connected)
+            return;
+        const header = new Uint8Array(4);
+        header[0] = (msg.type >> 8) & 0xFF;
+        header[1] = msg.type & 0xFF;
+        header[2] = msg.channel;
+        header[3] = (msg.reliable ? 1 : 0) | (msg.ordered ? 2 : 0);
+        const buf = new Uint8Array(4 + msg.data.length);
+        buf.set(header, 0);
+        buf.set(msg.data, 4);
+        this.ws.send(buf);
+    }
+    onMessage(handler) { this.msgHandlers.push(handler); }
+    onConnect(handler) { this.connectHandlers.push(handler); }
+    onDisconnect(handler) { this.disconnectHandlers.push(handler); }
+    isConnected() { return this.connected; }
+    getRTT() { return this.rtt; }
+    getPacketLoss() { return this.packetLoss; }
+    startPing() {
+        this.stopPing();
+        this.pingInterval = setInterval(() => {
+            if (!this.connected)
+                return;
+            this.lastPing = performance.now();
+            const ping = new Uint8Array(4);
+            ping[0] = 0xFF;
+            ping[1] = 0xFF;
+            this.ws?.send(ping);
+        }, 1000);
+    }
+    stopPing() {
+        if (this.pingInterval !== null) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+}
+export function createTransport(type) {
+    switch (type) {
+        case "websocket": return new WebSocketTransport();
+        case "webrtc": return new WebRTCTransport();
+        case "mock": return new MockTransport();
+        default: return new MockTransport();
+    }
+}

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

@@ -0,0 +1,266 @@
+import { safeJsonParse } from "@downdraft/engine";
+export function isValidIceCandidate(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return false;
+    const c = obj;
+    return (typeof c.candidate === "string" &&
+        (c.sdpMid === null || typeof c.sdpMid === "string") &&
+        (c.sdpMLineIndex === null || typeof c.sdpMLineIndex === "number"));
+}
+export class WebSocketSignalingClient {
+    ws = null;
+    connected = false;
+    peerId = null;
+    msgCbs = [];
+    connectCbs = [];
+    disconnectCbs = [];
+    async connect(url) {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(url);
+            this.ws.onopen = () => {
+                this.connected = true;
+                this.connectCbs.forEach((cb) => cb());
+                resolve();
+            };
+            this.ws.onerror = (e) => {
+                if (!this.connected)
+                    reject(e);
+            };
+            this.ws.onclose = () => {
+                this.connected = false;
+                this.disconnectCbs.forEach((cb) => cb());
+            };
+            this.ws.onmessage = (e) => {
+                try {
+                    const msg = safeJsonParse(e.data);
+                    if (msg.type === "join" && !this.peerId) {
+                        this.peerId = msg.fromPeerId;
+                    }
+                    this.msgCbs.forEach((cb) => cb(msg));
+                }
+                catch {
+                    // ignore malformed messages
+                }
+            };
+        });
+    }
+    async disconnect() {
+        this.ws?.close();
+        this.ws = null;
+        this.connected = false;
+        this.disconnectCbs.forEach((cb) => cb());
+    }
+    send(msg) {
+        if (!this.ws || !this.connected)
+            return;
+        this.ws.send(JSON.stringify(msg));
+    }
+    onMessage(cb) {
+        this.msgCbs.push(cb);
+    }
+    onConnect(cb) {
+        this.connectCbs.push(cb);
+    }
+    onDisconnect(cb) {
+        this.disconnectCbs.push(cb);
+    }
+    getPeerId() {
+        return this.peerId;
+    }
+}
+export class WebRTCTransport {
+    type = "webrtc";
+    pc = null;
+    dc = null;
+    connected = false;
+    msgHandlers = [];
+    connectHandlers = [];
+    disconnectHandlers = [];
+    rtt = 0;
+    packetLoss = 0;
+    signaling = null;
+    isInitiator = false;
+    lastPing = 0;
+    pingInterval = null;
+    constructor(signaling) {
+        this.signaling = signaling ?? null;
+    }
+    setSignaling(signaling) {
+        this.signaling = signaling;
+    }
+    async connect(url) {
+        if (!this.signaling) {
+            throw new Error("WebRTCTransport requires a signaling client");
+        }
+        await this.signaling.connect(url);
+        this.isInitiator = true;
+        const config = { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] };
+        this.pc = new RTCPeerConnection(config);
+        this.dc = this.pc.createDataChannel("game", {
+            ordered: false,
+            maxRetransmits: 0,
+        });
+        this.setupDataChannel();
+        this.signaling.onMessage((msg) => {
+            if (msg.type === "answer" && this.pc) {
+                this.pc.setRemoteDescription({ type: "answer", sdp: msg.data });
+            }
+            else if (msg.type === "ice-candidate" && this.pc && msg.data) {
+                const candidate = safeJsonParse(msg.data);
+                if (isValidIceCandidate(candidate)) {
+                    this.pc.addIceCandidate(candidate);
+                }
+            }
+        });
+        this.pc.onicecandidate = (event) => {
+            if (event.candidate && this.signaling) {
+                this.signaling.send({
+                    type: "ice-candidate",
+                    fromPeerId: this.signaling.getPeerId() ?? "",
+                    data: JSON.stringify(event.candidate.toJSON()),
+                });
+            }
+        };
+        const offer = await this.pc.createOffer();
+        await this.pc.setLocalDescription(offer);
+        this.signaling.send({
+            type: "offer",
+            fromPeerId: this.signaling.getPeerId() ?? "",
+            data: offer.sdp,
+        });
+    }
+    async acceptConnection(pc) {
+        this.pc = pc;
+        this.isInitiator = false;
+        this.pc.ondatachannel = (event) => {
+            this.dc = event.channel;
+            this.setupDataChannel();
+        };
+        this.pc.onicecandidate = (event) => {
+            if (event.candidate && this.signaling) {
+                this.signaling.send({
+                    type: "ice-candidate",
+                    fromPeerId: this.signaling.getPeerId() ?? "",
+                    data: JSON.stringify(event.candidate.toJSON()),
+                });
+            }
+        };
+        this.signaling?.onMessage((msg) => {
+            if (msg.type === "offer" && this.pc) {
+                this.pc.setRemoteDescription({ type: "offer", sdp: msg.data });
+                this.pc.createAnswer().then((answer) => {
+                    this.pc.setLocalDescription(answer);
+                    this.signaling.send({
+                        type: "answer",
+                        fromPeerId: this.signaling.getPeerId() ?? "",
+                        data: answer.sdp,
+                    });
+                });
+            }
+            else if (msg.type === "ice-candidate" && this.pc && msg.data) {
+                const candidate = safeJsonParse(msg.data);
+                if (isValidIceCandidate(candidate)) {
+                    this.pc.addIceCandidate(candidate);
+                }
+            }
+        });
+    }
+    setupDataChannel() {
+        if (!this.dc)
+            return;
+        this.dc.onopen = () => {
+            this.connected = true;
+            this.connectHandlers.forEach((cb) => cb());
+            this.startPing();
+        };
+        this.dc.onclose = () => {
+            this.connected = false;
+            this.disconnectHandlers.forEach((cb) => cb());
+            this.stopPing();
+        };
+        this.dc.onmessage = (event) => {
+            const data = new Uint8Array(event.data);
+            const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+            if (data.length > MAX_MESSAGE_SIZE) {
+                this.dc?.close();
+                return;
+            }
+            if (data.length < 4)
+                return;
+            const type = (data[0] << 8) | data[1];
+            const channel = data[2];
+            const reliable = (data[3] & 1) !== 0;
+            const ordered = (data[3] & 2) !== 0;
+            const payload = data.slice(4);
+            if (type === 0xFFFF) {
+                this.rtt = performance.now() - this.lastPing;
+                return;
+            }
+            this.msgHandlers.forEach((h) => h({ type, data: payload, reliable, ordered, channel }));
+        };
+    }
+    async disconnect() {
+        this.stopPing();
+        this.dc?.close();
+        this.pc?.close();
+        this.dc = null;
+        this.pc = null;
+        this.connected = false;
+        this.disconnectHandlers.forEach((cb) => cb());
+        await this.signaling?.disconnect();
+    }
+    send(msg) {
+        if (!this.dc || this.dc.readyState !== "open")
+            return;
+        const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+        if (4 + msg.data.length > MAX_MESSAGE_SIZE)
+            return;
+        const header = new Uint8Array(4);
+        header[0] = (msg.type >> 8) & 0xFF;
+        header[1] = msg.type & 0xFF;
+        header[2] = msg.channel;
+        header[3] = (msg.reliable ? 1 : 0) | (msg.ordered ? 2 : 0);
+        const buf = new Uint8Array(4 + msg.data.length);
+        buf.set(header, 0);
+        buf.set(msg.data, 4);
+        this.dc.send(buf);
+    }
+    onMessage(handler) {
+        this.msgHandlers.push(handler);
+    }
+    onConnect(handler) {
+        this.connectHandlers.push(handler);
+    }
+    onDisconnect(handler) {
+        this.disconnectHandlers.push(handler);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getRTT() {
+        return this.rtt;
+    }
+    getPacketLoss() {
+        return this.packetLoss;
+    }
+    startPing() {
+        this.pingInterval = setInterval(() => {
+            if (!this.connected || !this.dc || this.dc.readyState !== "open")
+                return;
+            this.lastPing = performance.now();
+            const ping = new Uint8Array(4);
+            ping[0] = 0xFF;
+            ping[1] = 0xFF;
+            this.dc.send(ping);
+        }, 1000);
+    }
+    stopPing() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+}
+export function createWebRTCTransport(signaling) {
+    return new WebRTCTransport(signaling);
+}

package/dist/libraries/pathfinding-2d/src/astar-grid.js

@@ -0,0 +1,255 @@
+// ============================================================================
+// A* grid pathfinder — weighted multi-goal search over a 2D cell grid
+//
+// Extracted from overburden's grid-movement pathfinder: the generic machinery
+// (binary min-heap, visited/gScore/cameFrom arrays, multi-goal A* loop, path
+// reconstruction, adjacent-goal enumeration, cylinder wrap on X) lives here;
+// the game supplies movement grading via `gradeMove` and optional extra
+// neighbor expansion via `expandExtra`.
+//
+// Pure + synchronous + worker-agnostic: zero-alloc hot path (all scratch
+// arrays are per-instance typed arrays), safe to call from a dedicated
+// worker reading a SharedArrayBuffer-backed grid.
+// ============================================================================
+export function createAStarGrid(config) {
+    const W = config.width;
+    const H = config.height;
+    const defaultWrap = config.wrap ?? false;
+    const MAX_NODES = config.maxNodes ?? 4096;
+    // Per-search wrap flag — set at the top of each findPath* call.
+    let wrap = defaultWrap;
+    const gradeMove = config.gradeMove;
+    const expandExtra = config.expandExtra;
+    // ---------------------------------------------------------------------------
+    // Binary heap (min-heap by fScore), 1-indexed.
+    // ---------------------------------------------------------------------------
+    const heapData = new Int32Array(MAX_NODES + 1);
+    const heapFScore = new Float32Array(MAX_NODES + 1);
+    let heapSize = 0;
+    function heapPush(cellIdx, fScore) {
+        if (heapSize >= MAX_NODES)
+            return false;
+        heapSize++;
+        let i = heapSize;
+        heapData[i] = cellIdx;
+        heapFScore[i] = fScore;
+        while (i > 1) {
+            const parent = i >> 1;
+            if (heapFScore[parent] <= heapFScore[i])
+                break;
+            const td = heapData[parent];
+            heapData[parent] = heapData[i];
+            heapData[i] = td;
+            const tf = heapFScore[parent];
+            heapFScore[parent] = heapFScore[i];
+            heapFScore[i] = tf;
+            i = parent;
+        }
+        return true;
+    }
+    function heapPop() {
+        if (heapSize === 0)
+            return -1;
+        const result = heapData[1];
+        heapData[1] = heapData[heapSize];
+        heapFScore[1] = heapFScore[heapSize];
+        heapSize--;
+        let i = 1;
+        while (true) {
+            let min = i;
+            const left = i << 1;
+            const right = left + 1;
+            if (left <= heapSize && heapFScore[left] < heapFScore[min])
+                min = left;
+            if (right <= heapSize && heapFScore[right] < heapFScore[min])
+                min = right;
+            if (min === i)
+                break;
+            const td = heapData[min];
+            heapData[min] = heapData[i];
+            heapData[i] = td;
+            const tf = heapFScore[min];
+            heapFScore[min] = heapFScore[i];
+            heapFScore[i] = tf;
+            i = min;
+        }
+        return result;
+    }
+    // ---------------------------------------------------------------------------
+    // Visited tracking
+    // ---------------------------------------------------------------------------
+    const cameFrom = new Int32Array(W * H);
+    const gScore = new Float32Array(W * H);
+    const closed = new Uint8Array(W * H);
+    function heuristic(ax, ay, bx, by) {
+        const dy = Math.abs(ay - by);
+        let dx = Math.abs(ax - bx);
+        if (wrap)
+            dx = Math.min(dx, W - dx);
+        return dx + dy;
+    }
+    function minHeuristic(x, y, goals) {
+        let min = Infinity;
+        goals.forEach((g) => {
+            const h = heuristic(x, y, g.x, g.y);
+            if (h < min)
+                min = h;
+        });
+        return min;
+    }
+    function reconstructPath(goalIdx, sx, sy) {
+        const path = [];
+        let current = goalIdx;
+        while (current >= 0) {
+            const cx = current % W;
+            const cy = Math.floor(current / W);
+            path.push({ x: cx, y: cy });
+            if (current === sy * W + sx)
+                break;
+            current = cameFrom[current];
+        }
+        path.reverse();
+        if (path.length > 0 && path[0].x === sx && path[0].y === sy) {
+            path.shift();
+        }
+        return path;
+    }
+    function expandNeighbor(cx, cy, nx, ny, currentIdx, currentG, goalCoords) {
+        const graded = gradeMove(cx, cy, nx, ny);
+        if (!graded)
+            return;
+        const nIdx = graded.ny * W + graded.nx;
+        if (closed[nIdx])
+            return;
+        const tentativeG = currentG + graded.cost;
+        if (tentativeG < gScore[nIdx]) {
+            gScore[nIdx] = tentativeG;
+            cameFrom[nIdx] = currentIdx;
+            const f = tentativeG + minHeuristic(graded.nx, graded.ny, goalCoords);
+            heapPush(nIdx, f);
+        }
+    }
+    function findPathMultiGoal(sx, sy, goalSet, goalCoords) {
+        const startIdx = sy * W + sx;
+        if (goalSet.has(startIdx))
+            return [];
+        cameFrom.fill(-1);
+        closed.fill(0);
+        gScore.fill(Infinity);
+        heapSize = 0;
+        let nodesExpanded = 0;
+        gScore[startIdx] = 0;
+        if (!heapPush(startIdx, minHeuristic(sx, sy, goalCoords)))
+            return null;
+        while (heapSize > 0) {
+            const current = heapPop();
+            if (current < 0)
+                break;
+            if (goalSet.has(current)) {
+                return reconstructPath(current, sx, sy);
+            }
+            if (closed[current])
+                continue;
+            closed[current] = 1;
+            nodesExpanded++;
+            if (nodesExpanded > MAX_NODES)
+                return null;
+            const cx = current % W;
+            const cy = Math.floor(current / W);
+            const currentG = gScore[current];
+            // 4-directional expansion (left, right, up, down).
+            let nx = cx - 1;
+            if (nx < 0)
+                nx = wrap ? W - 1 : -1;
+            if (nx >= 0)
+                expandNeighbor(cx, cy, nx, cy, current, currentG, goalCoords);
+            nx = cx + 1;
+            if (nx >= W)
+                nx = wrap ? 0 : -1;
+            if (nx >= 0)
+                expandNeighbor(cx, cy, nx, cy, current, currentG, goalCoords);
+            if (cy - 1 >= 0)
+                expandNeighbor(cx, cy, cx, cy - 1, current, currentG, goalCoords);
+            if (cy + 1 < H)
+                expandNeighbor(cx, cy, cx, cy + 1, current, currentG, goalCoords);
+            // Game-specific extra moves (jumps, diagonal climbs, teleports...).
+            expandExtra?.(cx, cy, (nx2, ny2, cost, mode) => {
+                if (nx2 < 0 || nx2 >= W || ny2 < 0 || ny2 >= H)
+                    return;
+                const nIdx = ny2 * W + nx2;
+                if (closed[nIdx])
+                    return;
+                const tentativeG = currentG + cost;
+                if (tentativeG < gScore[nIdx]) {
+                    gScore[nIdx] = tentativeG;
+                    cameFrom[nIdx] = current;
+                    const f = tentativeG + minHeuristic(nx2, ny2, goalCoords);
+                    heapPush(nIdx, f);
+                }
+            });
+        }
+        return null;
+    }
+    function clampX(x) {
+        return Math.max(0, Math.min(W - 1, x));
+    }
+    function clampY(y) {
+        return Math.max(0, Math.min(H - 1, y));
+    }
+    return {
+        findPath(sx, sy, gx, gy, wrapOverride) {
+            wrap = wrapOverride ?? defaultWrap;
+            const cSx = clampX(sx), cSy = clampY(sy), cGx = clampX(gx), cGy = clampY(gy);
+            if (cSx === cGx && cSy === cGy)
+                return [];
+            return findPathMultiGoal(cSx, cSy, new Set([cGy * W + cGx]), [{ x: cGx, y: cGy }]);
+        },
+        findPathToGoals(sx, sy, goals, wrapOverride) {
+            wrap = wrapOverride ?? defaultWrap;
+            const cSx = clampX(sx), cSy = clampY(sy);
+            const goalSet = new Set();
+            const goalCoords = [];
+            goals.forEach((g) => {
+                const gx = clampX(g.x), gy = clampY(g.y);
+                const idx = gy * W + gx;
+                if (!goalSet.has(idx)) {
+                    goalSet.add(idx);
+                    goalCoords.push({ x: gx, y: gy });
+                }
+            });
+            if (goalSet.size === 0)
+                return null;
+            return findPathMultiGoal(cSx, cSy, goalSet, goalCoords);
+        },
+        findPathToAdjacent(sx, sy, tx, ty, isValidGoal, wrapOverride) {
+            wrap = wrapOverride ?? defaultWrap;
+            const cSx = clampX(sx), cSy = clampY(sy);
+            const cTx = clampX(tx), cTy = clampY(ty);
+            const goalSet = new Set();
+            const goalCoords = [];
+            const add = (cx, cy) => {
+                if (cx < 0 || cx >= W || cy < 0 || cy >= H)
+                    return;
+                if (isValidGoal && !isValidGoal(cx, cy))
+                    return;
+                const idx = cy * W + cx;
+                if (!goalSet.has(idx)) {
+                    goalSet.add(idx);
+                    goalCoords.push({ x: cx, y: cy });
+                }
+            };
+            add(cTx, cTy);
+            add(cTx - 1, cTy);
+            add(cTx + 1, cTy);
+            add(cTx, cTy - 1);
+            add(cTx, cTy + 1);
+            add(cTx - 1, cTy - 1);
+            add(cTx + 1, cTy - 1);
+            add(cTx - 1, cTy + 1);
+            add(cTx + 1, cTy + 1);
+            if (goalSet.size === 0)
+                return null;
+            return findPathMultiGoal(cSx, cSy, goalSet, goalCoords);
+        },
+    };
+}

package/dist/libraries/pathfinding-2d/src/index.js

@@ -0,0 +1,9 @@
+// ============================================================================
+// @downdraft/engine/libraries/pathfinding-2d — weighted multi-goal A* over a 2D grid
+//
+// Generic A* machinery (binary heap, visited arrays, multi-goal search,
+// adjacent-goal enumeration, X-axis cylinder wrap). The game supplies move
+// grading via `gradeMove` (walkability, support, gravity modeling, per-mode
+// costs) and optional `expandExtra` for non-cardinal moves like jumps.
+// ============================================================================
+export { createAStarGrid } from "./astar-grid.js";