@nice2dev/game-engine 1.3.15 → 1.3.17

package/dist/cjs/native-engine/NetworkingSystem.js

@@ -1,820 +1,760 @@
-'use strict';
-
-/**
- * @file NetworkingSystem.ts
- * @description Networking System for Nice2Dev Game Engine
- * PRO-1.11.6: Networking System
- *
- * Features:
- * - WebSocket multiplayer
- * - WebRTC peer-to-peer
- * - State synchronization
- * - Client-side prediction
- * - Lag compensation
- * - Matchmaking
- * - Lobby system
- */
-// ============================================================
-// Network Manager
-// ============================================================
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 class NetworkManager {
-    constructor(config) {
-        this.connection = null;
-        this.players = new Map();
-        this.localPlayer = null;
-        this.entities = new Map();
-        this.snapshotBuffer = [];
-        this.currentTick = 0;
-        this.serverTimeOffset = 0;
-        this.callbacks = {};
-        this.messageHandlers = new Map();
-        this.config = {
-            maxPlayers: 16,
-            tickRate: 60,
-            interpolationDelay: 100,
-            predictionEnabled: true,
-            lagCompensationWindow: 200,
-            reconciliationEnabled: true,
-            snapshotBufferSize: 120,
-            heartbeatInterval: 1000,
-            timeoutDuration: 10000,
-            compressionEnabled: true,
-            encryptionEnabled: false,
-            ...config,
-        };
-    }
-    // ─── Connection ────────────────────────────────────────
-    async connectToServer(url, playerName) {
-        if (this.connection) {
-            throw new Error('Already connected');
-        }
-        this.connection = new WebSocketConnection(url, this.config);
-        await this.connection.connect();
-        // Set up message handling
-        this.connection.onMessage((msg) => this.handleMessage(msg));
-        this.connection.onDisconnect((reason) => {
-            this.callbacks.onDisconnected?.(reason);
-            this.cleanup();
-        });
-        // Send join request
-        this.sendMessage({
-            type: 'join-request',
-            channel: 'system',
-            mode: 'reliable',
-            data: { playerName },
-        });
-        // Wait for join response
-        await this.waitForJoinResponse();
-        this.callbacks.onConnected?.();
-    }
-    async waitForJoinResponse() {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('Join timeout'));
-            }, this.config.timeoutDuration);
-            this.messageHandlers.set('join-response', (msg) => {
-                clearTimeout(timeout);
-                const data = msg.data;
-                this.localPlayer = {
-                    id: data.playerId,
-                    name: '',
-                    role: 'client',
-                    ping: 0,
-                    state: 'connected',
-                    inputSequence: 0,
-                    pendingInputs: [],
-                };
-                this.serverTimeOffset = data.serverTime - Date.now();
-                for (const player of data.players) {
-                    this.players.set(player.id, player);
-                }
-                resolve();
-            });
-        });
-    }
-    async hostServer(port, playerName) {
-        this.connection = new WebSocketServer(port, this.config);
-        await this.connection.start();
+  constructor(config) {
+    this.connection = null;
+    this.players = /* @__PURE__ */ new Map();
+    this.localPlayer = null;
+    this.entities = /* @__PURE__ */ new Map();
+    this.snapshotBuffer = [];
+    this.currentTick = 0;
+    this.serverTimeOffset = 0;
+    this.callbacks = {};
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    this.config = {
+      maxPlayers: 16,
+      tickRate: 60,
+      interpolationDelay: 100,
+      predictionEnabled: true,
+      lagCompensationWindow: 200,
+      reconciliationEnabled: true,
+      snapshotBufferSize: 120,
+      heartbeatInterval: 1e3,
+      timeoutDuration: 1e4,
+      compressionEnabled: true,
+      encryptionEnabled: false,
+      ...config
+    };
+  }
+  // ─── Connection ────────────────────────────────────────
+  async connectToServer(url, playerName) {
+    if (this.connection) {
+      throw new Error("Already connected");
+    }
+    this.connection = new WebSocketConnection(url, this.config);
+    await this.connection.connect();
+    this.connection.onMessage((msg) => this.handleMessage(msg));
+    this.connection.onDisconnect((reason) => {
+      this.callbacks.onDisconnected?.(reason);
+      this.cleanup();
+    });
+    this.sendMessage({
+      type: "join-request",
+      channel: "system",
+      mode: "reliable",
+      data: { playerName }
+    });
+    await this.waitForJoinResponse();
+    this.callbacks.onConnected?.();
+  }
+  async waitForJoinResponse() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Join timeout"));
+      }, this.config.timeoutDuration);
+      this.messageHandlers.set("join-response", (msg) => {
+        clearTimeout(timeout);
+        const data = msg.data;
         this.localPlayer = {
-            id: 'host',
-            name: playerName,
-            role: 'host',
-            ping: 0,
-            state: 'playing',
-            inputSequence: 0,
-            pendingInputs: [],
-        };
-        this.players.set('host', this.localPlayer);
-    }
-    disconnect() {
-        if (this.connection) {
-            this.sendMessage({
-                type: 'leave',
-                channel: 'system',
-                mode: 'reliable',
-                data: {},
-            });
-            this.connection.disconnect();
-            this.cleanup();
-        }
-    }
-    cleanup() {
-        this.connection = null;
-        this.players.clear();
-        this.localPlayer = null;
-        this.entities.clear();
-        this.snapshotBuffer = [];
-        this.currentTick = 0;
-    }
-    isConnected() {
-        return this.connection?.getState() === 'connected';
-    }
-    getConnectionState() {
-        return this.connection?.getState() ?? 'disconnected';
-    }
-    // ─── Players ───────────────────────────────────────────
-    getLocalPlayer() {
-        return this.localPlayer;
-    }
-    getPlayer(id) {
-        return this.players.get(id);
-    }
-    getPlayers() {
-        return Array.from(this.players.values());
-    }
-    getPlayerCount() {
-        return this.players.size;
-    }
-    // ─── Entities ──────────────────────────────────────────
-    registerEntity(entity) {
-        this.entities.set(entity.networkId, entity);
-    }
-    unregisterEntity(entity) {
-        this.entities.delete(entity.networkId);
-    }
-    getEntity(id) {
-        return this.entities.get(id);
-    }
-    isEntityOwner(entity) {
-        return entity.ownerId === this.localPlayer?.id;
-    }
-    // ─── Messages ──────────────────────────────────────────
-    sendMessage(message) {
-        if (!this.connection) {
-            return;
-        }
-        const fullMessage = {
-            ...message,
-            timestamp: Date.now() + this.serverTimeOffset,
-            senderId: this.localPlayer?.id ?? 'unknown',
-        };
-        this.connection.send(fullMessage);
-    }
-    sendToPlayer(playerId, message) {
-        this.sendMessage({
-            ...message,
-            data: { ...message.data, targetPlayerId: playerId },
-        });
-    }
-    broadcast(message, excludeSelf = false) {
-        this.sendMessage({
-            ...message,
-            data: { ...message.data, broadcast: true, excludeSelf },
-        });
-    }
-    handleMessage(message) {
-        // Check for registered handler
-        const handler = this.messageHandlers.get(message.type);
-        if (handler) {
-            handler(message);
-            return;
-        }
-        switch (message.type) {
-            case 'player-joined':
-                this.handlePlayerJoined(message);
-                break;
-            case 'player-left':
-                this.handlePlayerLeft(message);
-                break;
-            case 'state-sync':
-                this.handleStateSync(message);
-                break;
-            case 'ping':
-                this.handlePing(message);
-                break;
-            default:
-                this.callbacks.onMessage?.(message);
-        }
-    }
-    handlePlayerJoined(message) {
-        const player = message.data;
-        this.players.set(player.id, player);
-        this.callbacks.onPlayerJoined?.(player);
-    }
-    handlePlayerLeft(message) {
-        const { playerId } = message.data;
-        const player = this.players.get(playerId);
-        if (player) {
-            this.players.delete(playerId);
-            this.callbacks.onPlayerLeft?.(player);
-        }
-    }
-    handleStateSync(message) {
-        const snapshot = message.data;
-        // Add to buffer
-        this.snapshotBuffer.push(snapshot);
-        if (this.snapshotBuffer.length > this.config.snapshotBufferSize) {
-            this.snapshotBuffer.shift();
-        }
-        this.callbacks.onStateSync?.(snapshot);
-    }
-    handlePing(message) {
-        const { sendTime } = message.data;
-        const ping = Date.now() - sendTime;
-        if (this.localPlayer) {
-            this.localPlayer.ping = ping;
-        }
-        this.callbacks.onPingUpdate?.(ping);
-    }
-    // ─── Input ─────────────────────────────────────────────
-    sendInput(input) {
-        if (!this.localPlayer) {
-            return;
-        }
-        const playerInput = {
-            sequence: ++this.localPlayer.inputSequence,
-            timestamp: Date.now() + this.serverTimeOffset,
-            actions: input,
+          id: data.playerId,
+          name: "",
+          role: "client",
+          ping: 0,
+          state: "connected",
+          inputSequence: 0,
+          pendingInputs: []
         };
-        // Store for reconciliation
+        this.serverTimeOffset = data.serverTime - Date.now();
+        for (const player of data.players) {
+          this.players.set(player.id, player);
+        }
+        resolve();
+      });
+    });
+  }
+  async hostServer(port, playerName) {
+    this.connection = new WebSocketServer(port, this.config);
+    await this.connection.start();
+    this.localPlayer = {
+      id: "host",
+      name: playerName,
+      role: "host",
+      ping: 0,
+      state: "playing",
+      inputSequence: 0,
+      pendingInputs: []
+    };
+    this.players.set("host", this.localPlayer);
+  }
+  disconnect() {
+    if (this.connection) {
+      this.sendMessage({
+        type: "leave",
+        channel: "system",
+        mode: "reliable",
+        data: {}
+      });
+      this.connection.disconnect();
+      this.cleanup();
+    }
+  }
+  cleanup() {
+    this.connection = null;
+    this.players.clear();
+    this.localPlayer = null;
+    this.entities.clear();
+    this.snapshotBuffer = [];
+    this.currentTick = 0;
+  }
+  isConnected() {
+    return this.connection?.getState() === "connected";
+  }
+  getConnectionState() {
+    return this.connection?.getState() ?? "disconnected";
+  }
+  // ─── Players ───────────────────────────────────────────
+  getLocalPlayer() {
+    return this.localPlayer;
+  }
+  getPlayer(id) {
+    return this.players.get(id);
+  }
+  getPlayers() {
+    return Array.from(this.players.values());
+  }
+  getPlayerCount() {
+    return this.players.size;
+  }
+  // ─── Entities ──────────────────────────────────────────
+  registerEntity(entity) {
+    this.entities.set(entity.networkId, entity);
+  }
+  unregisterEntity(entity) {
+    this.entities.delete(entity.networkId);
+  }
+  getEntity(id) {
+    return this.entities.get(id);
+  }
+  isEntityOwner(entity) {
+    return entity.ownerId === this.localPlayer?.id;
+  }
+  // ─── Messages ──────────────────────────────────────────
+  sendMessage(message) {
+    if (!this.connection) {
+      return;
+    }
+    const fullMessage = {
+      ...message,
+      timestamp: Date.now() + this.serverTimeOffset,
+      senderId: this.localPlayer?.id ?? "unknown"
+    };
+    this.connection.send(fullMessage);
+  }
+  sendToPlayer(playerId, message) {
+    this.sendMessage({
+      ...message,
+      data: { ...message.data, targetPlayerId: playerId }
+    });
+  }
+  broadcast(message, excludeSelf = false) {
+    this.sendMessage({
+      ...message,
+      data: { ...message.data, broadcast: true, excludeSelf }
+    });
+  }
+  handleMessage(message) {
+    const handler = this.messageHandlers.get(message.type);
+    if (handler) {
+      handler(message);
+      return;
+    }
+    switch (message.type) {
+      case "player-joined":
+        this.handlePlayerJoined(message);
+        break;
+      case "player-left":
+        this.handlePlayerLeft(message);
+        break;
+      case "state-sync":
+        this.handleStateSync(message);
+        break;
+      case "ping":
+        this.handlePing(message);
+        break;
+      default:
+        this.callbacks.onMessage?.(message);
+    }
+  }
+  handlePlayerJoined(message) {
+    const player = message.data;
+    this.players.set(player.id, player);
+    this.callbacks.onPlayerJoined?.(player);
+  }
+  handlePlayerLeft(message) {
+    const { playerId } = message.data;
+    const player = this.players.get(playerId);
+    if (player) {
+      this.players.delete(playerId);
+      this.callbacks.onPlayerLeft?.(player);
+    }
+  }
+  handleStateSync(message) {
+    const snapshot = message.data;
+    this.snapshotBuffer.push(snapshot);
+    if (this.snapshotBuffer.length > this.config.snapshotBufferSize) {
+      this.snapshotBuffer.shift();
+    }
+    this.callbacks.onStateSync?.(snapshot);
+  }
+  handlePing(message) {
+    const { sendTime } = message.data;
+    const ping = Date.now() - sendTime;
+    if (this.localPlayer) {
+      this.localPlayer.ping = ping;
+    }
+    this.callbacks.onPingUpdate?.(ping);
+  }
+  // ─── Input ─────────────────────────────────────────────
+  sendInput(input) {
+    if (!this.localPlayer) {
+      return;
+    }
+    const playerInput = {
+      sequence: ++this.localPlayer.inputSequence,
+      timestamp: Date.now() + this.serverTimeOffset,
+      actions: input
+    };
+    if (this.config.predictionEnabled) {
+      this.localPlayer.pendingInputs.push(playerInput);
+    }
+    this.sendMessage({
+      type: "player-input",
+      channel: "gameplay",
+      mode: "reliable-ordered",
+      data: playerInput
+    });
+  }
+  // ─── State Synchronization ─────────────────────────────
+  update(_deltaTime) {
+    if (!this.connection) {
+      return;
+    }
+    this.currentTick++;
+    if (this.currentTick % (this.config.tickRate * (this.config.heartbeatInterval / 1e3)) === 0) {
+      this.sendMessage({
+        type: "ping",
+        channel: "system",
+        mode: "unreliable",
+        data: { sendTime: Date.now() }
+      });
+    }
+    const renderTime = Date.now() - this.config.interpolationDelay + this.serverTimeOffset;
+    for (const entity of this.entities.values()) {
+      if (this.isEntityOwner(entity)) {
         if (this.config.predictionEnabled) {
-            this.localPlayer.pendingInputs.push(playerInput);
-        }
-        this.sendMessage({
-            type: 'player-input',
-            channel: 'gameplay',
-            mode: 'reliable-ordered',
-            data: playerInput,
-        });
-    }
-    // ─── State Synchronization ─────────────────────────────
-    update(_deltaTime) {
-        if (!this.connection) {
-            return;
-        }
-        this.currentTick++;
-        // Update ping
-        if (this.currentTick % (this.config.tickRate * (this.config.heartbeatInterval / 1000)) === 0) {
-            this.sendMessage({
-                type: 'ping',
-                channel: 'system',
-                mode: 'unreliable',
-                data: { sendTime: Date.now() },
-            });
-        }
-        // Interpolation for remote entities
-        const renderTime = Date.now() - this.config.interpolationDelay + this.serverTimeOffset;
-        for (const entity of this.entities.values()) {
-            if (this.isEntityOwner(entity)) {
-                // Local entity - apply prediction
-                if (this.config.predictionEnabled) {
-                    this.applyPrediction(entity);
-                }
-            }
-            else {
-                // Remote entity - interpolate
-                this.interpolateEntity(entity, renderTime);
-            }
-        }
-    }
-    applyPrediction(_entity) {
-        // Apply pending inputs to predict entity state
-        if (!this.localPlayer) {
-            return;
-        }
-        for (const _input of this.localPlayer.pendingInputs) {
-            // Would apply input to entity simulation
-        }
-    }
-    interpolateEntity(entity, renderTime) {
-        // Find surrounding snapshots
-        let before = null;
-        let after = null;
-        for (const snapshot of this.snapshotBuffer) {
-            if (snapshot.timestamp <= renderTime) {
-                before = snapshot;
-            }
-            else {
-                after = snapshot;
-                break;
-            }
-        }
-        if (!before || !after) {
-            // Extrapolate from latest
-            if (this.snapshotBuffer.length > 0) {
-                const latest = this.snapshotBuffer[this.snapshotBuffer.length - 1];
-                const entityState = latest.entities.find((e) => e.id === entity.networkId);
-                if (entityState) {
-                    entity.applyState(entityState);
-                }
-            }
-            return;
-        }
-        // Interpolate between snapshots
-        const t = (renderTime - before.timestamp) / (after.timestamp - before.timestamp);
-        const beforeState = before.entities.find((e) => e.id === entity.networkId);
-        const afterState = after.entities.find((e) => e.id === entity.networkId);
-        if (beforeState && afterState) {
-            const interpolated = {
-                id: entity.networkId,
-                ownerId: entity.ownerId,
-                type: entity.type,
-                position: this.lerpVec3(beforeState.position, afterState.position, t),
-                rotation: this.slerpQuat(beforeState.rotation, afterState.rotation, t),
-                velocity: beforeState.velocity && afterState.velocity
-                    ? this.lerpVec3(beforeState.velocity, afterState.velocity, t)
-                    : undefined,
-            };
-            entity.applyState(interpolated);
-        }
-    }
-    lerpVec3(a, b, t) {
-        return {
-            x: a.x + (b.x - a.x) * t,
-            y: a.y + (b.y - a.y) * t,
-            z: a.z + (b.z - a.z) * t,
-        };
-    }
-    slerpQuat(a, b, t) {
-        // Simplified spherical linear interpolation
-        let cosHalfTheta = a.w * b.w + a.x * b.x + a.y * b.y + a.z * b.z;
-        if (Math.abs(cosHalfTheta) >= 1.0) {
-            return a;
-        }
-        if (cosHalfTheta < 0) {
-            b = { x: -b.x, y: -b.y, z: -b.z, w: -b.w };
-            cosHalfTheta = -cosHalfTheta;
-        }
-        const halfTheta = Math.acos(cosHalfTheta);
-        const sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta);
-        if (Math.abs(sinHalfTheta) < 0.001) {
-            return {
-                x: a.x * 0.5 + b.x * 0.5,
-                y: a.y * 0.5 + b.y * 0.5,
-                z: a.z * 0.5 + b.z * 0.5,
-                w: a.w * 0.5 + b.w * 0.5,
-            };
-        }
-        const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
-        const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
-        return {
-            x: a.x * ratioA + b.x * ratioB,
-            y: a.y * ratioA + b.y * ratioB,
-            z: a.z * ratioA + b.z * ratioB,
-            w: a.w * ratioA + b.w * ratioB,
-        };
-    }
-    // ─── Server Authority ──────────────────────────────────
-    reconcileState(serverSequence, serverState) {
-        if (!this.localPlayer || !this.config.reconciliationEnabled) {
-            return;
-        }
-        // Remove acknowledged inputs
-        this.localPlayer.pendingInputs = this.localPlayer.pendingInputs.filter((input) => input.sequence > serverSequence);
-        // Get local entity
-        const entity = this.entities.get(serverState.id);
-        if (!entity || !this.isEntityOwner(entity)) {
-            return;
-        }
-        // Apply server state
-        entity.applyState(serverState);
-        // Re-apply pending inputs
-        for (const _input of this.localPlayer.pendingInputs) {
-            // Would re-simulate with input
-        }
-    }
-    // ─── Events ────────────────────────────────────────────
-    on(event, callback) {
-        this.callbacks[event] = callback;
-    }
-    off(event) {
-        delete this.callbacks[event];
-    }
-    // ─── Custom Message Types ──────────────────────────────
-    registerMessageHandler(type, handler) {
-        this.messageHandlers.set(type, handler);
-    }
-    unregisterMessageHandler(type) {
-        this.messageHandlers.delete(type);
-    }
+          this.applyPrediction(entity);
+        }
+      } else {
+        this.interpolateEntity(entity, renderTime);
+      }
+    }
+  }
+  applyPrediction(_entity) {
+    if (!this.localPlayer) {
+      return;
+    }
+    for (const _input of this.localPlayer.pendingInputs) {
+    }
+  }
+  interpolateEntity(entity, renderTime) {
+    let before = null;
+    let after = null;
+    for (const snapshot of this.snapshotBuffer) {
+      if (snapshot.timestamp <= renderTime) {
+        before = snapshot;
+      } else {
+        after = snapshot;
+        break;
+      }
+    }
+    if (!before || !after) {
+      if (this.snapshotBuffer.length > 0) {
+        const latest = this.snapshotBuffer[this.snapshotBuffer.length - 1];
+        const entityState = latest.entities.find((e) => e.id === entity.networkId);
+        if (entityState) {
+          entity.applyState(entityState);
+        }
+      }
+      return;
+    }
+    const t = (renderTime - before.timestamp) / (after.timestamp - before.timestamp);
+    const beforeState = before.entities.find((e) => e.id === entity.networkId);
+    const afterState = after.entities.find((e) => e.id === entity.networkId);
+    if (beforeState && afterState) {
+      const interpolated = {
+        id: entity.networkId,
+        ownerId: entity.ownerId,
+        type: entity.type,
+        position: this.lerpVec3(beforeState.position, afterState.position, t),
+        rotation: this.slerpQuat(beforeState.rotation, afterState.rotation, t),
+        velocity: beforeState.velocity && afterState.velocity ? this.lerpVec3(beforeState.velocity, afterState.velocity, t) : void 0
+      };
+      entity.applyState(interpolated);
+    }
+  }
+  lerpVec3(a, b, t) {
+    return {
+      x: a.x + (b.x - a.x) * t,
+      y: a.y + (b.y - a.y) * t,
+      z: a.z + (b.z - a.z) * t
+    };
+  }
+  slerpQuat(a, b, t) {
+    let cosHalfTheta = a.w * b.w + a.x * b.x + a.y * b.y + a.z * b.z;
+    if (Math.abs(cosHalfTheta) >= 1) {
+      return a;
+    }
+    if (cosHalfTheta < 0) {
+      b = { x: -b.x, y: -b.y, z: -b.z, w: -b.w };
+      cosHalfTheta = -cosHalfTheta;
+    }
+    const halfTheta = Math.acos(cosHalfTheta);
+    const sinHalfTheta = Math.sqrt(1 - cosHalfTheta * cosHalfTheta);
+    if (Math.abs(sinHalfTheta) < 1e-3) {
+      return {
+        x: a.x * 0.5 + b.x * 0.5,
+        y: a.y * 0.5 + b.y * 0.5,
+        z: a.z * 0.5 + b.z * 0.5,
+        w: a.w * 0.5 + b.w * 0.5
+      };
+    }
+    const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
+    const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+    return {
+      x: a.x * ratioA + b.x * ratioB,
+      y: a.y * ratioA + b.y * ratioB,
+      z: a.z * ratioA + b.z * ratioB,
+      w: a.w * ratioA + b.w * ratioB
+    };
+  }
+  // ─── Server Authority ──────────────────────────────────
+  reconcileState(serverSequence, serverState) {
+    if (!this.localPlayer || !this.config.reconciliationEnabled) {
+      return;
+    }
+    this.localPlayer.pendingInputs = this.localPlayer.pendingInputs.filter(
+      (input) => input.sequence > serverSequence
+    );
+    const entity = this.entities.get(serverState.id);
+    if (!entity || !this.isEntityOwner(entity)) {
+      return;
+    }
+    entity.applyState(serverState);
+    for (const _input of this.localPlayer.pendingInputs) {
+    }
+  }
+  // ─── Events ────────────────────────────────────────────
+  on(event, callback) {
+    this.callbacks[event] = callback;
+  }
+  off(event) {
+    delete this.callbacks[event];
+  }
+  // ─── Custom Message Types ──────────────────────────────
+  registerMessageHandler(type, handler) {
+    this.messageHandlers.set(type, handler);
+  }
+  unregisterMessageHandler(type) {
+    this.messageHandlers.delete(type);
+  }
 }
