@downdraft/engine 0.1.0 → 0.1.2-alpha.5

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

@@ -0,0 +1,273 @@
+import { RPCManager } from "./rpc.js";
+export class ReplicationManager {
+    transport;
+    config;
+    snapshots = new Map();
+    static MAX_SNAPSHOTS = 1024;
+    lastTick = 0;
+    tickAccumulator = 0;
+    isServer;
+    entityComponents = new Map();
+    rpc;
+    constructor(transport, isServer, config) {
+        this.transport = transport;
+        this.isServer = isServer;
+        this.config = {
+            tickRate: config?.tickRate ?? 20,
+            maxEntitiesPerPacket: config?.maxEntitiesPerPacket ?? 64,
+            components: config?.components ?? new Map(),
+        };
+        this.rpc = new RPCManager(transport, isServer);
+        this.transport.onMessage((msg) => this.handleMessage(msg));
+    }
+    registerComponent(componentId, fields, mode = "authoritative") {
+        this.config.components.set(componentId, { componentId, fields, mode });
+    }
+    trackEntity(entityId) {
+        this.entityComponents.set(entityId, new Map());
+    }
+    untrackEntity(entityId) {
+        this.entityComponents.delete(entityId);
+    }
+    updateEntityComponent(entityId, componentId, data) {
+        let entityMap = this.entityComponents.get(entityId);
+        if (!entityMap) {
+            entityMap = new Map();
+            this.entityComponents.set(entityId, entityMap);
+        }
+        entityMap.set(componentId, data);
+    }
+    update(dt) {
+        if (!this.isServer)
+            return;
+        this.tickAccumulator += dt;
+        const tickInterval = 1 / this.config.tickRate;
+        if (this.tickAccumulator >= tickInterval) {
+            this.tickAccumulator -= tickInterval;
+            this.lastTick++;
+            this.sendSnapshot();
+        }
+    }
+    sendSnapshot() {
+        const entities = [];
+        let count = 0;
+        for (const [entityId, components] of this.entityComponents.entries()) {
+            if (count >= this.config.maxEntitiesPerPacket)
+                break;
+            const componentData = [];
+            for (const [componentId, data] of components.entries()) {
+                const replComp = this.config.components.get(componentId);
+                if (!replComp)
+                    continue;
+                const serialized = this.serializeComponent(data, replComp.fields);
+                componentData.push({ componentId, data: serialized });
+            }
+            if (componentData.length > 0) {
+                entities.push({ entityId, components: componentData });
+                count++;
+            }
+        }
+        if (entities.length === 0)
+            return;
+        const snapshot = {
+            tick: this.lastTick,
+            entities,
+        };
+        const data = this.serializeSnapshot(snapshot);
+        this.transport.send({
+            type: 1, // SNAPSHOT
+            data,
+            reliable: false,
+            ordered: false,
+            channel: 0,
+        });
+    }
+    handleMessage(msg) {
+        if (msg.type === 1) {
+            // SNAPSHOT
+            if (this.isServer)
+                return;
+            const snapshot = this.deserializeSnapshot(msg.data);
+            // LRU eviction — delete oldest entry (first key) when at capacity.
+            if (this.snapshots.size >= ReplicationManager.MAX_SNAPSHOTS) {
+                const oldestKey = this.snapshots.keys().next().value;
+                if (oldestKey !== undefined)
+                    this.snapshots.delete(oldestKey);
+            }
+            this.snapshots.set(snapshot.tick, snapshot);
+            this.applySnapshot(snapshot);
+        }
+        // RPC messages (type 2) are handled by RPCManager directly
+    }
+    applySnapshot(snapshot) {
+        snapshot.entities.forEach((entity) => {
+            let entityMap = this.entityComponents.get(entity.entityId);
+            if (!entityMap) {
+                entityMap = new Map();
+                this.entityComponents.set(entity.entityId, entityMap);
+            }
+            for (let _i = 0, _it = entity.components, _n = _it.length; _i < _n; _i++) {
+                const comp = _it[_i];
+                const replComp = this.config.components.get(comp.componentId);
+                if (!replComp)
+                    continue;
+                const data = this.deserializeComponent(comp.data, replComp.fields);
+                entityMap.set(comp.componentId, data);
+            }
+        });
+    }
+    getEntityData(entityId, componentId) {
+        return this.entityComponents.get(entityId)?.get(componentId);
+    }
+    serializeComponent(data, fields) {
+        const buffers = [];
+        for (let _i = 0, _it = fields, _n = _it.length; _i < _n; _i++) {
+            const field = _it[_i];
+            const value = data[field.name];
+            if (value === undefined)
+                continue;
+            const buf = this.serializeField(value, field.type, field.precision);
+            buffers.push(buf);
+        }
+        const total = buffers.reduce((sum, b) => sum + b.length, 0);
+        const result = new Uint8Array(total);
+        let offset = 0;
+        buffers.forEach((buf) => {
+            result.set(buf, offset);
+            offset += buf.length;
+        });
+        return result;
+    }
+    deserializeComponent(data, fields) {
+        const result = {};
+        let offset = 0;
+        fields.forEach((field) => {
+            const { value, size } = this.deserializeField(data, offset, field.type);
+            result[field.name] = value;
+            offset += size;
+        });
+        return result;
+    }
+    serializeField(value, type, precision) {
+        switch (type) {
+            case "float32": {
+                const buf = new ArrayBuffer(4);
+                new DataView(buf).setFloat32(0, value);
+                return new Uint8Array(buf);
+            }
+            case "float64": {
+                const buf = new ArrayBuffer(8);
+                new DataView(buf).setFloat64(0, value);
+                return new Uint8Array(buf);
+            }
+            case "uint8": return new Uint8Array([value]);
+            case "uint16": {
+                const buf = new ArrayBuffer(2);
+                new DataView(buf).setUint16(0, value);
+                return new Uint8Array(buf);
+            }
+            case "uint32": {
+                const buf = new ArrayBuffer(4);
+                new DataView(buf).setUint32(0, value);
+                return new Uint8Array(buf);
+            }
+            case "int8": {
+                const buf = new ArrayBuffer(1);
+                new DataView(buf).setInt8(0, value);
+                return new Uint8Array(buf);
+            }
+            case "int16": {
+                const buf = new ArrayBuffer(2);
+                new DataView(buf).setInt16(0, value);
+                return new Uint8Array(buf);
+            }
+            case "int32": {
+                const buf = new ArrayBuffer(4);
+                new DataView(buf).setInt32(0, value);
+                return new Uint8Array(buf);
+            }
+            case "boolean": return new Uint8Array([value ? 1 : 0]);
+            default: return new Uint8Array(0);
+        }
+    }
+    deserializeField(data, offset, type) {
+        const dv = new DataView(data.buffer, data.byteOffset + offset);
+        switch (type) {
+            case "float32": return { value: dv.getFloat32(0), size: 4 };
+            case "float64": return { value: dv.getFloat64(0), size: 8 };
+            case "uint8": return { value: data[offset], size: 1 };
+            case "uint16": return { value: dv.getUint16(0), size: 2 };
+            case "uint32": return { value: dv.getUint32(0), size: 4 };
+            case "int8": return { value: dv.getInt8(0), size: 1 };
+            case "int16": return { value: dv.getInt16(0), size: 2 };
+            case "int32": return { value: dv.getInt32(0), size: 4 };
+            case "boolean": return { value: data[offset] !== 0, size: 1 };
+            default: return { value: null, size: 0 };
+        }
+    }
+    serializeSnapshot(snapshot) {
+        const parts = [];
+        const tickBuf = new ArrayBuffer(4);
+        new DataView(tickBuf).setUint32(0, snapshot.tick);
+        parts.push(new Uint8Array(tickBuf));
+        const countBuf = new ArrayBuffer(2);
+        new DataView(countBuf).setUint16(0, snapshot.entities.length);
+        parts.push(new Uint8Array(countBuf));
+        snapshot.entities.forEach((entity) => {
+            const idBuf = new ArrayBuffer(4);
+            new DataView(idBuf).setUint32(0, entity.entityId);
+            parts.push(new Uint8Array(idBuf));
+            const compCountBuf = new ArrayBuffer(2);
+            new DataView(compCountBuf).setUint16(0, entity.components.length);
+            parts.push(new Uint8Array(compCountBuf));
+            entity.components.forEach((comp) => {
+                const compIdBuf = new ArrayBuffer(4);
+                new DataView(compIdBuf).setUint32(0, comp.componentId);
+                parts.push(new Uint8Array(compIdBuf));
+                const lenBuf = new ArrayBuffer(2);
+                new DataView(lenBuf).setUint16(0, comp.data.length);
+                parts.push(new Uint8Array(lenBuf));
+                parts.push(comp.data);
+            });
+        });
+        const total = parts.reduce((sum, p) => sum + p.length, 0);
+        const result = new Uint8Array(total);
+        let offset = 0;
+        parts.forEach((part) => {
+            result.set(part, offset);
+            offset += part.length;
+        });
+        return result;
+    }
+    deserializeSnapshot(data) {
+        const dv = new DataView(data.buffer, data.byteOffset);
+        let offset = 0;
+        const tick = dv.getUint32(offset);
+        offset += 4;
+        const entityCount = dv.getUint16(offset);
+        offset += 2;
+        const entities = [];
+        for (let i = 0; i < entityCount; i++) {
+            const entityId = dv.getUint32(offset);
+            offset += 4;
+            const compCount = dv.getUint16(offset);
+            offset += 2;
+            const components = [];
+            for (let j = 0; j < compCount; j++) {
+                const componentId = dv.getUint32(offset);
+                offset += 4;
+                const len = dv.getUint16(offset);
+                offset += 2;
+                const compData = data.slice(offset, offset + len);
+                offset += len;
+                components.push({ componentId, data: compData });
+            }
+            entities.push({ entityId, components });
+        }
+        return { tick, entities };
+    }
+    getTickRate() { return this.config.tickRate; }
+    hasComponent(componentId) { return this.config.components.has(componentId); }
+    getRTT() { return this.transport.getRTT(); }
+    getPacketLoss() { return this.transport.getPacketLoss(); }
+}

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

