@downdraft/engine 0.1.1 → 0.2.0

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

@@ -0,0 +1,16 @@
+export { ReplicationManager } from "./replication.js";
+export { RPCManager } from "./rpc.js";
+export { createTransport, MockTransport, WebSocketTransport } from "./transport.js";
+export { createWebRTCTransport, isValidIceCandidate, WebRTCTransport, WebSocketSignalingClient } from "./webrtc.js";
+export { createMockPlatformAdapter, MockPlatformAdapter } from "./platform-adapter.js";
+export { SessionManager } from "./session.js";
+export { LobbyManager } from "./lobby.js";
+export { ConnectionManager } from "./connection.js";
+export { REMOTE_INPUT_MSG_TYPE, RemoteInputBridge } from "./remote-input.js";
+export { createEpicEOSAdapter, EpicEOSAdapter } from "./epic-adapter.js";
+export { createRCSAdapter, RCSAdapter } from "./rcs-adapter.js";
+export { DeltaDecoder, DeltaEncoder, InterestManager, InterpolationManager } from "./enhanced-replication.js";
+export { AuthorityManager } from "./authority.js";
+// Engine library descriptor (declarative GameModule wiring)
+export { NetworkClientTok, NetworkingLib } from "./library.js";
+export { LanDiscovery, MdnsBrowser } from "./discovery.js";

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

@@ -0,0 +1,45 @@
+// ============================================================================
+// NetworkingLib — declarative engine library descriptor for @downdraft/engine/libraries/networking
+//
+// Games declare `libraries: [NetworkingLib]` (or with config override) in their
+// GameModule. The host creates the ConnectionManager (sim-side only — networking
+// state is simulated on the sim thread) and exposes it via the NetworkClientTok
+// typed token.
+//
+// The platform adapter (Epic EOS, RCS, Mock, etc.) is game-specific, so games
+// pass it via the config. Games that need full control can still import
+// ConnectionManager / SessionManager / ReplicationManager directly (escape hatch).
+// ============================================================================
+import { resourceToken } from "@downdraft/engine";
+import { ConnectionManager } from "./connection.js";
+// ── Typed tokens (DI) ──
+/** Token for the sim-side connection manager. Inject in sim systems that send/receive net messages. */
+export const NetworkClientTok = resourceToken("networking:client");
+// ── Descriptor ──
+export const NetworkingLib = {
+    name: "networking",
+    version: "1.0.0",
+    // No SAB channels — networking state lives in-process on the sim thread;
+    // replication snapshots are synced via the main SimBuffer or RPC events.
+    sabChannels: [],
+    provides: [NetworkClientTok],
+    sim: {
+        create(config, ctx) {
+            const client = new ConnectionManager(config.platform, config.transport);
+            ctx.provide(NetworkClientTok, client);
+            return client;
+        },
+        dispose(client) {
+            // ConnectionManager has no destroy() — disconnectAll() tears down peers.
+            client.disconnectAll();
+        },
+        // tick is game-specific (calls client.updatePeerRTTs(), processes
+        // replication snapshots, dispatches RPCs, etc.) — games wire this via
+        // onReady or a sim system.
+    },
+    tickPhase: "pre-physics",
+    // No renderer setup — networking is entirely sim-side.
+    defaultConfig: {
+        maxReconnectAttempts: 5,
+    },
+};

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

