modd-network 1.0.1 → 1.0.3

package/dist/modd-engine.js

@@ -1,40 +1,98 @@
 "use strict";
 /**
  * MODD Engine SDK
- * Game synchronization utilities for multiplayer games
- * - Proximity-based authority
- * - Delta compression
- * - Rest detection
- * - Soft sync / interpolation
+ * Unified game networking with state synchronization
+ *
+ * Usage:
+ *   const game = await moddEngine.connect('my-app-id', 'my-room', {
+ *       stateSync: { lerpSpeed: 0.3 },
+ *       onConnect: (snapshot, inputs, frame) => { ... }
+ *   });
+ *
+ *   game.setLocalPlayer(playerId);
+ *   game.addPlayer(playerId, { x, y, z });
+ *   game.registerEntity('box1', adapter);
+ *   game.tick();
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEngine = createEngine;
+exports.connectToRoom = void 0;
+exports.connect = connect;
 exports.rapierAdapter = rapierAdapter;
 exports.generic2DAdapter = generic2DAdapter;
+exports.init = init;
+exports.getThree = getThree;
+exports.getRapier = getRapier;
+exports.createStateSync = createStateSync;
+const modd_network_1 = require("./modd-network");
 // ============================================
-// Engine Implementation
+// State Sync Factory (internal)
 // ============================================
-function createEngine(options = {}) {
-    // Configuration with defaults
-    const config = {
-        softSyncLerp: options.softSyncLerp ?? 0.5,
+function createStateSync(options = {}) {
+    // State sync config with defaults
+    const syncConfig = {
+        lerpSpeed: options.lerpSpeed ?? 0.3,
         positionThreshold: options.positionThreshold ?? 0.01,
         velocityThreshold: options.velocityThreshold ?? 0.1,
         rotationThreshold: options.rotationThreshold ?? 0.01,
         restVelocityThreshold: options.restVelocityThreshold ?? 0.05,
         restFramesRequired: options.restFramesRequired ?? 30,
-        touchBonusScore: options.touchBonusScore ?? 50,
-        touchBonusDecay: options.touchBonusDecay ?? 100,
+        authorityRadius: options.authorityRadius ?? 50,
+        playerSendRate: options.playerSendRate ?? 3, // Send every 3 ticks = 10Hz
+        entitySendRate: options.entitySendRate ?? 3,
+        staleThreshold: options.staleThreshold ?? 500, // 500ms without updates = likely AFK
     };
     // State
     const entities = new Map();
     const players = new Map();
     let localPlayerId = null;
-    let currentFrame = 0;
+    let frame = 0;
     let connection = null;
+    let roomId = null;
     // ==========================================
-    // Authority Computation
+    // Utility
     // ==========================================
+    function lerp(a, b, t) {
+        return a + (b - a) * t;
+    }
+    function distance(a, b) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        const dz = a.z - b.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
     function simpleHash(str) {
         let h = 0;
         for (let i = 0; i < str.length; i++) {
@@ -42,7 +100,96 @@ function createEngine(options = {}) {
         }
         return Math.abs(h);
     }
-    function computeAuthority(entityId) {
+    // ==========================================
+    // Delta Detection
+    // ==========================================
+    function hasPositionChanged(curr, last) {
+        return Math.abs(curr.x - last.x) > syncConfig.positionThreshold ||
+            Math.abs(curr.y - last.y) > syncConfig.positionThreshold ||
+            Math.abs(curr.z - last.z) > syncConfig.positionThreshold;
+    }
+    function hasVelocityChanged(curr, last) {
+        return Math.abs((curr.vx || 0) - (last.vx || 0)) > syncConfig.velocityThreshold ||
+            Math.abs((curr.vy || 0) - (last.vy || 0)) > syncConfig.velocityThreshold ||
+            Math.abs((curr.vz || 0) - (last.vz || 0)) > syncConfig.velocityThreshold;
+    }
+    function hasRotationChanged(curr, last) {
+        // Check euler rotY (simple Y rotation)
+        if (curr.rotY !== undefined || last.rotY !== undefined) {
+            if (Math.abs((curr.rotY || 0) - (last.rotY || 0)) > syncConfig.rotationThreshold) {
+                return true;
+            }
+        }
+        // Check quaternion rotation
+        return Math.abs((curr.qx || 0) - (last.qx || 0)) > syncConfig.rotationThreshold ||
+            Math.abs((curr.qy || 0) - (last.qy || 0)) > syncConfig.rotationThreshold ||
+            Math.abs((curr.qz || 0) - (last.qz || 0)) > syncConfig.rotationThreshold ||
+            Math.abs((curr.qw || 1) - (last.qw || 1)) > syncConfig.rotationThreshold;
+    }
+    // Known physics fields that have special threshold handling
+    const PHYSICS_FIELDS = new Set(['x', 'y', 'z', 'vx', 'vy', 'vz', 'qx', 'qy', 'qz', 'qw', 'rotY', 'avx', 'avy', 'avz']);
+    function computeDelta(curr, last) {
+        const delta = {};
+        let hasChange = false;
+        // Check physics fields with thresholds
+        if (hasPositionChanged(curr, last)) {
+            delta.x = curr.x;
+            delta.y = curr.y;
+            delta.z = curr.z;
+            hasChange = true;
+        }
+        if (hasVelocityChanged(curr, last)) {
+            delta.vx = curr.vx;
+            delta.vy = curr.vy;
+            delta.vz = curr.vz;
+            hasChange = true;
+        }
+        if (hasRotationChanged(curr, last)) {
+            // Include rotY if present (euler Y rotation)
+            if (curr.rotY !== undefined) {
+                delta.rotY = curr.rotY;
+            }
+            // Include quaternion if present
+            if (curr.qx !== undefined || curr.qy !== undefined || curr.qz !== undefined || curr.qw !== undefined) {
+                delta.qx = curr.qx;
+                delta.qy = curr.qy;
+                delta.qz = curr.qz;
+                delta.qw = curr.qw;
+            }
+            hasChange = true;
+        }
+        if (hasChange && (curr.avx !== undefined || curr.avy !== undefined || curr.avz !== undefined)) {
+            delta.avx = curr.avx;
+            delta.avy = curr.avy;
+            delta.avz = curr.avz;
+        }
+        // Check custom fields (hp, dead, etc.) - any change triggers delta
+        for (const key of Object.keys(curr)) {
+            if (PHYSICS_FIELDS.has(key))
+                continue;
+            if (curr[key] !== last[key]) {
+                delta[key] = curr[key];
+                hasChange = true;
+            }
+        }
+        return hasChange ? delta : null;
+    }
+    // ==========================================
+    // Rest Detection
+    // ==========================================
+    function isAtRest(state) {
+        const speed = Math.sqrt((state.vx || 0) ** 2 +
+            (state.vy || 0) ** 2 +
+            (state.vz || 0) ** 2);
+        const angSpeed = Math.sqrt((state.avx || 0) ** 2 +
+            (state.avy || 0) ** 2 +
+            (state.avz || 0) ** 2);
+        return speed < syncConfig.restVelocityThreshold && angSpeed < syncConfig.restVelocityThreshold;
+    }
+    // ==========================================
+    // Authority
+    // ==========================================
+    function computeEntityAuthority(entityId) {
         const entity = entities.get(entityId);
         if (!entity)
             return null;
@@ -53,20 +200,10 @@ function createEngine(options = {}) {
         let bestScore = -Infinity;
         for (const pid of playerIds) {
             const player = players.get(pid);
-            if (player.dead)
+            const dist = distance(entity.localState, player.state);
+            if (dist > syncConfig.authorityRadius)
                 continue;
-            // Distance-based score (closer = higher)
-            const dx = player.x - entity.state.x;
-            const dz = player.z - entity.state.z;
-            const dist = Math.sqrt(dx * dx + dz * dz);
-            let score = 1000 - dist * 10;
-            // Touch bonus (decays over time)
-            if (entity.lastTouchedBy === pid) {
-                const framesSinceTouch = currentFrame - (entity.lastTouchFrame || 0);
-                const decayRate = config.touchBonusScore / config.touchBonusDecay;
-                score += Math.max(0, config.touchBonusScore - framesSinceTouch * decayRate);
-            }
-            // Deterministic tiebreaker
+            let score = syncConfig.authorityRadius - dist;
             score += simpleHash(pid + entityId) * 0.0001;
             if (score > bestScore) {
                 bestScore = score;
@@ -75,175 +212,257 @@ function createEngine(options = {}) {
         }
         return bestPlayer;
     }
-    function isLocalAuthority(entityId) {
-        return localPlayerId !== null && computeAuthority(entityId) === localPlayerId;
-    }
-    // ==========================================
-    // Delta Compression
-    // ==========================================
-    function hasStateChanged(entityId) {
+    function updateEntityAuthority(entityId) {
         const entity = entities.get(entityId);
-        if (!entity || !entity.lastSentState)
-            return true;
-        const curr = entity.state;
-        const last = entity.lastSentState;
-        // Position
-        if (Math.abs(curr.x - last.x) > config.positionThreshold)
-            return true;
-        if (Math.abs(curr.y - last.y) > config.positionThreshold)
-            return true;
-        if (Math.abs(curr.z - last.z) > config.positionThreshold)
-            return true;
-        // Velocity
-        if (Math.abs((curr.vx || 0) - (last.vx || 0)) > config.velocityThreshold)
-            return true;
-        if (Math.abs((curr.vy || 0) - (last.vy || 0)) > config.velocityThreshold)
-            return true;
-        if (Math.abs((curr.vz || 0) - (last.vz || 0)) > config.velocityThreshold)
-            return true;
-        // Rotation
-        if (Math.abs((curr.qx || 0) - (last.qx || 0)) > config.rotationThreshold)
-            return true;
-        if (Math.abs((curr.qy || 0) - (last.qy || 0)) > config.rotationThreshold)
-            return true;
-        if (Math.abs((curr.qz || 0) - (last.qz || 0)) > config.rotationThreshold)
-            return true;
-        if (Math.abs((curr.qw || 1) - (last.qw || 1)) > config.rotationThreshold)
-            return true;
-        return false;
+        if (!entity)
+            return;
+        entity.isAuthority = computeEntityAuthority(entityId) === localPlayerId;
     }
     // ==========================================
-    // Rest Detection
+    // Interpolation
     // ==========================================
-    function isAtRest(entityId) {
-        const entity = entities.get(entityId);
-        if (!entity)
-            return false;
-        const state = entity.state;
-        const speed = Math.sqrt((state.vx || 0) ** 2 +
-            (state.vy || 0) ** 2 +
-            (state.vz || 0) ** 2);
-        const angSpeed = Math.sqrt((state.avx || 0) ** 2 +
-            (state.avy || 0) ** 2 +
-            (state.avz || 0) ** 2);
-        if (speed < config.restVelocityThreshold && angSpeed < config.restVelocityThreshold) {
-            entity.restFrames++;
-            return entity.restFrames > config.restFramesRequired;
-        }
-        else {
-            entity.restFrames = 0;
-            return false;
-        }
-    }
-    function wakeEntity(entityId) {
-        const entity = entities.get(entityId);
-        if (entity) {
-            entity.restFrames = 0;
-        }
+    function interpolateState(current, target, t) {
+        // Start with all properties from current and target (preserves custom props like hp, dead)
+        return {
+            ...current,
+            ...target,
+            // Override with interpolated physics values
+            x: lerp(current.x, target.x, t),
+            y: lerp(current.y, target.y, t),
+            z: lerp(current.z, target.z, t),
+            vx: target.vx,
+            vy: target.vy,
+            vz: target.vz,
+            rotY: target.rotY !== undefined ? lerp(current.rotY || 0, target.rotY, t) : current.rotY,
+            qx: lerp(current.qx || 0, target.qx || 0, t),
+            qy: lerp(current.qy || 0, target.qy || 0, t),
+            qz: lerp(current.qz || 0, target.qz || 0, t),
+            qw: lerp(current.qw || 1, target.qw || 1, t),
+            avx: target.avx,
+            avy: target.avy,
+            avz: target.avz,
+        };
     }
     // ==========================================
-    // Soft Sync
+    // Sending State (rate limited)
     // ==========================================
-    function applySoftSync(entityId, targetState) {
-        const entity = entities.get(entityId);
-        if (!entity)
+    function sendPlayerState() {
+        if (!connection?.connected || !localPlayerId)
+            return;
+        // Rate limit: only send every N ticks
+        if (frame % syncConfig.playerSendRate !== 0)
             return;
-        // Skip if we're authority
-        if (isLocalAuthority(entityId))
+        const player = players.get(localPlayerId);
+        if (!player)
             return;
-        const lerp = config.softSyncLerp;
-        // Lerp position
-        entity.state.x += (targetState.x - entity.state.x) * lerp;
-        entity.state.y += (targetState.y - entity.state.y) * lerp;
-        entity.state.z += (targetState.z - entity.state.z) * lerp;
-        // Hard sync velocity
-        entity.state.vx = targetState.vx;
-        entity.state.vy = targetState.vy;
-        entity.state.vz = targetState.vz;
-        // Hard sync rotation
-        entity.state.qx = targetState.qx;
-        entity.state.qy = targetState.qy;
-        entity.state.qz = targetState.qz;
-        entity.state.qw = targetState.qw;
-        // Hard sync angular velocity
-        entity.state.avx = targetState.avx;
-        entity.state.avy = targetState.avy;
-        entity.state.avz = targetState.avz;
-        // Apply to physics
-        entity.adapter.setState(entity.state);
-        // Wake the entity
-        wakeEntity(entityId);
+        const delta = computeDelta(player.state, player.targetState);
+        if (!delta)
+            return;
+        connection.send({
+            type: 'playerState',
+            id: localPlayerId,
+            ...delta,
+            frame
+        });
+        Object.assign(player.targetState, player.state);
     }
-    // ==========================================
-    // Network Integration
-    // ==========================================
-    function sendEntityUpdates() {
-        if (!connection?.connected)
+    function sendEntityStates() {
+        if (!connection?.connected || !localPlayerId)
+            return;
+        // Rate limit: only send every N ticks
+        if (frame % syncConfig.entitySendRate !== 0)
             return;
         for (const [id, entity] of entities) {
-            // Skip if not authority
-            if (!isLocalAuthority(id))
+            if (!entity.isAuthority)
                 continue;
-            // Skip if at rest
-            if (isAtRest(id))
-                continue;
-            // Skip if no meaningful change
-            if (!hasStateChanged(id))
+            entity.localState = entity.adapter.getState();
+            if (isAtRest(entity.localState)) {
+                entity.restFrames++;
+                if (entity.restFrames > syncConfig.restFramesRequired)
+                    continue;
+            }
+            else {
+                entity.restFrames = 0;
+            }
+            const delta = computeDelta(entity.localState, entity.lastSentState);
+            if (!delta)
                 continue;
-            // Sync state from physics
-            entity.state = entity.adapter.getState();
-            // Send update
             connection.send({
                 type: 'entityState',
                 id,
-                ...entity.state
+                ...delta,
+                frame
             });
-            // Remember what we sent
-            entity.lastSentState = { ...entity.state };
+            Object.assign(entity.lastSentState, entity.localState);
+        }
+    }
+    // ==========================================
+    // Receiving State
+    // ==========================================
+    // Apply all received properties to target state
+    function applyStateUpdate(target, state) {
+        for (const key of Object.keys(state)) {
+            if (key === 'type' || key === 'id' || key === 'frame')
+                continue; // Skip metadata
+            if (state[key] !== undefined) {
+                target[key] = state[key];
+            }
+        }
+    }
+    function receivePlayerState(id, state) {
+        if (id === localPlayerId)
+            return;
+        let player = players.get(id);
+        if (!player) {
+            const fullState = {
+                x: state.x ?? 0,
+                y: state.y ?? 0,
+                z: state.z ?? 0,
+                vx: state.vx ?? 0,
+                vy: state.vy ?? 0,
+                vz: state.vz ?? 0,
+            };
+            // Apply any additional properties from initial state
+            applyStateUpdate(fullState, state);
+            player = {
+                id,
+                state: { ...fullState },
+                targetState: { ...fullState },
+                lastUpdate: Date.now(),
+            };
+            players.set(id, player);
+            return;
+        }
+        // Apply all received properties to target state
+        applyStateUpdate(player.targetState, state);
+        // For non-interpolated properties, apply directly to current state too
+        for (const key of Object.keys(state)) {
+            if (PHYSICS_FIELDS.has(key))
+                continue; // Physics fields are interpolated
+            if (key === 'type' || key === 'id' || key === 'frame')
+                continue;
+            if (state[key] !== undefined) {
+                player.state[key] = state[key];
+            }
         }
+        player.lastUpdate = Date.now();
     }
-    function handleEntityState(id, state) {
+    function receiveEntityState(id, state) {
         const entity = entities.get(id);
         if (!entity)
             return;
-        // Skip if we're authority
-        if (isLocalAuthority(id))
+        if (entity.isAuthority)
             return;
-        applySoftSync(id, state);
+        // Apply all received properties to target state
+        applyStateUpdate(entity.targetState, state);
+        entity.lastUpdate = Date.now();
+        entity.restFrames = 0;
     }
-    function handleEntityTouch(id, touchedBy, frame) {
-        const entity = entities.get(id);
-        if (entity) {
-            entity.lastTouchedBy = touchedBy;
-            entity.lastTouchFrame = frame;
-            wakeEntity(id);
+    // ==========================================
+    // Tick
+    // ==========================================
+    function tick() {
+        frame++;
+        for (const [id] of entities) {
+            updateEntityAuthority(id);
+        }
+        for (const [id, player] of players) {
+            if (id === localPlayerId)
+                continue;
+            player.state = interpolateState(player.state, player.targetState, syncConfig.lerpSpeed);
         }
+        for (const [, entity] of entities) {
+            if (entity.isAuthority) {
+                entity.localState = entity.adapter.getState();
+            }
+            else {
+                entity.localState = interpolateState(entity.localState, entity.targetState, syncConfig.lerpSpeed);
+                entity.adapter.setState(entity.localState);
+            }
+        }
+        sendPlayerState();
+        sendEntityStates();
     }
     // ==========================================
-    // Public API
+    // Process Input
     // ==========================================
-    return {
-        // Configuration
-        get config() {
-            return { ...config };
+    function processInput(input) {
+        if (input.type === 'playerState') {
+            receivePlayerState(input.id, input);
+        }
+        else if (input.type === 'entityState') {
+            receiveEntityState(input.id, input);
+        }
+    }
+    // ==========================================
+    // Game Object
+    // ==========================================
+    const game = {
+        get connected() { return connection?.connected ?? false; },
+        get room() { return roomId; },
+        get node() { return connection?.node ?? null; },
+        get bandwidthIn() { return connection?.bandwidthIn ?? 0; },
+        get bandwidthOut() { return connection?.bandwidthOut ?? 0; },
+        get frame() { return frame; },
+        get localPlayerId() { return localPlayerId; },
+        get config() { return { ...syncConfig }; },
+        disconnect() {
+            connection?.close();
         },
-        // Setup
-        setConnection(conn) {
-            connection = conn;
+        send(data) {
+            connection?.send(data);
+        },
+        setLocalPlayer(id) {
+            localPlayerId = id;
+        },
+        addPlayer(id, initialState) {
+            players.set(id, {
+                id,
+                state: { ...initialState },
+                targetState: { ...initialState },
+                lastUpdate: Date.now(),
+            });
+        },
+        removePlayer(id) {
+            players.delete(id);
         },
-        setLocalPlayer(playerId) {
-            localPlayerId = playerId;
+        getPlayer(id) {
+            return players.get(id);
         },
-        setFrame(frame) {
-            currentFrame = frame;
+        getPlayers() {
+            return Array.from(players.values());
+        },
+        isPlayerStale(id) {
+            if (id === localPlayerId)
+                return false; // Local player is never stale
+            const player = players.get(id);
+            if (!player)
+                return false;
+            return Date.now() - player.lastUpdate > syncConfig.staleThreshold;
+        },
+        getStalePlayers() {
+            const now = Date.now();
+            return Array.from(players.values()).filter(p => p.id !== localPlayerId && now - p.lastUpdate > syncConfig.staleThreshold);
+        },
+        updateLocalPlayerState(state) {
+            if (!localPlayerId)
+                return;
+            const player = players.get(localPlayerId);
+            if (player) {
+                player.state = { ...state };
+            }
         },
-        // Entity management
         registerEntity(id, adapter) {
+            const state = adapter.getState();
             entities.set(id, {
                 id,
                 adapter,
-                state: adapter.getState(),
-                restFrames: 0
+                localState: { ...state },
+                targetState: { ...state },
+                lastSentState: { ...state },
+                restFrames: 0,
+                isAuthority: false,
+                lastUpdate: Date.now(),
             });
         },
         unregisterEntity(id) {
@@ -252,90 +471,53 @@ function createEngine(options = {}) {
         getEntity(id) {
             return entities.get(id);
         },
-        // Player management (for authority calculation)
-        updatePlayer(id, x, y, z, dead = false) {
-            players.set(id, { id, x, y, z, dead });
+        getEntities() {
+            return Array.from(entities.values());
         },
-        removePlayer(id) {
-            players.delete(id);
-        },
-        // Authority
-        computeAuthority,
-        isLocalAuthority,
-        // Sync operations
-        syncFromPhysics(entityId) {
-            const entity = entities.get(entityId);
-            if (entity) {
-                entity.state = entity.adapter.getState();
-            }
+        isAuthority(entityId) {
+            return entities.get(entityId)?.isAuthority ?? false;
         },
-        syncAllFromPhysics() {
-            for (const entity of entities.values()) {
-                entity.state = entity.adapter.getState();
-            }
+        tick,
+        processInput,
+        // Internal: set connection after async connect
+        setConnection(conn) {
+            connection = conn;
         },
-        // Network operations (call each tick)
-        sendUpdates: sendEntityUpdates,
-        // Input handlers (call from processInput)
-        handleEntityState,
-        handleEntityTouch,
-        // Touch detection (call after physics step)
-        checkPlayerTouches(playerId, playerX, playerZ, touchDistance = 2.0) {
-            if (!connection?.connected || playerId !== localPlayerId)
-                return;
-            for (const [id, entity] of entities) {
-                const dx = playerX - entity.state.x;
-                const dz = playerZ - entity.state.z;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist < touchDistance && entity.lastTouchedBy !== playerId) {
-                    connection.send({
-                        type: 'entityTouch',
-                        id,
-                        touchedBy: playerId,
-                        frame: currentFrame
-                    });
-                }
+    };
+    return game;
+}
+// ============================================
+// Main Connect Function
+// ============================================
+async function connect(appId, room, options = {}) {
+    // Create the game/state sync object
+    const game = createStateSync(options.stateSync);
+    // Set up onTick to process inputs
+    const userOnTick = options.onTick;
+    const gameOptions = {
+        ...options,
+        onTick: (frame, inputs) => {
+            for (const input of inputs) {
+                game.processInput(input.data);
             }
-        },
-        checkEntityCollisions(touchDistance = 4.0) {
-            if (!connection?.connected)
-                return;
-            const entityIds = Array.from(entities.keys());
-            for (let i = 0; i < entityIds.length; i++) {
-                const idA = entityIds[i];
-                if (!isLocalAuthority(idA))
-                    continue;
-                const entityA = entities.get(idA);
-                for (let j = i + 1; j < entityIds.length; j++) {
-                    const idB = entityIds[j];
-                    const entityB = entities.get(idB);
-                    const dx = entityA.state.x - entityB.state.x;
-                    const dz = entityA.state.z - entityB.state.z;
-                    const dist = Math.sqrt(dx * dx + dz * dz);
-                    if (dist < touchDistance && entityB.lastTouchedBy !== localPlayerId) {
-                        connection.send({
-                            type: 'entityTouch',
-                            id: idB,
-                            touchedBy: localPlayerId,
-                            frame: currentFrame
-                        });
-                    }
-                }
+            if (userOnTick) {
+                userOnTick(frame, inputs);
             }
         },
-        // Utility
-        wakeEntity,
-        isAtRest,
-        hasStateChanged,
     };
+    // Connect to network
+    const connection = await (0, modd_network_1.connect)(appId, room, gameOptions);
+    game.setConnection(connection);
+    // Return public interface (without setConnection)
+    return game;
 }
 // ============================================
 // Physics Adapters
 // ============================================
-/**
- * Rapier 3D physics adapter
- */
 function rapierAdapter(body) {
+    if (!body || typeof body.translation !== 'function') {
+        throw new Error('rapierAdapter: Invalid Rapier body');
+    }
     return {
         getState() {
             const pos = body.translation();
@@ -357,9 +539,6 @@ function rapierAdapter(body) {
         }
     };
 }
-/**
- * Generic 2D physics adapter (for Matter.js, Planck, etc.)
- */
 function generic2DAdapter(getBody, setBody) {
     return {
         getState() {
@@ -374,16 +553,72 @@ function generic2DAdapter(getBody, setBody) {
             };
         },
         setState(state) {
-            setBody({
-                x: state.x,
-                y: state.y,
-                vx: state.vx,
-                vy: state.vy
-            });
+            setBody({ x: state.x, y: state.y, vx: state.vx, vy: state.vy });
         }
     };
 }
-// Browser global fallback
+// ============================================
+// Auto-load Dependencies
+// ============================================
+let THREE = null;
+let RAPIER = null;
+let initPromise = null;
+const DEFAULT_THREE_URL = 'https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js';
+const DEFAULT_RAPIER_URL = 'https://cdn.jsdelivr.net/npm/@dimforge/rapier3d-deterministic-compat@0.19.0/rapier.mjs';
+async function loadModule(url) {
+    return Promise.resolve(`${url}`).then(s => __importStar(require(s)));
+}
+async function init(options = {}) {
+    if (initPromise)
+        return initPromise.then(() => ({ THREE, RAPIER }));
+    initPromise = (async () => {
+        const promises = [];
+        if (!options.skipThree) {
+            promises.push(loadModule(options.threeUrl || DEFAULT_THREE_URL).then((mod) => {
+                THREE = mod;
+                if (typeof window !== 'undefined') {
+                    window.THREE = THREE;
+                }
+            }));
+        }
+        if (!options.skipRapier) {
+            promises.push(loadModule(options.rapierUrl || DEFAULT_RAPIER_URL).then(async (mod) => {
+                RAPIER = mod.default || mod;
+                await RAPIER.init();
+                if (typeof window !== 'undefined') {
+                    window.RAPIER = RAPIER;
+                }
+            }));
+        }
+        await Promise.all(promises);
+    })();
+    await initPromise;
+    return { THREE, RAPIER };
+}
+function getThree() {
+    if (!THREE)
+        throw new Error('THREE not loaded. Call moddEngine.init() first.');
+    return THREE;
+}
+function getRapier() {
+    if (!RAPIER)
+        throw new Error('RAPIER not loaded. Call moddEngine.init() first.');
+    return RAPIER;
+}
+// Alias for backwards compat
+exports.connectToRoom = connect;
+// Browser global
 if (typeof window !== 'undefined') {
-    window.moddEngine = { createEngine, rapierAdapter, generic2DAdapter };
+    window.moddEngine = {
+        connect,
+        createStateSync,
+        rapierAdapter,
+        generic2DAdapter,
+        init,
+        getThree,
+        getRapier,
+        get THREE() { return THREE; },
+        get RAPIER() { return RAPIER; },
+        VERSION: '2.0.0'
+    };
 }