@@ -0,0 +1,172 @@
+export class RPCManager {
+    transport;
+    handlers = new Map();
+    definitions = new Map();
+    nextId = 1;
+    isServer;
+    authToken;
+    authenticated = false;
+    callTimestamps = new Map();
+    static RATE_LIMIT_MAX_CALLS = 100;
+    static RATE_LIMIT_WINDOW_MS = 1000;
+    constructor(transport, isServer, authToken) {
+        this.transport = transport;
+        this.isServer = isServer;
+        this.authToken = authToken;
+        if (!authToken)
+            this.authenticated = true;
+        this.transport.onMessage((msg) => {
+            if (msg.type === 2) {
+                this.handleMessage(msg);
+            }
+        });
+    }
+    setAuthToken(token) {
+        this.authToken = token;
+        this.authenticated = false;
+    }
+    register(name, handler, reliable = true) {
+        const id = this.nextId++;
+        const def = { id, name, reliable };
+        this.definitions.set(name, def);
+        this.handlers.set(id, handler);
+        return id;
+    }
+    unregister(name) {
+        const def = this.definitions.get(name);
+        if (def) {
+            this.handlers.delete(def.id);
+            this.definitions.delete(name);
+        }
+    }
+    call(name, args) {
+        const def = this.definitions.get(name);
+        if (def) {
+            const buf = new Uint8Array(4 + args.length);
+            const dv = new DataView(buf.buffer);
+            dv.setUint32(0, def.id);
+            buf.set(args, 4);
+            this.transport.send({
+                type: 2,
+                data: buf,
+                reliable: def.reliable,
+                ordered: true,
+                channel: 1,
+            });
+        }
+        else {
+            const nameBytes = new TextEncoder().encode(name);
+            const buf = new Uint8Array(4 + 2 + nameBytes.length + args.length);
+            const dv = new DataView(buf.buffer);
+            dv.setUint32(0, 0);
+            dv.setUint16(4, nameBytes.length);
+            buf.set(nameBytes, 6);
+            buf.set(args, 6 + nameBytes.length);
+            this.transport.send({
+                type: 2,
+                data: buf,
+                reliable: true,
+                ordered: true,
+                channel: 1,
+            });
+        }
+    }
+    callById(rpcId, args, reliable = true) {
+        const buf = new Uint8Array(4 + args.length);
+        const dv = new DataView(buf.buffer);
+        dv.setUint32(0, rpcId);
+        buf.set(args, 4);
+        this.transport.send({
+            type: 2,
+            data: buf,
+            reliable,
+            ordered: true,
+            channel: 1,
+        });
+    }
+    handleMessage(msg) {
+        if (msg.data.length < 4)
+            return;
+        // Optional authentication: the first message from a peer must match the token.
+        if (this.authToken && !this.authenticated) {
+            const tokenText = new TextDecoder().decode(msg.data);
+            if (tokenText === this.authToken) {
+                this.authenticated = true;
+                return;
+            }
+            // reject the connection on auth failure
+            this.transport.disconnect();
+            return;
+        }
+        const dv = new DataView(msg.data.buffer, msg.data.byteOffset);
+        const rpcId = dv.getUint32(0);
+        let handler;
+        let args;
+        let handlerName;
+        if (rpcId === 0) {
+            if (msg.data.length < 6)
+                return;
+            const nameLen = dv.getUint16(4);
+            if (msg.data.length < 6 + nameLen)
+                return;
+            const name = new TextDecoder().decode(msg.data.slice(6, 6 + nameLen));
+            const def = this.definitions.get(name);
+            handler = def ? this.handlers.get(def.id) : undefined;
+            args = msg.data.slice(6 + nameLen);
+            handlerName = name;
+        }
+        else {
+            handler = this.handlers.get(rpcId);
+            args = msg.data.slice(4);
+            handlerName = String(rpcId);
+        }
+        if (handler) {
+            if (!this.checkRateLimit(handlerName))
+                return;
+            const result = handler(args);
+            if (result && this.isServer) {
+                const respBuf = new Uint8Array(4 + result.length);
+                const respDv = new DataView(respBuf.buffer);
+                respDv.setUint32(0, rpcId);
+                respBuf.set(result, 4);
+                this.transport.send({
+                    type: 2,
+                    data: respBuf,
+                    reliable: true,
+                    ordered: true,
+                    channel: 1,
+                });
+            }
+        }
+    }
+    getDefinition(name) {
+        return this.definitions.get(name);
+    }
+    getHandler(rpcId) {
+        return this.handlers.get(rpcId);
+    }
+    checkRateLimit(handlerName) {
+        const now = performance.now();
+        const windowMs = RPCManager.RATE_LIMIT_WINDOW_MS;
+        const timestamps = this.callTimestamps.get(handlerName) ?? [];
+        const cutoff = now - windowMs;
+        // prune entries older than 1 second
+        let firstValid = 0;
+        while (firstValid < timestamps.length && timestamps[firstValid] < cutoff) {
+            firstValid++;
+        }
+        const recent = firstValid > 0 ? timestamps.slice(firstValid) : timestamps;
+        if (recent.length >= RPCManager.RATE_LIMIT_MAX_CALLS) {
+            this.callTimestamps.set(handlerName, recent);
+            return false;
+        }
+        recent.push(now);
+        this.callTimestamps.set(handlerName, recent);
+        return true;
+    }
+    dispose() {
+        this.handlers.clear();
+        this.definitions.clear();
+        this.callTimestamps.clear();
+    }
+}

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