-// ============================================================
-// Network Entity
-// ============================================================
 class NetworkEntity {
-    constructor(networkId, ownerId, type) {
-        this.position = { x: 0, y: 0, z: 0 };
-        this.rotation = { x: 0, y: 0, z: 0, w: 1 };
-        this.velocity = { x: 0, y: 0, z: 0 };
-        this.customState = {};
-        this.networkId = networkId;
-        this.ownerId = ownerId;
-        this.type = type;
-    }
-    getState() {
-        return {
-            id: this.networkId,
-            ownerId: this.ownerId,
-            type: this.type,
-            position: { ...this.position },
-            rotation: { ...this.rotation },
-            velocity: { ...this.velocity },
-            customState: { ...this.customState },
-        };
-    }
-    applyState(state) {
-        this.position = { ...state.position };
-        this.rotation = { ...state.rotation };
-        if (state.velocity) {
-            this.velocity = { ...state.velocity };
-        }
-        if (state.customState) {
-            this.customState = { ...state.customState };
-        }
-    }
+  constructor(networkId, ownerId, type) {
+    this.position = { x: 0, y: 0, z: 0 };
+    this.rotation = { x: 0, y: 0, z: 0, w: 1 };
+    this.velocity = { x: 0, y: 0, z: 0 };
+    this.customState = {};
+    this.networkId = networkId;
+    this.ownerId = ownerId;
+    this.type = type;
+  }
+  getState() {
+    return {
+      id: this.networkId,
+      ownerId: this.ownerId,
+      type: this.type,
+      position: { ...this.position },
+      rotation: { ...this.rotation },
+      velocity: { ...this.velocity },
+      customState: { ...this.customState }
+    };
+  }
+  applyState(state) {
+    this.position = { ...state.position };
+    this.rotation = { ...state.rotation };
+    if (state.velocity) {
+      this.velocity = { ...state.velocity };
+    }
+    if (state.customState) {
+      this.customState = { ...state.customState };
+    }
+  }
 }