@@ -0,0 +1,84 @@
+export class LobbyManager {
+    platform;
+    state = "idle";
+    lobby = null;
+    config;
+    stateChangeCbs = [];
+    memberChangeCbs = [];
+    constructor(platform, config = {}) {
+        this.platform = platform;
+        this.config = {
+            maxPlayers: config.maxPlayers ?? 8,
+            publicLobby: config.publicLobby ?? true,
+            metadata: config.metadata ?? {},
+        };
+    }
+    async create() {
+        this.setState("creating");
+        this.lobby = await this.platform.createLobby({
+            maxPlayers: this.config.maxPlayers,
+            isHost: true,
+            metadata: this.config.metadata,
+        });
+        this.setState("waiting");
+        return this.lobby;
+    }
+    async join(lobbyId) {
+        this.setState("joining");
+        this.lobby = await this.platform.joinLobby(lobbyId);
+        this.setState("active");
+        return this.lobby;
+    }
+    async leave() {
+        await this.platform.leaveLobby();
+        this.lobby = null;
+        this.setState("closed");
+    }
+    startGame() {
+        if (this.state === "waiting" || this.state === "active") {
+            this.setState("active");
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    getLobby() {
+        return this.lobby;
+    }
+    getMembers() {
+        return this.lobby?.members ?? [];
+    }
+    isFull() {
+        if (!this.lobby)
+            return false;
+        return this.lobby.members.length >= this.lobby.maxMembers;
+    }
+    isEmpty() {
+        if (!this.lobby)
+            return true;
+        return this.lobby.members.length === 0;
+    }
+    getMemberCount() {
+        return this.lobby?.members.length ?? 0;
+    }
+    getMaxMembers() {
+        return this.lobby?.maxMembers ?? this.config.maxPlayers;
+    }
+    setMetadata(key, value) {
+        this.config.metadata[key] = value;
+    }
+    onStateChange(cb) {
+        this.stateChangeCbs.push(cb);
+    }
+    onMemberChange(cb) {
+        this.memberChangeCbs.push(cb);
+        this.platform.onLobbyUpdate((lobby) => {
+            this.lobby = lobby;
+            this.memberChangeCbs.forEach((c) => c(lobby.members));
+        });
+    }
+    setState(state) {
+        this.state = state;
+        this.stateChangeCbs.forEach((cb) => cb(state));
+    }
+}

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

@@ -0,0 +1,92 @@
+export class MockPlatformAdapter {
+    platformId = "mock";
+    initialized = false;
+    localPlayer = null;
+    lobby = null;
+    connectionState = "disconnected";
+    lobbyUpdateCbs = [];
+    peerMessageCbs = [];
+    peerConnectCbs = [];
+    peerDisconnectCbs = [];
+    richPresence = {};
+    async init() {
+        this.initialized = true;
+        this.localPlayer = {
+            platformId: "mock",
+            platformPlayerId: "mock-local",
+            displayName: "MockPlayer",
+        };
+    }
+    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: `mock-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: "remote-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 = {};
+    }
+    getRichPresence() {
+        return this.richPresence;
+    }
+}
+export function createMockPlatformAdapter() {
+    return new MockPlatformAdapter();
+}

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

@@ -0,0 +1,100 @@
+export class RCSAdapter {
+    platformId = "rcs";
+    initialized = false;
+    localPlayer = null;
+    lobby = null;
+    connectionState = "disconnected";
+    config;
+    lobbyUpdateCbs = [];
+    peerMessageCbs = [];
+    peerConnectCbs = [];
+    peerDisconnectCbs = [];
+    richPresence = {};
+    constructor(config = {}) {
+        this.config = {
+            apiKey: config.apiKey ?? "",
+            projectId: config.projectId ?? "",
+            region: config.region ?? "us-east-1",
+        };
+    }
+    async init() {
+        if (!this.config.apiKey) {
+            throw new Error("RCSAdapter requires apiKey");
+        }
+        this.initialized = true;
+        this.localPlayer = {
+            platformId: "rcs",
+            platformPlayerId: "rcs-local-stub",
+            displayName: "RCSPlayer",
+        };
+    }
+    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: `rcs-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: "rcs-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 createRCSAdapter(config) {
+    return new RCSAdapter(config);
+}

package/dist/libraries/networking/src/remote-input.js

@@ -0,0 +1,162 @@
+export const REMOTE_INPUT_MSG_TYPE = 0x10;
+export class RemoteInputBridge {
+    writer;
+    platform;
+    slotMap = new Map();
+    nextSlot = 1;
+    maxSlots;
+    constructor(writer, platform, maxSlots = 8) {
+        this.writer = writer;
+        this.platform = platform;
+        this.maxSlots = maxSlots;
+        this.platform.onPeerMessage((peerId, data) => {
+            this.handleMessage(peerId, data);
+        });
+    }
+    assignSlot(peerId, slot) {
+        this.slotMap.set(peerId, slot);
+    }
+    assignNextSlot(peerId) {
+        const slot = this.nextSlot++;
+        if (slot >= this.maxSlots)
+            return -1;
+        this.slotMap.set(peerId, slot);
+        return slot;
+    }
+    getSlot(peerId) {
+        return this.slotMap.get(peerId);
+    }
+    removePeer(peerId) {
+        const slot = this.slotMap.get(peerId);
+        if (slot !== undefined) {
+            this.writer.clearPlayer(slot);
+        }
+        this.slotMap.delete(peerId);
+    }
+    sendLocalInput(peerIds, packet) {
+        const data = this.serializePacket(packet);
+        peerIds.forEach((peerId) => {
+            this.platform.sendToPeer(peerId, data, false);
+        });
+    }
+    handleMessage(peerId, data) {
+        if (data.length < 1)
+            return;
+        const msgType = data[0];
+        if (msgType !== REMOTE_INPUT_MSG_TYPE)
+            return;
+        const packet = this.deserializePacket(data);
+        if (!packet)
+            return;
+        let slot = this.slotMap.get(peerId);
+        if (slot === undefined) {
+            slot = this.assignNextSlot(peerId);
+            if (slot < 0)
+                return;
+        }
+        this.writer.writePlayerInput(slot, packet.keys, packet.mouseX, packet.mouseY, packet.mouseDeltaX, packet.mouseDeltaY, packet.mouseButtons, packet.wheelDelta, packet.gamepadButtons, packet.gamepadAxes);
+    }
+    serializePacket(packet) {
+        const keyCount = packet.keys.length;
+        const mbCount = packet.mouseButtons.length;
+        const gpBtnCount = packet.gamepadButtons.length;
+        const gpAxisCount = packet.gamepadAxes.length;
+        const headerSize = 1 + 1 + 2 + 4 * 6 + 1 + 1 + 1 + 1;
+        const keysSize = keyCount * 4;
+        const mbSize = mbCount * 4;
+        const gpBtnSize = gpBtnCount * 4;
+        const gpAxisSize = gpAxisCount * 4;
+        const total = headerSize + keysSize + mbSize + gpBtnSize + gpAxisSize;
+        const buf = new Uint8Array(total);
+        const dv = new DataView(buf.buffer);
+        let offset = 0;
+        buf[offset++] = REMOTE_INPUT_MSG_TYPE;
+        buf[offset++] = packet.playerSlot;
+        dv.setUint16(offset, keyCount);
+        offset += 2;
+        dv.setFloat32(offset, packet.mouseX);
+        offset += 4;
+        dv.setFloat32(offset, packet.mouseY);
+        offset += 4;
+        dv.setFloat32(offset, packet.mouseDeltaX);
+        offset += 4;
+        dv.setFloat32(offset, packet.mouseDeltaY);
+        offset += 4;
+        dv.setFloat32(offset, packet.wheelDelta);
+        offset += 4;
+        buf[offset++] = mbCount;
+        buf[offset++] = gpBtnCount;
+        buf[offset++] = gpAxisCount;
+        packet.keys.forEach((key) => {
+            dv.setUint32(offset, key);
+            offset += 4;
+        });
+        packet.mouseButtons.forEach((mb) => {
+            dv.setUint32(offset, mb);
+            offset += 4;
+        });
+        packet.gamepadButtons.forEach((btn) => {
+            dv.setUint32(offset, btn);
+            offset += 4;
+        });
+        packet.gamepadAxes.forEach((axis) => {
+            dv.setFloat32(offset, axis);
+            offset += 4;
+        });
+        return buf;
+    }
+    deserializePacket(data) {
+        if (data.length < 28)
+            return null;
+        const dv = new DataView(data.buffer, data.byteOffset);
+        let offset = 1;
+        const playerSlot = data[offset++];
+        const keyCount = dv.getUint16(offset);
+        offset += 2;
+        const mouseX = dv.getFloat32(offset);
+        offset += 4;
+        const mouseY = dv.getFloat32(offset);
+        offset += 4;
+        const mouseDeltaX = dv.getFloat32(offset);
+        offset += 4;
+        const mouseDeltaY = dv.getFloat32(offset);
+        offset += 4;
+        const wheelDelta = dv.getFloat32(offset);
+        offset += 4;
+        const mbCount = data[offset++];
+        const gpBtnCount = data[offset++];
+        const gpAxisCount = data[offset++];
+        const keys = [];
+        for (let i = 0; i < keyCount; i++) {
+            keys.push(dv.getUint32(offset));
+            offset += 4;
+        }
+        const mouseButtons = [];
+        for (let i = 0; i < mbCount; i++) {
+            mouseButtons.push(dv.getUint32(offset));
+            offset += 4;
+        }
+        const gamepadButtons = [];
+        for (let i = 0; i < gpBtnCount; i++) {
+            gamepadButtons.push(dv.getUint32(offset));
+            offset += 4;
+        }
+        const gamepadAxes = [];
+        for (let i = 0; i < gpAxisCount; i++) {
+            gamepadAxes.push(dv.getFloat32(offset));
+            offset += 4;
+        }
+        return {
+            playerSlot,
+            keys,
+            mouseX,
+            mouseY,
+            mouseDeltaX,
+            mouseDeltaY,
+            mouseButtons,
+            wheelDelta,
+            gamepadButtons,
+            gamepadAxes,
+        };
+    }
+}