@esengine/network 1.0.0 → 2.1.1

package/dist/index.js

@@ -4,7 +4,46 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
-import { serviceProto as serviceProto2 } from "@esengine/network-protocols";
+import { rpc as rpc2 } from "@esengine/rpc";
+
+// src/protocol.ts
+import { rpc } from "@esengine/rpc";
+var gameProtocol = rpc.define({
+  api: {
+    /**
+     * @zh 加入房间
+     * @en Join room
+     */
+    join: rpc.api(),
+    /**
+     * @zh 离开房间
+     * @en Leave room
+     */
+    leave: rpc.api()
+  },
+  msg: {
+    /**
+     * @zh 玩家输入
+     * @en Player input
+     */
+    input: rpc.msg(),
+    /**
+     * @zh 状态同步
+     * @en State sync
+     */
+    sync: rpc.msg(),
+    /**
+     * @zh 实体生成
+     * @en Entity spawn
+     */
+    spawn: rpc.msg(),
+    /**
+     * @zh 实体销毁
+     * @en Entity despawn
+     */
+    despawn: rpc.msg()
+  }
+});
 
 // src/tokens.ts
 import { createServiceToken } from "@esengine/ecs-framework";
@@ -17,128 +56,166 @@ var NetworkInputSystemToken = createServiceToken("networkInputSystem");
 import { Core } from "@esengine/ecs-framework";
 
 // src/services/NetworkService.ts
