@esengine/network 2.1.0 → 2.2.0

package/dist/index.js

@@ -19,7 +19,12 @@ var gameProtocol = rpc.define({
      * @zh 离开房间
      * @en Leave room
      */
-    leave: rpc.api()
+    leave: rpc.api(),
+    /**
+     * @zh 重连
+     * @en Reconnect
+     */
+    reconnect: rpc.api()
   },
   msg: {
     /**
@@ -41,7 +46,12 @@ var gameProtocol = rpc.define({
      * @zh 实体销毁
      * @en Entity despawn
      */
-    despawn: rpc.msg()
+    despawn: rpc.msg(),
+    /**
+     * @zh 完整状态快照
+     * @en Full state snapshot
+     */
+    fullState: rpc.msg()
   }
 });
 
@@ -51,6 +61,8 @@ var NetworkServiceToken = createServiceToken("networkService");
 var NetworkSyncSystemToken = createServiceToken("networkSyncSystem");
 var NetworkSpawnSystemToken = createServiceToken("networkSpawnSystem");
 var NetworkInputSystemToken = createServiceToken("networkInputSystem");
+var NetworkPredictionSystemToken = createServiceToken("networkPredictionSystem");
+var NetworkAOISystemToken = createServiceToken("networkAOISystem");
 
 // src/NetworkPlugin.ts
 import { Core } from "@esengine/ecs-framework";
@@ -454,222 +466,1602 @@ NetworkTransform = _ts_decorate2([
   })
 ], NetworkTransform);
 
-// src/systems/NetworkSyncSystem.ts
-var _NetworkSyncSystem = class _NetworkSyncSystem extends EntitySystem {
-  constructor() {
-    super(Matcher.all(NetworkIdentity, NetworkTransform));
-    __publicField(this, "_netIdToEntity", /* @__PURE__ */ new Map());
+// 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 Handle sync message
+   * @zh 获取插值延迟
+   * @en Get interpolation delay
    */
-  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);
+  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();
     }
   }
-  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);
+  /**
+   * @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 Register network entity
+   * @zh 获取最新快照
+   * @en Get latest snapshot
    */
