@esengine/server 4.0.0 → 4.2.0

package/dist/chunk-BIAOJF7P.js

@@ -0,0 +1,729 @@
+import { __name, __publicField } from './chunk-T626JPC7.js';
+import * as path from 'path';
+import { createServer as createServer$1 } from 'http';
+import { serve } from '@esengine/rpc/server';
+import { rpc } from '@esengine/rpc';
+import * as fs from 'fs';
+import { pathToFileURL } from 'url';
+
+// src/http/router.ts
+async function createRequest(req) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  let body = null;
+  if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") {
+    body = await parseBody(req);
+  }
+  const ip = req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.socket?.remoteAddress || "unknown";
+  return {
+    raw: req,
+    method: req.method ?? "GET",
+    path: url.pathname,
+    query,
+    headers: req.headers,
+    body,
+    ip
+  };
+}
+__name(createRequest, "createRequest");
+function parseBody(req) {
+  return new Promise((resolve2) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      const rawBody = Buffer.concat(chunks).toString("utf-8");
+      if (!rawBody) {
+        resolve2(null);
+        return;
+      }
+      const contentType = req.headers["content-type"] ?? "";
+      if (contentType.includes("application/json")) {
+        try {
+          resolve2(JSON.parse(rawBody));
+        } catch {
+          resolve2(rawBody);
+        }
+      } else if (contentType.includes("application/x-www-form-urlencoded")) {
+        const params = new URLSearchParams(rawBody);
+        const result = {};
+        params.forEach((value, key) => {
+          result[key] = value;
+        });
+        resolve2(result);
+      } else {
+        resolve2(rawBody);
+      }
+    });
+    req.on("error", () => {
+      resolve2(null);
+    });
+  });
+}
+__name(parseBody, "parseBody");
+function createResponse(res) {
+  let statusCode = 200;
+  const response = {
+    raw: res,
+    status(code) {
+      statusCode = code;
+      return response;
+    },
+    header(name, value) {
+      res.setHeader(name, value);
+      return response;
+    },
+    json(data) {
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.statusCode = statusCode;
+      res.end(JSON.stringify(data));
+    },
+    text(data) {
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.statusCode = statusCode;
+      res.end(data);
+    },
+    error(code, message) {
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.statusCode = code;
+      res.end(JSON.stringify({
+        error: message
+      }));
+    }
+  };
+  return response;
+}
+__name(createResponse, "createResponse");
+function applyCors(res, req, cors) {
+  const origin = req.headers.origin;
+  if (cors.origin === true || cors.origin === "*") {
+    res.setHeader("Access-Control-Allow-Origin", origin ?? "*");
+  } else if (typeof cors.origin === "string") {
+    res.setHeader("Access-Control-Allow-Origin", cors.origin);
+  } else if (Array.isArray(cors.origin) && origin && cors.origin.includes(origin)) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+  }
+  if (cors.methods) {
+    res.setHeader("Access-Control-Allow-Methods", cors.methods.join(", "));
+  } else {
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  }
+  if (cors.allowedHeaders) {
+    res.setHeader("Access-Control-Allow-Headers", cors.allowedHeaders.join(", "));
+  } else {
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  }
+  if (cors.credentials) {
+    res.setHeader("Access-Control-Allow-Credentials", "true");
+  }
+  if (cors.maxAge) {
+    res.setHeader("Access-Control-Max-Age", String(cors.maxAge));
+  }
+}
+__name(applyCors, "applyCors");
+function createHttpRouter(routes, cors) {
+  const parsedRoutes = [];
+  for (const [path3, handlerOrMethods] of Object.entries(routes)) {
+    if (typeof handlerOrMethods === "function") {
+      parsedRoutes.push({
+        method: "*",
+        path: path3,
+        handler: handlerOrMethods
+      });
+    } else {
+      for (const [method, handler] of Object.entries(handlerOrMethods)) {
+        if (handler !== void 0) {
+          parsedRoutes.push({
+            method,
+            path: path3,
+            handler
+          });
+        }
+      }
+    }
+  }
+  const corsOptions = cors === true ? {
+    origin: true,
+    credentials: true
+  } : cors === false ? null : cors ?? null;
+  return /* @__PURE__ */ __name(async function handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path3 = url.pathname;
+    const method = req.method ?? "GET";
+    if (corsOptions) {
+      applyCors(res, req, corsOptions);
+      if (method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return true;
+      }
+    }
+    const route = parsedRoutes.find((r) => r.path === path3 && (r.method === "*" || r.method === method));
+    if (!route) {
+      return false;
+    }
+    try {
+      const httpReq = await createRequest(req);
+      const httpRes = createResponse(res);
+      await route.handler(httpReq, httpRes);
+      return true;
+    } catch (error) {
+      console.error("[HTTP] Route handler error:", error);
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({
+        error: "Internal Server Error"
+      }));
+      return true;
+    }
+  }, "handleRequest");
+}
+__name(createHttpRouter, "createHttpRouter");
+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");
+function scanDirectoryRecursive(dir, baseDir = dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files = [];
+  const entries = fs.readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...scanDirectoryRecursive(fullPath, baseDir));
+    } else if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name)) {
+      if (entry.name.startsWith("_") || entry.name.startsWith("index.")) {
+        continue;
+      }
+      const relativePath = path.relative(baseDir, fullPath);
+      files.push({
+        filePath: fullPath,
+        relativePath
+      });
+    }
+  }
+  return files;
+}
+__name(scanDirectoryRecursive, "scanDirectoryRecursive");
+function filePathToRoute(relativePath, prefix) {
+  let route = relativePath.replace(/\.(ts|js|mts|mjs)$/, "").replace(/\\/g, "/").replace(/\[([^\]]+)\]/g, ":$1");
+  if (!route.startsWith("/")) {
+    route = "/" + route;
+  }
+  const fullRoute = prefix.endsWith("/") ? prefix.slice(0, -1) + route : prefix + route;
+  return fullRoute;
+}
+__name(filePathToRoute, "filePathToRoute");
+async function loadHttpHandlers(httpDir, prefix = "/api") {
+  const files = scanDirectoryRecursive(httpDir);
+  const handlers = [];
+  for (const { filePath, relativePath } of files) {
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const definition = module.default;
+      if (definition && typeof definition.handler === "function") {
+        const route = filePathToRoute(relativePath, prefix);
+        const method = definition.method ?? "POST";
+        handlers.push({
+          route,
+          method,
+          path: filePath,
+          definition
+        });
+      }
+    } catch (err) {
+      console.warn(`[Server] Failed to load HTTP handler: ${filePath}`, err);
+    }
+  }
+  return handlers;
+}
+__name(loadHttpHandlers, "loadHttpHandlers");
+
+// 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",
+  httpDir: "src/http",
+  httpPrefix: "/api",
+  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));
+  const httpDir = config.httpDir ?? opts.httpDir;
+  const httpPrefix = config.httpPrefix ?? opts.httpPrefix;
+  const httpHandlers = await loadHttpHandlers(path.resolve(cwd, httpDir), httpPrefix);
+  if (apiHandlers.length > 0) {
+    console.log(`[Server] Loaded ${apiHandlers.length} API handlers`);
+  }
+  if (msgHandlers.length > 0) {
+    console.log(`[Server] Loaded ${msgHandlers.length} message handlers`);
+  }
+  if (httpHandlers.length > 0) {
+    console.log(`[Server] Loaded ${httpHandlers.length} HTTP handlers`);
+  }
+  const mergedHttpRoutes = {};
+  for (const handler of httpHandlers) {
+    const existingRoute = mergedHttpRoutes[handler.route];
+    if (existingRoute && typeof existingRoute !== "function") {
+      existingRoute[handler.method] = handler.definition.handler;
+    } else {
+      mergedHttpRoutes[handler.route] = {
+        [handler.method]: handler.definition.handler
+      };
+    }
+  }
+  if (config.http) {
+    for (const [route, handlerOrMethods] of Object.entries(config.http)) {
+      if (typeof handlerOrMethods === "function") {
+        mergedHttpRoutes[route] = handlerOrMethods;
+      } else {
+        const existing = mergedHttpRoutes[route];
+        if (existing && typeof existing !== "function") {
+          Object.assign(existing, handlerOrMethods);
+        } else {
+          mergedHttpRoutes[route] = handlerOrMethods;
+        }
+      }
+    }
+  }
+  const hasHttpRoutes = Object.keys(mergedHttpRoutes).length > 0;
+  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;
+  let httpServer = 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);
+        };
+      }
+      if (hasHttpRoutes) {
+        const httpRouter = createHttpRouter(mergedHttpRoutes, config.cors ?? true);
+        httpServer = createServer$1(async (req, res) => {
+          const handled = await httpRouter(req, res);
+          if (!handled) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+              error: "Not Found"
+            }));
+          }
+        });
+        rpcServer = serve(protocol, {
+          server: httpServer,
+          createConnData: /* @__PURE__ */ __name(() => ({}), "createConnData"),
+          onStart: /* @__PURE__ */ __name(() => {
+            console.log(`[Server] Started on http://localhost:${opts.port}`);
+            opts.onStart?.(opts.port);
+          }, "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();
+        await new Promise((resolve2) => {
+          httpServer.listen(opts.port, () => resolve2());
+        });
+      } else {
+        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;
+      }
+      if (httpServer) {
+        await new Promise((resolve2, reject) => {
+          httpServer.close((err) => {
+            if (err) reject(err);
+            else resolve2();
+          });
+        });
+        httpServer = null;
+      }
+    },
+    broadcast(name, data) {
+      rpcServer?.broadcast(name, data);
+    },
+    send(conn, name, data) {
+      rpcServer?.send(conn, name, data);
+    }
+  };
+  return gameServer;
+}
+__name(createServer, "createServer");
+
+export { createHttpRouter, createServer };
+//# sourceMappingURL=chunk-BIAOJF7P.js.map
+//# sourceMappingURL=chunk-BIAOJF7P.js.map