@downdraft/engine 0.1.1 → 0.1.2-alpha.5

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

@@ -0,0 +1,314 @@
+// ============================================================================
+// discovery.ts — LAN service/session discovery.
+//
+// Two complementary mechanisms:
+//
+//   LanDiscovery — DownDraft-native beacon: JSON announce/query packets on
+//   a UDP multicast group. Games advertise a session, joiners browse.
+//   Zero external interop; both ends run this code.
+//
+//   MdnsBrowser — real mDNS/DNS-SD browse (PTR query → SRV/TXT/A via
+//   dns-packet). For finding foreign services on the LAN — media servers,
+//   Ember instances, printers, `services.google.com` cast targets, etc.
+//
+// Both use node:dgram (works on Node/Bun; Deno via node compat). When UDP
+// is unavailable (sandboxed contexts) `create()` returns null — degrade to
+// manual address entry.
+// ============================================================================
+// ── shared helpers ──
+async function loadDgram() {
+    try {
+        return await import("node:dgram");
+    }
+    catch {
+        return null;
+    }
+}
+function openSocket(dgram, port, group, onMsg) {
+    return new Promise((resolve, reject) => {
+        const s = dgram.createSocket({ type: "udp4", reuseAddr: true });
+        s.on("error", reject);
+        s.on("message", (buf, rinfo) => {
+            try {
+                onMsg(buf, rinfo);
+            }
+            catch { /* malformed packet */ }
+        });
+        s.bind(port, () => {
+            s.off("error", reject);
+            try {
+                if (group)
+                    s.addMembership(group);
+                s.setMulticastTTL(4);
+                resolve(s);
+            }
+            catch (e) {
+                s.close();
+                reject(e);
+            }
+        });
+    });
+}
+/**
+ * UDP-multicast session directory. `advertise()` announces a session on a
+ * timer; `browse()` lists live peers. A listener also answers `query`
+ * packets so new joiners populate instantly instead of waiting a cycle.
+ */
+export class LanDiscovery {
+    sock;
+    opts;
+    me = null;
+    peers = new Map();
+    timer = null;
+    listeners = {
+        join: new Set(),
+        leave: new Set(),
+        update: new Set(),
+    };
+    constructor(sock, opts) {
+        this.sock = sock;
+        this.opts = {
+            group: opts.group ?? "239.255.77.77",
+            port: opts.port ?? 47777,
+            intervalMs: opts.intervalMs ?? 1200,
+            ttlMs: opts.ttlMs ?? 5000,
+            now: opts.now ?? (() => Date.now()),
+        };
+    }
+    /** Open the multicast socket; null when UDP is unavailable. */
+    static async create(opts = {}) {
+        const dgram = await loadDgram();
+        if (!dgram)
+            return null;
+        const port = opts.port ?? 47777;
+        const group = opts.group ?? "239.255.77.77";
+        let inst = null;
+        try {
+            const sock = await openSocket(dgram, port, group, (buf, rinfo) => inst?.onPacket(buf, rinfo));
+            inst = new LanDiscovery(sock, opts);
+            inst.query(); // ask current advertisers to re-announce immediately
+            return inst;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Start announcing this session; call again to update fields. */
+    advertise(b) {
+        this.me = { v: 1, t: "beacon", ...b };
+        if (!this.timer) {
+            this.timer = setInterval(() => this.tick(), this.opts.intervalMs);
+        }
+        this.sendBeacon();
+    }
+    stopAdvertising() {
+        this.me = null;
+    }
+    /** Live peer table (excluding self), freshest first. */
+    browse() {
+        this.expire();
+        return [...this.peers.values()].sort((a, b) => b.lastSeenMs - a.lastSeenMs);
+    }
+    onJoin(fn) { this.listeners.join.add(fn); return () => this.listeners.join.delete(fn); }
+    onLeave(fn) { this.listeners.leave.add(fn); return () => this.listeners.leave.delete(fn); }
+    onUpdate(fn) { this.listeners.update.add(fn); return () => this.listeners.update.delete(fn); }
+    /** Manual expiry pass — called internally; exposed for manual pumps/tests. */
+    tick() {
+        this.expire();
+        this.sendBeacon();
+    }
+    dispose() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        try {
+            this.sock.close();
+        }
+        catch { /* already closed */ }
+    }
+    sendBeacon() {
+        if (!this.me)
+            return;
+        this.send({ ...this.me, t: "beacon" });
+    }
+    query() {
+        const me = this.me;
+        this.send({ v: 1, t: "query", app: me?.app ?? "*", id: me?.id ?? "", name: "", port: 0 });
+    }
+    send(pkt) {
+        try {
+            const buf = Buffer.from(JSON.stringify(pkt));
+            this.sock.send(buf, this.opts.port, this.opts.group);
+        }
+        catch { /* send failure is transient */ }
+    }
+    onPacket(buf, rinfo) {
+        let pkt;
+        try {
+            pkt = JSON.parse(buf.toString("utf8"));
+        }
+        catch {
+            return;
+        }
+        if (pkt.v !== 1 || !pkt.app)
+            return;
+        if (pkt.t === "query") {
+            if (this.me && (pkt.app === "*" || pkt.app === this.me.app))
+                this.sendBeacon();
+            return;
+        }
+        if (pkt.t !== "beacon" || !pkt.id)
+            return;
+        if (this.me && pkt.id === this.me.id)
+            return; // ignore self
+        const existing = this.peers.get(pkt.id);
+        const peer = { ...pkt, host: rinfo.address, lastSeenMs: this.opts.now() };
+        this.peers.set(pkt.id, peer);
+        if (!existing)
+            for (const f of this.listeners.join)
+                f(peer);
+        else if (existing.name !== peer.name || existing.port !== peer.port
+            || JSON.stringify(existing.meta) !== JSON.stringify(peer.meta)) {
+            for (const f of this.listeners.update)
+                f(peer);
+        }
+    }
+    expire() {
+        const cutoff = this.opts.now() - this.opts.ttlMs;
+        for (const [id, p] of this.peers) {
+            if (p.lastSeenMs < cutoff) {
+                this.peers.delete(id);
+                for (const f of this.listeners.leave)
+                    f(p);
+            }
+        }
+    }
+}
+/**
+ * One-shot + repeating mDNS browser. `query("_smb._tcp.local")` sends a PTR
+ * question to 224.0.0.251:5353 and correlates SRV/TXT/A records into
+ * `services()`. Entries expire on their DNS TTL.
+ */
+export class MdnsBrowser {
+    sock;
+    dns;
+    opts;
+    table = new Map(); // key = `${name}.${type}`
+    timer = null;
+    watched = new Set();
+    constructor(sock, dns, opts) {
+        this.sock = sock;
+        this.dns = dns;
+        this.opts = { intervalMs: opts.intervalMs ?? 30000, now: opts.now ?? (() => Date.now()) };
+    }
+    /** null when UDP/dns-packet are unavailable. */
+    static async create(opts = {}) {
+        const [dgram, dns] = await Promise.all([
+            loadDgram(),
+            import("dns-packet").catch(() => null),
+        ]);
+        if (!dgram || !dns)
+            return null;
+        let inst = null;
+        try {
+            const sock = await openSocket(dgram, 5353, "224.0.0.251", (buf) => inst?.onPacket(buf));
+            inst = new MdnsBrowser(sock, dns, opts);
+            inst.timer = setInterval(() => inst.requery(), inst.opts.intervalMs);
+            return inst;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Subscribe a service type; sends an immediate PTR query. */
+    query(serviceType) {
+        const type = serviceType.endsWith(".local") ? serviceType : `${serviceType}.local`;
+        this.watched.add(type);
+        this.sendQuery(type);
+    }
+    requery() {
+        for (const t of this.watched)
+            this.sendQuery(t);
+        this.expire();
+    }
+    sendQuery(type) {
+        try {
+            const buf = this.dns.encode({
+                type: "query",
+                flags: 0, // standard query, no recursion — mDNS is multicast
+                questions: [{ type: "PTR", name: type }],
+            });
+            this.sock.send(buf, 5353, "224.0.0.251");
+        }
+        catch { /* transient */ }
+    }
+    services() {
+        this.expire();
+        return [...this.table.values()];
+    }
+    dispose() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        try {
+            this.sock.close();
+        }
+        catch { /* closed */ }
+    }
+    expire() {
+        const now = this.opts.now();
+        for (const [k, s] of this.table) {
+            if (s.lastSeenMs + s.ttlMs < now)
+                this.table.delete(k);
+        }
+    }
+    /** Correlate PTR/SRV/TXT/A records into the service table. */
+    onPacket(buf) {
+        let pkt;
+        try {
+            pkt = this.dns.decode(buf);
+        }
+        catch {
+            return;
+        }
+        // Records that carry data (PTR/SRV/TXT/A) — OPT pseudo-records excluded.
+        const recs = [...(pkt.answers ?? []), ...(pkt.additionals ?? [])]
+            .filter((r) => "data" in r);
+        const now = this.opts.now();
+        // PTR gives instance names; SRV/TXT/A for the same instance fill detail.
+        for (const r of recs) {
+            if (r.type !== "PTR" || !this.watched.has(r.name))
+                continue;
+            const instance = r.data;
+            const key = `${instance}@${r.name}`;
+            const srv = recs.find((x) => x.type === "SRV" && x.name === instance);
+            const txt = recs.find((x) => x.type === "TXT" && x.name === instance);
+            const host = srv ? srv.data.target : "";
+            const addresses = recs
+                .filter((x) => x.type === "A" && x.name === host)
+                .map((x) => x.data);
+            const ttlMin = Math.min(...(recs.filter((x) => x.name === instance || x.name === r.name || x.name === host)
+                .map((x) => x.ttl ?? 120)));
+            const txtMap = {};
+            if (txt) {
+                for (const item of txt.data) {
+                    const s = item.toString("utf8");
+                    const eq = s.indexOf("=");
+                    txtMap[eq < 0 ? s : s.slice(0, eq)] = eq < 0 ? "" : s.slice(eq + 1);
+                }
+            }
+            const prev = this.table.get(key);
+            this.table.set(key, {
+                name: instance.replace(new RegExp(`\\.${r.name.replace(/\./g, "\\.")}$`), ""),
+                type: r.name,
+                host,
+                port: srv ? srv.data.port : 0,
+                addresses,
+                txt: txtMap,
+                ttlMs: (ttlMin === Infinity ? 120 : ttlMin) * 1000,
+                lastSeenMs: now,
+            });
+            void prev;
+        }
+    }
+}

package/dist/libraries/networking/src/enhanced-replication.js

@@ -0,0 +1,282 @@
+export class DeltaEncoder {
+    previousData = new Map();
+    previousTick = 0;
+    encodeDelta(snapshot, componentDefs) {
+        const entities = [];
+        snapshot.entities.forEach((entity) => {
+            const prevEntity = this.previousData.get(entity.entityId);
+            const changedComponents = [];
+            for (let _i = 0, _it = entity.components, _n = _it.length; _i < _n; _i++) {
+                const comp = _it[_i];
+                const compDef = componentDefs.get(comp.componentId);
+                if (!compDef)
+                    continue;
+                const prevComp = prevEntity?.get(comp.componentId);
+                const fieldMask = new Uint8Array(Math.ceil(compDef.fields.length / 8));
+                const changedFields = [];
+                let anyChanged = false;
+                if (!prevComp) {
+                    for (let i = 0; i < compDef.fields.length; i++) {
+                        fieldMask[Math.floor(i / 8)] |= (1 << (i % 8));
+                        anyChanged = true;
+                    }
+                    changedFields.push(comp.data);
+                }
+                else {
+                    const fieldSize = this.getFieldSizes(compDef.fields);
+                    let dataOffset = 0;
+                    for (let i = 0; i < compDef.fields.length; i++) {
+                        const size = fieldSize[i];
+                        const oldSlice = prevComp.slice(dataOffset, dataOffset + size);
+                        const newSlice = comp.data.slice(dataOffset, dataOffset + size);
+                        let changed = false;
+                        for (let b = 0; b < size; b++) {
+                            if (oldSlice[b] !== newSlice[b]) {
+                                changed = true;
+                                break;
+                            }
+                        }
+                        if (changed) {
+                            fieldMask[Math.floor(i / 8)] |= (1 << (i % 8));
+                            changedFields.push(newSlice);
+                            anyChanged = true;
+                        }
+                        dataOffset += size;
+                    }
+                }
+                if (anyChanged) {
+                    const totalSize = changedFields.reduce((s, f) => s + f.length, 0);
+                    const merged = new Uint8Array(totalSize);
+                    let off = 0;
+                    changedFields.forEach((f) => {
+                        merged.set(f, off);
+                        off += f.length;
+                    });
+                    changedComponents.push({ componentId: comp.componentId, fieldMask, data: merged });
+                }
+            }
+            if (changedComponents.length > 0) {
+                entities.push({ entityId: entity.entityId, changedComponents });
+            }
+        });
+        const delta = {
+            tick: snapshot.tick,
+            baseTick: this.previousTick,
+            entities,
+        };
+        snapshot.entities.forEach((entity) => {
+            if (!this.previousData.has(entity.entityId)) {
+                this.previousData.set(entity.entityId, new Map());
+            }
+            entity.components.forEach((comp) => {
+                this.previousData.get(entity.entityId).set(comp.componentId, comp.data);
+            });
+        });
+        this.previousTick = snapshot.tick;
+        return delta;
+    }
+    reset() {
+        this.previousData.clear();
+        this.previousTick = 0;
+    }
+    fieldSizesCache = new Map();
+    getFieldSizes(fields) {
+        return fields.map((f) => this.getFieldSize(f.type));
+    }
+    getFieldSize(type) {
+        const cached = this.fieldSizesCache.get(type);
+        if (cached !== undefined)
+            return cached;
+        const size = (() => {
+            switch (type) {
+                case "float32": return 4;
+                case "float64": return 8;
+                case "uint8": return 1;
+                case "uint16": return 2;
+                case "uint32": return 4;
+                case "int8": return 1;
+                case "int16": return 2;
+                case "int32": return 4;
+                case "boolean": return 1;
+                default: return 0;
+            }
+        })();
+        this.fieldSizesCache.set(type, size);
+        return size;
+    }
+}
+export class DeltaDecoder {
+    baseData = new Map();
+    decodeDelta(delta, componentDefs) {
+        const entities = [];
+        delta.entities.forEach((entity) => {
+            const components = [];
+            for (let _i = 0, _it = entity.changedComponents, _n = _it.length; _i < _n; _i++) {
+                const comp = _it[_i];
+                const compDef = componentDefs.get(comp.componentId);
+                if (!compDef)
+                    continue;
+                const baseComp = this.baseData.get(entity.entityId)?.get(comp.componentId);
+                const fieldSizes = compDef.fields.map((f) => this.getFieldSize(f.type));
+                const totalSize = fieldSizes.reduce((s, v) => s + v, 0);
+                const reconstructed = new Uint8Array(totalSize);
+                if (baseComp) {
+                    let baseOffset = 0;
+                    for (let i = 0; i < fieldSizes.length; i++) {
+                        const size = fieldSizes[i];
+                        if (comp.fieldMask[Math.floor(i / 8)] & (1 << (i % 8))) {
+                            // Field is in delta data — will be filled below
+                        }
+                        else {
+                            reconstructed.set(baseComp.slice(baseOffset, baseOffset + size), baseOffset);
+                        }
+                        baseOffset += size;
+                    }
+                }
+                let deltaOffset = 0;
+                let baseOffset = 0;
+                for (let i = 0; i < fieldSizes.length; i++) {
+                    const size = fieldSizes[i];
+                    if (comp.fieldMask[Math.floor(i / 8)] & (1 << (i % 8))) {
+                        reconstructed.set(comp.data.slice(deltaOffset, deltaOffset + size), baseOffset);
+                        deltaOffset += size;
+                    }
+                    baseOffset += size;
+                }
+                components.push({ componentId: comp.componentId, data: reconstructed });
+                if (!this.baseData.has(entity.entityId)) {
+                    this.baseData.set(entity.entityId, new Map());
+                }
+                this.baseData.get(entity.entityId).set(comp.componentId, reconstructed);
+            }
+            if (components.length > 0) {
+                entities.push({ entityId: entity.entityId, components });
+            }
+        });
+        return { tick: delta.tick, entities };
+    }
+    fieldSizesCache = new Map();
+    getFieldSize(type) {
+        const cached = this.fieldSizesCache.get(type);
+        if (cached !== undefined)
+            return cached;
+        const size = (() => {
+            switch (type) {
+                case "float32": return 4;
+                case "float64": return 8;
+                case "uint8": return 1;
+                case "uint16": return 2;
+                case "uint32": return 4;
+                case "int8": return 1;
+                case "int16": return 2;
+                case "int32": return 4;
+                case "boolean": return 1;
+                default: return 0;
+            }
+        })();
+        this.fieldSizesCache.set(type, size);
+        return size;
+    }
+}
+export class InterestManager {
+    areas = new Map();
+    entityPositions = new Map();
+    static MAX_ENTITY_POSITIONS = 10000;
+    setArea(peerId, area) {
+        this.areas.set(peerId, area);
+    }
+    removeArea(peerId) {
+        this.areas.delete(peerId);
+    }
+    updateEntityPosition(entityId, x, y, z) {
+        // LRU eviction — delete oldest entry (first key) when at capacity.
+        if (!this.entityPositions.has(entityId) && this.entityPositions.size >= InterestManager.MAX_ENTITY_POSITIONS) {
+            const oldestKey = this.entityPositions.keys().next().value;
+            if (oldestKey !== undefined)
+                this.entityPositions.delete(oldestKey);
+        }
+        this.entityPositions.set(entityId, { entityId, x, y, z });
+    }
+    removeEntity(entityId) {
+        this.entityPositions.delete(entityId);
+    }
+    getRelevantEntities(peerId) {
+        const area = this.areas.get(peerId);
+        if (!area)
+            return [...this.entityPositions.keys()];
+        const relevant = [];
+        const radiusSq = area.radius * area.radius;
+        for (const [entityId, pos] of this.entityPositions.entries()) {
+            const dx = pos.x - area.centerX;
+            const dy = pos.y - area.centerY;
+            const dz = pos.z - area.centerZ;
+            const distSq = dx * dx + dy * dy + dz * dz;
+            if (distSq <= radiusSq) {
+                relevant.push(entityId);
+            }
+        }
+        return relevant;
+    }
+    filterSnapshot(snapshot, peerId) {
+        const relevant = new Set(this.getRelevantEntities(peerId));
+        return {
+            tick: snapshot.tick,
+            entities: snapshot.entities.filter((e) => relevant.has(e.entityId)),
+        };
+    }
+}
+export class InterpolationManager {
+    buffer = [];
+    maxBufferSize = 4;
+    renderTime = 0;
+    interpolationDelay = 0.1;
+    setInterpolationDelay(delay) {
+        this.interpolationDelay = delay;
+    }
+    addSnapshot(tick, data, timestamp) {
+        this.buffer.push({ tick, data, timestamp });
+        if (this.buffer.length > this.maxBufferSize) {
+            this.buffer.shift();
+        }
+    }
+    update(renderTime) {
+        this.renderTime = renderTime;
+    }
+    getInterpolatedState(entityId, componentId, fieldName) {
+        if (this.buffer.length < 2) {
+            const latest = this.buffer[this.buffer.length - 1];
+            return latest?.data.get(entityId)?.get(componentId)?.[fieldName] ?? null;
+        }
+        const targetTime = this.renderTime - this.interpolationDelay;
+        let prev = null;
+        let next = null;
+        for (let i = 0; i < this.buffer.length - 1; i++) {
+            if (this.buffer[i].timestamp <= targetTime && this.buffer[i + 1].timestamp >= targetTime) {
+                prev = this.buffer[i];
+                next = this.buffer[i + 1];
+                break;
+            }
+        }
+        if (!prev || !next) {
+            const latest = this.buffer[this.buffer.length - 1];
+            return latest?.data.get(entityId)?.get(componentId)?.[fieldName] ?? null;
+        }
+        const prevVal = prev.data.get(entityId)?.get(componentId)?.[fieldName];
+        const nextVal = next.data.get(entityId)?.get(componentId)?.[fieldName];
+        if (prevVal === undefined || nextVal === undefined)
+            return null;
+        if (typeof prevVal !== "number" || typeof nextVal !== "number")
+            return nextVal;
+        const timeRange = next.timestamp - prev.timestamp;
+        if (timeRange === 0)
+            return nextVal;
+        const alpha = (targetTime - prev.timestamp) / timeRange;
+        return prevVal + (nextVal - prevVal) * Math.max(0, Math.min(1, alpha));
+    }
+    getBufferSize() {
+        return this.buffer.length;
+    }
+    clear() {
+        this.buffer = [];
+    }
+}

package/dist/libraries/networking/src/epic-adapter.js

@@ -0,0 +1,101 @@
+export class EpicEOSAdapter {
+    platformId = "epic";
+    initialized = false;
+    localPlayer = null;
+    lobby = null;
+    connectionState = "disconnected";
+    config;
+    lobbyUpdateCbs = [];
+    peerMessageCbs = [];
+    peerConnectCbs = [];
+    peerDisconnectCbs = [];
+    richPresence = {};
+    constructor(config = {}) {
+        this.config = {
+            clientId: config.clientId ?? "",
+            clientSecret: config.clientSecret ?? "",
+            deploymentId: config.deploymentId ?? "",
+            sandboxId: config.sandboxId ?? "",
+        };
+    }
+    async init() {
+        if (!this.config.clientId) {
+            throw new Error("EpicEOSAdapter requires clientId");
+        }
+        this.initialized = true;
+        this.localPlayer = {
+            platformId: "epic",
+            platformPlayerId: "epic-local-stub",
+            displayName: "EpicPlayer",
+        };
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    async shutdown() {
+        this.initialized = false;
+        this.localPlayer = null;
+        this.lobby = null;
+        this.connectionState = "disconnected";
+    }
+    getLocalPlayer() {
+        return this.localPlayer;
+    }
+    async createLobby(config) {
+        this.lobby = {
+            lobbyId: `epic-lobby-${Date.now()}`,
+            ownerId: this.localPlayer?.platformPlayerId ?? "unknown",
+            members: this.localPlayer ? [this.localPlayer] : [],
+            maxMembers: config.maxPlayers,
+            metadata: { ...config.metadata },
+        };
+        this.connectionState = "connected";
+        return this.lobby;
+    }
+    async joinLobby(lobbyId) {
+        this.lobby = {
+            lobbyId,
+            ownerId: "epic-host",
+            members: this.localPlayer ? [this.localPlayer] : [],
+            maxMembers: 8,
+            metadata: {},
+        };
+        this.connectionState = "connected";
+        return this.lobby;
+    }
+    async leaveLobby() {
+        this.lobby = null;
+        this.connectionState = "disconnected";
+    }
+    getLobby() {
+        return this.lobby;
+    }
+    onLobbyUpdate(cb) {
+        this.lobbyUpdateCbs.push(cb);
+    }
+    sendToPeer(_peerId, _data, _reliable) { }
+    onPeerMessage(cb) {
+        this.peerMessageCbs.push(cb);
+    }
+    onPeerConnect(cb) {
+        this.peerConnectCbs.push(cb);
+    }
+    onPeerDisconnect(cb) {
+        this.peerDisconnectCbs.push(cb);
+    }
+    getConnectionState() {
+        return this.connectionState;
+    }
+    getRTT(_peerId) {
+        return 0;
+    }
+    setRichPresence(key, value) {
+        this.richPresence[key] = value;
+    }
+    clearRichPresence() {
+        this.richPresence = {};
+    }
+}
+export function createEpicEOSAdapter(config) {
+    return new EpicEOSAdapter(config);
+}