-import { WsClient } from "tsrpc-browser";
-import { serviceProto } from "@esengine/network-protocols";
-var ENetworkState = /* @__PURE__ */ (function(ENetworkState2) {
-  ENetworkState2[ENetworkState2["Disconnected"] = 0] = "Disconnected";
-  ENetworkState2[ENetworkState2["Connecting"] = 1] = "Connecting";
-  ENetworkState2[ENetworkState2["Connected"] = 2] = "Connected";
-  return ENetworkState2;
+import { RpcClient } from "@esengine/rpc/client";
+var NetworkState = /* @__PURE__ */ (function(NetworkState2) {
+  NetworkState2[NetworkState2["Disconnected"] = 0] = "Disconnected";
+  NetworkState2[NetworkState2["Connecting"] = 1] = "Connecting";
+  NetworkState2[NetworkState2["Connected"] = 2] = "Connected";
+  return NetworkState2;
 })({});
-function createClient(serverUrl) {
-  return new WsClient(serviceProto, {
-    server: serverUrl,
-    json: true,
-    logLevel: "warn"
-  });
-}
-__name(createClient, "createClient");
-var _NetworkService = class _NetworkService {
-  constructor() {
+var _RpcService = class _RpcService {
+  constructor(_protocol) {
+    __publicField(this, "_protocol");
     __publicField(this, "_client", null);
     __publicField(this, "_state", 0);
-    __publicField(this, "_clientId", 0);
-    __publicField(this, "_roomId", "");
-    __publicField(this, "_callbacks", {});
+    this._protocol = _protocol;
   }
+  /**
+   * @zh 获取连接状态
+   * @en Get connection state
+   */
   get state() {
     return this._state;
   }
-  get clientId() {
-    return this._clientId;
-  }
-  get roomId() {
-    return this._roomId;
-  }
+  /**
+   * @zh 是否已连接
+   * @en Whether connected
+   */
   get isConnected() {
     return this._state === 2;
   }
   /**
-   * 设置回调
-   * Set callbacks
+   * @zh 获取底层 RPC 客户端
+   * @en Get underlying RPC client
    */
-  setCallbacks(callbacks) {
-    this._callbacks = {
-      ...this._callbacks,
-      ...callbacks
-    };
+  get client() {
+    return this._client;
   }
   /**
-   * 连接到服务器
-   * Connect to server
+   * @zh 连接到服务器
+   * @en Connect to server
    */
-  async connect(serverUrl, playerName, roomId) {
+  async connect(options) {
     if (this._state !== 0) {
-      return false;
+      throw new Error("Already connected or connecting");
     }
     this._state = 1;
-    this._client = createClient(serverUrl);
-    this._setupListeners();
-    const connectResult = await this._client.connect();
-    if (!connectResult.isSucc) {
-      this._state = 0;
-      this._callbacks.onError?.(new Error(connectResult.errMsg));
-      return false;
-    }
-    const joinResult = await this._client.callApi("Join", {
-      playerName,
-      roomId
-    });
-    if (!joinResult.isSucc) {
-      await this._client.disconnect();
+    try {
+      this._client = new RpcClient(this._protocol, options.url, {
+        ...options,
+        onConnect: /* @__PURE__ */ __name(() => {
+          this._state = 2;
+          options.onConnect?.();
+        }, "onConnect"),
+        onDisconnect: /* @__PURE__ */ __name((reason) => {
+          this._state = 0;
+          options.onDisconnect?.(reason);
+        }, "onDisconnect"),
+        onError: options.onError
+      });
+      await this._client.connect();
+      this._state = 2;
+    } catch (err) {
       this._state = 0;
-      this._callbacks.onError?.(new Error(joinResult.err.message));
-      return false;
+      this._client = null;
+      throw err;
     }
-    this._clientId = joinResult.res.clientId;
-    this._roomId = joinResult.res.roomId;
-    this._state = 2;
-    this._callbacks.onConnected?.(this._clientId, this._roomId);
-    return true;
   }
   /**
-   * 断开连接
-   * Disconnect
+   * @zh 断开连接
+   * @en Disconnect
    */
-  async disconnect() {
-    if (this._client) {
-      await this._client.disconnect();
-    }
-    this._state = 0;
-    this._clientId = 0;
-    this._roomId = "";
+  disconnect() {
+    this._client?.disconnect();
     this._client = null;
+    this._state = 0;
+  }
+  /**
+   * @zh 调用 API
+   * @en Call API
+   */
+  call(name, input) {
+    if (!this._client) {
+      return Promise.reject(new Error("Not connected"));
+    }
+    return this._client.call(name, input);
+  }
+  /**
+   * @zh 发送消息
+   * @en Send message
+   */
+  send(name, data) {
+    this._client?.send(name, data);
+  }
+  /**
+   * @zh 监听消息
+   * @en Listen to message
+   */
+  on(name, handler) {
+    this._client?.on(name, handler);
+    return this;
+  }
+  /**
+   * @zh 取消监听消息
+   * @en Remove message listener
+   */
+  off(name, handler) {
+    this._client?.off(name, handler);
+    return this;
   }
   /**
-   * 发送输入
-   * Send input
+   * @zh 监听消息（只触发一次）
+   * @en Listen to message (once)
+   */
+  once(name, handler) {
+    this._client?.once(name, handler);
+    return this;
+  }
+};
+__name(_RpcService, "RpcService");
+var RpcService = _RpcService;
+var _GameNetworkService = class _GameNetworkService extends RpcService {
+  constructor() {
+    super(gameProtocol);
+  }
+  /**
+   * @zh 发送玩家输入
+   * @en Send player input
    */
   sendInput(input) {
-    if (!this.isConnected || !this._client) return;
-    this._client.sendMsg("Input", {
-      input
-    });
+    this.send("input", input);
   }
-  _setupListeners() {
-    if (!this._client) return;
-    this._client.listenMsg("Sync", (msg) => {
-      this._callbacks.onSync?.(msg);
-    });
-    this._client.listenMsg("Spawn", (msg) => {
-      this._callbacks.onSpawn?.(msg);
-    });
-    this._client.listenMsg("Despawn", (msg) => {
-      this._callbacks.onDespawn?.(msg);
-    });
-    this._client.flows.postDisconnectFlow.push((v) => {
-      this._state = 0;
-      this._callbacks.onDisconnected?.();
-      return v;
-    });
+  /**
+   * @zh 监听状态同步
+   * @en Listen to state sync
+   */
+  onSync(handler) {
+    return this.on("sync", handler);
+  }
+  /**
+   * @zh 监听实体生成
+   * @en Listen to entity spawn
+   */
+  onSpawn(handler) {
+    return this.on("spawn", handler);
+  }
+  /**
+   * @zh 监听实体销毁
+   * @en Listen to entity despawn
+   */
+  onDespawn(handler) {
+    return this.on("despawn", handler);
   }
 };
-__name(_NetworkService, "NetworkService");
-var NetworkService = _NetworkService;
+__name(_GameNetworkService, "GameNetworkService");
+var GameNetworkService = _GameNetworkService;
+function createNetworkService(protocol) {
+  if (protocol) {
+    return new RpcService(protocol);
+  }
+  return new GameNetworkService();
+}
+__name(createNetworkService, "createNetworkService");
 
 // src/systems/NetworkSyncSystem.ts
 import { EntitySystem, Matcher, Time } from "@esengine/ecs-framework";
@@ -379,21 +456,26 @@ NetworkTransform = _ts_decorate2([
 
 // src/systems/NetworkSyncSystem.ts
 var _NetworkSyncSystem = class _NetworkSyncSystem extends EntitySystem {
-  constructor(networkService) {
+  constructor() {
     super(Matcher.all(NetworkIdentity, NetworkTransform));
-    __publicField(this, "_networkService");
     __publicField(this, "_netIdToEntity", /* @__PURE__ */ new Map());
-    this._networkService = networkService;
-  }
-  onInitialize() {
-    this._networkService.setCallbacks({
-      onSync: this._handleSync.bind(this)
-    });
   }
   /**
-   * 处理实体列表
-   * Process entities
+   * @zh 处理同步消息
+   * @en Handle sync message
    */
+  handleSync(msg) {
+    for (const state of msg.entities) {
+      const entityId = this._netIdToEntity.get(state.netId);
+      if (entityId === void 0) continue;
+      const entity = this.scene?.findEntityById(entityId);
+      if (!entity) continue;
+      const transform = entity.getComponent(NetworkTransform);
+      if (transform && state.pos) {
+        transform.setTarget(state.pos.x, state.pos.y, state.rot ?? 0);
+      }
+    }
+  }
   process(entities) {
     const deltaTime = Time.deltaTime;
     for (const entity of entities) {
@@ -405,38 +487,26 @@ var _NetworkSyncSystem = class _NetworkSyncSystem extends EntitySystem {
     }
   }
   /**
-   * 注册网络实体
-   * Register network entity
+   * @zh 注册网络实体
+   * @en Register network entity
    */
   registerEntity(netId, entityId) {
     this._netIdToEntity.set(netId, entityId);
   }
   /**
-   * 注销网络实体
-   * Unregister network entity
+   * @zh 注销网络实体
+   * @en Unregister network entity
    */
   unregisterEntity(netId) {
     this._netIdToEntity.delete(netId);
   }
   /**
-   * 根据网络 ID 获取实体 ID
-   * Get entity ID by network ID
+   * @zh 根据网络 ID 获取实体 ID
+   * @en Get entity ID by network ID
    */
   getEntityId(netId) {
     return this._netIdToEntity.get(netId);
   }
-  _handleSync(msg) {
-    for (const state of msg.entities) {
-      const entityId = this._netIdToEntity.get(state.netId);
-      if (entityId === void 0) continue;
-      const entity = this.scene?.findEntityById(entityId);
-      if (!entity) continue;
-      const transform = entity.getComponent(NetworkTransform);
-      if (transform && state.pos) {
-        transform.setTarget(state.pos.x, state.pos.y, state.rot);
-      }
-    }
-  }
   _interpolate(transform, deltaTime) {
     const t = Math.min(1, transform.lerpSpeed * deltaTime);
     transform.currentX += (transform.targetX - transform.currentX) * t;
@@ -456,54 +526,49 @@ var NetworkSyncSystem = _NetworkSyncSystem;
 // src/systems/NetworkSpawnSystem.ts
 import { EntitySystem as EntitySystem2, Matcher as Matcher2 } from "@esengine/ecs-framework";
 var _NetworkSpawnSystem = class _NetworkSpawnSystem extends EntitySystem2 {
-  constructor(networkService, syncSystem) {
+  constructor(syncSystem) {
     super(Matcher2.nothing());
-    __publicField(this, "_networkService");
     __publicField(this, "_syncSystem");
     __publicField(this, "_prefabFactories", /* @__PURE__ */ new Map());
-    this._networkService = networkService;
+    __publicField(this, "_localPlayerId", 0);
     this._syncSystem = syncSystem;
   }
-  onInitialize() {
-    this._networkService.setCallbacks({
-      onSpawn: this._handleSpawn.bind(this),
-      onDespawn: this._handleDespawn.bind(this)
-    });
-  }
   /**
-   * 注册预制体工厂
-   * Register prefab factory
+   * @zh 设置本地玩家 ID
+   * @en Set local player ID
    */
-  registerPrefab(prefabType, factory) {
-    this._prefabFactories.set(prefabType, factory);
+  setLocalPlayerId(id) {
+    this._localPlayerId = id;
   }
   /**
-   * 注销预制体工厂
-   * Unregister prefab factory
+   * @zh 处理生成消息
+   * @en Handle spawn message
    */
-  unregisterPrefab(prefabType) {
-    this._prefabFactories.delete(prefabType);
-  }
-  _handleSpawn(msg) {
-    if (!this.scene) return;
+  handleSpawn(msg) {
+    if (!this.scene) return null;
     const factory = this._prefabFactories.get(msg.prefab);
     if (!factory) {
       this.logger.warn(`Unknown prefab: ${msg.prefab}`);
-      return;
+      return null;
     }
     const entity = factory(this.scene, msg);
     const identity = entity.addComponent(new NetworkIdentity());
     identity.netId = msg.netId;
     identity.ownerId = msg.ownerId;
     identity.prefabType = msg.prefab;
-    identity.bHasAuthority = msg.ownerId === this._networkService.clientId;
+    identity.bHasAuthority = msg.ownerId === this._localPlayerId;
     identity.bIsLocalPlayer = identity.bHasAuthority;
     const transform = entity.addComponent(new NetworkTransform());
-    transform.setTarget(msg.pos.x, msg.pos.y, msg.rot);
+    transform.setTarget(msg.pos.x, msg.pos.y, msg.rot ?? 0);
     transform.snap();
     this._syncSystem.registerEntity(msg.netId, entity.id);
+    return entity;
   }
-  _handleDespawn(msg) {
+  /**
+   * @zh 处理销毁消息
+   * @en Handle despawn message
+   */
+  handleDespawn(msg) {
     const entityId = this._syncSystem.getEntityId(msg.netId);
     if (entityId === void 0) return;
     const entity = this.scene?.findEntityById(entityId);
@@ -512,6 +577,20 @@ var _NetworkSpawnSystem = class _NetworkSpawnSystem extends EntitySystem2 {
     }
     this._syncSystem.unregisterEntity(msg.netId);
   }
+  /**
+   * @zh 注册预制体工厂
+   * @en Register prefab factory
+   */
+  registerPrefab(prefabType, factory) {
+    this._prefabFactories.set(prefabType, factory);
+  }
+  /**
+   * @zh 注销预制体工厂
+   * @en Unregister prefab factory
+   */
+  unregisterPrefab(prefabType) {
+    this._prefabFactories.delete(prefabType);
+  }
   onDestroy() {
     this._prefabFactories.clear();
   }
@@ -530,8 +609,8 @@ var _NetworkInputSystem = class _NetworkInputSystem extends EntitySystem3 {
     this._networkService = networkService;
   }
   /**
-   * 处理输入队列
-   * Process input queue
+   * @zh 处理输入队列
+   * @en Process input queue
    */
   process() {
     if (!this._networkService.isConnected) return;
@@ -543,8 +622,8 @@ var _NetworkInputSystem = class _NetworkInputSystem extends EntitySystem3 {
     }
   }
   /**
-   * 添加移动输入
-   * Add move input
+   * @zh 添加移动输入
+   * @en Add move input
    */
   addMoveInput(x, y) {
     this._inputQueue.push({
@@ -556,8 +635,8 @@ var _NetworkInputSystem = class _NetworkInputSystem extends EntitySystem3 {
     });
   }
   /**
-   * 添加动作输入
-   * Add action input
+   * @zh 添加动作输入
+   * @en Add action input
    */
   addActionInput(action) {
     const lastInput = this._inputQueue[this._inputQueue.length - 1];
@@ -584,104 +663,139 @@ var NetworkInputSystem = _NetworkInputSystem;
 var _NetworkPlugin = class _NetworkPlugin {
   constructor() {
     __publicField(this, "name", "@esengine/network");
-    __publicField(this, "version", "1.0.0");
+    __publicField(this, "version", "2.0.0");
     __publicField(this, "_networkService");
     __publicField(this, "_syncSystem");
     __publicField(this, "_spawnSystem");
     __publicField(this, "_inputSystem");
+    __publicField(this, "_localPlayerId", 0);
   }
   /**
-   * 网络服务
-   * Network service
+   * @zh 网络服务
+   * @en Network service
    */
   get networkService() {
     return this._networkService;
   }
   /**
-   * 同步系统
-   * Sync system
+   * @zh 同步系统
+   * @en Sync system
    */
   get syncSystem() {
     return this._syncSystem;
   }
   /**
-   * 生成系统
-   * Spawn system
+   * @zh 生成系统
+   * @en Spawn system
    */
   get spawnSystem() {
     return this._spawnSystem;
   }
   /**
-   * 输入系统
-   * Input system
+   * @zh 输入系统
+   * @en Input system
    */
   get inputSystem() {
     return this._inputSystem;
   }
   /**
-   * 是否已连接
-   * Is connected
+   * @zh 本地玩家 ID
+   * @en Local player ID
+   */
+  get localPlayerId() {
+    return this._localPlayerId;
+  }
+  /**
+   * @zh 是否已连接
+   * @en Is connected
    */
   get isConnected() {
     return this._networkService?.isConnected ?? false;
   }
   /**
-   * 安装插件
-   * Install plugin
+   * @zh 安装插件
+   * @en Install plugin
    */
   install(_core, _services) {
-    this._networkService = new NetworkService();
+    this._networkService = new GameNetworkService();
     const scene = Core.scene;
     if (scene) {
       this._setupSystems(scene);
     }
   }
   /**
-   * 卸载插件
-   * Uninstall plugin
+   * @zh 卸载插件
+   * @en Uninstall plugin
    */
   uninstall() {
     this._networkService?.disconnect();
   }
   _setupSystems(scene) {
-    this._syncSystem = new NetworkSyncSystem(this._networkService);
-    this._spawnSystem = new NetworkSpawnSystem(this._networkService, this._syncSystem);
+    this._syncSystem = new NetworkSyncSystem();
+    this._spawnSystem = new NetworkSpawnSystem(this._syncSystem);
     this._inputSystem = new NetworkInputSystem(this._networkService);
     scene.addSystem(this._syncSystem);
     scene.addSystem(this._spawnSystem);
     scene.addSystem(this._inputSystem);
+    this._setupMessageHandlers();
+  }
+  _setupMessageHandlers() {
+    this._networkService.onSync((data) => {
+      this._syncSystem.handleSync({
+        entities: data.entities
+      });
+    }).onSpawn((data) => {
+      this._spawnSystem.handleSpawn(data);
+    }).onDespawn((data) => {
+      this._spawnSystem.handleDespawn(data);
+    });
   }
   /**
-   * 连接到服务器
-   * Connect to server
+   * @zh 连接到服务器
+   * @en Connect to server
    */
-  async connect(serverUrl, playerName, roomId) {
-    return this._networkService.connect(serverUrl, playerName, roomId);
+  async connect(options) {
+    try {
+      await this._networkService.connect(options);
+      const result = await this._networkService.call("join", {
+        playerName: options.playerName,
+        roomId: options.roomId
+      });
+      this._localPlayerId = result.playerId;
+      this._spawnSystem.setLocalPlayerId(this._localPlayerId);
+      return true;
+    } catch (err) {
+      return false;
+    }
   }
   /**
-   * 断开连接
-   * Disconnect
+   * @zh 断开连接
+   * @en Disconnect
    */
   async disconnect() {
-    await this._networkService.disconnect();
+    try {
+      await this._networkService.call("leave", void 0);
+    } catch {
+    }
+    this._networkService.disconnect();
   }
   /**
-   * 注册预制体工厂
-   * Register prefab factory
+   * @zh 注册预制体工厂
+   * @en Register prefab factory
    */
   registerPrefab(prefabType, factory) {
     this._spawnSystem?.registerPrefab(prefabType, factory);
   }
   /**
-   * 发送移动输入
-   * Send move input
+   * @zh 发送移动输入
+   * @en Send move input
    */
   sendMoveInput(x, y) {
     this._inputSystem?.addMoveInput(x, y);
   }
   /**
-   * 发送动作输入
-   * Send action input
+   * @zh 发送动作输入
+   * @en Send action input
    */
   sendActionInput(action) {
     this._inputSystem?.addActionInput(action);
@@ -1310,7 +1424,7 @@ var NetworkNodeDefinitions = {
 };
 export {
   ClientPrediction,
-  ENetworkState,
+  GameNetworkService,
   GetLocalPlayerIdExecutor,
   GetLocalPlayerIdTemplate,
   GetNetworkIdExecutor,
@@ -1327,22 +1441,26 @@ export {
   NetworkInputSystemToken,
   NetworkNodeDefinitions,
   NetworkPlugin,
-  NetworkService,
+  GameNetworkService as NetworkService,
   NetworkServiceToken,
   NetworkSpawnSystem,
   NetworkSpawnSystemToken,
+  NetworkState,
   NetworkSyncSystem,
   NetworkSyncSystemToken,
   NetworkTransform,
+  RpcService,
   SnapshotBuffer,
   TransformInterpolator,
   createClientPrediction,
   createHermiteTransformInterpolator,
+  createNetworkService,
   createSnapshotBuffer,
   createTransformInterpolator,
+  gameProtocol,
   lerp,
   lerpAngle,
-  serviceProto2 as serviceProto,
+  rpc2 as rpc,
   smoothDamp
 };
 //# sourceMappingURL=index.js.map