@gamerstake/game-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1632 @@
+import pino from 'pino';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var defaultLogger = pino({
+  level: process.env.LOG_LEVEL || "info",
+  transport: process.env.NODE_ENV === "development" ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "HH:MM:ss",
+      ignore: "pid,hostname"
+    }
+  } : void 0,
+  base: {
+    package: "@gamerstake/game-core"
+  }
+});
+var logger = defaultLogger;
+function setLogger(customLogger) {
+  logger = customLogger;
+}
+__name(setLogger, "setLogger");
+function createChildLogger(bindings) {
+  return logger.child(bindings);
+}
+__name(createChildLogger, "createChildLogger");
+var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
+  logger;
+  constructor(bindings) {
+    this.logger = bindings ? logger.child(bindings) : logger;
+  }
+  debug(objOrMsg, msg) {
+    if (typeof objOrMsg === "string") {
+      this.logger.debug(objOrMsg);
+    } else {
+      this.logger.debug(objOrMsg, msg);
+    }
+  }
+  info(objOrMsg, msg) {
+    if (typeof objOrMsg === "string") {
+      this.logger.info(objOrMsg);
+    } else {
+      this.logger.info(objOrMsg, msg);
+    }
+  }
+  warn(objOrMsg, msg) {
+    if (typeof objOrMsg === "string") {
+      this.logger.warn(objOrMsg);
+    } else {
+      this.logger.warn(objOrMsg, msg);
+    }
+  }
+  error(objOrMsg, msg) {
+    if (typeof objOrMsg === "string") {
+      this.logger.error(objOrMsg);
+    } else {
+      this.logger.error(objOrMsg, msg);
+    }
+  }
+  child(bindings) {
+    const childLogger = new _Logger();
+    childLogger.logger = this.logger.child(bindings);
+    return childLogger;
+  }
+};
+
+// src/core/GameLoop.ts
+var GameLoop = class {
+  static {
+    __name(this, "GameLoop");
+  }
+  tickRate;
+  tickMs;
+  tickNumber = 0;
+  lastTickTime = 0;
+  running = false;
+  timeout = null;
+  handlers = [];
+  // Performance metrics
+  tickTimes = [];
+  metricsWindowSize = 100;
+  /**
+  * Create a new game loop.
+  *
+  * @param tickRate - Ticks per second (default: 20)
+  */
+  constructor(tickRate = 20) {
+    this.tickRate = tickRate;
+    this.tickMs = 1e3 / tickRate;
+  }
+  /**
+  * Register a tick handler.
+  */
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  /**
+  * Remove a tick handler.
+  */
+  removeHandler(handler) {
+    const index = this.handlers.indexOf(handler);
+    if (index !== -1) {
+      this.handlers.splice(index, 1);
+    }
+  }
+  /**
+  * Start the game loop.
+  */
+  start() {
+    if (this.running) {
+      logger.warn("Game loop already running");
+      return;
+    }
+    this.running = true;
+    this.lastTickTime = performance.now();
+    this.tickNumber = 0;
+    logger.info({
+      tickRate: this.tickRate,
+      tickMs: this.tickMs
+    }, "Game loop started");
+    this.scheduleNextTick();
+  }
+  /**
+  * Stop the game loop.
+  */
+  stop() {
+    this.running = false;
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    logger.info({
+      totalTicks: this.tickNumber
+    }, "Game loop stopped");
+  }
+  /**
+  * Check if loop is running.
+  */
+  isRunning() {
+    return this.running;
+  }
+  /**
+  * Get current tick number.
+  */
+  getCurrentTick() {
+    return this.tickNumber;
+  }
+  /**
+  * Get tick rate (TPS).
+  */
+  getTickRate() {
+    return this.tickRate;
+  }
+  /**
+  * Get tick duration (ms).
+  */
+  getTickMs() {
+    return this.tickMs;
+  }
+  /**
+  * Get performance metrics.
+  */
+  getMetrics() {
+    if (this.tickTimes.length === 0) {
+      return {
+        avgTickTime: 0,
+        maxTickTime: 0,
+        minTickTime: 0,
+        ticksPerSecond: 0
+      };
+    }
+    const sum = this.tickTimes.reduce((a, b) => a + b, 0);
+    const avg = sum / this.tickTimes.length;
+    return {
+      avgTickTime: avg,
+      maxTickTime: Math.max(...this.tickTimes),
+      minTickTime: Math.min(...this.tickTimes),
+      ticksPerSecond: 1e3 / avg
+    };
+  }
+  /**
+  * Schedule the next tick with drift compensation.
+  */
+  scheduleNextTick() {
+    if (!this.running) return;
+    const now = performance.now();
+    const elapsed = now - this.lastTickTime;
+    const drift = elapsed - this.tickMs;
+    const nextDelay = Math.max(0, this.tickMs - drift);
+    this.timeout = setTimeout(() => this.tick(), nextDelay);
+  }
+  /**
+  * Execute one tick.
+  */
+  tick() {
+    const tickStart = performance.now();
+    const deltaMs = tickStart - this.lastTickTime;
+    this.lastTickTime = tickStart;
+    this.tickNumber++;
+    try {
+      for (const handler of this.handlers) {
+        handler.onTick(this.tickNumber, deltaMs);
+      }
+    } catch (error) {
+      logger.error({
+        error,
+        tick: this.tickNumber
+      }, "Error in tick handler");
+    }
+    const tickDuration = performance.now() - tickStart;
+    this.recordTickTime(tickDuration);
+    if (tickDuration > this.tickMs * 0.8) {
+      logger.warn({
+        tickNumber: this.tickNumber,
+        duration: tickDuration,
+        budget: this.tickMs
+      }, "Tick took too long");
+    }
+    this.scheduleNextTick();
+  }
+  /**
+  * Record tick time for metrics.
+  */
+  recordTickTime(duration) {
+    this.tickTimes.push(duration);
+    if (this.tickTimes.length > this.metricsWindowSize) {
+      this.tickTimes.shift();
+    }
+  }
+};
+
+// src/entities/Registry.ts
+var Registry = class {
+  static {
+    __name(this, "Registry");
+  }
+  entities = /* @__PURE__ */ new Map();
+  dirtyEntities = /* @__PURE__ */ new Set();
+  // Pre-allocated buffers to avoid allocations in hot paths
+  dirtyBuffer = [];
+  allBuffer = [];
+  /**
+  * Add an entity to the registry.
+  */
+  add(entity) {
+    if (this.entities.has(entity.id)) {
+      logger.warn({
+        entityId: entity.id
+      }, "Entity already exists in registry");
+      return;
+    }
+    this.entities.set(entity.id, entity);
+    this.dirtyEntities.add(entity.id);
+    logger.debug({
+      entityId: entity.id
+    }, "Entity added to registry");
+  }
+  /**
+  * Remove an entity from the registry.
+  */
+  remove(entityId) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return false;
+    this.entities.delete(entityId);
+    this.dirtyEntities.delete(entityId);
+    logger.debug({
+      entityId
+    }, "Entity removed from registry");
+    return true;
+  }
+  /**
+  * Get an entity by ID.
+  */
+  get(entityId) {
+    return this.entities.get(entityId);
+  }
+  /**
+  * Check if entity exists.
+  */
+  has(entityId) {
+    return this.entities.has(entityId);
+  }
+  /**
+  * Mark an entity as dirty (needs broadcast).
+  */
+  markDirty(entityId) {
+    if (this.entities.has(entityId)) {
+      this.dirtyEntities.add(entityId);
+    }
+  }
+  /**
+  * Get all dirty entities and clear dirty flags.
+  * OPTIMIZED: Reuses buffer array to avoid allocations.
+  *
+  * @returns Array of dirty entities (reused buffer - don't store reference!)
+  */
+  getDirtyEntities() {
+    this.dirtyBuffer.length = 0;
+    for (const entityId of this.dirtyEntities) {
+      const entity = this.entities.get(entityId);
+      if (entity) {
+        this.dirtyBuffer.push(entity);
+        entity.markClean();
+      }
+    }
+    this.dirtyEntities.clear();
+    return this.dirtyBuffer;
+  }
+  /**
+  * Get all entities.
+  * OPTIMIZED: Reuses buffer array to avoid allocations.
+  *
+  * @returns Array of all entities (reused buffer - don't store reference!)
+  */
+  getAll() {
+    this.allBuffer.length = 0;
+    for (const entity of this.entities.values()) {
+      this.allBuffer.push(entity);
+    }
+    return this.allBuffer;
+  }
+  /**
+  * Get entity count.
+  */
+  size() {
+    return this.entities.size;
+  }
+  /**
+  * Get dirty entity count.
+  */
+  dirtyCount() {
+    return this.dirtyEntities.size;
+  }
+  /**
+  * Clear all entities.
+  */
+  clear() {
+    this.entities.clear();
+    this.dirtyEntities.clear();
+    logger.debug("Registry cleared");
+  }
+  /**
+  * Execute callback for each entity.
+  */
+  forEach(callback) {
+    for (const entity of this.entities.values()) {
+      callback(entity);
+    }
+  }
+  /**
+  * Filter entities by predicate.
+  *
+  * @param predicate - Filter function
+  * @returns New array of matching entities
+  */
+  filter(predicate) {
+    const result = [];
+    for (const entity of this.entities.values()) {
+      if (predicate(entity)) {
+        result.push(entity);
+      }
+    }
+    return result;
+  }
+};
+
+// src/spatial/Grid.ts
+var Grid = class {
+  static {
+    __name(this, "Grid");
+  }
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  entityCells = /* @__PURE__ */ new Map();
+  /**
+  * Create a new spatial grid.
+  *
+  * @param cellSize - Size of each cell in world units (default: 512)
+  */
+  constructor(cellSize = 512) {
+    this.cellSize = cellSize;
+  }
+  /**
+  * Convert world coordinates to cell key.
+  */
+  getCellKey(worldX, worldY) {
+    const cellX = Math.floor(worldX / this.cellSize);
+    const cellY = Math.floor(worldY / this.cellSize);
+    return `${cellX},${cellY}`;
+  }
+  /**
+  * Get or create a cell at world coordinates.
+  */
+  getCell(worldX, worldY) {
+    const key = this.getCellKey(worldX, worldY);
+    let cell = this.cells.get(key);
+    if (!cell) {
+      const cellX = Math.floor(worldX / this.cellSize);
+      const cellY = Math.floor(worldY / this.cellSize);
+      cell = {
+        x: cellX,
+        y: cellY,
+        entities: /* @__PURE__ */ new Set()
+      };
+      this.cells.set(key, cell);
+    }
+    return cell;
+  }
+  /**
+  * Add an entity to the grid.
+  */
+  addEntity(entityId, x, y) {
+    const cell = this.getCell(x, y);
+    cell.entities.add(entityId);
+    this.entityCells.set(entityId, this.getCellKey(x, y));
+    logger.debug({
+      entityId,
+      cellX: cell.x,
+      cellY: cell.y
+    }, "Entity added to grid");
+  }
+  /**
+  * Remove an entity from the grid.
+  */
+  removeEntity(entityId) {
+    const cellKey = this.entityCells.get(entityId);
+    if (!cellKey) return;
+    const cell = this.cells.get(cellKey);
+    if (cell) {
+      cell.entities.delete(entityId);
+      if (cell.entities.size === 0) {
+        this.cells.delete(cellKey);
+      }
+    }
+    this.entityCells.delete(entityId);
+    logger.debug({
+      entityId
+    }, "Entity removed from grid");
+  }
+  /**
+  * Move an entity to a new position.
+  * Returns true if the entity changed cells.
+  */
+  moveEntity(entityId, oldX, oldY, newX, newY) {
+    const oldKey = this.getCellKey(oldX, oldY);
+    const newKey = this.getCellKey(newX, newY);
+    if (oldKey === newKey) {
+      return false;
+    }
+    const oldCell = this.cells.get(oldKey);
+    if (oldCell) {
+      oldCell.entities.delete(entityId);
+      if (oldCell.entities.size === 0) {
+        this.cells.delete(oldKey);
+      }
+    }
+    const newCell = this.getCell(newX, newY);
+    newCell.entities.add(entityId);
+    this.entityCells.set(entityId, newKey);
+    logger.debug({
+      entityId,
+      oldKey,
+      newKey
+    }, "Entity moved to new cell");
+    return true;
+  }
+  /**
+  * Get all entities in nearby cells.
+  *
+  * @param worldX - World X coordinate
+  * @param worldY - World Y coordinate
+  * @param range - Range in grid cells (default: 1 = 3x3 area)
+  */
+  getNearbyEntities(worldX, worldY, range = 1) {
+    const centerCellX = Math.floor(worldX / this.cellSize);
+    const centerCellY = Math.floor(worldY / this.cellSize);
+    const entities = [];
+    for (let dx = -range; dx <= range; dx++) {
+      for (let dy = -range; dy <= range; dy++) {
+        const key = `${centerCellX + dx},${centerCellY + dy}`;
+        const cell = this.cells.get(key);
+        if (cell) {
+          entities.push(...cell.entities);
+        }
+      }
+    }
+    return entities;
+  }
+  /**
+  * Get entities in a specific cell.
+  */
+  getEntitiesInCell(worldX, worldY) {
+    const cell = this.cells.get(this.getCellKey(worldX, worldY));
+    return cell ? Array.from(cell.entities) : [];
+  }
+  /**
+  * Get the cell an entity is in.
+  */
+  getEntityCell(entityId) {
+    return this.entityCells.get(entityId);
+  }
+  /**
+  * Get total number of active cells.
+  */
+  getCellCount() {
+    return this.cells.size;
+  }
+  /**
+  * Get total entities in grid.
+  */
+  getEntityCount() {
+    return this.entityCells.size;
+  }
+  /**
+  * Clear all cells and entities.
+  */
+  clear() {
+    this.cells.clear();
+    this.entityCells.clear();
+    logger.debug("Grid cleared");
+  }
+};
+
+// src/utils/RingBuffer.ts
+var RingBuffer = class {
+  static {
+    __name(this, "RingBuffer");
+  }
+  capacity;
+  buffer;
+  head;
+  tail;
+  count;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.head = 0;
+    this.tail = 0;
+    this.count = 0;
+    this.buffer = new Array(capacity);
+  }
+  /**
+  * Add item to buffer. O(1)
+  * Returns false if buffer is full.
+  */
+  push(item) {
+    if (this.count >= this.capacity) {
+      return false;
+    }
+    this.buffer[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    this.count++;
+    return true;
+  }
+  /**
+  * Add item, overwriting oldest if full. O(1)
+  */
+  pushOverwrite(item) {
+    let dropped;
+    if (this.count >= this.capacity) {
+      dropped = this.buffer[this.tail];
+      this.tail = (this.tail + 1) % this.capacity;
+      this.count--;
+    }
+    this.buffer[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    this.count++;
+    return dropped;
+  }
+  /**
+  * Remove and return oldest item. O(1)
+  */
+  shift() {
+    if (this.count === 0) {
+      return void 0;
+    }
+    const item = this.buffer[this.tail];
+    this.buffer[this.tail] = void 0;
+    this.tail = (this.tail + 1) % this.capacity;
+    this.count--;
+    return item;
+  }
+  /**
+  * Peek at oldest item without removing. O(1)
+  */
+  peek() {
+    if (this.count === 0) {
+      return void 0;
+    }
+    return this.buffer[this.tail];
+  }
+  /**
+  * Get current size.
+  */
+  size() {
+    return this.count;
+  }
+  /**
+  * Check if empty.
+  */
+  isEmpty() {
+    return this.count === 0;
+  }
+  /**
+  * Check if full.
+  */
+  isFull() {
+    return this.count >= this.capacity;
+  }
+  /**
+  * Clear all items. O(1)
+  */
+  clear() {
+    this.head = 0;
+    this.tail = 0;
+    this.count = 0;
+  }
+  /**
+  * Get capacity.
+  */
+  getCapacity() {
+    return this.capacity;
+  }
+};
+
+// src/input/InputQueue.ts
+var InputQueue = class {
+  static {
+    __name(this, "InputQueue");
+  }
+  queues = /* @__PURE__ */ new Map();
+  maxQueueSize;
+  /**
+  * Create a new input queue manager.
+  *
+  * @param maxQueueSize - Maximum inputs per player (default: 100)
+  */
+  constructor(maxQueueSize = 100) {
+    this.maxQueueSize = maxQueueSize;
+  }
+  /**
+  * Get or create a player's queue.
+  */
+  getQueue(playerId) {
+    let queue = this.queues.get(playerId);
+    if (!queue) {
+      queue = new RingBuffer(this.maxQueueSize);
+      this.queues.set(playerId, queue);
+    }
+    return queue;
+  }
+  /**
+  * Add an input to a player's queue. O(1)
+  */
+  push(playerId, input) {
+    const queue = this.getQueue(playerId);
+    const dropped = queue.pushOverwrite(input);
+    if (dropped) {
+      logger.debug({
+        playerId
+      }, "Input queue overflow, dropped oldest");
+    }
+  }
+  /**
+  * Get and remove the next input for a player. O(1)
+  */
+  pop(playerId) {
+    const queue = this.queues.get(playerId);
+    if (!queue) return void 0;
+    return queue.shift();
+  }
+  /**
+  * Peek at the next input without removing. O(1)
+  */
+  peek(playerId) {
+    const queue = this.queues.get(playerId);
+    return queue?.peek();
+  }
+  /**
+  * Get all inputs for a player and clear.
+  */
+  drain(playerId) {
+    const queue = this.queues.get(playerId);
+    if (!queue) return [];
+    const inputs = [];
+    while (!queue.isEmpty()) {
+      const input = queue.shift();
+      if (input) inputs.push(input);
+    }
+    return inputs;
+  }
+  /**
+  * Get queue size for a player.
+  */
+  size(playerId) {
+    return this.queues.get(playerId)?.size() ?? 0;
+  }
+  /**
+  * Clear a player's queue.
+  */
+  clear(playerId) {
+    const queue = this.queues.get(playerId);
+    if (queue) {
+      queue.clear();
+    }
+  }
+  /**
+  * Remove a player's queue entirely.
+  */
+  remove(playerId) {
+    this.queues.delete(playerId);
+  }
+  /**
+  * Clear all queues.
+  */
+  clearAll() {
+    this.queues.clear();
+  }
+  /**
+  * Get total queued inputs across all players.
+  */
+  getTotalSize() {
+    let total = 0;
+    for (const queue of this.queues.values()) {
+      total += queue.size();
+    }
+    return total;
+  }
+};
+
+// src/network/Network.ts
+var Network = class {
+  static {
+    __name(this, "Network");
+  }
+  io = null;
+  sockets = /* @__PURE__ */ new Map();
+  /**
+  * Set the Socket.io server instance.
+  */
+  setServer(io) {
+    this.io = io;
+  }
+  /**
+  * Register a socket connection.
+  */
+  registerSocket(playerId, socket) {
+    this.sockets.set(playerId, socket);
+    logger.debug({
+      playerId
+    }, "Socket registered");
+  }
+  /**
+  * Unregister a socket connection.
+  */
+  unregisterSocket(playerId) {
+    this.sockets.delete(playerId);
+    logger.debug({
+      playerId
+    }, "Socket unregistered");
+  }
+  /**
+  * Get a socket by player ID.
+  */
+  getSocket(playerId) {
+    return this.sockets.get(playerId);
+  }
+  /**
+  * Broadcast event to all connected players.
+  */
+  broadcast(event) {
+    if (!this.io) {
+      logger.warn("Cannot broadcast - no Socket.io server set");
+      return;
+    }
+    this.io.emit(event.op, event);
+    logger.debug({
+      opcode: event.op
+    }, "Broadcast event");
+  }
+  /**
+  * Broadcast event to all players in a room.
+  */
+  broadcastToRoom(roomId, event) {
+    if (!this.io) {
+      logger.warn("Cannot broadcast - no Socket.io server set");
+      return;
+    }
+    this.io.to(roomId).emit(event.op, event);
+    logger.debug({
+      roomId,
+      opcode: event.op
+    }, "Broadcast to room");
+  }
+  /**
+  * Send event to a specific player.
+  */
+  sendTo(playerId, event) {
+    const socket = this.sockets.get(playerId);
+    if (!socket) {
+      logger.warn({
+        playerId
+      }, "Cannot send - socket not found");
+      return;
+    }
+    socket.emit(event.op, event);
+    logger.debug({
+      playerId,
+      opcode: event.op
+    }, "Sent to player");
+  }
+  /**
+  * Send event to multiple players.
+  */
+  sendToMany(playerIds, event) {
+    for (const playerId of playerIds) {
+      this.sendTo(playerId, event);
+    }
+  }
+  /**
+  * Get connected player count.
+  */
+  getPlayerCount() {
+    return this.sockets.size;
+  }
+  /**
+  * Clear all sockets.
+  */
+  clear() {
+    this.sockets.clear();
+  }
+};
+
+// src/network/Snapshot.ts
+var Snapshot = class {
+  static {
+    __name(this, "Snapshot");
+  }
+  /**
+  * Create a full state snapshot from entities.
+  *
+  * @param tick - Current tick number
+  * @param entities - Array of entities to snapshot
+  * @returns Full state snapshot
+  */
+  static create(tick, entities) {
+    return {
+      tick,
+      timestamp: Date.now(),
+      entities: entities.map((e) => this.entityToSnapshot(e))
+    };
+  }
+  /**
+  * Convert an entity to a snapshot.
+  */
+  static entityToSnapshot(entity) {
+    return {
+      id: entity.id,
+      x: entity.x,
+      y: entity.y,
+      vx: entity.vx,
+      vy: entity.vy
+    };
+  }
+  /**
+  * Create a delta snapshot (only dirty entities).
+  *
+  * @param tick - Current tick number
+  * @param dirtyEntities - Array of dirty entities
+  * @returns Delta snapshot
+  */
+  static createDelta(tick, dirtyEntities) {
+    return {
+      tick,
+      timestamp: Date.now(),
+      entities: dirtyEntities.map((e) => this.entityToSnapshot(e))
+    };
+  }
+};
+
+// src/core/Room.ts
+var Room = class {
+  static {
+    __name(this, "Room");
+  }
+  /** Room identifier */
+  id;
+  /** Game-specific logic */
+  rules;
+  // Core systems
+  registry;
+  grid;
+  loop;
+  inputQueue;
+  network;
+  // State
+  players = /* @__PURE__ */ new Map();
+  tickCount = 0;
+  startTime = 0;
+  config;
+  /**
+  * Create a new room.
+  *
+  * @param id - Unique room identifier
+  * @param rules - Game-specific logic
+  * @param config - Room configuration
+  */
+  constructor(id, rules, config) {
+    this.id = id;
+    this.rules = rules;
+    this.config = {
+      tickRate: config?.tickRate ?? 20,
+      cellSize: config?.cellSize ?? 512,
+      maxInputQueueSize: config?.maxInputQueueSize ?? 100,
+      maxEntities: config?.maxEntities ?? 1e3,
+      visibilityRange: config?.visibilityRange ?? 1
+    };
+    this.registry = new Registry();
+    this.grid = new Grid(this.config.cellSize);
+    this.loop = new GameLoop(this.config.tickRate);
+    this.inputQueue = new InputQueue(this.config.maxInputQueueSize);
+    this.network = new Network();
+    this.loop.addHandler(this);
+    logger.info({
+      roomId: id,
+      config: this.config
+    }, "Room created");
+  }
+  /**
+  * Start the room (begins tick loop).
+  */
+  start() {
+    this.startTime = Date.now();
+    try {
+      this.rules.onRoomCreated(this);
+    } catch (error) {
+      logger.error({
+        error,
+        roomId: this.id
+      }, "Error in onRoomCreated");
+    }
+    this.loop.start();
+    logger.info({
+      roomId: this.id
+    }, "Room started");
+  }
+  /**
+  * Stop the room (ends tick loop).
+  */
+  stop() {
+    this.loop.stop();
+    logger.info({
+      roomId: this.id,
+      totalTicks: this.tickCount
+    }, "Room stopped");
+  }
+  /**
+  * Add a player to the room.
+  */
+  addPlayer(player) {
+    if (this.players.has(player.id)) {
+      logger.warn({
+        playerId: player.id
+      }, "Player already in room");
+      return;
+    }
+    this.players.set(player.id, player);
+    this.registry.add(player);
+    this.grid.addEntity(player.id, player.x, player.y);
+    try {
+      this.rules.onPlayerJoin(this, player);
+    } catch (error) {
+      logger.error({
+        error,
+        playerId: player.id
+      }, "Error in onPlayerJoin");
+    }
+    logger.info({
+      roomId: this.id,
+      playerId: player.id
+    }, "Player joined");
+  }
+  /**
+  * Remove a player from the room.
+  */
+  removePlayer(playerId) {
+    const player = this.players.get(playerId);
+    if (!player) return;
+    this.players.delete(playerId);
+    this.registry.remove(playerId);
+    this.grid.removeEntity(playerId);
+    this.inputQueue.remove(playerId);
+    try {
+      this.rules.onPlayerLeave(this, playerId);
+    } catch (error) {
+      logger.error({
+        error,
+        playerId
+      }, "Error in onPlayerLeave");
+    }
+    logger.info({
+      roomId: this.id,
+      playerId
+    }, "Player left");
+  }
+  /**
+  * Spawn a non-player entity.
+  */
+  spawnEntity(entity) {
+    if (this.registry.size() >= this.config.maxEntities) {
+      logger.warn({
+        roomId: this.id
+      }, "Max entities reached, cannot spawn");
+      return;
+    }
+    this.registry.add(entity);
+    this.grid.addEntity(entity.id, entity.x, entity.y);
+    logger.debug({
+      entityId: entity.id
+    }, "Entity spawned");
+  }
+  /**
+  * Destroy an entity.
+  */
+  destroyEntity(entityId) {
+    const entity = this.registry.get(entityId);
+    if (!entity) return;
+    this.registry.remove(entityId);
+    this.grid.removeEntity(entityId);
+    logger.debug({
+      entityId
+    }, "Entity destroyed");
+  }
+  /**
+  * Queue a player input.
+  */
+  queueInput(playerId, command) {
+    if (!this.players.has(playerId)) {
+      logger.warn({
+        playerId
+      }, "Input from non-player");
+      return;
+    }
+    this.inputQueue.push(playerId, command);
+  }
+  /**
+  * Broadcast event to all players.
+  */
+  broadcast(event) {
+    this.network.broadcastToRoom(this.id, event);
+  }
+  /**
+  * Send event to specific player.
+  */
+  sendTo(playerId, event) {
+    this.network.sendTo(playerId, event);
+  }
+  /**
+  * Get full state snapshot.
+  */
+  getSnapshot() {
+    return Snapshot.create(this.tickCount, this.registry.getAll());
+  }
+  /**
+  * Get delta snapshot (only dirty entities).
+  */
+  getDeltaSnapshot() {
+    return Snapshot.createDelta(this.tickCount, this.registry.getDirtyEntities());
+  }
+  /**
+  * Main tick function (called by GameLoop).
+  */
+  onTick(tickNumber, deltaMs) {
+    this.tickCount = tickNumber;
+    for (const [playerId] of this.players) {
+      const inputs = this.inputQueue.drain(playerId);
+      for (const input of inputs) {
+        try {
+          this.rules.onCommand(this, playerId, input);
+        } catch (error) {
+          logger.error({
+            error,
+            playerId,
+            command: input.type
+          }, "Error in onCommand");
+        }
+      }
+    }
+    try {
+      this.rules.onTick(this, deltaMs);
+    } catch (error) {
+      logger.error({
+        error,
+        tick: tickNumber
+      }, "Error in onTick");
+    }
+    const dirtyEntities = this.registry.getDirtyEntities();
+    if (dirtyEntities.length > 0) {
+      const delta = Snapshot.createDelta(this.tickCount, dirtyEntities);
+      this.broadcast({
+        op: "S_UPDATE",
+        ...delta
+      });
+    }
+    try {
+      if (this.rules.shouldEndRoom(this)) {
+        logger.info({
+          roomId: this.id
+        }, "Room ending per game rules");
+        this.stop();
+      }
+    } catch (error) {
+      logger.error({
+        error
+      }, "Error in shouldEndRoom");
+    }
+  }
+  // Getters
+  /**
+  * Get all players.
+  */
+  getPlayers() {
+    return this.players;
+  }
+  /**
+  * Get entity registry.
+  */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+  * Get spatial grid.
+  */
+  getGrid() {
+    return this.grid;
+  }
+  /**
+  * Get network layer.
+  */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+  * Get input queue.
+  */
+  getInputQueue() {
+    return this.inputQueue;
+  }
+  /**
+  * Get current tick number.
+  */
+  getTickCount() {
+    return this.tickCount;
+  }
+  /**
+  * Get uptime in milliseconds.
+  */
+  getUptime() {
+    return Date.now() - this.startTime;
+  }
+  /**
+  * Check if room is running.
+  */
+  isRunning() {
+    return this.loop.isRunning();
+  }
+  /**
+  * Get room configuration.
+  */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+  /**
+  * Get room metrics.
+  */
+  getMetrics() {
+    const loopMetrics = this.loop.getMetrics();
+    return {
+      roomId: this.id,
+      tickCount: this.tickCount,
+      uptime: this.getUptime(),
+      playerCount: this.players.size,
+      entityCount: this.registry.size(),
+      cellCount: this.grid.getCellCount(),
+      queuedInputs: this.inputQueue.getTotalSize(),
+      ...loopMetrics
+    };
+  }
+};
+
+// src/core/GameServer.ts
+var GameServer = class {
+  static {
+    __name(this, "GameServer");
+  }
+  rooms = /* @__PURE__ */ new Map();
+  io = null;
+  /**
+  * Set the Socket.io server instance.
+  *
+  * This should be called before creating rooms to enable
+  * network functionality.
+  */
+  setServer(io) {
+    this.io = io;
+    for (const room of this.rooms.values()) {
+      room.getNetwork().setServer(io);
+    }
+    logger.info("Socket.io server set");
+  }
+  /**
+  * Create a new room.
+  *
+  * @param id - Unique room identifier
+  * @param rules - Game-specific logic
+  * @param config - Room configuration
+  * @returns The created room
+  * @throws If room with same ID already exists
+  */
+  createRoom(id, rules, config) {
+    if (this.rooms.has(id)) {
+      throw new Error(`Room ${id} already exists`);
+    }
+    const room = new Room(id, rules, config);
+    if (this.io) {
+      room.getNetwork().setServer(this.io);
+    }
+    this.rooms.set(id, room);
+    room.start();
+    logger.info({
+      roomId: id
+    }, "Room created and started");
+    return room;
+  }
+  /**
+  * Destroy a room.
+  *
+  * Stops the room's tick loop and removes it from the server.
+  *
+  * @param id - Room identifier
+  * @returns True if room was destroyed, false if not found
+  */
+  destroyRoom(id) {
+    const room = this.rooms.get(id);
+    if (!room) {
+      logger.warn({
+        roomId: id
+      }, "Cannot destroy - room not found");
+      return false;
+    }
+    room.stop();
+    this.rooms.delete(id);
+    logger.info({
+      roomId: id
+    }, "Room destroyed");
+    return true;
+  }
+  /**
+  * Get a room by ID.
+  */
+  getRoom(id) {
+    return this.rooms.get(id);
+  }
+  /**
+  * Get a room with specific entity type.
+  *
+  * @param id - Room identifier
+  * @returns Room cast to specific entity type, or undefined
+  */
+  getRoomAs(id) {
+    return this.rooms.get(id);
+  }
+  /**
+  * Check if room exists.
+  */
+  hasRoom(id) {
+    return this.rooms.has(id);
+  }
+  /**
+  * Get all rooms.
+  */
+  getRooms() {
+    return this.rooms;
+  }
+  /**
+  * Get room count.
+  */
+  getRoomCount() {
+    return this.rooms.size;
+  }
+  /**
+  * Get total player count across all rooms.
+  */
+  getTotalPlayerCount() {
+    let total = 0;
+    for (const room of this.rooms.values()) {
+      total += room.getPlayers().size;
+    }
+    return total;
+  }
+  /**
+  * Get server health metrics.
+  */
+  getMetrics() {
+    return {
+      roomCount: this.rooms.size,
+      totalPlayers: this.getTotalPlayerCount(),
+      rooms: Array.from(this.rooms.values()).map((room) => ({
+        id: room.id,
+        playerCount: room.getPlayers().size,
+        entityCount: room.getRegistry().size(),
+        tickCount: room.getTickCount(),
+        isRunning: room.isRunning(),
+        avgTickTime: room.getMetrics().avgTickTime,
+        ticksPerSecond: room.getMetrics().ticksPerSecond
+      }))
+    };
+  }
+  /**
+  * Stop all rooms.
+  */
+  stopAll() {
+    logger.info({
+      roomCount: this.rooms.size
+    }, "Stopping all rooms");
+    for (const room of this.rooms.values()) {
+      room.stop();
+    }
+  }
+  /**
+  * Destroy all rooms.
+  */
+  destroyAll() {
+    logger.info({
+      roomCount: this.rooms.size
+    }, "Destroying all rooms");
+    for (const room of this.rooms.values()) {
+      room.stop();
+    }
+    this.rooms.clear();
+  }
+};
+
+// src/entities/Entity.ts
+var Entity = class {
+  static {
+    __name(this, "Entity");
+  }
+  /** Unique entity identifier */
+  id;
+  /** World X position */
+  x;
+  /** World Y position */
+  y;
+  /** Velocity X (units/second) */
+  vx;
+  /** Velocity Y (units/second) */
+  vy;
+  /** Dirty flag - entity needs to be broadcast */
+  dirty;
+  /** Last update timestamp */
+  lastUpdate;
+  /**
+  * Create a new entity.
+  *
+  * @param id - Unique identifier
+  * @param x - Initial X position
+  * @param y - Initial Y position
+  */
+  constructor(id, x, y) {
+    this.id = id;
+    this.x = x;
+    this.y = y;
+    this.vx = 0;
+    this.vy = 0;
+    this.dirty = true;
+    this.lastUpdate = Date.now();
+  }
+  /**
+  * Update position based on velocity and delta time.
+  *
+  * @param deltaMs - Time since last update (milliseconds)
+  */
+  updatePosition(deltaMs) {
+    if (this.vx !== 0 || this.vy !== 0) {
+      const deltaSec = deltaMs / 1e3;
+      this.x += this.vx * deltaSec;
+      this.y += this.vy * deltaSec;
+      this.dirty = true;
+      this.lastUpdate = Date.now();
+    }
+  }
+  /**
+  * Set velocity.
+  */
+  setVelocity(vx, vy) {
+    if (this.vx !== vx || this.vy !== vy) {
+      this.vx = vx;
+      this.vy = vy;
+      this.dirty = true;
+      this.lastUpdate = Date.now();
+    }
+  }
+  /**
+  * Teleport to position (no velocity integration).
+  */
+  setPosition(x, y) {
+    if (this.x !== x || this.y !== y) {
+      this.x = x;
+      this.y = y;
+      this.dirty = true;
+      this.lastUpdate = Date.now();
+    }
+  }
+  /**
+  * Mark entity as clean (after broadcast).
+  */
+  markClean() {
+    this.dirty = false;
+  }
+  /**
+  * Mark entity as dirty (needs broadcast).
+  */
+  markDirty() {
+    this.dirty = true;
+  }
+  /**
+  * Get entity as plain object for serialization.
+  */
+  toJSON() {
+    return {
+      id: this.id,
+      x: this.x,
+      y: this.y,
+      vx: this.vx,
+      vy: this.vy
+    };
+  }
+};
+
+// src/physics/AABB.ts
+var AABBCollision = class {
+  static {
+    __name(this, "AABBCollision");
+  }
+  /**
+  * Check if two AABBs overlap.
+  */
+  static overlaps(a, b) {
+    const aHalfW = a.width / 2;
+    const aHalfH = a.height / 2;
+    const bHalfW = b.width / 2;
+    const bHalfH = b.height / 2;
+    return Math.abs(a.x - b.x) < aHalfW + bHalfW && Math.abs(a.y - b.y) < aHalfH + bHalfH;
+  }
+  /**
+  * Check if a point is inside an AABB.
+  */
+  static containsPoint(aabb, x, y) {
+    const halfW = aabb.width / 2;
+    const halfH = aabb.height / 2;
+    return x >= aabb.x - halfW && x <= aabb.x + halfW && y >= aabb.y - halfH && y <= aabb.y + halfH;
+  }
+  /**
+  * Create AABB from entity.
+  */
+  static fromEntity(entity, width, height) {
+    return {
+      x: entity.x,
+      y: entity.y,
+      width,
+      height
+    };
+  }
+  /**
+  * Get the distance between two AABBs.
+  * Returns 0 if overlapping.
+  */
+  static distance(a, b) {
+    const dx = Math.abs(a.x - b.x);
+    const dy = Math.abs(a.y - b.y);
+    const combinedHalfW = (a.width + b.width) / 2;
+    const combinedHalfH = (a.height + b.height) / 2;
+    const gapX = Math.max(0, dx - combinedHalfW);
+    const gapY = Math.max(0, dy - combinedHalfH);
+    return Math.sqrt(gapX * gapX + gapY * gapY);
+  }
+  /**
+  * Compute the overlap amount between two AABBs.
+  * Returns { x: 0, y: 0 } if not overlapping.
+  */
+  static overlap(a, b) {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    const combinedHalfW = (a.width + b.width) / 2;
+    const combinedHalfH = (a.height + b.height) / 2;
+    const overlapX = combinedHalfW - Math.abs(dx);
+    const overlapY = combinedHalfH - Math.abs(dy);
+    if (overlapX > 0 && overlapY > 0) {
+      return {
+        x: overlapX * Math.sign(dx),
+        y: overlapY * Math.sign(dy)
+      };
+    }
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+};
+
+// src/physics/Movement.ts
+var Movement = class {
+  static {
+    __name(this, "Movement");
+  }
+  /**
+  * Update entity position based on velocity.
+  *
+  * @param entity - Entity to update
+  * @param deltaMs - Time delta in milliseconds
+  */
+  static integrate(entity, deltaMs) {
+    if (entity.vx === 0 && entity.vy === 0) return;
+    const deltaSec = deltaMs / 1e3;
+    entity.x += entity.vx * deltaSec;
+    entity.y += entity.vy * deltaSec;
+    entity.markDirty();
+  }
+  /**
+  * Apply velocity to entity.
+  */
+  static applyVelocity(entity, vx, vy) {
+    entity.setVelocity(vx, vy);
+  }
+  /**
+  * Stop entity movement.
+  */
+  static stop(entity) {
+    entity.setVelocity(0, 0);
+  }
+  /**
+  * Constrain entity to boundary.
+  *
+  * @param entity - Entity to constrain
+  * @param boundary - Boundary constraints
+  * @returns True if entity was clamped
+  */
+  static constrainToBoundary(entity, boundary) {
+    let clamped = false;
+    if (entity.x < boundary.minX) {
+      entity.x = boundary.minX;
+      entity.vx = 0;
+      clamped = true;
+    } else if (entity.x > boundary.maxX) {
+      entity.x = boundary.maxX;
+      entity.vx = 0;
+      clamped = true;
+    }
+    if (entity.y < boundary.minY) {
+      entity.y = boundary.minY;
+      entity.vy = 0;
+      clamped = true;
+    } else if (entity.y > boundary.maxY) {
+      entity.y = boundary.maxY;
+      entity.vy = 0;
+      clamped = true;
+    }
+    if (clamped) {
+      entity.markDirty();
+    }
+    return clamped;
+  }
+  /**
+  * Calculate distance between two entities.
+  */
+  static distance(a, b) {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /**
+  * Normalize a direction vector.
+  */
+  static normalize(x, y) {
+    const length = Math.sqrt(x * x + y * y);
+    if (length === 0) return {
+      x: 0,
+      y: 0
+    };
+    return {
+      x: x / length,
+      y: y / length
+    };
+  }
+  /**
+  * Calculate velocity from direction and speed.
+  */
+  static velocityFromDirection(dirX, dirY, speed) {
+    const normalized = this.normalize(dirX, dirY);
+    return {
+      vx: normalized.x * speed,
+      vy: normalized.y * speed
+    };
+  }
+};
+
+// src/types/protocol.ts
+var ClientOpcode;
+(function(ClientOpcode2) {
+  ClientOpcode2["C_MOVE"] = "C_MOVE";
+  ClientOpcode2["C_STOP"] = "C_STOP";
+  ClientOpcode2["C_ACTION"] = "C_ACTION";
+})(ClientOpcode || (ClientOpcode = {}));
+var ServerOpcode;
+(function(ServerOpcode2) {
+  ServerOpcode2["S_INIT"] = "S_INIT";
+  ServerOpcode2["S_UPDATE"] = "S_UPDATE";
+  ServerOpcode2["S_SPAWN"] = "S_SPAWN";
+  ServerOpcode2["S_DESPAWN"] = "S_DESPAWN";
+  ServerOpcode2["S_EVENT"] = "S_EVENT";
+  ServerOpcode2["S_ERROR"] = "S_ERROR";
+})(ServerOpcode || (ServerOpcode = {}));
+
+export { AABBCollision, ClientOpcode, Entity, GameLoop, GameServer, Grid, InputQueue, Logger, Movement, Network, Registry, RingBuffer, Room, ServerOpcode, Snapshot, createChildLogger, logger, setLogger };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map