-// ============================================================
-// Connection Implementations
-// ============================================================
 class NetworkConnection {
-    constructor() {
-        this.state = 'disconnected';
-        this.messageCallback = null;
-        this.disconnectCallback = null;
-    }
-    getState() {
-        return this.state;
-    }
-    onMessage(callback) {
-        this.messageCallback = callback;
-    }
-    onDisconnect(callback) {
-        this.disconnectCallback = callback;
-    }
+  constructor() {
+    this.state = "disconnected";
+    this.messageCallback = null;
+    this.disconnectCallback = null;
+  }
+  getState() {
+    return this.state;
+  }
+  onMessage(callback) {
+    this.messageCallback = callback;
+  }
+  onDisconnect(callback) {
+    this.disconnectCallback = callback;
+  }
 }
 class WebSocketConnection extends NetworkConnection {
-    constructor(url, config) {
-        super();
-        this.socket = null;
+  constructor(url, config) {
+    super();
+    this.socket = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.url = url;
+    this.config = config;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.state = "connecting";
+      this.socket = new WebSocket(this.url);
+      this.socket.onopen = () => {
+        this.state = "connected";
         this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = 5;
-        this.url = url;
-        this.config = config;
-    }
-    async connect() {
-        return new Promise((resolve, reject) => {
-            this.state = 'connecting';
-            this.socket = new WebSocket(this.url);
-            this.socket.onopen = () => {
-                this.state = 'connected';
-                this.reconnectAttempts = 0;
-                resolve();
-            };
-            this.socket.onmessage = (event) => {
-                try {
-                    const message = JSON.parse(event.data);
-                    this.messageCallback?.(message);
-                }
-                catch (e) {
-                    console.error('Failed to parse message:', e);
-                }
-            };
-            this.socket.onclose = (event) => {
-                this.state = 'disconnected';
-                this.disconnectCallback?.(event.reason || 'Connection closed');
-                // Attempt reconnection
-                if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                    this.reconnectAttempts++;
-                    setTimeout(() => this.connect(), 1000 * this.reconnectAttempts);
-                }
-            };
-            this.socket.onerror = () => {
-                this.state = 'disconnected';
-                reject(new Error('WebSocket connection failed'));
-            };
-            // Connection timeout
-            setTimeout(() => {
-                if (this.state === 'connecting') {
-                    this.socket?.close();
-                    reject(new Error('Connection timeout'));
-                }
-            }, this.config.timeoutDuration);
-        });
-    }
-    disconnect() {
-        this.state = 'disconnecting';
-        this.socket?.close();
-        this.socket = null;
-        this.state = 'disconnected';
-    }
-    send(message) {
-        if (this.socket && this.state === 'connected') {
-            const data = this.config.compressionEnabled
-                ? this.compress(JSON.stringify(message))
-                : JSON.stringify(message);
-            this.socket.send(data);
-        }
-    }
-    async start() {
-        // Client connection - use connect() instead
-        throw new Error('Use connect() for client connections');
-    }
-    compress(data) {
-        // Would implement compression
-        return data;
-    }
+        resolve();
+      };
+      this.socket.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.messageCallback?.(message);
+        } catch (e) {
+          console.error("Failed to parse message:", e);
+        }
+      };
+      this.socket.onclose = (event) => {
+        this.state = "disconnected";
+        this.disconnectCallback?.(event.reason || "Connection closed");
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.reconnectAttempts++;
+          setTimeout(() => this.connect(), 1e3 * this.reconnectAttempts);
+        }
+      };
+      this.socket.onerror = () => {
+        this.state = "disconnected";
+        reject(new Error("WebSocket connection failed"));
+      };
+      setTimeout(() => {
+        if (this.state === "connecting") {
+          this.socket?.close();
+          reject(new Error("Connection timeout"));
+        }
+      }, this.config.timeoutDuration);
+    });
+  }
+  disconnect() {
+    this.state = "disconnecting";
+    this.socket?.close();
+    this.socket = null;
+    this.state = "disconnected";
+  }
+  send(message) {
+    if (this.socket && this.state === "connected") {
+      const data = this.config.compressionEnabled ? this.compress(JSON.stringify(message)) : JSON.stringify(message);
+      this.socket.send(data);
+    }
+  }
+  async start() {
+    throw new Error("Use connect() for client connections");
+  }
+  compress(data) {
+    return data;
+  }
 }
 class WebSocketServer extends NetworkConnection {
-    constructor(port, config) {
-        super();
-        this.clients = new Map();
-        this.port = port;
-        this.config = config;
-    }
-    async connect() {
-        // Server doesn't connect - use start() instead
-        throw new Error('Use start() for server');
-    }
-    async start() {
-        // In browser environment, this would require a signaling server
-        // For Node.js, would use ws package
-        this.state = 'connected';
-        console.log(`Server started on port ${this.port}`);
-    }
-    disconnect() {
-        this.state = 'disconnecting';
-        for (const client of this.clients.values()) {
-            client.close();
-        }
-        this.clients.clear();
-        this.state = 'disconnected';
-    }
-    send(message) {
-        const data = JSON.stringify(message);
-        for (const client of this.clients.values()) {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(data);
-            }
-        }
-    }
-    sendToClient(clientId, message) {
-        const client = this.clients.get(clientId);
-        if (client && client.readyState === WebSocket.OPEN) {
-            client.send(JSON.stringify(message));
-        }
-    }
+  constructor(port, config) {
+    super();
+    this.clients = /* @__PURE__ */ new Map();
+    this.port = port;
+    this.config = config;
+  }
+  async connect() {
+    throw new Error("Use start() for server");
+  }
+  async start() {
+    this.state = "connected";
+    console.log(`Server started on port ${this.port}`);
+  }
+  disconnect() {
+    this.state = "disconnecting";
+    for (const client of this.clients.values()) {
+      client.close();
+    }
+    this.clients.clear();
+    this.state = "disconnected";
+  }
+  send(message) {
+    const data = JSON.stringify(message);
+    for (const client of this.clients.values()) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+  sendToClient(clientId, message) {
+    const client = this.clients.get(clientId);
+    if (client && client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify(message));
+    }
+  }
 }
 class LobbyManager {
-    constructor(network) {
-        this.currentLobby = null;
-        this.availableLobbies = [];
-        this.callbacks = {};
-        this.network = network;
-        this.setupMessageHandlers();
-    }
-    setupMessageHandlers() {
-        this.network.registerMessageHandler('lobby-created', (msg) => {
-            const lobby = msg.data;
-            this.currentLobby = lobby;
-            this.callbacks.onLobbyCreated?.(lobby);
-        });
-        this.network.registerMessageHandler('lobby-joined', (msg) => {
-            const lobby = msg.data;
-            this.currentLobby = lobby;
-            this.callbacks.onLobbyJoined?.(lobby);
-        });
-        this.network.registerMessageHandler('lobby-player-joined', (msg) => {
-            const player = msg.data;
-            if (this.currentLobby) {
-                this.currentLobby.players.push(player);
-                this.callbacks.onPlayerJoined?.(player);
-            }
-        });
-        this.network.registerMessageHandler('lobby-player-left', (msg) => {
-            const { playerId } = msg.data;
-            if (this.currentLobby) {
-                const idx = this.currentLobby.players.findIndex((p) => p.id === playerId);
-                if (idx >= 0) {
-                    const player = this.currentLobby.players.splice(idx, 1)[0];
-                    this.callbacks.onPlayerLeft?.(player);
-                }
-            }
-        });
-        this.network.registerMessageHandler('lobby-list', (msg) => {
-            this.availableLobbies = msg.data;
-        });
-        this.network.registerMessageHandler('game-starting', () => {
-            if (this.currentLobby) {
-                this.currentLobby.state = 'starting';
-                this.callbacks.onGameStarted?.();
-            }
-        });
-    }
-    // ─── Lobby Management ──────────────────────────────────
-    createLobby(config) {
-        this.network.sendMessage({
-            type: 'create-lobby',
-            channel: 'system',
-            mode: 'reliable',
-            data: config,
-        });
-    }
-    joinLobby(lobbyId, password) {
-        this.network.sendMessage({
-            type: 'join-lobby',
-            channel: 'system',
-            mode: 'reliable',
-            data: { lobbyId, password },
-        });
-    }
-    leaveLobby() {
-        if (!this.currentLobby) {
-            return;
-        }
-        this.network.sendMessage({
-            type: 'leave-lobby',
-            channel: 'system',
-            mode: 'reliable',
-            data: { lobbyId: this.currentLobby.id },
-        });
-        this.currentLobby = null;
-        this.callbacks.onLobbyLeft?.();
-    }
-    refreshLobbyList() {
-        this.network.sendMessage({
-            type: 'list-lobbies',
-            channel: 'system',
-            mode: 'reliable',
-            data: {},
-        });
-    }
-    startGame() {
-        if (!this.currentLobby) {
-            return;
-        }
-        this.network.sendMessage({
-            type: 'start-game',
-            channel: 'system',
-            mode: 'reliable',
-            data: { lobbyId: this.currentLobby.id },
-        });
-    }
-    // ─── Lobby Settings ────────────────────────────────────
-    updateLobbySettings(settings) {
-        if (!this.currentLobby) {
-            return;
-        }
-        this.network.sendMessage({
-            type: 'update-lobby',
-            channel: 'system',
-            mode: 'reliable',
-            data: { lobbyId: this.currentLobby.id, settings },
-        });
-    }
-    kickPlayer(playerId) {
-        if (!this.currentLobby) {
-            return;
-        }
-        this.network.sendMessage({
-            type: 'kick-player',
-            channel: 'system',
-            mode: 'reliable',
-            data: { lobbyId: this.currentLobby.id, playerId },
-        });
-    }
-    // ─── Getters ───────────────────────────────────────────
-    getCurrentLobby() {
-        return this.currentLobby;
-    }
-    getAvailableLobbies() {
-        return this.availableLobbies;
-    }
-    isInLobby() {
-        return this.currentLobby !== null;
-    }
-    isHost() {
-        const localPlayer = this.network.getLocalPlayer();
-        return this.currentLobby?.host.id === localPlayer?.id;
-    }
-    // ─── Events ────────────────────────────────────────────
-    on(event, callback) {
-        this.callbacks[event] = callback;
-    }
+  constructor(network) {
+    this.currentLobby = null;
+    this.availableLobbies = [];
+    this.callbacks = {};
+    this.network = network;
+    this.setupMessageHandlers();
+  }
+  setupMessageHandlers() {
+    this.network.registerMessageHandler("lobby-created", (msg) => {
+      const lobby = msg.data;
+      this.currentLobby = lobby;
+      this.callbacks.onLobbyCreated?.(lobby);
+    });
+    this.network.registerMessageHandler("lobby-joined", (msg) => {
+      const lobby = msg.data;
+      this.currentLobby = lobby;
+      this.callbacks.onLobbyJoined?.(lobby);
+    });
+    this.network.registerMessageHandler("lobby-player-joined", (msg) => {
+      const player = msg.data;
+      if (this.currentLobby) {
+        this.currentLobby.players.push(player);
+        this.callbacks.onPlayerJoined?.(player);
+      }
+    });
+    this.network.registerMessageHandler("lobby-player-left", (msg) => {
+      const { playerId } = msg.data;
+      if (this.currentLobby) {
+        const idx = this.currentLobby.players.findIndex((p) => p.id === playerId);
+        if (idx >= 0) {
+          const player = this.currentLobby.players.splice(idx, 1)[0];
+          this.callbacks.onPlayerLeft?.(player);
+        }
+      }
+    });
+    this.network.registerMessageHandler("lobby-list", (msg) => {
+      this.availableLobbies = msg.data;
+    });
+    this.network.registerMessageHandler("game-starting", () => {
+      if (this.currentLobby) {
+        this.currentLobby.state = "starting";
+        this.callbacks.onGameStarted?.();
+      }
+    });
+  }
+  // ─── Lobby Management ──────────────────────────────────
+  createLobby(config) {
+    this.network.sendMessage({
+      type: "create-lobby",
+      channel: "system",
+      mode: "reliable",
+      data: config
+    });
+  }
+  joinLobby(lobbyId, password) {
+    this.network.sendMessage({
+      type: "join-lobby",
+      channel: "system",
+      mode: "reliable",
+      data: { lobbyId, password }
+    });
+  }
+  leaveLobby() {
+    if (!this.currentLobby) {
+      return;
+    }
+    this.network.sendMessage({
+      type: "leave-lobby",
+      channel: "system",
+      mode: "reliable",
+      data: { lobbyId: this.currentLobby.id }
+    });
+    this.currentLobby = null;
+    this.callbacks.onLobbyLeft?.();
+  }
+  refreshLobbyList() {
+    this.network.sendMessage({
+      type: "list-lobbies",
+      channel: "system",
+      mode: "reliable",
+      data: {}
+    });
+  }
+  startGame() {
+    if (!this.currentLobby) {
+      return;
+    }
+    this.network.sendMessage({
+      type: "start-game",
+      channel: "system",
+      mode: "reliable",
+      data: { lobbyId: this.currentLobby.id }
+    });
+  }
+  // ─── Lobby Settings ────────────────────────────────────
+  updateLobbySettings(settings) {
+    if (!this.currentLobby) {
+      return;
+    }
+    this.network.sendMessage({
+      type: "update-lobby",
+      channel: "system",
+      mode: "reliable",
+      data: { lobbyId: this.currentLobby.id, settings }
+    });
+  }
+  kickPlayer(playerId) {
+    if (!this.currentLobby) {
+      return;
+    }
+    this.network.sendMessage({
+      type: "kick-player",
+      channel: "system",
+      mode: "reliable",
+      data: { lobbyId: this.currentLobby.id, playerId }
+    });
+  }
+  // ─── Getters ───────────────────────────────────────────
+  getCurrentLobby() {
+    return this.currentLobby;
+  }
+  getAvailableLobbies() {
+    return this.availableLobbies;
+  }
+  isInLobby() {
+    return this.currentLobby !== null;
+  }
+  isHost() {
+    const localPlayer = this.network.getLocalPlayer();
+    return this.currentLobby?.host.id === localPlayer?.id;
+  }
+  // ─── Events ────────────────────────────────────────────
+  on(event, callback) {
+    this.callbacks[event] = callback;
+  }
 }
 class MatchmakingManager {
-    constructor(network) {
-        this.status = {
-            state: 'idle',
-            playersFound: 0,
-            playersRequired: 0,
-            estimatedWait: 0,
-        };
-        this.callbacks = {};
-        this.network = network;
-        this.setupMessageHandlers();
-    }
-    setupMessageHandlers() {
-        this.network.registerMessageHandler('matchmaking-status', (msg) => {
-            this.status = msg.data;
-            this.callbacks.onStatusUpdate?.(this.status);
-        });
-        this.network.registerMessageHandler('match-found', (msg) => {
-            const { matchId } = msg.data;
-            this.status.state = 'found';
-            this.status.matchId = matchId;
-            this.callbacks.onMatchFound?.(matchId);
-        });
-        this.network.registerMessageHandler('match-failed', (msg) => {
-            const { reason } = msg.data;
-            this.status.state = 'failed';
-            this.callbacks.onMatchFailed?.(reason);
-        });
-    }
-    startMatchmaking(criteria) {
-        this.status = {
-            state: 'searching',
-            playersFound: 1,
-            playersRequired: criteria.teamSize ?? 2,
-            estimatedWait: 30,
-        };
-        this.network.sendMessage({
-            type: 'start-matchmaking',
-            channel: 'system',
-            mode: 'reliable',
-            data: criteria,
-        });
-        this.callbacks.onStatusUpdate?.(this.status);
-    }
-    cancelMatchmaking() {
-        this.network.sendMessage({
-            type: 'cancel-matchmaking',
-            channel: 'system',
-            mode: 'reliable',
-            data: {},
-        });
-        this.status.state = 'idle';
-        this.callbacks.onStatusUpdate?.(this.status);
-    }
-    acceptMatch() {
-        if (!this.status.matchId) {
-            return;
-        }
-        this.status.state = 'joining';
-        this.network.sendMessage({
-            type: 'accept-match',
-            channel: 'system',
-            mode: 'reliable',
-            data: { matchId: this.status.matchId },
-        });
-        this.callbacks.onStatusUpdate?.(this.status);
-    }
-    declineMatch() {
-        if (!this.status.matchId) {
-            return;
-        }
-        this.network.sendMessage({
-            type: 'decline-match',
-            channel: 'system',
-            mode: 'reliable',
-            data: { matchId: this.status.matchId },
-        });
-        this.status.state = 'searching';
-        delete this.status.matchId;
-        this.callbacks.onStatusUpdate?.(this.status);
-    }
-    getStatus() {
-        return { ...this.status };
-    }
-    isSearching() {
-        return this.status.state === 'searching';
-    }
-    on(event, callback) {
-        this.callbacks[event] = callback;
-    }
+  constructor(network) {
+    this.status = {
+      state: "idle",
+      playersFound: 0,
+      playersRequired: 0,
+      estimatedWait: 0
+    };
+    this.callbacks = {};
+    this.network = network;
+    this.setupMessageHandlers();
+  }
+  setupMessageHandlers() {
+    this.network.registerMessageHandler("matchmaking-status", (msg) => {
+      this.status = msg.data;
+      this.callbacks.onStatusUpdate?.(this.status);
+    });
+    this.network.registerMessageHandler("match-found", (msg) => {
+      const { matchId } = msg.data;
+      this.status.state = "found";
+      this.status.matchId = matchId;
+      this.callbacks.onMatchFound?.(matchId);
+    });
+    this.network.registerMessageHandler("match-failed", (msg) => {
+      const { reason } = msg.data;
+      this.status.state = "failed";
+      this.callbacks.onMatchFailed?.(reason);
+    });
+  }
+  startMatchmaking(criteria) {
+    this.status = {
+      state: "searching",
+      playersFound: 1,
+      playersRequired: criteria.teamSize ?? 2,
+      estimatedWait: 30
+    };
+    this.network.sendMessage({
+      type: "start-matchmaking",
+      channel: "system",
+      mode: "reliable",
+      data: criteria
+    });
+    this.callbacks.onStatusUpdate?.(this.status);
+  }
+  cancelMatchmaking() {
+    this.network.sendMessage({
+      type: "cancel-matchmaking",
+      channel: "system",
+      mode: "reliable",
+      data: {}
+    });
+    this.status.state = "idle";
+    this.callbacks.onStatusUpdate?.(this.status);
+  }
+  acceptMatch() {
+    if (!this.status.matchId) {
+      return;
+    }
+    this.status.state = "joining";
+    this.network.sendMessage({
+      type: "accept-match",
+      channel: "system",
+      mode: "reliable",
+      data: { matchId: this.status.matchId }
+    });
+    this.callbacks.onStatusUpdate?.(this.status);
+  }
+  declineMatch() {
+    if (!this.status.matchId) {
+      return;
+    }
+    this.network.sendMessage({
+      type: "decline-match",
+      channel: "system",
+      mode: "reliable",
+      data: { matchId: this.status.matchId }
+    });
+    this.status.state = "searching";
+    delete this.status.matchId;
+    this.callbacks.onStatusUpdate?.(this.status);
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  isSearching() {
+    return this.status.state === "searching";
+  }
+  on(event, callback) {
+    this.callbacks[event] = callback;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createNetworkManager(config) {
-    return new NetworkManager(config);
+  return new NetworkManager(config);
 }
 function createLobbyManager(network) {
-    return new LobbyManager(network);
+  return new LobbyManager(network);
 }
 function createMatchmakingManager(network) {
-    return new MatchmakingManager(network);
+  return new MatchmakingManager(network);
 }
-
 exports.LobbyManager = LobbyManager;
 exports.MatchmakingManager = MatchmakingManager;
 exports.NetworkEntity = NetworkEntity;