-  registerEntity(netId, entityId) {
-    this._netIdToEntity.set(netId, entityId);
+  getLatest() {
+    return this._buffer.length > 0 ? this._buffer[this._buffer.length - 1] : null;
   }
   /**
-   * @zh 注销网络实体
-   * @en Unregister network entity
+   * @zh 获取特定时间之后的所有快照
+   * @en Get all snapshots after a specific time
    */
-  unregisterEntity(netId) {
-    this._netIdToEntity.delete(netId);
+  getSnapshotsAfter(timestamp) {
+    return this._buffer.filter((s) => s.timestamp > timestamp);
   }
   /**
-   * @zh 根据网络 ID 获取实体 ID
-   * @en Get entity ID by network ID
+   * @zh 清空缓冲区
+   * @en Clear buffer
    */
-  getEntityId(netId) {
-    return this._netIdToEntity.get(netId);
-  }
-  _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();
+  clear() {
+    this._buffer.length = 0;
   }
 };
-__name(_NetworkSyncSystem, "NetworkSyncSystem");
-var NetworkSyncSystem = _NetworkSyncSystem;
+__name(_SnapshotBuffer, "SnapshotBuffer");
+var SnapshotBuffer = _SnapshotBuffer;
+function createSnapshotBuffer(maxSize = 30, interpolationDelay = 100) {
+  return new SnapshotBuffer({
+    maxSize,
+    interpolationDelay
+  });
+}
+__name(createSnapshotBuffer, "createSnapshotBuffer");
 
-// src/systems/NetworkSpawnSystem.ts
-import { EntitySystem as EntitySystem2, Matcher as Matcher2 } from "@esengine/ecs-framework";
-var _NetworkSpawnSystem = class _NetworkSpawnSystem extends EntitySystem2 {
-  constructor(syncSystem) {
-    super(Matcher2.nothing());
-    __publicField(this, "_syncSystem");
-    __publicField(this, "_prefabFactories", /* @__PURE__ */ new Map());
-    __publicField(this, "_localPlayerId", 0);
-    this._syncSystem = syncSystem;
-  }
-  /**
-   * @zh 设置本地玩家 ID
-   * @en Set local player ID
-   */
-  setLocalPlayerId(id) {
-    this._localPlayerId = id;
-  }
-  /**
-   * @zh 处理生成消息
-   * @en Handle spawn message
-   */
-  handleSpawn(msg) {
-    if (!this.scene) return null;
-    const factory = this._prefabFactories.get(msg.prefab);
-    if (!factory) {
-      this.logger.warn(`Unknown prefab: ${msg.prefab}`);
-      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._localPlayerId;
-    identity.bIsLocalPlayer = identity.bHasAuthority;
-    const transform = entity.addComponent(new NetworkTransform());
-    transform.setTarget(msg.pos.x, msg.pos.y, msg.rot ?? 0);
-    transform.snap();
-    this._syncSystem.registerEntity(msg.netId, entity.id);
-    return entity;
+// 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 Handle despawn message
+   * @zh 在两个变换状态之间插值
+   * @en Interpolate between two transform states
    */
-  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);
+  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 Register prefab factory
+   * @zh 基于速度外推变换状态
+   * @en Extrapolate transform state based on velocity
    */
-  registerPrefab(prefabType, factory) {
-    this._prefabFactories.set(prefabType, factory);
+  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 Unregister prefab factory
+   * @zh 使用赫尔米特插值
+   * @en Use Hermite interpolation
    */
-  unregisterPrefab(prefabType) {
-    this._prefabFactories.delete(prefabType);
-  }
-  onDestroy() {
-    this._prefabFactories.clear();
-  }
+  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/sync/StateDelta.ts
+var DeltaFlags = {
+  NONE: 0,
+  POSITION: 1 << 0,
+  ROTATION: 1 << 1,
+  VELOCITY: 1 << 2,
+  ANGULAR_VELOCITY: 1 << 3,
+  CUSTOM: 1 << 4
+};
+var DEFAULT_CONFIG = {
+  positionThreshold: 0.01,
+  rotationThreshold: 1e-3,
+  velocityThreshold: 0.1,
+  fullSnapshotInterval: 60
+};
+var _StateDeltaCompressor = class _StateDeltaCompressor {
+  constructor(config) {
+    __publicField(this, "_config");
+    __publicField(this, "_lastStates", /* @__PURE__ */ new Map());
+    __publicField(this, "_frameCounter", 0);
+    this._config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+  }
+  /**
+   * @zh 获取配置
+   * @en Get configuration
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * @zh 压缩同步数据为增量格式
+   * @en Compress sync data to delta format
+   */
+  compress(data) {
+    this._frameCounter++;
+    const isFullSnapshot = this._frameCounter % this._config.fullSnapshotInterval === 0;
+    const deltaEntities = [];
+    for (const entity of data.entities) {
+      const lastState = this._lastStates.get(entity.netId);
+      if (isFullSnapshot || !lastState) {
+        deltaEntities.push(this._createFullDelta(entity));
+      } else {
+        const delta = this._calculateDelta(lastState, entity);
+        if (delta) {
+          deltaEntities.push(delta);
+        }
+      }
+      this._lastStates.set(entity.netId, {
+        ...entity
+      });
+    }
+    return {
+      frame: data.frame,
+      timestamp: data.timestamp,
+      ackSeq: data.ackSeq,
+      entities: deltaEntities,
+      isFullSnapshot
+    };
+  }
+  /**
+   * @zh 解压增量数据为完整同步数据
+   * @en Decompress delta data to full sync data
+   */
+  decompress(data) {
+    const entities = [];
+    for (const delta of data.entities) {
+      const lastState = this._lastStates.get(delta.netId);
+      const fullState = this._applyDelta(lastState, delta);
+      entities.push(fullState);
+      this._lastStates.set(delta.netId, fullState);
+    }
+    return {
+      frame: data.frame,
+      timestamp: data.timestamp,
+      ackSeq: data.ackSeq,
+      entities
+    };
+  }
+  /**
+   * @zh 移除实体状态
+   * @en Remove entity state
+   */
+  removeEntity(netId) {
+    this._lastStates.delete(netId);
+  }
+  /**
+   * @zh 清除所有状态
+   * @en Clear all states
+   */
+  clear() {
+    this._lastStates.clear();
+    this._frameCounter = 0;
+  }
+  /**
+   * @zh 强制下一次发送完整快照
+   * @en Force next send to be a full snapshot
+   */
+  forceFullSnapshot() {
+    this._frameCounter = this._config.fullSnapshotInterval - 1;
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  _createFullDelta(entity) {
+    let flags = 0;
+    if (entity.pos) flags |= DeltaFlags.POSITION;
+    if (entity.rot !== void 0) flags |= DeltaFlags.ROTATION;
+    if (entity.vel) flags |= DeltaFlags.VELOCITY;
+    if (entity.angVel !== void 0) flags |= DeltaFlags.ANGULAR_VELOCITY;
+    if (entity.custom) flags |= DeltaFlags.CUSTOM;
+    return {
+      netId: entity.netId,
+      flags,
+      pos: entity.pos,
+      rot: entity.rot,
+      vel: entity.vel,
+      angVel: entity.angVel,
+      custom: entity.custom
+    };
+  }
+  _calculateDelta(lastState, currentState) {
+    let flags = 0;
+    const delta = {
+      netId: currentState.netId,
+      flags: 0
+    };
+    if (currentState.pos) {
+      const posChanged = !lastState.pos || Math.abs(currentState.pos.x - lastState.pos.x) > this._config.positionThreshold || Math.abs(currentState.pos.y - lastState.pos.y) > this._config.positionThreshold;
+      if (posChanged) {
+        flags |= DeltaFlags.POSITION;
+        delta.pos = currentState.pos;
+      }
+    }
+    if (currentState.rot !== void 0) {
+      const rotChanged = lastState.rot === void 0 || Math.abs(currentState.rot - lastState.rot) > this._config.rotationThreshold;
+      if (rotChanged) {
+        flags |= DeltaFlags.ROTATION;
+        delta.rot = currentState.rot;
+      }
+    }
+    if (currentState.vel) {
+      const velChanged = !lastState.vel || Math.abs(currentState.vel.x - lastState.vel.x) > this._config.velocityThreshold || Math.abs(currentState.vel.y - lastState.vel.y) > this._config.velocityThreshold;
+      if (velChanged) {
+        flags |= DeltaFlags.VELOCITY;
+        delta.vel = currentState.vel;
+      }
+    }
+    if (currentState.angVel !== void 0) {
+      const angVelChanged = lastState.angVel === void 0 || Math.abs(currentState.angVel - lastState.angVel) > this._config.velocityThreshold;
+      if (angVelChanged) {
+        flags |= DeltaFlags.ANGULAR_VELOCITY;
+        delta.angVel = currentState.angVel;
+      }
+    }
+    if (currentState.custom) {
+      const customChanged = !this._customDataEqual(lastState.custom, currentState.custom);
+      if (customChanged) {
+        flags |= DeltaFlags.CUSTOM;
+        delta.custom = currentState.custom;
+      }
+    }
+    if (flags === 0) {
+      return null;
+    }
+    delta.flags = flags;
+    return delta;
+  }
+  _applyDelta(lastState, delta) {
+    const state = {
+      netId: delta.netId
+    };
+    if (delta.flags & DeltaFlags.POSITION) {
+      state.pos = delta.pos;
+    } else if (lastState?.pos) {
+      state.pos = lastState.pos;
+    }
+    if (delta.flags & DeltaFlags.ROTATION) {
+      state.rot = delta.rot;
+    } else if (lastState?.rot !== void 0) {
+      state.rot = lastState.rot;
+    }
+    if (delta.flags & DeltaFlags.VELOCITY) {
+      state.vel = delta.vel;
+    } else if (lastState?.vel) {
+      state.vel = lastState.vel;
+    }
+    if (delta.flags & DeltaFlags.ANGULAR_VELOCITY) {
+      state.angVel = delta.angVel;
+    } else if (lastState?.angVel !== void 0) {
+      state.angVel = lastState.angVel;
+    }
+    if (delta.flags & DeltaFlags.CUSTOM) {
+      state.custom = delta.custom;
+    } else if (lastState?.custom) {
+      state.custom = lastState.custom;
+    }
+    return state;
+  }
+  _customDataEqual(a, b) {
+    if (a === b) return true;
+    if (!a || !b) return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (a[key] !== b[key]) return false;
+    }
+    return true;
+  }
+};
+__name(_StateDeltaCompressor, "StateDeltaCompressor");
+var StateDeltaCompressor = _StateDeltaCompressor;
+function createStateDeltaCompressor(config) {
+  return new StateDeltaCompressor(config);
+}
+__name(createStateDeltaCompressor, "createStateDeltaCompressor");
+
+// src/systems/NetworkSyncSystem.ts
+var DEFAULT_CONFIG2 = {
+  bufferSize: 30,
+  interpolationDelay: 100,
+  enableExtrapolation: true,
+  maxExtrapolationTime: 200,
+  useHermiteInterpolation: false
+};
+var _NetworkSyncSystem = class _NetworkSyncSystem extends EntitySystem {
+  constructor(config) {
+    super(Matcher.all(NetworkIdentity, NetworkTransform));
+    __publicField(this, "_netIdToEntity", /* @__PURE__ */ new Map());
+    __publicField(this, "_entitySnapshots", /* @__PURE__ */ new Map());
+    __publicField(this, "_interpolator");
+    __publicField(this, "_config");
+    __publicField(this, "_serverTimeOffset", 0);
+    __publicField(this, "_lastSyncTime", 0);
+    __publicField(this, "_renderTime", 0);
+    this._config = {
+      ...DEFAULT_CONFIG2,
+      ...config
+    };
+    this._interpolator = createTransformInterpolator();
+  }
+  /**
+   * @zh 获取配置
+   * @en Get configuration
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * @zh 获取服务器时间偏移
+   * @en Get server time offset
+   */
+  get serverTimeOffset() {
+    return this._serverTimeOffset;
+  }
+  /**
+   * @zh 获取当前渲染时间
+   * @en Get current render time
+   */
+  get renderTime() {
+    return this._renderTime;
+  }
+  /**
+   * @zh 处理同步消息（新版，带时间戳）
+   * @en Handle sync message (new version with timestamp)
+   */
+  handleSyncData(data) {
+    const serverTime = data.timestamp;
+    const clientTime = Date.now();
+    this._serverTimeOffset = serverTime - clientTime;
+    this._lastSyncTime = clientTime;
+    for (const state of data.entities) {
+      this._processEntityState(state, serverTime);
+    }
+  }
+  /**
+   * @zh 处理同步消息（兼容旧版）
+   * @en Handle sync message (backwards compatible)
+   */
+  handleSync(msg) {
+    const now = Date.now();
+    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);
+      }
+      this._processEntityState({
+        netId: state.netId,
+        pos: state.pos,
+        rot: state.rot
+      }, now);
+    }
+  }
+  _processEntityState(state, serverTime) {
+    const entityId = this._netIdToEntity.get(state.netId);
+    if (entityId === void 0) return;
+    let snapshotData = this._entitySnapshots.get(state.netId);
+    if (!snapshotData) {
+      snapshotData = {
+        buffer: createSnapshotBuffer(this._config.bufferSize, this._config.interpolationDelay),
+        lastServerTime: 0
+      };
+      this._entitySnapshots.set(state.netId, snapshotData);
+    }
+    const transformState = {
+      x: state.pos?.x ?? 0,
+      y: state.pos?.y ?? 0,
+      rotation: state.rot ?? 0,
+      velocityX: state.vel?.x ?? 0,
+      velocityY: state.vel?.y ?? 0,
+      angularVelocity: state.angVel ?? 0
+    };
+    const snapshot = {
+      timestamp: serverTime,
+      state: transformState
+    };
+    snapshotData.buffer.push(snapshot);
+    snapshotData.lastServerTime = serverTime;
+  }
+  process(entities) {
+    const deltaTime = Time.deltaTime;
+    const clientTime = Date.now();
+    this._renderTime = clientTime + this._serverTimeOffset;
+    for (const entity of entities) {
+      const transform = this.requireComponent(entity, NetworkTransform);
+      const identity = this.requireComponent(entity, NetworkIdentity);
+      if (identity.bHasAuthority) continue;
+      if (transform.bInterpolate) {
+        this._interpolateEntity(identity.netId, transform, deltaTime);
+      }
+    }
+  }
+  _interpolateEntity(netId, transform, deltaTime) {
+    const snapshotData = this._entitySnapshots.get(netId);
+    if (snapshotData && snapshotData.buffer.size >= 2) {
+      const result = snapshotData.buffer.getInterpolationSnapshots(this._renderTime);
+      if (result) {
+        const [prev, next, t] = result;
+        const interpolated = this._interpolator.interpolate(prev.state, next.state, t);
+        transform.currentX = interpolated.x;
+        transform.currentY = interpolated.y;
+        transform.currentRotation = interpolated.rotation;
+        transform.targetX = next.state.x;
+        transform.targetY = next.state.y;
+        transform.targetRotation = next.state.rotation;
+        return;
+      }
+      if (this._config.enableExtrapolation) {
+        const latest = snapshotData.buffer.getLatest();
+        if (latest) {
+          const timeSinceLastSnapshot = this._renderTime - latest.timestamp;
+          if (timeSinceLastSnapshot > 0 && timeSinceLastSnapshot < this._config.maxExtrapolationTime) {
+            const extrapolated = this._interpolator.extrapolate(latest.state, timeSinceLastSnapshot / 1e3);
+            transform.currentX = extrapolated.x;
+            transform.currentY = extrapolated.y;
+            transform.currentRotation = extrapolated.rotation;
+            return;
+          }
+        }
+      }
+    }
+    this._simpleLerp(transform, deltaTime);
+  }
+  _simpleLerp(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;
+  }
+  /**
+   * @zh 注册网络实体
+   * @en Register network entity
+   */
+  registerEntity(netId, entityId) {
+    this._netIdToEntity.set(netId, entityId);
+  }
+  /**
+   * @zh 注销网络实体
+   * @en Unregister network entity
+   */
+  unregisterEntity(netId) {
+    this._netIdToEntity.delete(netId);
+    this._entitySnapshots.delete(netId);
+  }
+  /**
+   * @zh 根据网络 ID 获取实体 ID
+   * @en Get entity ID by network ID
+   */
+  getEntityId(netId) {
+    return this._netIdToEntity.get(netId);
+  }
+  /**
+   * @zh 获取实体的快照缓冲区
+   * @en Get entity's snapshot buffer
+   */
+  getSnapshotBuffer(netId) {
+    return this._entitySnapshots.get(netId)?.buffer;
+  }
+  /**
+   * @zh 清空所有快照缓冲
+   * @en Clear all snapshot buffers
+   */
+  clearSnapshots() {
+    for (const data of this._entitySnapshots.values()) {
+      data.buffer.clear();
+    }
+  }
+  onDestroy() {
+    this._netIdToEntity.clear();
+    this._entitySnapshots.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(syncSystem) {
+    super(Matcher2.nothing());
+    __publicField(this, "_syncSystem");
+    __publicField(this, "_prefabFactories", /* @__PURE__ */ new Map());
+    __publicField(this, "_localPlayerId", 0);
+    this._syncSystem = syncSystem;
+  }
+  /**
+   * @zh 设置本地玩家 ID
+   * @en Set local player ID
+   */
+  setLocalPlayerId(id) {
+    this._localPlayerId = id;
+  }
+  /**
+   * @zh 处理生成消息
+   * @en Handle spawn message
+   */
+  handleSpawn(msg) {
+    if (!this.scene) return null;
+    const factory = this._prefabFactories.get(msg.prefab);
+    if (!factory) {
+      this.logger.warn(`Unknown prefab: ${msg.prefab}`);
+      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._localPlayerId;
+    identity.bIsLocalPlayer = identity.bHasAuthority;
+    const transform = entity.addComponent(new NetworkTransform());
+    transform.setTarget(msg.pos.x, msg.pos.y, msg.rot ?? 0);
+    transform.snap();
+    this._syncSystem.registerEntity(msg.netId, entity.id);
+    return entity;
+  }
+  /**
+   * @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);
+    if (entity) {
+      entity.destroy();
+    }
+    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();
+  }
+};
+__name(_NetworkSpawnSystem, "NetworkSpawnSystem");
+var NetworkSpawnSystem = _NetworkSpawnSystem;
+
+// src/systems/NetworkInputSystem.ts
+import { EntitySystem as EntitySystem3, Matcher as Matcher3 } from "@esengine/ecs-framework";
+var DEFAULT_CONFIG3 = {
+  sendInterval: 16,
+  mergeIdenticalInputs: true,
+  maxQueueLength: 10
+};
+var _NetworkInputSystem = class _NetworkInputSystem extends EntitySystem3 {
+  constructor(networkService, config) {
+    super(Matcher3.nothing());
+    __publicField(this, "_networkService");
+    __publicField(this, "_config");
+    __publicField(this, "_predictionSystem", null);
+    __publicField(this, "_frame", 0);
+    __publicField(this, "_inputSequence", 0);
+    __publicField(this, "_inputQueue", []);
+    __publicField(this, "_lastSendTime", 0);
+    __publicField(this, "_lastMoveDir", {
+      x: 0,
+      y: 0
+    });
+    this._networkService = networkService;
+    this._config = {
+      ...DEFAULT_CONFIG3,
+      ...config
+    };
+  }
+  /**
+   * @zh 获取配置
+   * @en Get configuration
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * @zh 获取当前帧号
+   * @en Get current frame number
+   */
+  get frame() {
+    return this._frame;
+  }
+  /**
+   * @zh 获取当前输入序列号
+   * @en Get current input sequence
+   */
+  get inputSequence() {
+    return this._inputSequence;
+  }
+  /**
+   * @zh 设置预测系统引用
+   * @en Set prediction system reference
+   */
+  setPredictionSystem(system) {
+    this._predictionSystem = system;
+  }
+  /**
+   * @zh 处理输入队列
+   * @en Process input queue
+   */
+  process() {
+    if (!this._networkService.isConnected) return;
+    this._frame++;
+    const now = Date.now();
+    if (now - this._lastSendTime < this._config.sendInterval) return;
+    if (this._predictionSystem) {
+      const predictedInput = this._predictionSystem.getInputToSend();
+      if (predictedInput) {
+        this._networkService.sendInput(predictedInput);
+        this._lastSendTime = now;
+      }
+      return;
+    }
+    if (this._inputQueue.length === 0) return;
+    let mergedInput;
+    if (this._config.mergeIdenticalInputs && this._inputQueue.length > 1) {
+      mergedInput = this._mergeInputs(this._inputQueue);
+      this._inputQueue.length = 0;
+    } else {
+      mergedInput = this._inputQueue.shift();
+    }
+    this._inputSequence++;
+    const input = {
+      seq: this._inputSequence,
+      frame: this._frame,
+      timestamp: mergedInput.timestamp,
+      moveDir: mergedInput.moveDir,
+      actions: mergedInput.actions
+    };
+    this._networkService.sendInput(input);
+    this._lastSendTime = now;
+  }
+  _mergeInputs(inputs) {
+    const allActions = [];
+    let lastMoveDir;
+    for (const input of inputs) {
+      if (input.moveDir) {
+        lastMoveDir = input.moveDir;
+      }
+      if (input.actions) {
+        allActions.push(...input.actions);
+      }
+    }
+    return {
+      moveDir: lastMoveDir,
+      actions: allActions.length > 0 ? allActions : void 0,
+      timestamp: inputs[inputs.length - 1].timestamp
+    };
+  }
+  /**
+   * @zh 添加移动输入
+   * @en Add move input
+   */
+  addMoveInput(x, y) {
+    if (this._config.mergeIdenticalInputs && this._lastMoveDir.x === x && this._lastMoveDir.y === y && this._inputQueue.length > 0) {
+      return;
+    }
+    this._lastMoveDir = {
+      x,
+      y
+    };
+    if (this._predictionSystem) {
+      this._predictionSystem.setInput(x, y);
+    }
+    this._addToQueue({
+      moveDir: {
+        x,
+        y
+      },
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * @zh 添加动作输入
+   * @en 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._addToQueue({
+        actions: [
+          action
+        ],
+        timestamp: Date.now()
+      });
+    }
+    if (this._predictionSystem) {
+      this._predictionSystem.setInput(this._lastMoveDir.x, this._lastMoveDir.y, [
+        action
+      ]);
+    }
+  }
+  _addToQueue(input) {
+    this._inputQueue.push(input);
+    while (this._inputQueue.length > this._config.maxQueueLength) {
+      this._inputQueue.shift();
+    }
+  }
+  /**
+   * @zh 清空输入队列
+   * @en Clear input queue
+   */
+  clearQueue() {
+    this._inputQueue.length = 0;
+    this._lastMoveDir = {
+      x: 0,
+      y: 0
+    };
+  }
+  /**
+   * @zh 重置状态
+   * @en Reset state
+   */
+  reset() {
+    this._frame = 0;
+    this._inputSequence = 0;
+    this.clearQueue();
+  }
+  onDestroy() {
+    this._inputQueue.length = 0;
+    this._predictionSystem = null;
+  }
+};
+__name(_NetworkInputSystem, "NetworkInputSystem");
+var NetworkInputSystem = _NetworkInputSystem;
+function createNetworkInputSystem(networkService, config) {
+  return new NetworkInputSystem(networkService, config);
+}
+__name(createNetworkInputSystem, "createNetworkInputSystem");
+
+// src/systems/NetworkPredictionSystem.ts
+import { EntitySystem as EntitySystem4, Matcher as Matcher4, Time as Time2 } from "@esengine/ecs-framework";
+var DEFAULT_CONFIG4 = {
+  moveSpeed: 200,
+  enabled: true,
+  maxUnacknowledgedInputs: 60,
+  reconciliationThreshold: 0.5,
+  reconciliationSpeed: 10
+};
+var _a;
+var SimpleMovementPredictor = (_a = class {
+  constructor(_moveSpeed) {
+    __publicField(this, "_moveSpeed");
+    this._moveSpeed = _moveSpeed;
+  }
+  predict(state, input, deltaTime) {
+    const velocityX = input.x * this._moveSpeed;
+    const velocityY = input.y * this._moveSpeed;
+    return {
+      x: state.x + velocityX * deltaTime,
+      y: state.y + velocityY * deltaTime,
+      rotation: state.rotation,
+      velocityX,
+      velocityY
+    };
+  }
+}, __name(_a, "SimpleMovementPredictor"), _a);
+var _NetworkPredictionSystem = class _NetworkPredictionSystem extends EntitySystem4 {
+  constructor(config) {
+    super(Matcher4.all(NetworkIdentity, NetworkTransform));
+    __publicField(this, "_config");
+    __publicField(this, "_predictor");
+    __publicField(this, "_prediction", null);
+    __publicField(this, "_localPlayerNetId", -1);
+    __publicField(this, "_currentInput", {
+      x: 0,
+      y: 0
+    });
+    __publicField(this, "_inputSequence", 0);
+    this._config = {
+      ...DEFAULT_CONFIG4,
+      ...config
+    };
+    this._predictor = new SimpleMovementPredictor(this._config.moveSpeed);
+  }
+  /**
+   * @zh 获取配置
+   * @en Get configuration
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * @zh 获取当前输入序列号
+   * @en Get current input sequence number
+   */
+  get inputSequence() {
+    return this._inputSequence;
+  }
+  /**
+   * @zh 获取待确认输入数量
+   * @en Get pending input count
+   */
+  get pendingInputCount() {
+    return this._prediction?.pendingInputCount ?? 0;
+  }
+  /**
+   * @zh 是否启用预测
+   * @en Whether prediction is enabled
+   */
+  get enabled() {
+    return this._config.enabled;
+  }
+  set enabled(value) {
+    this._config.enabled = value;
+  }
+  /**
+   * @zh 设置本地玩家网络 ID
+   * @en Set local player network ID
+   */
+  setLocalPlayerNetId(netId) {
+    this._localPlayerNetId = netId;
+    this._prediction = createClientPrediction(this._predictor, {
+      maxUnacknowledgedInputs: this._config.maxUnacknowledgedInputs,
+      reconciliationThreshold: this._config.reconciliationThreshold,
+      reconciliationSpeed: this._config.reconciliationSpeed
+    });
+  }
+  /**
+   * @zh 设置移动输入
+   * @en Set movement input
+   */
+  setInput(x, y, actions) {
+    this._currentInput = {
+      x,
+      y,
+      actions
+    };
+  }
+  /**
+   * @zh 获取下一个要发送的输入（带序列号）
+   * @en Get next input to send (with sequence number)
+   */
+  getInputToSend() {
+    if (!this._prediction) return null;
+    const input = this._prediction.getInputToSend();
+    if (!input) return null;
+    return {
+      seq: input.sequence,
+      frame: 0,
+      timestamp: input.timestamp,
+      moveDir: {
+        x: input.input.x,
+        y: input.input.y
+      },
+      actions: input.input.actions
+    };
+  }
+  /**
+   * @zh 处理服务器同步数据进行校正
+   * @en Process server sync data for reconciliation
+   */
+  reconcileWithServer(data) {
+    if (!this._prediction || this._localPlayerNetId < 0) return;
+    const localState = data.entities.find((e) => e.netId === this._localPlayerNetId);
+    if (!localState || !localState.pos) return;
+    const serverState = {
+      x: localState.pos.x,
+      y: localState.pos.y,
+      rotation: localState.rot ?? 0,
+      velocityX: localState.vel?.x ?? 0,
+      velocityY: localState.vel?.y ?? 0
+    };
+    if (data.ackSeq !== void 0) {
+      this._prediction.reconcile(serverState, data.ackSeq, (state) => ({
+        x: state.x,
+        y: state.y
+      }), Time2.deltaTime);
+    }
+  }
+  process(entities) {
+    if (!this._config.enabled || !this._prediction) return;
+    const deltaTime = Time2.deltaTime;
+    for (const entity of entities) {
+      const identity = this.requireComponent(entity, NetworkIdentity);
+      if (!identity.bHasAuthority || identity.netId !== this._localPlayerNetId) continue;
+      const transform = this.requireComponent(entity, NetworkTransform);
+      const currentState = {
+        x: transform.currentX,
+        y: transform.currentY,
+        rotation: transform.currentRotation,
+        velocityX: 0,
+        velocityY: 0
+      };
+      if (this._currentInput.x !== 0 || this._currentInput.y !== 0) {
+        const predicted = this._prediction.recordInput(this._currentInput, currentState, deltaTime);
+        transform.currentX = predicted.x;
+        transform.currentY = predicted.y;
+        transform.currentRotation = predicted.rotation;
+        transform.targetX = predicted.x;
+        transform.targetY = predicted.y;
+        transform.targetRotation = predicted.rotation;
+        this._inputSequence = this._prediction.currentSequence;
+      }
+      const offset = this._prediction.correctionOffset;
+      if (Math.abs(offset.x) > 0.01 || Math.abs(offset.y) > 0.01) {
+        transform.currentX += offset.x * deltaTime * 5;
+        transform.currentY += offset.y * deltaTime * 5;
+      }
+    }
+  }
+  /**
+   * @zh 重置预测状态
+   * @en Reset prediction state
+   */
+  reset() {
+    this._prediction?.clear();
+    this._inputSequence = 0;
+    this._currentInput = {
+      x: 0,
+      y: 0
+    };
+  }
+  onDestroy() {
+    this._prediction?.clear();
+    this._prediction = null;
+  }
 };
-__name(_NetworkSpawnSystem, "NetworkSpawnSystem");
-var NetworkSpawnSystem = _NetworkSpawnSystem;
+__name(_NetworkPredictionSystem, "NetworkPredictionSystem");
+var NetworkPredictionSystem = _NetworkPredictionSystem;
+function createNetworkPredictionSystem(config) {
+  return new NetworkPredictionSystem(config);
+}
+__name(createNetworkPredictionSystem, "createNetworkPredictionSystem");
 
-// 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;
+// src/systems/NetworkAOISystem.ts
+import { EntitySystem as EntitySystem5, Matcher as Matcher5 } from "@esengine/ecs-framework";
+var DEFAULT_CONFIG5 = {
+  cellSize: 100,
+  defaultViewRange: 500,
+  enabled: true
+};
+var _NetworkAOISystem = class _NetworkAOISystem extends EntitySystem5 {
+  constructor(config) {
+    super(Matcher5.all(NetworkIdentity, NetworkTransform));
+    __publicField(this, "_config");
+    __publicField(this, "_observers", /* @__PURE__ */ new Map());
+    __publicField(this, "_cells", /* @__PURE__ */ new Map());
+    __publicField(this, "_listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "_entityNetIdMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_netIdEntityMap", /* @__PURE__ */ new Map());
+    this._config = {
+      ...DEFAULT_CONFIG5,
+      ...config
+    };
   }
   /**
-   * @zh 处理输入队列
-   * @en Process input queue
+   * @zh 获取配置
+   * @en Get configuration
    */
-  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);
-    }
+  get config() {
+    return this._config;
   }
   /**
-   * @zh 添加移动输入
-   * @en Add move input
+   * @zh 是否启用
+   * @en Is enabled
    */
-  addMoveInput(x, y) {
-    this._inputQueue.push({
-      frame: 0,
-      moveDir: {
+  get enabled() {
+    return this._config.enabled;
+  }
+  set enabled(value) {
+    this._config.enabled = value;
+  }
+  /**
+   * @zh 观察者数量
+   * @en Observer count
+   */
+  get observerCount() {
+    return this._observers.size;
+  }
+  // =========================================================================
+  // 观察者管理 | Observer Management
+  // =========================================================================
+  /**
+   * @zh 添加观察者（通常是玩家实体）
+   * @en Add observer (usually player entity)
+   */
+  addObserver(netId, x, y, viewRange) {
+    if (this._observers.has(netId)) {
+      this.updateObserverPosition(netId, x, y);
+      return;
+    }
+    const range = viewRange ?? this._config.defaultViewRange;
+    const cellKey = this._getCellKey(x, y);
+    const data = {
+      netId,
+      position: {
         x,
         y
+      },
+      viewRange: range,
+      viewRangeSq: range * range,
+      cellKey,
+      visibleEntities: /* @__PURE__ */ new Set()
+    };
+    this._observers.set(netId, data);
+    this._addToCell(cellKey, netId);
+    this._updateVisibility(data);
+  }
+  /**
+   * @zh 移除观察者
+   * @en Remove observer
+   */
+  removeObserver(netId) {
+    const data = this._observers.get(netId);
+    if (!data) return false;
+    for (const visibleNetId of data.visibleEntities) {
+      this._emitEvent({
+        type: "exit",
+        observerNetId: netId,
+        targetNetId: visibleNetId
+      });
+    }
+    this._removeFromCell(data.cellKey, netId);
+    this._observers.delete(netId);
+    return true;
+  }
+  /**
+   * @zh 更新观察者位置
+   * @en Update observer position
+   */
+  updateObserverPosition(netId, x, y) {
+    const data = this._observers.get(netId);
+    if (!data) return;
+    const newCellKey = this._getCellKey(x, y);
+    if (newCellKey !== data.cellKey) {
+      this._removeFromCell(data.cellKey, netId);
+      data.cellKey = newCellKey;
+      this._addToCell(newCellKey, netId);
+    }
+    data.position.x = x;
+    data.position.y = y;
+    this._updateVisibility(data);
+  }
+  /**
+   * @zh 更新观察者视野范围
+   * @en Update observer view range
+   */
+  updateObserverViewRange(netId, viewRange) {
+    const data = this._observers.get(netId);
+    if (!data) return;
+    data.viewRange = viewRange;
+    data.viewRangeSq = viewRange * viewRange;
+    this._updateVisibility(data);
+  }
+  // =========================================================================
+  // 实体管理 | Entity Management
+  // =========================================================================
+  /**
+   * @zh 注册网络实体
+   * @en Register network entity
+   */
+  registerEntity(entity, netId) {
+    this._entityNetIdMap.set(entity, netId);
+    this._netIdEntityMap.set(netId, entity);
+  }
+  /**
+   * @zh 注销网络实体
+   * @en Unregister network entity
+   */
+  unregisterEntity(entity) {
+    const netId = this._entityNetIdMap.get(entity);
+    if (netId !== void 0) {
+      for (const [, data] of this._observers) {
+        if (data.visibleEntities.has(netId)) {
+          data.visibleEntities.delete(netId);
+          this._emitEvent({
+            type: "exit",
+            observerNetId: data.netId,
+            targetNetId: netId
+          });
+        }
+      }
+      this._netIdEntityMap.delete(netId);
+    }
+    this._entityNetIdMap.delete(entity);
+  }
+  // =========================================================================
+  // 查询接口 | Query Interface
+  // =========================================================================
+  /**
+   * @zh 获取观察者能看到的实体网络 ID 列表
+   * @en Get list of entity network IDs visible to observer
+   */
+  getVisibleEntities(observerNetId) {
+    const data = this._observers.get(observerNetId);
+    return data ? Array.from(data.visibleEntities) : [];
+  }
+  /**
+   * @zh 获取能看到指定实体的观察者网络 ID 列表
+   * @en Get list of observer network IDs that can see the entity
+   */
+  getObserversOf(entityNetId) {
+    const observers = [];
+    for (const [, data] of this._observers) {
+      if (data.visibleEntities.has(entityNetId)) {
+        observers.push(data.netId);
       }
+    }
+    return observers;
+  }
+  /**
+   * @zh 检查观察者是否能看到目标
+   * @en Check if observer can see target
+   */
+  canSee(observerNetId, targetNetId) {
+    const data = this._observers.get(observerNetId);
+    return data?.visibleEntities.has(targetNetId) ?? false;
+  }
+  /**
+   * @zh 过滤同步数据，只保留观察者能看到的实体
+   * @en Filter sync data to only include entities visible to observer
+   */
+  filterSyncData(observerNetId, entities) {
+    if (!this._config.enabled) {
+      return entities;
+    }
+    const data = this._observers.get(observerNetId);
+    if (!data) {
+      return entities;
+    }
+    return entities.filter((entity) => {
+      if (entity.netId === observerNetId) return true;
+      return data.visibleEntities.has(entity.netId);
     });
   }
+  // =========================================================================
+  // 事件系统 | Event System
+  // =========================================================================
   /**
-   * @zh 添加动作输入
-   * @en Add action input
+   * @zh 添加事件监听器
+   * @en Add event listener
    */
-  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
-        ]
-      });
+  addListener(listener) {
+    this._listeners.add(listener);
+  }
+  /**
+   * @zh 移除事件监听器
+   * @en Remove event listener
+   */
+  removeListener(listener) {
+    this._listeners.delete(listener);
+  }
+  // =========================================================================
+  // 系统生命周期 | System Lifecycle
+  // =========================================================================
+  process(entities) {
+    if (!this._config.enabled) return;
+    for (const entity of entities) {
+      const identity = this.requireComponent(entity, NetworkIdentity);
+      const transform = this.requireComponent(entity, NetworkTransform);
+      if (!this._entityNetIdMap.has(entity)) {
+        this.registerEntity(entity, identity.netId);
+      }
+      if (identity.bHasAuthority && this._observers.has(identity.netId)) {
+        this.updateObserverPosition(identity.netId, transform.currentX, transform.currentY);
+      }
+    }
+    this._updateAllObserversVisibility(entities);
+  }
+  _updateAllObserversVisibility(entities) {
+    for (const [, data] of this._observers) {
+      const newVisible = /* @__PURE__ */ new Set();
+      for (const entity of entities) {
+        const identity = this.requireComponent(entity, NetworkIdentity);
+        const transform = this.requireComponent(entity, NetworkTransform);
+        if (identity.netId === data.netId) continue;
+        const dx = transform.currentX - data.position.x;
+        const dy = transform.currentY - data.position.y;
+        const distSq = dx * dx + dy * dy;
+        if (distSq <= data.viewRangeSq) {
+          newVisible.add(identity.netId);
+        }
+      }
+      for (const netId of newVisible) {
+        if (!data.visibleEntities.has(netId)) {
+          this._emitEvent({
+            type: "enter",
+            observerNetId: data.netId,
+            targetNetId: netId
+          });
+        }
+      }
+      for (const netId of data.visibleEntities) {
+        if (!newVisible.has(netId)) {
+          this._emitEvent({
+            type: "exit",
+            observerNetId: data.netId,
+            targetNetId: netId
+          });
+        }
+      }
+      data.visibleEntities = newVisible;
     }
   }
+  /**
+   * @zh 清除所有数据
+   * @en Clear all data
+   */
+  clear() {
+    this._observers.clear();
+    this._cells.clear();
+    this._entityNetIdMap.clear();
+    this._netIdEntityMap.clear();
+  }
   onDestroy() {
-    this._inputQueue.length = 0;
+    this.clear();
+    this._listeners.clear();
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  _getCellKey(x, y) {
+    const cellX = Math.floor(x / this._config.cellSize);
+    const cellY = Math.floor(y / this._config.cellSize);
+    return `${cellX},${cellY}`;
+  }
+  _addToCell(cellKey, netId) {
+    let cell = this._cells.get(cellKey);
+    if (!cell) {
+      cell = /* @__PURE__ */ new Set();
+      this._cells.set(cellKey, cell);
+    }
+    cell.add(netId);
+  }
+  _removeFromCell(cellKey, netId) {
+    const cell = this._cells.get(cellKey);
+    if (cell) {
+      cell.delete(netId);
+      if (cell.size === 0) {
+        this._cells.delete(cellKey);
+      }
+    }
+  }
+  _updateVisibility(data) {
+  }
+  _emitEvent(event) {
+    for (const listener of this._listeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        console.error("[NetworkAOISystem] Listener error:", e);
+      }
+    }
   }
 };
-__name(_NetworkInputSystem, "NetworkInputSystem");
-var NetworkInputSystem = _NetworkInputSystem;
+__name(_NetworkAOISystem, "NetworkAOISystem");
+var NetworkAOISystem = _NetworkAOISystem;
+function createNetworkAOISystem(config) {
+  return new NetworkAOISystem(config);
+}
+__name(createNetworkAOISystem, "createNetworkAOISystem");
 
 // src/NetworkPlugin.ts
+var DEFAULT_CONFIG6 = {
+  enablePrediction: true,
+  enableAutoReconnect: true,
+  maxReconnectAttempts: 5,
+  reconnectInterval: 2e3,
+  enableAOI: false
+};
 var _NetworkPlugin = class _NetworkPlugin {
-  constructor() {
+  constructor(config) {
     __publicField(this, "name", "@esengine/network");
-    __publicField(this, "version", "2.0.0");
+    __publicField(this, "version", "2.1.0");
+    __publicField(this, "_config");
     __publicField(this, "_networkService");
     __publicField(this, "_syncSystem");
     __publicField(this, "_spawnSystem");
     __publicField(this, "_inputSystem");
+    __publicField(this, "_predictionSystem", null);
+    __publicField(this, "_aoiSystem", null);
     __publicField(this, "_localPlayerId", 0);
+    __publicField(this, "_reconnectState", null);
+    __publicField(this, "_reconnectTimer", null);
+    __publicField(this, "_lastConnectOptions", null);
+    this._config = {
+      ...DEFAULT_CONFIG6,
+      ...config
+    };
   }
+  // =========================================================================
+  // Getters | 属性访问器
+  // =========================================================================
   /**
    * @zh 网络服务
    * @en Network service
@@ -698,6 +2090,20 @@ var _NetworkPlugin = class _NetworkPlugin {
   get inputSystem() {
     return this._inputSystem;
   }
+  /**
+   * @zh 预测系统
+   * @en Prediction system
+   */
+  get predictionSystem() {
+    return this._predictionSystem;
+  }
+  /**
+   * @zh AOI 系统
+   * @en AOI system
+   */
+  get aoiSystem() {
+    return this._aoiSystem;
+  }
   /**
    * @zh 本地玩家 ID
    * @en Local player ID
@@ -712,6 +2118,30 @@ var _NetworkPlugin = class _NetworkPlugin {
   get isConnected() {
     return this._networkService?.isConnected ?? false;
   }
+  /**
+   * @zh 是否正在重连
+   * @en Is reconnecting
+   */
+  get isReconnecting() {
+    return this._reconnectState?.isReconnecting ?? false;
+  }
+  /**
+   * @zh 是否启用预测
+   * @en Is prediction enabled
+   */
+  get isPredictionEnabled() {
+    return this._config.enablePrediction && this._predictionSystem !== null;
+  }
+  /**
+   * @zh 是否启用 AOI
+   * @en Is AOI enabled
+   */
+  get isAOIEnabled() {
+    return this._config.enableAOI && this._aoiSystem !== null;
+  }
+  // =========================================================================
+  // Plugin Lifecycle | 插件生命周期
+  // =========================================================================
   /**
    * @zh 安装插件
    * @en Install plugin
@@ -728,12 +2158,22 @@ var _NetworkPlugin = class _NetworkPlugin {
    * @en Uninstall plugin
    */
   uninstall() {
+    this._clearReconnectTimer();
     this._networkService?.disconnect();
   }
   _setupSystems(scene) {
-    this._syncSystem = new NetworkSyncSystem();
+    this._syncSystem = new NetworkSyncSystem(this._config.syncConfig);
     this._spawnSystem = new NetworkSpawnSystem(this._syncSystem);
-    this._inputSystem = new NetworkInputSystem(this._networkService);
+    this._inputSystem = new NetworkInputSystem(this._networkService, this._config.inputConfig);
+    if (this._config.enablePrediction) {
+      this._predictionSystem = new NetworkPredictionSystem(this._config.predictionConfig);
+      this._inputSystem.setPredictionSystem(this._predictionSystem);
+      scene.addSystem(this._predictionSystem);
+    }
+    if (this._config.enableAOI) {
+      this._aoiSystem = new NetworkAOISystem(this._config.aoiConfig);
+      scene.addSystem(this._aoiSystem);
+    }
     scene.addSystem(this._syncSystem);
     scene.addSystem(this._spawnSystem);
     scene.addSystem(this._inputSystem);
@@ -741,21 +2181,34 @@ var _NetworkPlugin = class _NetworkPlugin {
   }
   _setupMessageHandlers() {
     this._networkService.onSync((data) => {
-      this._syncSystem.handleSync({
-        entities: data.entities
-      });
+      this._syncSystem.handleSyncData(data);
+      if (this._predictionSystem) {
+        this._predictionSystem.reconcileWithServer(data);
+      }
     }).onSpawn((data) => {
       this._spawnSystem.handleSpawn(data);
     }).onDespawn((data) => {
       this._spawnSystem.handleDespawn(data);
     });
+    this._networkService.on("fullState", (data) => {
+      this._handleFullState(data);
+    });
   }
+  // =========================================================================
+  // Connection | 连接管理
+  // =========================================================================
   /**
    * @zh 连接到服务器
    * @en Connect to server
    */
   async connect(options) {
+    this._lastConnectOptions = options;
     try {
+      const originalOnDisconnect = options.onDisconnect;
+      options.onDisconnect = (reason) => {
+        originalOnDisconnect?.(reason);
+        this._handleDisconnect(reason);
+      };
       await this._networkService.connect(options);
       const result = await this._networkService.call("join", {
         playerName: options.playerName,
@@ -763,8 +2216,20 @@ var _NetworkPlugin = class _NetworkPlugin {
       });
       this._localPlayerId = result.playerId;
       this._spawnSystem.setLocalPlayerId(this._localPlayerId);
+      if (this._predictionSystem) {
+      }
+      if (this._config.enableAutoReconnect) {
+        this._reconnectState = {
+          token: this._generateReconnectToken(),
+          playerId: result.playerId,
+          roomId: result.roomId,
+          attempts: 0,
+          isReconnecting: false
+        };
+      }
       return true;
     } catch (err) {
+      console.error("[NetworkPlugin] Connection failed:", err);
       return false;
     }
   }
@@ -773,386 +2238,181 @@ var _NetworkPlugin = class _NetworkPlugin {
    * @en Disconnect
    */
   async disconnect() {
+    this._clearReconnectTimer();
+    this._reconnectState = null;
     try {
       await this._networkService.call("leave", void 0);
     } catch {
     }
     this._networkService.disconnect();
+    this._cleanup();
   }
-  /**
-   * @zh 注册预制体工厂
-   * @en Register prefab factory
-   */
-  registerPrefab(prefabType, factory) {
-    this._spawnSystem?.registerPrefab(prefabType, factory);
-  }
-  /**
-   * @zh 发送移动输入
-   * @en Send move input
-   */
-  sendMoveInput(x, y) {
-    this._inputSystem?.addMoveInput(x, y);
-  }
-  /**
-   * @zh 发送动作输入
-   * @en 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();
+  _handleDisconnect(reason) {
+    console.log("[NetworkPlugin] Disconnected:", reason);
+    if (this._config.enableAutoReconnect && this._reconnectState && !this._reconnectState.isReconnecting) {
+      this._attemptReconnect();
     }
   }
-  /**
-   * @zh 获取用于插值的两个快照
-   * @en Get two snapshots for interpolation
-   */
-  getInterpolationSnapshots(renderTime) {
-    if (this._buffer.length < 2) {
-      return null;
+  _attemptReconnect() {
+    if (!this._reconnectState || !this._lastConnectOptions) return;
+    if (this._reconnectState.attempts >= this._config.maxReconnectAttempts) {
+      console.error("[NetworkPlugin] Max reconnection attempts reached");
+      this._reconnectState = null;
+      return;
     }
-    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))
-        ];
+    this._reconnectState.isReconnecting = true;
+    this._reconnectState.attempts++;
+    console.log(`[NetworkPlugin] Attempting reconnection (${this._reconnectState.attempts}/${this._config.maxReconnectAttempts})`);
+    this._reconnectTimer = setTimeout(async () => {
+      try {
+        await this._networkService.connect(this._lastConnectOptions);
+        const result = await this._networkService.call("reconnect", {
+          playerId: this._reconnectState.playerId,
+          roomId: this._reconnectState.roomId,
+          token: this._reconnectState.token
+        });
+        if (result.success) {
+          console.log("[NetworkPlugin] Reconnection successful");
+          this._reconnectState.isReconnecting = false;
+          this._reconnectState.attempts = 0;
+          if (result.state) {
+            this._handleFullState(result.state);
+          }
+        } else {
+          console.error("[NetworkPlugin] Reconnection rejected:", result.error);
+          this._attemptReconnect();
+        }
+      } catch (err) {
+        console.error("[NetworkPlugin] Reconnection failed:", err);
+        if (this._reconnectState) {
+          this._reconnectState.isReconnecting = false;
+        }
+        this._attemptReconnect();
+      }
+    }, this._config.reconnectInterval);
+  }
+  _handleFullState(data) {
+    this._syncSystem.clearSnapshots();
+    for (const entityData of data.entities) {
+      this._spawnSystem.handleSpawn(entityData);
+      if (entityData.state) {
+        this._syncSystem.handleSyncData({
+          frame: data.frame,
+          timestamp: data.timestamp,
+          entities: [
+            entityData.state
+          ]
+        });
       }
     }
-    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)
-      ];
+  }
+  _clearReconnectTimer() {
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
     }
-    return null;
   }
-  /**
-   * @zh 获取最新快照
-   * @en Get latest snapshot
-   */
-  getLatest() {
-    return this._buffer.length > 0 ? this._buffer[this._buffer.length - 1] : null;
+  _generateReconnectToken() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
   }
-  /**
-   * @zh 获取特定时间之后的所有快照
-   * @en Get all snapshots after a specific time
-   */
-  getSnapshotsAfter(timestamp) {
-    return this._buffer.filter((s) => s.timestamp > timestamp);
+  _cleanup() {
+    this._localPlayerId = 0;
+    this._syncSystem?.clearSnapshots();
+    this._predictionSystem?.reset();
+    this._inputSystem?.reset();
   }
+  // =========================================================================
+  // Game API | 游戏接口
+  // =========================================================================
   /**
-   * @zh 清空缓冲区
-   * @en Clear buffer
+   * @zh 注册预制体工厂
+   * @en Register prefab factory
    */
-  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;
+  registerPrefab(prefabType, factory) {
+    this._spawnSystem?.registerPrefab(prefabType, factory);
   }
-  return [
-    newValue,
-    newVelocity
-  ];
-}
-__name(smoothDamp, "smoothDamp");
-
-// src/sync/TransformInterpolator.ts
-var _TransformInterpolator = class _TransformInterpolator {
   /**
-   * @zh 在两个变换状态之间插值
-   * @en Interpolate between two transform states
+   * @zh 发送移动输入
+   * @en Send move input
    */
-  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)
-    };
+  sendMoveInput(x, y) {
+    this._inputSystem?.addMoveInput(x, y);
   }
   /**
-   * @zh 基于速度外推变换状态
-   * @en Extrapolate transform state based on velocity
+   * @zh 发送动作输入
+   * @en Send action input
    */
-  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
-    };
+  sendActionInput(action) {
+    this._inputSystem?.addActionInput(action);
   }
-};
-__name(_TransformInterpolator, "TransformInterpolator");
-var TransformInterpolator = _TransformInterpolator;
-var _HermiteTransformInterpolator = class _HermiteTransformInterpolator {
   /**
-   * @zh 使用赫尔米特插值
-   * @en Use Hermite interpolation
+   * @zh 设置本地玩家网络 ID（用于预测）
+   * @en Set local player network ID (for prediction)
    */
-  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
-    };
+  setLocalPlayerNetId(netId) {
+    if (this._predictionSystem) {
+      this._predictionSystem.setLocalPlayerNetId(netId);
+    }
   }
   /**
-   * @zh 获取当前预测状态
-   * @en Get current predicted state
+   * @zh 启用/禁用预测
+   * @en Enable/disable prediction
    */
-  get predictedState() {
-    return this._predictedState;
+  setPredictionEnabled(enabled) {
+    if (this._predictionSystem) {
+      this._predictionSystem.enabled = enabled;
+    }
   }
+  // =========================================================================
+  // AOI API | AOI 接口
+  // =========================================================================
   /**
-   * @zh 获取校正偏移
-   * @en Get correction offset
+   * @zh 添加 AOI 观察者（玩家）
+   * @en Add AOI observer (player)
    */
-  get correctionOffset() {
-    return this._correctionOffset;
+  addAOIObserver(netId, x, y, viewRange) {
+    this._aoiSystem?.addObserver(netId, x, y, viewRange);
   }
   /**
-   * @zh 获取待确认输入数量
-   * @en Get pending input count
+   * @zh 移除 AOI 观察者
+   * @en Remove AOI observer
    */
-  get pendingInputCount() {
-    return this._pendingInputs.length;
+  removeAOIObserver(netId) {
+    this._aoiSystem?.removeObserver(netId);
   }
   /**
-   * @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
+   * @zh 更新 AOI 观察者位置
+   * @en Update AOI observer position
    */
-  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;
+  updateAOIObserverPosition(netId, x, y) {
+    this._aoiSystem?.updateObserverPosition(netId, x, y);
   }
   /**
-   * @zh 获取下一个要发送的输入
-   * @en Get next input to send
+   * @zh 获取观察者可见的实体
+   * @en Get entities visible to observer
    */
-  getInputToSend() {
-    return this._pendingInputs.length > 0 ? this._pendingInputs[this._pendingInputs.length - 1] : null;
+  getVisibleEntities(observerNetId) {
+    return this._aoiSystem?.getVisibleEntities(observerNetId) ?? [];
   }
   /**
-   * @zh 获取当前序列号
-   * @en Get current sequence number
+   * @zh 检查是否可见
+   * @en Check if visible
    */
-  get currentSequence() {
-    return this._currentSequence;
+  canSee(observerNetId, targetNetId) {
+    return this._aoiSystem?.canSee(observerNetId, targetNetId) ?? true;
   }
   /**
-   * @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
+   * @zh 启用/禁用 AOI
+   * @en Enable/disable AOI
    */
-  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;
+  setAOIEnabled(enabled) {
+    if (this._aoiSystem) {
+      this._aoiSystem.enabled = enabled;
     }
-    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");
+__name(_NetworkPlugin, "NetworkPlugin");
+var NetworkPlugin = _NetworkPlugin;
 
 // src/nodes/NetworkNodes.ts
 var IsLocalPlayerTemplate = {
@@ -1184,15 +2444,15 @@ var IsLocalPlayerTemplate = {
 };
 var _IsLocalPlayerExecutor = class _IsLocalPlayerExecutor {
   execute(node, context) {
-    var _a;
+    var _a2;
     const ctx = context;
     let isLocal = false;
     if (ctx.entity) {
-      const identity = ctx.entity.getComponent((_a = class {
+      const identity = ctx.entity.getComponent((_a2 = class {
         constructor() {
           __publicField(this, "bIsLocalPlayer", false);
         }
-      }, __name(_a, "NetworkIdentity"), _a));
+      }, __name(_a2, "NetworkIdentity"), _a2));
       if (identity) {
         isLocal = identity.bIsLocalPlayer;
       }
@@ -1272,15 +2532,15 @@ var HasAuthorityTemplate = {
 };
 var _HasAuthorityExecutor = class _HasAuthorityExecutor {
   execute(node, context) {
-    var _a;
+    var _a2;
     const ctx = context;
     let hasAuthority = false;
     if (ctx.entity) {
-      const identity = ctx.entity.getComponent((_a = class {
+      const identity = ctx.entity.getComponent((_a2 = class {
         constructor() {
           __publicField(this, "bHasAuthority", false);
         }
-      }, __name(_a, "NetworkIdentity"), _a));
+      }, __name(_a2, "NetworkIdentity"), _a2));
       if (identity) {
         hasAuthority = identity.bHasAuthority;
       }
@@ -1327,17 +2587,17 @@ var GetNetworkIdTemplate = {
 };
 var _GetNetworkIdExecutor = class _GetNetworkIdExecutor {
   execute(node, context) {
-    var _a;
+    var _a2;
     const ctx = context;
     let netId = 0;
     let ownerId = 0;
     if (ctx.entity) {
-      const identity = ctx.entity.getComponent((_a = class {
+      const identity = ctx.entity.getComponent((_a2 = class {
         constructor() {
           __publicField(this, "netId", 0);
           __publicField(this, "ownerId", 0);
         }
-      }, __name(_a, "NetworkIdentity"), _a));
+      }, __name(_a2, "NetworkIdentity"), _a2));
       if (identity) {
         netId = identity.netId;
         ownerId = identity.ownerId;
@@ -1424,6 +2684,7 @@ var NetworkNodeDefinitions = {
 };
 export {
   ClientPrediction,
+  DeltaFlags,
   GameNetworkService,
   GetLocalPlayerIdExecutor,
   GetLocalPlayerIdTemplate,
@@ -1436,11 +2697,15 @@ export {
   IsLocalPlayerTemplate,
   IsServerExecutor,
   IsServerTemplate,
+  NetworkAOISystem,
+  NetworkAOISystemToken,
   NetworkIdentity,
   NetworkInputSystem,
   NetworkInputSystemToken,
   NetworkNodeDefinitions,
   NetworkPlugin,
+  NetworkPredictionSystem,
+  NetworkPredictionSystemToken,
   GameNetworkService as NetworkService,
   NetworkServiceToken,
   NetworkSpawnSystem,
@@ -1451,11 +2716,16 @@ export {
   NetworkTransform,
   RpcService,
   SnapshotBuffer,
+  StateDeltaCompressor,
   TransformInterpolator,
   createClientPrediction,
   createHermiteTransformInterpolator,
+  createNetworkAOISystem,
+  createNetworkInputSystem,
+  createNetworkPredictionSystem,
   createNetworkService,
   createSnapshotBuffer,
+  createStateDeltaCompressor,
   createTransformInterpolator,
   gameProtocol,
   lerp,