@@ -0,0 +1,129 @@
+export class SessionManager {
+    platform;
+    transport;
+    state = "offline";
+    lobby = null;
+    localPlayer = null;
+    players = [];
+    tick = 0;
+    maxPlayers;
+    isHost;
+    stateChangeCbs = [];
+    playerJoinCbs = [];
+    playerLeaveCbs = [];
+    constructor(config) {
+        this.platform = config.platform;
+        this.transport = config.transport ?? null;
+        this.maxPlayers = config.maxPlayers;
+        this.isHost = config.isHost;
+    }
+    async start() {
+        await this.platform.init();
+        this.localPlayer = this.platform.getLocalPlayer();
+        this.platform.onLobbyUpdate((lobby) => {
+            this.lobby = lobby;
+            this.updatePlayers(lobby.members);
+        });
+        this.platform.onPeerConnect((peerId) => {
+            const player = {
+                platformId: this.platform.platformId,
+                platformPlayerId: peerId,
+                displayName: peerId,
+            };
+            this.playerJoinCbs.forEach((cb) => cb(player));
+        });
+        this.platform.onPeerDisconnect((peerId) => {
+            const player = this.players.find((p) => p.platformPlayerId === peerId);
+            if (player) {
+                this.playerLeaveCbs.forEach((cb) => cb(player));
+            }
+        });
+        if (this.isHost) {
+            this.setState("connecting");
+            this.lobby = await this.platform.createLobby({
+                maxPlayers: this.maxPlayers,
+                isHost: true,
+                metadata: this.metadata,
+            });
+            this.setState("hosting");
+        }
+        else {
+            this.setState("connecting");
+        }
+    }
+    async join(lobbyId) {
+        this.setState("connecting");
+        this.lobby = await this.platform.joinLobby(lobbyId);
+        this.updatePlayers(this.lobby.members);
+        this.setState("connected");
+    }
+    async stop() {
+        await this.platform.leaveLobby();
+        await this.platform.shutdown();
+        this.lobby = null;
+        this.players = [];
+        this.setState("offline");
+    }
+    tick_(dt) {
+        this.tick++;
+    }
+    getState() {
+        return this.state;
+    }
+    getLobby() {
+        return this.lobby;
+    }
+    getLocalPlayer() {
+        return this.localPlayer;
+    }
+    getPlayers() {
+        return this.players;
+    }
+    getMaxPlayers() {
+        return this.maxPlayers;
+    }
+    isHosting() {
+        return this.isHost;
+    }
+    getInfo() {
+        return {
+            state: this.state,
+            lobbyId: this.lobby?.lobbyId ?? null,
+            localPlayer: this.localPlayer,
+            players: this.players,
+            tick: this.tick,
+        };
+    }
+    onStateChange(cb) {
+        this.stateChangeCbs.push(cb);
+    }
+    onPlayerJoin(cb) {
+        this.playerJoinCbs.push(cb);
+    }
+    onPlayerLeave(cb) {
+        this.playerLeaveCbs.push(cb);
+    }
+    setState(state) {
+        this.state = state;
+        this.stateChangeCbs.forEach((cb) => cb(state));
+    }
+    updatePlayers(members) {
+        const oldIds = new Set(this.players.map((p) => p.platformPlayerId));
+        const newIds = new Set(members.map((p) => p.platformPlayerId));
+        members.forEach((p) => {
+            if (!oldIds.has(p.platformPlayerId)) {
+                this.playerJoinCbs.forEach((cb) => cb(p));
+            }
+        });
+        this.players.forEach((p) => {
+            if (!newIds.has(p.platformPlayerId)) {
+                this.playerLeaveCbs.forEach((cb) => cb(p));
+            }
+        });
+        this.players = [...members];
+    }
+    metadata = {};
+    setMetadata(key, value) {
+        this.metadata[key] = value;
+    }
+}