@esengine/server 1.1.4 → 1.2.0

package/dist/chunk-7C6JZO4O.js

@@ -0,0 +1,744 @@
+import { __name, __publicField } from './chunk-T626JPC7.js';
+import * as path from 'path';
+import { serve } from '@esengine/rpc/server';
+import { rpc } from '@esengine/rpc';
+import * as fs from 'fs';
+import { pathToFileURL } from 'url';
+
+// src/room/Player.ts
+var _Player = class _Player {
+  constructor(options) {
+    __publicField(this, "id");
+    __publicField(this, "roomId");
+    __publicField(this, "data");
+    __publicField(this, "_conn");
+    __publicField(this, "_sendFn");
+    __publicField(this, "_leaveFn");
+    this.id = options.id;
+    this.roomId = options.roomId;
+    this._conn = options.conn;
+    this._sendFn = options.sendFn;
+    this._leaveFn = options.leaveFn;
+    this.data = options.initialData ?? {};
+  }
+  /**
+   * @zh 获取底层连接
+   * @en Get underlying connection
+   */
+  get connection() {
+    return this._conn;
+  }
+  /**
+   * @zh 发送消息给玩家
+   * @en Send message to player
+   */
+  send(type, data) {
+    this._sendFn(this._conn, type, data);
+  }
+  /**
+   * @zh 让玩家离开房间
+   * @en Make player leave the room
+   */
+  leave(reason) {
+    this._leaveFn(this, reason);
+  }
+};
+__name(_Player, "Player");
+var Player = _Player;
+
+// src/room/Room.ts
+var MESSAGE_HANDLERS = /* @__PURE__ */ Symbol("messageHandlers");
+var _Room = class _Room {
+  constructor() {
+    // ========================================================================
+    // 配置 | Configuration
+    // ========================================================================
+    /**
+     * @zh 最大玩家数
+     * @en Maximum players
+     */
+    __publicField(this, "maxPlayers", 16);
+    /**
+     * @zh Tick 速率（每秒），0 = 不自动 tick
+     * @en Tick rate (per second), 0 = no auto tick
+     */
+    __publicField(this, "tickRate", 0);
+    /**
+     * @zh 空房间自动销毁
+     * @en Auto dispose when empty
+     */
+    __publicField(this, "autoDispose", true);
+    // ========================================================================
+    // 状态 | State
+    // ========================================================================
+    /**
+     * @zh 房间状态
+     * @en Room state
+     */
+    __publicField(this, "state", {});
+    // ========================================================================
+    // 内部属性 | Internal properties
+    // ========================================================================
+    __publicField(this, "_id", "");
+    __publicField(this, "_players", /* @__PURE__ */ new Map());
+    __publicField(this, "_locked", false);
+    __publicField(this, "_disposed", false);
+    __publicField(this, "_tickInterval", null);
+    __publicField(this, "_lastTickTime", 0);
+    __publicField(this, "_broadcastFn", null);
+    __publicField(this, "_sendFn", null);
+    __publicField(this, "_disposeFn", null);
+  }
+  // ========================================================================
+  // 只读属性 | Readonly properties
+  // ========================================================================
+  /**
+   * @zh 房间 ID
+   * @en Room ID
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * @zh 所有玩家
+   * @en All players
+   */
+  get players() {
+    return Array.from(this._players.values());
+  }
+  /**
+   * @zh 玩家数量
+   * @en Player count
+   */
+  get playerCount() {
+    return this._players.size;
+  }
+  /**
+   * @zh 是否已满
+   * @en Is full
+   */
+  get isFull() {
+    return this._players.size >= this.maxPlayers;
+  }
+  /**
+   * @zh 是否已锁定
+   * @en Is locked
+   */
+  get isLocked() {
+    return this._locked;
+  }
+  /**
+   * @zh 是否已销毁
+   * @en Is disposed
+   */
+  get isDisposed() {
+    return this._disposed;
+  }
+  // ========================================================================
+  // 生命周期 | Lifecycle
+  // ========================================================================
+  /**
+   * @zh 房间创建时调用
+   * @en Called when room is created
+   */
+  onCreate(options) {
+  }
+  /**
+   * @zh 玩家加入时调用
+   * @en Called when player joins
+   */
+  onJoin(player) {
+  }
+  /**
+   * @zh 玩家离开时调用
+   * @en Called when player leaves
+   */
+  onLeave(player, reason) {
+  }
+  /**
+   * @zh 游戏循环
+   * @en Game tick
+   */
+  onTick(dt) {
+  }
+  /**
+   * @zh 房间销毁时调用
+   * @en Called when room is disposed
+   */
+  onDispose() {
+  }
+  // ========================================================================
+  // 公共方法 | Public methods
+  // ========================================================================
+  /**
+   * @zh 广播消息给所有玩家
+   * @en Broadcast message to all players
+   */
+  broadcast(type, data) {
+    for (const player of this._players.values()) {
+      player.send(type, data);
+    }
+  }
+  /**
+   * @zh 广播消息给除指定玩家外的所有玩家
+   * @en Broadcast message to all players except one
+   */
+  broadcastExcept(except, type, data) {
+    for (const player of this._players.values()) {
+      if (player.id !== except.id) {
+        player.send(type, data);
+      }
+    }
+  }
+  /**
+   * @zh 获取玩家
+   * @en Get player by id
+   */
+  getPlayer(id) {
+    return this._players.get(id);
+  }
+  /**
+   * @zh 踢出玩家
+   * @en Kick player
+   */
+  kick(player, reason) {
+    player.leave(reason ?? "kicked");
+  }
+  /**
+   * @zh 锁定房间
+   * @en Lock room
+   */
+  lock() {
+    this._locked = true;
+  }
+  /**
+   * @zh 解锁房间
+   * @en Unlock room
+   */
+  unlock() {
+    this._locked = false;
+  }
+  /**
+   * @zh 手动销毁房间
+   * @en Manually dispose room
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._stopTick();
+    for (const player of this._players.values()) {
+      player.leave("room_disposed");
+    }
+    this._players.clear();
+    this.onDispose();
+    this._disposeFn?.();
+  }
+  // ========================================================================
+  // 内部方法 | Internal methods
+  // ========================================================================
+  /**
+   * @internal
+   */
+  _init(options) {
+    this._id = options.id;
+    this._sendFn = options.sendFn;
+    this._broadcastFn = options.broadcastFn;
+    this._disposeFn = options.disposeFn;
+  }
+  /**
+   * @internal
+   */
+  async _create(options) {
+    await this.onCreate(options);
+    this._startTick();
+  }
+  /**
+   * @internal
+   */
+  async _addPlayer(id, conn) {
+    if (this._locked || this.isFull || this._disposed) {
+      return null;
+    }
+    const player = new Player({
+      id,
+      roomId: this._id,
+      conn,
+      sendFn: this._sendFn,
+      leaveFn: /* @__PURE__ */ __name((p, reason) => this._removePlayer(p.id, reason), "leaveFn")
+    });
+    this._players.set(id, player);
+    await this.onJoin(player);
+    return player;
+  }
+  /**
+   * @internal
+   */
+  async _removePlayer(id, reason) {
+    const player = this._players.get(id);
+    if (!player) return;
+    this._players.delete(id);
+    await this.onLeave(player, reason);
+    if (this.autoDispose && this._players.size === 0) {
+      this.dispose();
+    }
+  }
+  /**
+   * @internal
+   */
+  _handleMessage(type, data, playerId) {
+    const player = this._players.get(playerId);
+    if (!player) return;
+    const handlers = this.constructor[MESSAGE_HANDLERS];
+    if (handlers) {
+      for (const handler of handlers) {
+        if (handler.type === type) {
+          const method = this[handler.method];
+          if (typeof method === "function") {
+            method.call(this, data, player);
+          }
+        }
+      }
+    }
+  }
+  _startTick() {
+    if (this.tickRate <= 0) return;
+    this._lastTickTime = performance.now();
+    this._tickInterval = setInterval(() => {
+      const now = performance.now();
+      const dt = (now - this._lastTickTime) / 1e3;
+      this._lastTickTime = now;
+      this.onTick(dt);
+    }, 1e3 / this.tickRate);
+  }
+  _stopTick() {
+    if (this._tickInterval) {
+      clearInterval(this._tickInterval);
+      this._tickInterval = null;
+    }
+  }
+};
+__name(_Room, "Room");
+var Room = _Room;
+function registerMessageHandler(target, type, method) {
+  if (!target[MESSAGE_HANDLERS]) {
+    target[MESSAGE_HANDLERS] = [];
+  }
+  target[MESSAGE_HANDLERS].push({
+    type,
+    method
+  });
+}
+__name(registerMessageHandler, "registerMessageHandler");
+
+// src/room/decorators.ts
+function onMessage(type) {
+  return function(target, propertyKey, _descriptor) {
+    registerMessageHandler(target.constructor, type, propertyKey);
+  };
+}
+__name(onMessage, "onMessage");
+function fileNameToHandlerName(fileName) {
+  const baseName = fileName.replace(/\.(ts|js|mts|mjs)$/, "");
+  return baseName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(fileNameToHandlerName, "fileNameToHandlerName");
+function scanDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files = [];
+  const entries = fs.readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name)) {
+      if (entry.name.startsWith("_") || entry.name.startsWith("index.")) {
+        continue;
+      }
+      files.push(path.join(dir, entry.name));
+    }
+  }
+  return files;
+}
+__name(scanDirectory, "scanDirectory");
+async function loadApiHandlers(apiDir) {
+  const files = scanDirectory(apiDir);
+  const handlers = [];
+  for (const filePath of files) {
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const definition = module.default;
+      if (definition && typeof definition.handler === "function") {
+        const name = fileNameToHandlerName(path.basename(filePath));
+        handlers.push({
+          name,
+          path: filePath,
+          definition
+        });
+      }
+    } catch (err) {
+      console.warn(`[Server] Failed to load API handler: ${filePath}`, err);
+    }
+  }
+  return handlers;
+}
+__name(loadApiHandlers, "loadApiHandlers");
+async function loadMsgHandlers(msgDir) {
+  const files = scanDirectory(msgDir);
+  const handlers = [];
+  for (const filePath of files) {
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const definition = module.default;
+      if (definition && typeof definition.handler === "function") {
+        const name = fileNameToHandlerName(path.basename(filePath));
+        handlers.push({
+          name,
+          path: filePath,
+          definition
+        });
+      }
+    } catch (err) {
+      console.warn(`[Server] Failed to load msg handler: ${filePath}`, err);
+    }
+  }
+  return handlers;
+}
+__name(loadMsgHandlers, "loadMsgHandlers");
+
+// src/room/RoomManager.ts
+var _RoomManager = class _RoomManager {
+  constructor(sendFn) {
+    __publicField(this, "_definitions", /* @__PURE__ */ new Map());
+    __publicField(this, "_rooms", /* @__PURE__ */ new Map());
+    __publicField(this, "_playerToRoom", /* @__PURE__ */ new Map());
+    __publicField(this, "_nextRoomId", 1);
+    __publicField(this, "_sendFn");
+    this._sendFn = sendFn;
+  }
+  /**
+   * @zh 注册房间类型
+   * @en Define room type
+   */
+  define(name, roomClass) {
+    this._definitions.set(name, {
+      roomClass
+    });
+  }
+  /**
+   * @zh 创建房间
+   * @en Create room
+   */
+  async create(name, options) {
+    const def = this._definitions.get(name);
+    if (!def) {
+      console.warn(`[RoomManager] Room type not found: ${name}`);
+      return null;
+    }
+    const roomId = this._generateRoomId();
+    const room = new def.roomClass();
+    room._init({
+      id: roomId,
+      sendFn: this._sendFn,
+      broadcastFn: /* @__PURE__ */ __name((type, data) => {
+        for (const player of room.players) {
+          player.send(type, data);
+        }
+      }, "broadcastFn"),
+      disposeFn: /* @__PURE__ */ __name(() => {
+        this._rooms.delete(roomId);
+      }, "disposeFn")
+    });
+    this._rooms.set(roomId, room);
+    await room._create(options);
+    console.log(`[Room] Created: ${name} (${roomId})`);
+    return room;
+  }
+  /**
+   * @zh 加入或创建房间
+   * @en Join or create room
+   */
+  async joinOrCreate(name, playerId, conn, options) {
+    let room = this._findAvailableRoom(name);
+    if (!room) {
+      room = await this.create(name, options);
+      if (!room) return null;
+    }
+    const player = await room._addPlayer(playerId, conn);
+    if (!player) return null;
+    this._playerToRoom.set(playerId, room.id);
+    console.log(`[Room] Player ${playerId} joined ${room.id}`);
+    return {
+      room,
+      player
+    };
+  }
+  /**
+   * @zh 加入指定房间
+   * @en Join specific room
+   */
+  async joinById(roomId, playerId, conn) {
+    const room = this._rooms.get(roomId);
+    if (!room) return null;
+    const player = await room._addPlayer(playerId, conn);
+    if (!player) return null;
+    this._playerToRoom.set(playerId, room.id);
+    console.log(`[Room] Player ${playerId} joined ${room.id}`);
+    return {
+      room,
+      player
+    };
+  }
+  /**
+   * @zh 玩家离开
+   * @en Player leave
+   */
+  async leave(playerId, reason) {
+    const roomId = this._playerToRoom.get(playerId);
+    if (!roomId) return;
+    const room = this._rooms.get(roomId);
+    if (room) {
+      await room._removePlayer(playerId, reason);
+    }
+    this._playerToRoom.delete(playerId);
+    console.log(`[Room] Player ${playerId} left ${roomId}`);
+  }
+  /**
+   * @zh 处理消息
+   * @en Handle message
+   */
+  handleMessage(playerId, type, data) {
+    const roomId = this._playerToRoom.get(playerId);
+    if (!roomId) return;
+    const room = this._rooms.get(roomId);
+    if (room) {
+      room._handleMessage(type, data, playerId);
+    }
+  }
+  /**
+   * @zh 获取房间
+   * @en Get room
+   */
+  getRoom(roomId) {
+    return this._rooms.get(roomId);
+  }
+  /**
+   * @zh 获取玩家所在房间
+   * @en Get player's room
+   */
+  getPlayerRoom(playerId) {
+    const roomId = this._playerToRoom.get(playerId);
+    return roomId ? this._rooms.get(roomId) : void 0;
+  }
+  /**
+   * @zh 获取所有房间
+   * @en Get all rooms
+   */
+  getRooms() {
+    return Array.from(this._rooms.values());
+  }
+  /**
+   * @zh 获取指定类型的所有房间
+   * @en Get all rooms of a type
+   */
+  getRoomsByType(name) {
+    const def = this._definitions.get(name);
+    if (!def) return [];
+    return Array.from(this._rooms.values()).filter((room) => room instanceof def.roomClass);
+  }
+  _findAvailableRoom(name) {
+    const def = this._definitions.get(name);
+    if (!def) return null;
+    for (const room of this._rooms.values()) {
+      if (room instanceof def.roomClass && !room.isFull && !room.isLocked && !room.isDisposed) {
+        return room;
+      }
+    }
+    return null;
+  }
+  _generateRoomId() {
+    return `room_${this._nextRoomId++}`;
+  }
+};
+__name(_RoomManager, "RoomManager");
+var RoomManager = _RoomManager;
+
+// src/core/server.ts
+var DEFAULT_CONFIG = {
+  port: 3e3,
+  apiDir: "src/api",
+  msgDir: "src/msg",
+  tickRate: 20
+};
+async function createServer(config = {}) {
+  const opts = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  const cwd = process.cwd();
+  const apiHandlers = await loadApiHandlers(path.resolve(cwd, opts.apiDir));
+  const msgHandlers = await loadMsgHandlers(path.resolve(cwd, opts.msgDir));
+  if (apiHandlers.length > 0) {
+    console.log(`[Server] Loaded ${apiHandlers.length} API handlers`);
+  }
+  if (msgHandlers.length > 0) {
+    console.log(`[Server] Loaded ${msgHandlers.length} message handlers`);
+  }
+  const apiDefs = {
+    // 内置 API
+    JoinRoom: rpc.api(),
+    LeaveRoom: rpc.api()
+  };
+  const msgDefs = {
+    // 内置消息（房间消息透传）
+    RoomMessage: rpc.msg()
+  };
+  for (const handler of apiHandlers) {
+    apiDefs[handler.name] = rpc.api();
+  }
+  for (const handler of msgHandlers) {
+    msgDefs[handler.name] = rpc.msg();
+  }
+  const protocol = rpc.define({
+    api: apiDefs,
+    msg: msgDefs
+  });
+  let currentTick = 0;
+  let tickInterval = null;
+  let rpcServer = null;
+  const roomManager = new RoomManager((conn, type, data) => {
+    rpcServer?.send(conn, "RoomMessage", {
+      type,
+      data
+    });
+  });
+  const apiMap = {};
+  for (const handler of apiHandlers) {
+    apiMap[handler.name] = handler;
+  }
+  const msgMap = {};
+  for (const handler of msgHandlers) {
+    msgMap[handler.name] = handler;
+  }
+  const gameServer = {
+    get connections() {
+      return rpcServer?.connections ?? [];
+    },
+    get tick() {
+      return currentTick;
+    },
+    get rooms() {
+      return roomManager;
+    },
+    /**
+     * @zh 注册房间类型
+     * @en Define room type
+     */
+    define(name, roomClass) {
+      roomManager.define(name, roomClass);
+    },
+    async start() {
+      const apiHandlersObj = {};
+      apiHandlersObj["JoinRoom"] = async (input, conn) => {
+        const { roomType, roomId, options } = input;
+        if (roomId) {
+          const result = await roomManager.joinById(roomId, conn.id, conn);
+          if (!result) {
+            throw new Error("Failed to join room");
+          }
+          return {
+            roomId: result.room.id,
+            playerId: result.player.id
+          };
+        }
+        if (roomType) {
+          const result = await roomManager.joinOrCreate(roomType, conn.id, conn, options);
+          if (!result) {
+            throw new Error("Failed to join or create room");
+          }
+          return {
+            roomId: result.room.id,
+            playerId: result.player.id
+          };
+        }
+        throw new Error("roomType or roomId required");
+      };
+      apiHandlersObj["LeaveRoom"] = async (_input, conn) => {
+        await roomManager.leave(conn.id);
+        return {
+          success: true
+        };
+      };
+      for (const [name, handler] of Object.entries(apiMap)) {
+        apiHandlersObj[name] = async (input, conn) => {
+          const ctx = {
+            conn,
+            server: gameServer
+          };
+          return handler.definition.handler(input, ctx);
+        };
+      }
+      const msgHandlersObj = {};
+      msgHandlersObj["RoomMessage"] = async (data, conn) => {
+        const { type, data: payload } = data;
+        roomManager.handleMessage(conn.id, type, payload);
+      };
+      for (const [name, handler] of Object.entries(msgMap)) {
+        msgHandlersObj[name] = async (data, conn) => {
+          const ctx = {
+            conn,
+            server: gameServer
+          };
+          await handler.definition.handler(data, ctx);
+        };
+      }
+      rpcServer = serve(protocol, {
+        port: opts.port,
+        createConnData: /* @__PURE__ */ __name(() => ({}), "createConnData"),
+        onStart: /* @__PURE__ */ __name((p) => {
+          console.log(`[Server] Started on ws://localhost:${p}`);
+          opts.onStart?.(p);
+        }, "onStart"),
+        onConnect: /* @__PURE__ */ __name(async (conn) => {
+          await config.onConnect?.(conn);
+        }, "onConnect"),
+        onDisconnect: /* @__PURE__ */ __name(async (conn) => {
+          await roomManager?.leave(conn.id, "disconnected");
+          await config.onDisconnect?.(conn);
+        }, "onDisconnect"),
+        api: apiHandlersObj,
+        msg: msgHandlersObj
+      });
+      await rpcServer.start();
+      if (opts.tickRate > 0) {
+        tickInterval = setInterval(() => {
+          currentTick++;
+        }, 1e3 / opts.tickRate);
+      }
+    },
+    async stop() {
+      if (tickInterval) {
+        clearInterval(tickInterval);
+        tickInterval = null;
+      }
+      if (rpcServer) {
+        await rpcServer.stop();
+        rpcServer = null;
+      }
+    },
+    broadcast(name, data) {
+      rpcServer?.broadcast(name, data);
+    },
+    send(conn, name, data) {
+      rpcServer?.send(conn, name, data);
+    }
+  };
+  return gameServer;
+}
+__name(createServer, "createServer");
+
+export { Player, Room, createServer, onMessage };
+//# sourceMappingURL=chunk-7C6JZO4O.js.map
+//# sourceMappingURL=chunk-7C6JZO4O.js.map