@esengine/network 1.0.0

package/dist/index.js

@@ -0,0 +1,1348 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+import { serviceProto as serviceProto2 } from "@esengine/network-protocols";
+
+// src/tokens.ts
+import { createServiceToken } from "@esengine/ecs-framework";
+var NetworkServiceToken = createServiceToken("networkService");
+var NetworkSyncSystemToken = createServiceToken("networkSyncSystem");
+var NetworkSpawnSystemToken = createServiceToken("networkSpawnSystem");
+var NetworkInputSystemToken = createServiceToken("networkInputSystem");
+
+// src/NetworkPlugin.ts
+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;
+})({});
+function createClient(serverUrl) {
+  return new WsClient(serviceProto, {
+    server: serverUrl,
+    json: true,
+    logLevel: "warn"
+  });
+}
+__name(createClient, "createClient");
+var _NetworkService = class _NetworkService {
+  constructor() {
+    __publicField(this, "_client", null);
+    __publicField(this, "_state", 0);
+    __publicField(this, "_clientId", 0);
+    __publicField(this, "_roomId", "");
+    __publicField(this, "_callbacks", {});
+  }
+  get state() {
+    return this._state;
+  }
+  get clientId() {
+    return this._clientId;
+  }
+  get roomId() {
+    return this._roomId;
+  }
+  get isConnected() {
+    return this._state === 2;
+  }
+  /**
+   * 设置回调
+   * Set callbacks
+   */
+  setCallbacks(callbacks) {
+    this._callbacks = {
+      ...this._callbacks,
+      ...callbacks
+    };
+  }
+  /**
+   * 连接到服务器
+   * Connect to server
+   */
+  async connect(serverUrl, playerName, roomId) {
+    if (this._state !== 0) {
+      return false;
+    }
+    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();
+      this._state = 0;
+      this._callbacks.onError?.(new Error(joinResult.err.message));
+      return false;
+    }
+    this._clientId = joinResult.res.clientId;
+    this._roomId = joinResult.res.roomId;
+    this._state = 2;
+    this._callbacks.onConnected?.(this._clientId, this._roomId);
+    return true;
+  }
+  /**
+   * 断开连接
+   * Disconnect
+   */
+  async disconnect() {
+    if (this._client) {
+      await this._client.disconnect();
+    }
+    this._state = 0;
+    this._clientId = 0;
+    this._roomId = "";
+    this._client = null;
+  }
+  /**
+   * 发送输入
+   * Send input
+   */
+  sendInput(input) {
+    if (!this.isConnected || !this._client) return;
+    this._client.sendMsg("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;
+    });
+  }
+};
+__name(_NetworkService, "NetworkService");
+var NetworkService = _NetworkService;
+
+// src/systems/NetworkSyncSystem.ts
+import { EntitySystem, Matcher, Time } from "@esengine/ecs-framework";
+
+// src/components/NetworkIdentity.ts
+import { Component, ECSComponent, Serialize, Serializable, Property } from "@esengine/ecs-framework";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var _NetworkIdentity = class _NetworkIdentity extends Component {
+  constructor() {
+    super(...arguments);
+    /**
+     * 网络实体 ID
+     * Network entity ID
+     */
+    __publicField(this, "netId", 0);
+    /**
+     * 所有者客户端 ID
+     * Owner client ID
+     */
+    __publicField(this, "ownerId", 0);
+    /**
+     * 是否为本地玩家拥有
+     * Is owned by local player
+     */
+    __publicField(this, "bIsLocalPlayer", false);
+    /**
+     * 是否有权限控制
+     * Has authority
+     */
+    __publicField(this, "bHasAuthority", false);
+    /**
+     * 预制体类型
+     * Prefab type
+     */
+    __publicField(this, "prefabType", "");
+    /**
+     * 同步间隔 (ms)
+     * Sync interval in milliseconds
+     */
+    __publicField(this, "syncInterval", 100);
+    /**
+     * 上次同步时间
+     * Last sync time
+     */
+    __publicField(this, "lastSyncTime", 0);
+  }
+  /**
+   * 检查是否需要同步
+   * Check if sync is needed
+   */
+  needsSync(now) {
+    return now - this.lastSyncTime >= this.syncInterval;
+  }
+};
+__name(_NetworkIdentity, "NetworkIdentity");
+var NetworkIdentity = _NetworkIdentity;
+_ts_decorate([
+  Serialize(),
+  Property({
+    type: "integer",
+    label: "Net ID",
+    readOnly: true
+  }),
+  _ts_metadata("design:type", Number)
+], NetworkIdentity.prototype, "netId", void 0);
+_ts_decorate([
+  Serialize(),
+  Property({
+    type: "integer",
+    label: "Owner ID",
+    readOnly: true
+  }),
+  _ts_metadata("design:type", Number)
+], NetworkIdentity.prototype, "ownerId", void 0);
+_ts_decorate([
+  Serialize(),
+  Property({
+    type: "string",
+    label: "Prefab Type"
+  }),
+  _ts_metadata("design:type", String)
+], NetworkIdentity.prototype, "prefabType", void 0);
+_ts_decorate([
+  Serialize(),
+  Property({
+    type: "number",
+    label: "Sync Interval",
+    min: 16
+  }),
+  _ts_metadata("design:type", Number)
+], NetworkIdentity.prototype, "syncInterval", void 0);
+NetworkIdentity = _ts_decorate([
+  ECSComponent("NetworkIdentity"),
+  Serializable({
+    version: 1,
+    typeId: "NetworkIdentity"
+  })
+], NetworkIdentity);
+
+// src/components/NetworkTransform.ts
+import { Component as Component2, ECSComponent as ECSComponent2, Serialize as Serialize2, Serializable as Serializable2, Property as Property2 } from "@esengine/ecs-framework";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var _NetworkTransform = class _NetworkTransform extends Component2 {
+  constructor() {
+    super(...arguments);
+    /**
+     * 目标位置 X
+     * Target position X
+     */
+    __publicField(this, "targetX", 0);
+    /**
+     * 目标位置 Y
+     * Target position Y
+     */
+    __publicField(this, "targetY", 0);
+    /**
+     * 目标旋转
+     * Target rotation
+     */
+    __publicField(this, "targetRotation", 0);
+    /**
+     * 当前位置 X
+     * Current position X
+     */
+    __publicField(this, "currentX", 0);
+    /**
+     * 当前位置 Y
+     * Current position Y
+     */
+    __publicField(this, "currentY", 0);
+    /**
+     * 当前旋转
+     * Current rotation
+     */
+    __publicField(this, "currentRotation", 0);
+    /**
+     * 插值速度
+     * Interpolation speed
+     */
+    __publicField(this, "lerpSpeed", 10);
+    /**
+     * 是否启用插值
+     * Enable interpolation
+     */
+    __publicField(this, "bInterpolate", true);
+    /**
+     * 同步间隔 (ms)
+     * Sync interval in milliseconds
+     */
+    __publicField(this, "syncInterval", 50);
+    /**
+     * 上次同步时间
+     * Last sync time
+     */
+    __publicField(this, "lastSyncTime", 0);
+  }
+  /**
+   * 设置目标位置
+   * Set target position
+   */
+  setTarget(x, y, rotation) {
+    this.targetX = x;
+    this.targetY = y;
+    if (rotation !== void 0) {
+      this.targetRotation = rotation;
+    }
+  }
+  /**
+   * 立即跳转到目标位置
+   * Snap to target position immediately
+   */
+  snap() {
+    this.currentX = this.targetX;
+    this.currentY = this.targetY;
+    this.currentRotation = this.targetRotation;
+  }
+};
+__name(_NetworkTransform, "NetworkTransform");
+var NetworkTransform = _NetworkTransform;
+_ts_decorate2([
+  Serialize2(),
+  Property2({
+    type: "number",
+    label: "Lerp Speed",
+    min: 0.1,
+    max: 50
+  }),
+  _ts_metadata2("design:type", Number)
+], NetworkTransform.prototype, "lerpSpeed", void 0);
+_ts_decorate2([
+  Serialize2(),
+  Property2({
+    type: "boolean",
+    label: "Interpolate"
+  }),
+  _ts_metadata2("design:type", Boolean)
+], NetworkTransform.prototype, "bInterpolate", void 0);
+_ts_decorate2([
+  Serialize2(),
+  Property2({
+    type: "number",
+    label: "Sync Interval",
+    min: 16
+  }),
+  _ts_metadata2("design:type", Number)
+], NetworkTransform.prototype, "syncInterval", void 0);
+NetworkTransform = _ts_decorate2([
+  ECSComponent2("NetworkTransform", {
+    requires: [
+      "NetworkIdentity"
+    ]
+  }),
+  Serializable2({
+    version: 1,
+    typeId: "NetworkTransform"
+  })
+], NetworkTransform);
+
+// src/systems/NetworkSyncSystem.ts
+var _NetworkSyncSystem = class _NetworkSyncSystem extends EntitySystem {
+  constructor(networkService) {
+    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
+   */
+  process(entities) {
+    const deltaTime = Time.deltaTime;
+    for (const entity of entities) {
+      const transform = this.requireComponent(entity, NetworkTransform);
+      const identity = this.requireComponent(entity, NetworkIdentity);
+      if (!identity.bHasAuthority && transform.bInterpolate) {
+        this._interpolate(transform, deltaTime);
+      }
+    }
+  }
+  /**
+   * 注册网络实体
+   * Register network entity
+   */
+  registerEntity(netId, entityId) {
+    this._netIdToEntity.set(netId, entityId);
+  }
+  /**
+   * 注销网络实体
+   * Unregister network entity
+   */
+  unregisterEntity(netId) {
+    this._netIdToEntity.delete(netId);
+  }
+  /**
+   * 根据网络 ID 获取实体 ID
+   * 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;
+    transform.currentY += (transform.targetY - transform.currentY) * t;
+    let angleDiff = transform.targetRotation - transform.currentRotation;
+    while (angleDiff > Math.PI) angleDiff -= Math.PI * 2;
+    while (angleDiff < -Math.PI) angleDiff += Math.PI * 2;
+    transform.currentRotation += angleDiff * t;
+  }
+  onDestroy() {
+    this._netIdToEntity.clear();
+  }
+};
+__name(_NetworkSyncSystem, "NetworkSyncSystem");
+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) {
+    super(Matcher2.nothing());
+    __publicField(this, "_networkService");
+    __publicField(this, "_syncSystem");
+    __publicField(this, "_prefabFactories", /* @__PURE__ */ new Map());
+    this._networkService = networkService;
+    this._syncSystem = syncSystem;
+  }
+  onInitialize() {
+    this._networkService.setCallbacks({
+      onSpawn: this._handleSpawn.bind(this),
+      onDespawn: this._handleDespawn.bind(this)
+    });
+  }
+  /**
+   * 注册预制体工厂
+   * Register prefab factory
+   */
+  registerPrefab(prefabType, factory) {
+    this._prefabFactories.set(prefabType, factory);
+  }
+  /**
+   * 注销预制体工厂
+   * Unregister prefab factory
+   */
+  unregisterPrefab(prefabType) {
+    this._prefabFactories.delete(prefabType);
+  }
+  _handleSpawn(msg) {
+    if (!this.scene) return;
+    const factory = this._prefabFactories.get(msg.prefab);
+    if (!factory) {
+      this.logger.warn(`Unknown prefab: ${msg.prefab}`);
+      return;
+    }
+    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.bIsLocalPlayer = identity.bHasAuthority;
+    const transform = entity.addComponent(new NetworkTransform());
+    transform.setTarget(msg.pos.x, msg.pos.y, msg.rot);
+    transform.snap();
+    this._syncSystem.registerEntity(msg.netId, entity.id);
+  }
+  _handleDespawn(msg) {
+    const entityId = this._syncSystem.getEntityId(msg.netId);
+    if (entityId === void 0) return;
+    const entity = this.scene?.findEntityById(entityId);
+    if (entity) {
+      entity.destroy();
+    }
+    this._syncSystem.unregisterEntity(msg.netId);
+  }
+  onDestroy() {
+    this._prefabFactories.clear();
+  }
+};
+__name(_NetworkSpawnSystem, "NetworkSpawnSystem");
+var NetworkSpawnSystem = _NetworkSpawnSystem;
+
+// src/systems/NetworkInputSystem.ts
+import { EntitySystem as EntitySystem3, Matcher as Matcher3 } from "@esengine/ecs-framework";
+var _NetworkInputSystem = class _NetworkInputSystem extends EntitySystem3 {
+  constructor(networkService) {
+    super(Matcher3.nothing());
+    __publicField(this, "_networkService");
+    __publicField(this, "_frame", 0);
+    __publicField(this, "_inputQueue", []);
+    this._networkService = networkService;
+  }
+  /**
+   * 处理输入队列
+   * Process input queue
+   */
+  process() {
+    if (!this._networkService.isConnected) return;
+    this._frame++;
+    while (this._inputQueue.length > 0) {
+      const input = this._inputQueue.shift();
+      input.frame = this._frame;
+      this._networkService.sendInput(input);
+    }
+  }
+  /**
+   * 添加移动输入
+   * Add move input
+   */
+  addMoveInput(x, y) {
+    this._inputQueue.push({
+      frame: 0,
+      moveDir: {
+        x,
+        y
+      }
+    });
+  }
+  /**
+   * 添加动作输入
+   * Add action input
+   */
+  addActionInput(action) {
+    const lastInput = this._inputQueue[this._inputQueue.length - 1];
+    if (lastInput) {
+      lastInput.actions = lastInput.actions || [];
+      lastInput.actions.push(action);
+    } else {
+      this._inputQueue.push({
+        frame: 0,
+        actions: [
+          action
+        ]
+      });
+    }
+  }
+  onDestroy() {
+    this._inputQueue.length = 0;
+  }
+};
+__name(_NetworkInputSystem, "NetworkInputSystem");
+var NetworkInputSystem = _NetworkInputSystem;
+
+// src/NetworkPlugin.ts
+var _NetworkPlugin = class _NetworkPlugin {
+  constructor() {
+    __publicField(this, "name", "@esengine/network");
+    __publicField(this, "version", "1.0.0");
+    __publicField(this, "_networkService");
+    __publicField(this, "_syncSystem");
+    __publicField(this, "_spawnSystem");
+    __publicField(this, "_inputSystem");
+  }
+  /**
+   * 网络服务
+   * Network service
+   */
+  get networkService() {
+    return this._networkService;
+  }
+  /**
+   * 同步系统
+   * Sync system
+   */
+  get syncSystem() {
+    return this._syncSystem;
+  }
+  /**
+   * 生成系统
+   * Spawn system
+   */
+  get spawnSystem() {
+    return this._spawnSystem;
+  }
+  /**
+   * 输入系统
+   * Input system
+   */
+  get inputSystem() {
+    return this._inputSystem;
+  }
+  /**
+   * 是否已连接
+   * Is connected
+   */
+  get isConnected() {
+    return this._networkService?.isConnected ?? false;
+  }
+  /**
+   * 安装插件
+   * Install plugin
+   */
+  install(_core, _services) {
+    this._networkService = new NetworkService();
+    const scene = Core.scene;
+    if (scene) {
+      this._setupSystems(scene);
+    }
+  }
+  /**
+   * 卸载插件
+   * Uninstall plugin
+   */
+  uninstall() {
+    this._networkService?.disconnect();
+  }
+  _setupSystems(scene) {
+    this._syncSystem = new NetworkSyncSystem(this._networkService);
+    this._spawnSystem = new NetworkSpawnSystem(this._networkService, this._syncSystem);
+    this._inputSystem = new NetworkInputSystem(this._networkService);
+    scene.addSystem(this._syncSystem);
+    scene.addSystem(this._spawnSystem);
+    scene.addSystem(this._inputSystem);
+  }
+  /**
+   * 连接到服务器
+   * Connect to server
+   */
+  async connect(serverUrl, playerName, roomId) {
+    return this._networkService.connect(serverUrl, playerName, roomId);
+  }
+  /**
+   * 断开连接
+   * Disconnect
+   */
+  async disconnect() {
+    await this._networkService.disconnect();
+  }
+  /**
+   * 注册预制体工厂
+   * Register prefab factory
+   */
+  registerPrefab(prefabType, factory) {
+    this._spawnSystem?.registerPrefab(prefabType, factory);
+  }
+  /**
+   * 发送移动输入
+   * Send move input
+   */
+  sendMoveInput(x, y) {
+    this._inputSystem?.addMoveInput(x, y);
+  }
+  /**
+   * 发送动作输入
+   * Send action input
+   */
+  sendActionInput(action) {
+    this._inputSystem?.addActionInput(action);
+  }
+};
+__name(_NetworkPlugin, "NetworkPlugin");
+var NetworkPlugin = _NetworkPlugin;
+
+// src/sync/SnapshotBuffer.ts
+var _SnapshotBuffer = class _SnapshotBuffer {
+  constructor(config) {
+    __publicField(this, "_buffer", []);
+    __publicField(this, "_maxSize");
+    __publicField(this, "_interpolationDelay");
+    this._maxSize = config.maxSize;
+    this._interpolationDelay = config.interpolationDelay;
+  }
+  get size() {
+    return this._buffer.length;
+  }
+  /**
+   * @zh 获取插值延迟
+   * @en Get interpolation delay
+   */
+  get interpolationDelay() {
+    return this._interpolationDelay;
+  }
+  /**
+   * @zh 添加快照
+   * @en Add snapshot
+   */
+  push(snapshot) {
+    let insertIndex = this._buffer.length;
+    for (let i = this._buffer.length - 1; i >= 0; i--) {
+      if (this._buffer[i].timestamp <= snapshot.timestamp) {
+        insertIndex = i + 1;
+        break;
+      }
+      if (i === 0) {
+        insertIndex = 0;
+      }
+    }
+    this._buffer.splice(insertIndex, 0, snapshot);
+    while (this._buffer.length > this._maxSize) {
+      this._buffer.shift();
+    }
+  }
+  /**
+   * @zh 获取用于插值的两个快照
+   * @en Get two snapshots for interpolation
+   */
+  getInterpolationSnapshots(renderTime) {
+    if (this._buffer.length < 2) {
+      return null;
+    }
+    const targetTime = renderTime - this._interpolationDelay;
+    for (let i = 0; i < this._buffer.length - 1; i++) {
+      const prev = this._buffer[i];
+      const next = this._buffer[i + 1];
+      if (prev.timestamp <= targetTime && next.timestamp >= targetTime) {
+        const duration = next.timestamp - prev.timestamp;
+        const t = duration > 0 ? (targetTime - prev.timestamp) / duration : 0;
+        return [
+          prev,
+          next,
+          Math.max(0, Math.min(1, t))
+        ];
+      }
+    }
+    if (targetTime > this._buffer[this._buffer.length - 1].timestamp) {
+      const prev = this._buffer[this._buffer.length - 2];
+      const next = this._buffer[this._buffer.length - 1];
+      const duration = next.timestamp - prev.timestamp;
+      const t = duration > 0 ? (targetTime - prev.timestamp) / duration : 1;
+      return [
+        prev,
+        next,
+        Math.min(t, 2)
+      ];
+    }
+    return null;
+  }
+  /**
+   * @zh 获取最新快照
+   * @en Get latest snapshot
+   */
+  getLatest() {
+    return this._buffer.length > 0 ? this._buffer[this._buffer.length - 1] : null;
+  }
+  /**
+   * @zh 获取特定时间之后的所有快照
+   * @en Get all snapshots after a specific time
+   */
+  getSnapshotsAfter(timestamp) {
+    return this._buffer.filter((s) => s.timestamp > timestamp);
+  }
+  /**
+   * @zh 清空缓冲区
+   * @en Clear buffer
+   */
+  clear() {
+    this._buffer.length = 0;
+  }
+};
+__name(_SnapshotBuffer, "SnapshotBuffer");
+var SnapshotBuffer = _SnapshotBuffer;
+function createSnapshotBuffer(maxSize = 30, interpolationDelay = 100) {
+  return new SnapshotBuffer({
+    maxSize,
+    interpolationDelay
+  });
+}
+__name(createSnapshotBuffer, "createSnapshotBuffer");
+
+// src/sync/IInterpolator.ts
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+__name(lerp, "lerp");
+function lerpAngle(a, b, t) {
+  let diff = b - a;
+  while (diff > Math.PI) diff -= Math.PI * 2;
+  while (diff < -Math.PI) diff += Math.PI * 2;
+  return a + diff * t;
+}
+__name(lerpAngle, "lerpAngle");
+function smoothDamp(current, target, velocity, smoothTime, deltaTime, maxSpeed = Infinity) {
+  smoothTime = Math.max(1e-4, smoothTime);
+  const omega = 2 / smoothTime;
+  const x = omega * deltaTime;
+  const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
+  let change = current - target;
+  const maxChange = maxSpeed * smoothTime;
+  change = Math.max(-maxChange, Math.min(maxChange, change));
+  const temp = (velocity + omega * change) * deltaTime;
+  let newVelocity = (velocity - omega * temp) * exp;
+  let newValue = target + (change + temp) * exp;
+  if (target - current > 0 === newValue > target) {
+    newValue = target;
+    newVelocity = (newValue - target) / deltaTime;
+  }
+  return [
+    newValue,
+    newVelocity
+  ];
+}
+__name(smoothDamp, "smoothDamp");
+
+// src/sync/TransformInterpolator.ts
+var _TransformInterpolator = class _TransformInterpolator {
+  /**
+   * @zh 在两个变换状态之间插值
+   * @en Interpolate between two transform states
+   */
+  interpolate(from, to, t) {
+    return {
+      x: lerp(from.x, to.x, t),
+      y: lerp(from.y, to.y, t),
+      rotation: lerpAngle(from.rotation, to.rotation, t)
+    };
+  }
+  /**
+   * @zh 基于速度外推变换状态
+   * @en Extrapolate transform state based on velocity
+   */
+  extrapolate(state, deltaTime) {
+    return {
+      x: state.x + state.velocityX * deltaTime,
+      y: state.y + state.velocityY * deltaTime,
+      rotation: state.rotation + state.angularVelocity * deltaTime,
+      velocityX: state.velocityX,
+      velocityY: state.velocityY,
+      angularVelocity: state.angularVelocity
+    };
+  }
+};
+__name(_TransformInterpolator, "TransformInterpolator");
+var TransformInterpolator = _TransformInterpolator;
+var _HermiteTransformInterpolator = class _HermiteTransformInterpolator {
+  /**
+   * @zh 使用赫尔米特插值
+   * @en Use Hermite interpolation
+   */
+  interpolate(from, to, t) {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const h00 = 2 * t3 - 3 * t2 + 1;
+    const h10 = t3 - 2 * t2 + t;
+    const h01 = -2 * t3 + 3 * t2;
+    const h11 = t3 - t2;
+    const dt = 0.1;
+    const x = h00 * from.x + h10 * from.velocityX * dt + h01 * to.x + h11 * to.velocityX * dt;
+    const y = h00 * from.y + h10 * from.velocityY * dt + h01 * to.y + h11 * to.velocityY * dt;
+    const dh00 = 6 * t2 - 6 * t;
+    const dh10 = 3 * t2 - 4 * t + 1;
+    const dh01 = -6 * t2 + 6 * t;
+    const dh11 = 3 * t2 - 2 * t;
+    const velocityX = (dh00 * from.x + dh10 * from.velocityX * dt + dh01 * to.x + dh11 * to.velocityX * dt) / dt;
+    const velocityY = (dh00 * from.y + dh10 * from.velocityY * dt + dh01 * to.y + dh11 * to.velocityY * dt) / dt;
+    return {
+      x,
+      y,
+      rotation: lerpAngle(from.rotation, to.rotation, t),
+      velocityX,
+      velocityY,
+      angularVelocity: lerp(from.angularVelocity, to.angularVelocity, t)
+    };
+  }
+};
+__name(_HermiteTransformInterpolator, "HermiteTransformInterpolator");
+var HermiteTransformInterpolator = _HermiteTransformInterpolator;
+function createTransformInterpolator() {
+  return new TransformInterpolator();
+}
+__name(createTransformInterpolator, "createTransformInterpolator");
+function createHermiteTransformInterpolator() {
+  return new HermiteTransformInterpolator();
+}
+__name(createHermiteTransformInterpolator, "createHermiteTransformInterpolator");
+
+// src/sync/ClientPrediction.ts
+var _ClientPrediction = class _ClientPrediction {
+  constructor(predictor, config) {
+    __publicField(this, "_predictor");
+    __publicField(this, "_config");
+    __publicField(this, "_pendingInputs", []);
+    __publicField(this, "_lastAcknowledgedSequence", 0);
+    __publicField(this, "_currentSequence", 0);
+    __publicField(this, "_lastServerState", null);
+    __publicField(this, "_predictedState", null);
+    __publicField(this, "_correctionOffset", {
+      x: 0,
+      y: 0
+    });
+    this._predictor = predictor;
+    this._config = {
+      maxUnacknowledgedInputs: 60,
+      reconciliationThreshold: 0.1,
+      reconciliationSpeed: 10,
+      ...config
+    };
+  }
+  /**
+   * @zh 获取当前预测状态
+   * @en Get current predicted state
+   */
+  get predictedState() {
+    return this._predictedState;
+  }
+  /**
+   * @zh 获取校正偏移
+   * @en Get correction offset
+   */
+  get correctionOffset() {
+    return this._correctionOffset;
+  }
+  /**
+   * @zh 获取待确认输入数量
+   * @en Get pending input count
+   */
+  get pendingInputCount() {
+    return this._pendingInputs.length;
+  }
+  /**
+   * @zh 记录并预测输入
+   * @en Record and predict input
+   *
+   * @param input - @zh 输入数据 @en Input data
+   * @param currentState - @zh 当前状态 @en Current state
+   * @param deltaTime - @zh 时间间隔 @en Delta time
+   * @returns @zh 预测的状态 @en Predicted state
+   */
+  recordInput(input, currentState, deltaTime) {
+    this._currentSequence++;
+    const inputSnapshot = {
+      sequence: this._currentSequence,
+      input,
+      timestamp: Date.now()
+    };
+    this._pendingInputs.push(inputSnapshot);
+    while (this._pendingInputs.length > this._config.maxUnacknowledgedInputs) {
+      this._pendingInputs.shift();
+    }
+    this._predictedState = this._predictor.predict(currentState, input, deltaTime);
+    return this._predictedState;
+  }
+  /**
+   * @zh 获取下一个要发送的输入
+   * @en Get next input to send
+   */
+  getInputToSend() {
+    return this._pendingInputs.length > 0 ? this._pendingInputs[this._pendingInputs.length - 1] : null;
+  }
+  /**
+   * @zh 获取当前序列号
+   * @en Get current sequence number
+   */
+  get currentSequence() {
+    return this._currentSequence;
+  }
+  /**
+   * @zh 处理服务器状态并进行校正
+   * @en Process server state and reconcile
+   *
+   * @param serverState - @zh 服务器状态 @en Server state
+   * @param acknowledgedSequence - @zh 已确认的输入序列号 @en Acknowledged input sequence
+   * @param stateGetter - @zh 获取状态位置的函数 @en Function to get state position
+   * @param deltaTime - @zh 帧时间 @en Frame delta time
+   */
+  reconcile(serverState, acknowledgedSequence, stateGetter, deltaTime) {
+    this._lastServerState = serverState;
+    this._lastAcknowledgedSequence = acknowledgedSequence;
+    while (this._pendingInputs.length > 0 && this._pendingInputs[0].sequence <= acknowledgedSequence) {
+      this._pendingInputs.shift();
+    }
+    let state = serverState;
+    for (const inputSnapshot of this._pendingInputs) {
+      state = this._predictor.predict(state, inputSnapshot.input, deltaTime);
+    }
+    const serverPos = stateGetter(serverState);
+    const predictedPos = stateGetter(state);
+    const errorX = serverPos.x - predictedPos.x;
+    const errorY = serverPos.y - predictedPos.y;
+    const errorMagnitude = Math.sqrt(errorX * errorX + errorY * errorY);
+    if (errorMagnitude > this._config.reconciliationThreshold) {
+      const t = Math.min(1, this._config.reconciliationSpeed * deltaTime);
+      this._correctionOffset.x += errorX * t;
+      this._correctionOffset.y += errorY * t;
+    }
+    const decayRate = 0.9;
+    this._correctionOffset.x *= decayRate;
+    this._correctionOffset.y *= decayRate;
+    this._predictedState = state;
+    return state;
+  }
+  /**
+   * @zh 清空预测状态
+   * @en Clear prediction state
+   */
+  clear() {
+    this._pendingInputs.length = 0;
+    this._lastAcknowledgedSequence = 0;
+    this._currentSequence = 0;
+    this._lastServerState = null;
+    this._predictedState = null;
+    this._correctionOffset = {
+      x: 0,
+      y: 0
+    };
+  }
+};
+__name(_ClientPrediction, "ClientPrediction");
+var ClientPrediction = _ClientPrediction;
+function createClientPrediction(predictor, config) {
+  return new ClientPrediction(predictor, config);
+}
+__name(createClientPrediction, "createClientPrediction");
+
+// src/nodes/NetworkNodes.ts
+var IsLocalPlayerTemplate = {
+  type: "IsLocalPlayer",
+  title: "Is Local Player",
+  category: "entity",
+  description: "Check if this entity is the local player / \u68C0\u67E5\u6B64\u5B9E\u4F53\u662F\u5426\u662F\u672C\u5730\u73A9\u5BB6",
+  keywords: [
+    "network",
+    "local",
+    "player",
+    "authority",
+    "owner"
+  ],
+  menuPath: [
+    "Network",
+    "Is Local Player"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "isLocal",
+      displayName: "Is Local",
+      type: "bool"
+    }
+  ],
+  color: "#ff9800"
+};
+var _IsLocalPlayerExecutor = class _IsLocalPlayerExecutor {
+  execute(node, context) {
+    var _a;
+    const ctx = context;
+    let isLocal = false;
+    if (ctx.entity) {
+      const identity = ctx.entity.getComponent((_a = class {
+        constructor() {
+          __publicField(this, "bIsLocalPlayer", false);
+        }
+      }, __name(_a, "NetworkIdentity"), _a));
+      if (identity) {
+        isLocal = identity.bIsLocalPlayer;
+      }
+    }
+    return {
+      outputs: {
+        isLocal
+      }
+    };
+  }
+};
+__name(_IsLocalPlayerExecutor, "IsLocalPlayerExecutor");
+var IsLocalPlayerExecutor = _IsLocalPlayerExecutor;
+var IsServerTemplate = {
+  type: "IsServer",
+  title: "Is Server",
+  category: "entity",
+  description: "Check if running on server / \u68C0\u67E5\u662F\u5426\u5728\u670D\u52A1\u5668\u4E0A\u8FD0\u884C",
+  keywords: [
+    "network",
+    "server",
+    "authority",
+    "host"
+  ],
+  menuPath: [
+    "Network",
+    "Is Server"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "isServer",
+      displayName: "Is Server",
+      type: "bool"
+    }
+  ],
+  color: "#ff9800"
+};
+var _IsServerExecutor = class _IsServerExecutor {
+  execute(_node, context) {
+    const ctx = context;
+    return {
+      outputs: {
+        isServer: ctx.isServer ?? false
+      }
+    };
+  }
+};
+__name(_IsServerExecutor, "IsServerExecutor");
+var IsServerExecutor = _IsServerExecutor;
+var HasAuthorityTemplate = {
+  type: "HasAuthority",
+  title: "Has Authority",
+  category: "entity",
+  description: "Check if this entity has authority / \u68C0\u67E5\u6B64\u5B9E\u4F53\u662F\u5426\u6709\u6743\u9650\u63A7\u5236",
+  keywords: [
+    "network",
+    "authority",
+    "control",
+    "owner"
+  ],
+  menuPath: [
+    "Network",
+    "Has Authority"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "hasAuthority",
+      displayName: "Has Authority",
+      type: "bool"
+    }
+  ],
+  color: "#ff9800"
+};
+var _HasAuthorityExecutor = class _HasAuthorityExecutor {
+  execute(node, context) {
+    var _a;
+    const ctx = context;
+    let hasAuthority = false;
+    if (ctx.entity) {
+      const identity = ctx.entity.getComponent((_a = class {
+        constructor() {
+          __publicField(this, "bHasAuthority", false);
+        }
+      }, __name(_a, "NetworkIdentity"), _a));
+      if (identity) {
+        hasAuthority = identity.bHasAuthority;
+      }
+    }
+    return {
+      outputs: {
+        hasAuthority
+      }
+    };
+  }
+};
+__name(_HasAuthorityExecutor, "HasAuthorityExecutor");
+var HasAuthorityExecutor = _HasAuthorityExecutor;
+var GetNetworkIdTemplate = {
+  type: "GetNetworkId",
+  title: "Get Network ID",
+  category: "entity",
+  description: "Get the network ID of this entity / \u83B7\u53D6\u6B64\u5B9E\u4F53\u7684\u7F51\u7EDC ID",
+  keywords: [
+    "network",
+    "id",
+    "netid",
+    "identity"
+  ],
+  menuPath: [
+    "Network",
+    "Get Network ID"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "netId",
+      displayName: "Net ID",
+      type: "int"
+    },
+    {
+      name: "ownerId",
+      displayName: "Owner ID",
+      type: "int"
+    }
+  ],
+  color: "#ff9800"
+};
+var _GetNetworkIdExecutor = class _GetNetworkIdExecutor {
+  execute(node, context) {
+    var _a;
+    const ctx = context;
+    let netId = 0;
+    let ownerId = 0;
+    if (ctx.entity) {
+      const identity = ctx.entity.getComponent((_a = class {
+        constructor() {
+          __publicField(this, "netId", 0);
+          __publicField(this, "ownerId", 0);
+        }
+      }, __name(_a, "NetworkIdentity"), _a));
+      if (identity) {
+        netId = identity.netId;
+        ownerId = identity.ownerId;
+      }
+    }
+    return {
+      outputs: {
+        netId,
+        ownerId
+      }
+    };
+  }
+};
+__name(_GetNetworkIdExecutor, "GetNetworkIdExecutor");
+var GetNetworkIdExecutor = _GetNetworkIdExecutor;
+var GetLocalPlayerIdTemplate = {
+  type: "GetLocalPlayerId",
+  title: "Get Local Player ID",
+  category: "entity",
+  description: "Get the local player ID / \u83B7\u53D6\u672C\u5730\u73A9\u5BB6 ID",
+  keywords: [
+    "network",
+    "local",
+    "player",
+    "id"
+  ],
+  menuPath: [
+    "Network",
+    "Get Local Player ID"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "playerId",
+      displayName: "Player ID",
+      type: "int"
+    }
+  ],
+  color: "#ff9800"
+};
+var _GetLocalPlayerIdExecutor = class _GetLocalPlayerIdExecutor {
+  execute(_node, context) {
+    const ctx = context;
+    return {
+      outputs: {
+        playerId: ctx.localPlayerId ?? 0
+      }
+    };
+  }
+};
+__name(_GetLocalPlayerIdExecutor, "GetLocalPlayerIdExecutor");
+var GetLocalPlayerIdExecutor = _GetLocalPlayerIdExecutor;
+var NetworkNodeDefinitions = {
+  templates: [
+    IsLocalPlayerTemplate,
+    IsServerTemplate,
+    HasAuthorityTemplate,
+    GetNetworkIdTemplate,
+    GetLocalPlayerIdTemplate
+  ],
+  executors: /* @__PURE__ */ new Map([
+    [
+      "IsLocalPlayer",
+      new IsLocalPlayerExecutor()
+    ],
+    [
+      "IsServer",
+      new IsServerExecutor()
+    ],
+    [
+      "HasAuthority",
+      new HasAuthorityExecutor()
+    ],
+    [
+      "GetNetworkId",
+      new GetNetworkIdExecutor()
+    ],
+    [
+      "GetLocalPlayerId",
+      new GetLocalPlayerIdExecutor()
+    ]
+  ])
+};
+export {
+  ClientPrediction,
+  ENetworkState,
+  GetLocalPlayerIdExecutor,
+  GetLocalPlayerIdTemplate,
+  GetNetworkIdExecutor,
+  GetNetworkIdTemplate,
+  HasAuthorityExecutor,
+  HasAuthorityTemplate,
+  HermiteTransformInterpolator,
+  IsLocalPlayerExecutor,
+  IsLocalPlayerTemplate,
+  IsServerExecutor,
+  IsServerTemplate,
+  NetworkIdentity,
+  NetworkInputSystem,
+  NetworkInputSystemToken,
+  NetworkNodeDefinitions,
+  NetworkPlugin,
+  NetworkService,
+  NetworkServiceToken,
+  NetworkSpawnSystem,
+  NetworkSpawnSystemToken,
+  NetworkSyncSystem,
+  NetworkSyncSystemToken,
+  NetworkTransform,
+  SnapshotBuffer,
+  TransformInterpolator,
+  createClientPrediction,
+  createHermiteTransformInterpolator,
+  createSnapshotBuffer,
+  createTransformInterpolator,
+  lerp,
+  lerpAngle,
+  serviceProto2 as serviceProto,
+  smoothDamp
+};
+//# sourceMappingURL=index.js.map