@esengine/spatial 1.0.0

package/dist/index.js

@@ -0,0 +1,1607 @@
+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/ISpatialQuery.ts
+function createBounds(minX, minY, maxX, maxY) {
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY
+  };
+}
+__name(createBounds, "createBounds");
+function createBoundsFromCenter(center, width, height) {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return {
+    minX: center.x - halfWidth,
+    minY: center.y - halfHeight,
+    maxX: center.x + halfWidth,
+    maxY: center.y + halfHeight
+  };
+}
+__name(createBoundsFromCenter, "createBoundsFromCenter");
+function createBoundsFromCircle(center, radius) {
+  return {
+    minX: center.x - radius,
+    minY: center.y - radius,
+    maxX: center.x + radius,
+    maxY: center.y + radius
+  };
+}
+__name(createBoundsFromCircle, "createBoundsFromCircle");
+function isPointInBounds(point, bounds) {
+  return point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY;
+}
+__name(isPointInBounds, "isPointInBounds");
+function boundsIntersect(a, b) {
+  return a.minX <= b.maxX && a.maxX >= b.minX && a.minY <= b.maxY && a.maxY >= b.minY;
+}
+__name(boundsIntersect, "boundsIntersect");
+function boundsIntersectsCircle(bounds, center, radius) {
+  const closestX = Math.max(bounds.minX, Math.min(center.x, bounds.maxX));
+  const closestY = Math.max(bounds.minY, Math.min(center.y, bounds.maxY));
+  const distanceX = center.x - closestX;
+  const distanceY = center.y - closestY;
+  return distanceX * distanceX + distanceY * distanceY <= radius * radius;
+}
+__name(boundsIntersectsCircle, "boundsIntersectsCircle");
+function distanceSquared(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return dx * dx + dy * dy;
+}
+__name(distanceSquared, "distanceSquared");
+function distance(a, b) {
+  return Math.sqrt(distanceSquared(a, b));
+}
+__name(distance, "distance");
+
+// src/GridSpatialIndex.ts
+var _GridSpatialIndex = class _GridSpatialIndex {
+  constructor(config) {
+    __publicField(this, "_cellSize");
+    __publicField(this, "_cells", /* @__PURE__ */ new Map());
+    __publicField(this, "_itemMap", /* @__PURE__ */ new Map());
+    this._cellSize = config.cellSize;
+  }
+  // =========================================================================
+  // ISpatialIndex 实现 | ISpatialIndex Implementation
+  // =========================================================================
+  get count() {
+    return this._itemMap.size;
+  }
+  /**
+   * @zh 插入对象
+   * @en Insert object
+   */
+  insert(item, position) {
+    if (this._itemMap.has(item)) {
+      this.update(item, position);
+      return;
+    }
+    const cellKey = this._getCellKey(position);
+    const gridItem = {
+      item,
+      position: {
+        x: position.x,
+        y: position.y
+      },
+      cellKey
+    };
+    this._itemMap.set(item, gridItem);
+    this._addToCell(cellKey, gridItem);
+  }
+  /**
+   * @zh 移除对象
+   * @en Remove object
+   */
+  remove(item) {
+    const gridItem = this._itemMap.get(item);
+    if (!gridItem) {
+      return false;
+    }
+    this._removeFromCell(gridItem.cellKey, gridItem);
+    this._itemMap.delete(item);
+    return true;
+  }
+  /**
+   * @zh 更新对象位置
+   * @en Update object position
+   */
+  update(item, newPosition) {
+    const gridItem = this._itemMap.get(item);
+    if (!gridItem) {
+      return false;
+    }
+    const newCellKey = this._getCellKey(newPosition);
+    if (newCellKey !== gridItem.cellKey) {
+      this._removeFromCell(gridItem.cellKey, gridItem);
+      gridItem.cellKey = newCellKey;
+      this._addToCell(newCellKey, gridItem);
+    }
+    gridItem.position = {
+      x: newPosition.x,
+      y: newPosition.y
+    };
+    return true;
+  }
+  /**
+   * @zh 清空索引
+   * @en Clear index
+   */
+  clear() {
+    this._cells.clear();
+    this._itemMap.clear();
+  }
+  /**
+   * @zh 获取所有对象
+   * @en Get all objects
+   */
+  getAll() {
+    return Array.from(this._itemMap.keys());
+  }
+  // =========================================================================
+  // ISpatialQuery 实现 | ISpatialQuery Implementation
+  // =========================================================================
+  /**
+   * @zh 查找半径内的所有对象
+   * @en Find all objects within radius
+   */
+  findInRadius(center, radius, filter) {
+    const results = [];
+    const radiusSq = radius * radius;
+    const bounds = createBoundsFromCircle(center, radius);
+    this._forEachInBounds(bounds, (gridItem) => {
+      const distSq = distanceSquared(center, gridItem.position);
+      if (distSq <= radiusSq) {
+        if (!filter || filter(gridItem.item)) {
+          results.push(gridItem.item);
+        }
+      }
+    });
+    return results;
+  }
+  /**
+   * @zh 查找矩形区域内的所有对象
+   * @en Find all objects within rectangle
+   */
+  findInRect(bounds, filter) {
+    const results = [];
+    this._forEachInBounds(bounds, (gridItem) => {
+      const pos = gridItem.position;
+      if (pos.x >= bounds.minX && pos.x <= bounds.maxX && pos.y >= bounds.minY && pos.y <= bounds.maxY) {
+        if (!filter || filter(gridItem.item)) {
+          results.push(gridItem.item);
+        }
+      }
+    });
+    return results;
+  }
+  /**
+   * @zh 查找最近的对象
+   * @en Find nearest object
+   */
+  findNearest(center, maxDistance, filter) {
+    let nearest = null;
+    let nearestDistSq = maxDistance !== void 0 ? maxDistance * maxDistance : Infinity;
+    const searchRadius = maxDistance ?? this._cellSize * 10;
+    const bounds = createBoundsFromCircle(center, searchRadius);
+    this._forEachInBounds(bounds, (gridItem) => {
+      const distSq = distanceSquared(center, gridItem.position);
+      if (distSq < nearestDistSq) {
+        if (!filter || filter(gridItem.item)) {
+          nearest = gridItem.item;
+          nearestDistSq = distSq;
+        }
+      }
+    });
+    return nearest;
+  }
+  /**
+   * @zh 查找最近的 K 个对象
+   * @en Find K nearest objects
+   */
+  findKNearest(center, k, maxDistance, filter) {
+    if (k <= 0) return [];
+    const candidates = [];
+    const maxDistSq = maxDistance !== void 0 ? maxDistance * maxDistance : Infinity;
+    const searchRadius = maxDistance ?? this._cellSize * 10;
+    const bounds = createBoundsFromCircle(center, searchRadius);
+    this._forEachInBounds(bounds, (gridItem) => {
+      const distSq = distanceSquared(center, gridItem.position);
+      if (distSq <= maxDistSq) {
+        if (!filter || filter(gridItem.item)) {
+          candidates.push({
+            item: gridItem.item,
+            distSq
+          });
+        }
+      }
+    });
+    candidates.sort((a, b) => a.distSq - b.distSq);
+    return candidates.slice(0, k).map((c) => c.item);
+  }
+  /**
+   * @zh 射线检测
+   * @en Raycast
+   */
+  raycast(origin, direction, maxDistance, filter) {
+    const hits = [];
+    const rayBounds = this._getRayBounds(origin, direction, maxDistance);
+    this._forEachInBounds(rayBounds, (gridItem) => {
+      const hit = this._rayIntersectsPoint(origin, direction, gridItem.position, maxDistance);
+      if (hit && hit.distance <= maxDistance) {
+        if (!filter || filter(gridItem.item)) {
+          hits.push({
+            target: gridItem.item,
+            point: hit.point,
+            normal: hit.normal,
+            distance: hit.distance
+          });
+        }
+      }
+    });
+    hits.sort((a, b) => a.distance - b.distance);
+    return hits;
+  }
+  /**
+   * @zh 射线检测（仅返回第一个命中）
+   * @en Raycast (return first hit only)
+   */
+  raycastFirst(origin, direction, maxDistance, filter) {
+    const hits = this.raycast(origin, direction, maxDistance, filter);
+    return hits.length > 0 ? hits[0] : null;
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  _getCellKey(position) {
+    const cellX = Math.floor(position.x / this._cellSize);
+    const cellY = Math.floor(position.y / this._cellSize);
+    return `${cellX},${cellY}`;
+  }
+  _getCellCoords(position) {
+    return {
+      x: Math.floor(position.x / this._cellSize),
+      y: Math.floor(position.y / this._cellSize)
+    };
+  }
+  _addToCell(cellKey, gridItem) {
+    let cell = this._cells.get(cellKey);
+    if (!cell) {
+      cell = /* @__PURE__ */ new Set();
+      this._cells.set(cellKey, cell);
+    }
+    cell.add(gridItem);
+  }
+  _removeFromCell(cellKey, gridItem) {
+    const cell = this._cells.get(cellKey);
+    if (cell) {
+      cell.delete(gridItem);
+      if (cell.size === 0) {
+        this._cells.delete(cellKey);
+      }
+    }
+  }
+  _forEachInBounds(bounds, callback) {
+    const minCell = this._getCellCoords({
+      x: bounds.minX,
+      y: bounds.minY
+    });
+    const maxCell = this._getCellCoords({
+      x: bounds.maxX,
+      y: bounds.maxY
+    });
+    for (let x = minCell.x; x <= maxCell.x; x++) {
+      for (let y = minCell.y; y <= maxCell.y; y++) {
+        const cell = this._cells.get(`${x},${y}`);
+        if (cell) {
+          for (const gridItem of cell) {
+            callback(gridItem);
+          }
+        }
+      }
+    }
+  }
+  _getRayBounds(origin, direction, maxDistance) {
+    const endX = origin.x + direction.x * maxDistance;
+    const endY = origin.y + direction.y * maxDistance;
+    return {
+      minX: Math.min(origin.x, endX),
+      minY: Math.min(origin.y, endY),
+      maxX: Math.max(origin.x, endX),
+      maxY: Math.max(origin.y, endY)
+    };
+  }
+  _rayIntersectsPoint(origin, direction, point, _maxDistance, hitRadius = 0.5) {
+    const toPoint = {
+      x: point.x - origin.x,
+      y: point.y - origin.y
+    };
+    const projection = toPoint.x * direction.x + toPoint.y * direction.y;
+    if (projection < 0) {
+      return null;
+    }
+    const closestX = origin.x + direction.x * projection;
+    const closestY = origin.y + direction.y * projection;
+    const distToLine = Math.sqrt((point.x - closestX) * (point.x - closestX) + (point.y - closestY) * (point.y - closestY));
+    if (distToLine <= hitRadius) {
+      const hitDist = projection - Math.sqrt(hitRadius * hitRadius - distToLine * distToLine);
+      if (hitDist >= 0) {
+        const hitPoint = {
+          x: origin.x + direction.x * hitDist,
+          y: origin.y + direction.y * hitDist
+        };
+        const normal = {
+          x: hitPoint.x - point.x,
+          y: hitPoint.y - point.y
+        };
+        const normalLen = Math.sqrt(normal.x * normal.x + normal.y * normal.y);
+        if (normalLen > 0) {
+          normal.x /= normalLen;
+          normal.y /= normalLen;
+        }
+        return {
+          point: hitPoint,
+          normal,
+          distance: hitDist
+        };
+      }
+    }
+    return null;
+  }
+};
+__name(_GridSpatialIndex, "GridSpatialIndex");
+var GridSpatialIndex = _GridSpatialIndex;
+function createGridSpatialIndex(cellSize = 100) {
+  return new GridSpatialIndex({
+    cellSize
+  });
+}
+__name(createGridSpatialIndex, "createGridSpatialIndex");
+
+// src/aoi/GridAOI.ts
+var _GridAOI = class _GridAOI {
+  constructor(config) {
+    __publicField(this, "_cellSize");
+    __publicField(this, "_cells", /* @__PURE__ */ new Map());
+    __publicField(this, "_observers", /* @__PURE__ */ new Map());
+    __publicField(this, "_globalListeners", /* @__PURE__ */ new Set());
+    this._cellSize = config.cellSize;
+  }
+  // =========================================================================
+  // IAOIManager 实现 | IAOIManager Implementation
+  // =========================================================================
+  get count() {
+    return this._observers.size;
+  }
+  /**
+   * @zh 添加观察者
+   * @en Add observer
+   */
+  addObserver(entity, position, config) {
+    if (this._observers.has(entity)) {
+      this.updatePosition(entity, position);
+      this.updateViewRange(entity, config.viewRange);
+      return;
+    }
+    const cellKey = this._getCellKey(position);
+    const data = {
+      entity,
+      position: {
+        x: position.x,
+        y: position.y
+      },
+      viewRange: config.viewRange,
+      viewRangeSq: config.viewRange * config.viewRange,
+      observable: config.observable !== false,
+      cellKey,
+      visibleEntities: /* @__PURE__ */ new Set(),
+      listeners: /* @__PURE__ */ new Set()
+    };
+    this._observers.set(entity, data);
+    this._addToCell(cellKey, data);
+    this._updateVisibility(data);
+  }
+  /**
+   * @zh 移除观察者
+   * @en Remove observer
+   */
+  removeObserver(entity) {
+    const data = this._observers.get(entity);
+    if (!data) {
+      return false;
+    }
+    if (data.observable) {
+      for (const [, otherData] of this._observers) {
+        if (otherData !== data && otherData.visibleEntities.has(entity)) {
+          otherData.visibleEntities.delete(entity);
+          this._emitEvent({
+            type: "exit",
+            observer: otherData.entity,
+            target: entity,
+            position: data.position
+          }, otherData);
+        }
+      }
+    }
+    for (const visible of data.visibleEntities) {
+      const visibleData = this._observers.get(visible);
+      if (visibleData) {
+        this._emitEvent({
+          type: "exit",
+          observer: entity,
+          target: visible,
+          position: visibleData.position
+        }, data);
+      }
+    }
+    this._removeFromCell(data.cellKey, data);
+    this._observers.delete(entity);
+    return true;
+  }
+  /**
+   * @zh 更新观察者位置
+   * @en Update observer position
+   */
+  updatePosition(entity, newPosition) {
+    const data = this._observers.get(entity);
+    if (!data) {
+      return false;
+    }
+    const newCellKey = this._getCellKey(newPosition);
+    if (newCellKey !== data.cellKey) {
+      this._removeFromCell(data.cellKey, data);
+      data.cellKey = newCellKey;
+      this._addToCell(newCellKey, data);
+    }
+    data.position = {
+      x: newPosition.x,
+      y: newPosition.y
+    };
+    this._updateVisibility(data);
+    if (data.observable) {
+      this._updateObserversOfEntity(data);
+    }
+    return true;
+  }
+  /**
+   * @zh 更新观察者视野范围
+   * @en Update observer view range
+   */
+  updateViewRange(entity, newRange) {
+    const data = this._observers.get(entity);
+    if (!data) {
+      return false;
+    }
+    data.viewRange = newRange;
+    data.viewRangeSq = newRange * newRange;
+    this._updateVisibility(data);
+    return true;
+  }
+  /**
+   * @zh 获取实体视野内的所有对象
+   * @en Get all objects within entity's view
+   */
+  getEntitiesInView(entity) {
+    const data = this._observers.get(entity);
+    if (!data) {
+      return [];
+    }
+    return Array.from(data.visibleEntities);
+  }
+  /**
+   * @zh 获取能看到指定实体的所有观察者
+   * @en Get all observers who can see the specified entity
+   */
+  getObserversOf(entity) {
+    const data = this._observers.get(entity);
+    if (!data || !data.observable) {
+      return [];
+    }
+    const observers = [];
+    for (const [, otherData] of this._observers) {
+      if (otherData !== data && otherData.visibleEntities.has(entity)) {
+        observers.push(otherData.entity);
+      }
+    }
+    return observers;
+  }
+  /**
+   * @zh 检查观察者是否能看到目标
+   * @en Check if observer can see target
+   */
+  canSee(observer, target) {
+    const data = this._observers.get(observer);
+    if (!data) {
+      return false;
+    }
+    return data.visibleEntities.has(target);
+  }
+  /**
+   * @zh 添加全局事件监听器
+   * @en Add global event listener
+   */
+  addListener(listener) {
+    this._globalListeners.add(listener);
+  }
+  /**
+   * @zh 移除全局事件监听器
+   * @en Remove global event listener
+   */
+  removeListener(listener) {
+    this._globalListeners.delete(listener);
+  }
+  /**
+   * @zh 为特定观察者添加事件监听器
+   * @en Add event listener for specific observer
+   */
+  addEntityListener(entity, listener) {
+    const data = this._observers.get(entity);
+    if (data) {
+      data.listeners.add(listener);
+    }
+  }
+  /**
+   * @zh 移除特定观察者的事件监听器
+   * @en Remove event listener for specific observer
+   */
+  removeEntityListener(entity, listener) {
+    const data = this._observers.get(entity);
+    if (data) {
+      data.listeners.delete(listener);
+    }
+  }
+  /**
+   * @zh 清空所有观察者
+   * @en Clear all observers
+   */
+  clear() {
+    this._cells.clear();
+    this._observers.clear();
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  _getCellKey(position) {
+    const cellX = Math.floor(position.x / this._cellSize);
+    const cellY = Math.floor(position.y / this._cellSize);
+    return `${cellX},${cellY}`;
+  }
+  _getCellCoords(position) {
+    return {
+      x: Math.floor(position.x / this._cellSize),
+      y: Math.floor(position.y / this._cellSize)
+    };
+  }
+  _addToCell(cellKey, data) {
+    let cell = this._cells.get(cellKey);
+    if (!cell) {
+      cell = /* @__PURE__ */ new Set();
+      this._cells.set(cellKey, cell);
+    }
+    cell.add(data);
+  }
+  _removeFromCell(cellKey, data) {
+    const cell = this._cells.get(cellKey);
+    if (cell) {
+      cell.delete(data);
+      if (cell.size === 0) {
+        this._cells.delete(cellKey);
+      }
+    }
+  }
+  /**
+   * @zh 更新观察者的可见实体列表
+   * @en Update observer's visible entities list
+   */
+  _updateVisibility(data) {
+    const newVisible = /* @__PURE__ */ new Set();
+    const cellRadius = Math.ceil(data.viewRange / this._cellSize);
+    const centerCell = this._getCellCoords(data.position);
+    for (let dx = -cellRadius; dx <= cellRadius; dx++) {
+      for (let dy = -cellRadius; dy <= cellRadius; dy++) {
+        const cellKey = `${centerCell.x + dx},${centerCell.y + dy}`;
+        const cell = this._cells.get(cellKey);
+        if (!cell) continue;
+        for (const otherData of cell) {
+          if (otherData === data) continue;
+          if (!otherData.observable) continue;
+          const distSq = distanceSquared(data.position, otherData.position);
+          if (distSq <= data.viewRangeSq) {
+            newVisible.add(otherData.entity);
+          }
+        }
+      }
+    }
+    for (const entity of newVisible) {
+      if (!data.visibleEntities.has(entity)) {
+        const targetData = this._observers.get(entity);
+        if (targetData) {
+          this._emitEvent({
+            type: "enter",
+            observer: data.entity,
+            target: entity,
+            position: targetData.position
+          }, data);
+        }
+      }
+    }
+    for (const entity of data.visibleEntities) {
+      if (!newVisible.has(entity)) {
+        const targetData = this._observers.get(entity);
+        const position = targetData?.position ?? {
+          x: 0,
+          y: 0
+        };
+        this._emitEvent({
+          type: "exit",
+          observer: data.entity,
+          target: entity,
+          position
+        }, data);
+      }
+    }
+    data.visibleEntities = newVisible;
+  }
+  /**
+   * @zh 更新其他观察者对于某个实体的可见性
+   * @en Update other observers' visibility of an entity
+   */
+  _updateObserversOfEntity(movedData) {
+    const cellRadius = Math.ceil(this._getMaxViewRange() / this._cellSize) + 1;
+    const centerCell = this._getCellCoords(movedData.position);
+    for (let dx = -cellRadius; dx <= cellRadius; dx++) {
+      for (let dy = -cellRadius; dy <= cellRadius; dy++) {
+        const cellKey = `${centerCell.x + dx},${centerCell.y + dy}`;
+        const cell = this._cells.get(cellKey);
+        if (!cell) continue;
+        for (const otherData of cell) {
+          if (otherData === movedData) continue;
+          const distSq = distanceSquared(otherData.position, movedData.position);
+          const wasVisible = otherData.visibleEntities.has(movedData.entity);
+          const isVisible = distSq <= otherData.viewRangeSq;
+          if (isVisible && !wasVisible) {
+            otherData.visibleEntities.add(movedData.entity);
+            this._emitEvent({
+              type: "enter",
+              observer: otherData.entity,
+              target: movedData.entity,
+              position: movedData.position
+            }, otherData);
+          } else if (!isVisible && wasVisible) {
+            otherData.visibleEntities.delete(movedData.entity);
+            this._emitEvent({
+              type: "exit",
+              observer: otherData.entity,
+              target: movedData.entity,
+              position: movedData.position
+            }, otherData);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * @zh 获取最大视野范围（用于优化搜索）
+   * @en Get maximum view range (for search optimization)
+   */
+  _getMaxViewRange() {
+    let max = 0;
+    for (const [, data] of this._observers) {
+      if (data.viewRange > max) {
+        max = data.viewRange;
+      }
+    }
+    return max;
+  }
+  /**
+   * @zh 发送事件
+   * @en Emit event
+   */
+  _emitEvent(event, observerData) {
+    for (const listener of observerData.listeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        console.error("AOI entity listener error:", e);
+      }
+    }
+    for (const listener of this._globalListeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        console.error("AOI global listener error:", e);
+      }
+    }
+  }
+};
+__name(_GridAOI, "GridAOI");
+var GridAOI = _GridAOI;
+function createGridAOI(cellSize = 100) {
+  return new GridAOI({
+    cellSize
+  });
+}
+__name(createGridAOI, "createGridAOI");
+
+// src/tokens.ts
+import { createServiceToken } from "@esengine/ecs-framework";
+var SpatialIndexToken = createServiceToken("spatialIndex");
+var SpatialQueryToken = createServiceToken("spatialQuery");
+var AOIManagerToken = createServiceToken("aoiManager");
+
+// src/nodes/SpatialQueryNodes.ts
+var FindInRadiusTemplate = {
+  type: "FindInRadius",
+  title: "Find In Radius",
+  category: "entity",
+  description: "Find all objects within radius / \u67E5\u627E\u534A\u5F84\u5185\u7684\u6240\u6709\u5BF9\u8C61",
+  keywords: [
+    "spatial",
+    "find",
+    "radius",
+    "range",
+    "query"
+  ],
+  menuPath: [
+    "Spatial",
+    "Find In Radius"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "centerX",
+      displayName: "Center X",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "centerY",
+      displayName: "Center Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "radius",
+      displayName: "Radius",
+      type: "float",
+      defaultValue: 100
+    }
+  ],
+  outputs: [
+    {
+      name: "results",
+      displayName: "Results",
+      type: "array"
+    },
+    {
+      name: "count",
+      displayName: "Count",
+      type: "int"
+    }
+  ],
+  color: "#4a9eff"
+};
+var _FindInRadiusExecutor = class _FindInRadiusExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const centerX = ctx.evaluateInput(node.id, "centerX", 0);
+    const centerY = ctx.evaluateInput(node.id, "centerY", 0);
+    const radius = ctx.evaluateInput(node.id, "radius", 100);
+    const results = ctx.spatialQuery?.findInRadius({
+      x: centerX,
+      y: centerY
+    }, radius) ?? [];
+    return {
+      outputs: {
+        results,
+        count: results.length
+      }
+    };
+  }
+};
+__name(_FindInRadiusExecutor, "FindInRadiusExecutor");
+var FindInRadiusExecutor = _FindInRadiusExecutor;
+var FindInRectTemplate = {
+  type: "FindInRect",
+  title: "Find In Rect",
+  category: "entity",
+  description: "Find all objects within rectangle / \u67E5\u627E\u77E9\u5F62\u533A\u57DF\u5185\u7684\u6240\u6709\u5BF9\u8C61",
+  keywords: [
+    "spatial",
+    "find",
+    "rect",
+    "rectangle",
+    "area",
+    "query"
+  ],
+  menuPath: [
+    "Spatial",
+    "Find In Rect"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "minX",
+      displayName: "Min X",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "minY",
+      displayName: "Min Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "maxX",
+      displayName: "Max X",
+      type: "float",
+      defaultValue: 100
+    },
+    {
+      name: "maxY",
+      displayName: "Max Y",
+      type: "float",
+      defaultValue: 100
+    }
+  ],
+  outputs: [
+    {
+      name: "results",
+      displayName: "Results",
+      type: "array"
+    },
+    {
+      name: "count",
+      displayName: "Count",
+      type: "int"
+    }
+  ],
+  color: "#4a9eff"
+};
+var _FindInRectExecutor = class _FindInRectExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const minX = ctx.evaluateInput(node.id, "minX", 0);
+    const minY = ctx.evaluateInput(node.id, "minY", 0);
+    const maxX = ctx.evaluateInput(node.id, "maxX", 100);
+    const maxY = ctx.evaluateInput(node.id, "maxY", 100);
+    const bounds = {
+      minX,
+      minY,
+      maxX,
+      maxY
+    };
+    const results = ctx.spatialQuery?.findInRect(bounds) ?? [];
+    return {
+      outputs: {
+        results,
+        count: results.length
+      }
+    };
+  }
+};
+__name(_FindInRectExecutor, "FindInRectExecutor");
+var FindInRectExecutor = _FindInRectExecutor;
+var FindNearestTemplate = {
+  type: "FindNearest",
+  title: "Find Nearest",
+  category: "entity",
+  description: "Find nearest object to a point / \u67E5\u627E\u8DDD\u79BB\u70B9\u6700\u8FD1\u7684\u5BF9\u8C61",
+  keywords: [
+    "spatial",
+    "find",
+    "nearest",
+    "closest",
+    "query"
+  ],
+  menuPath: [
+    "Spatial",
+    "Find Nearest"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "centerX",
+      displayName: "Center X",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "centerY",
+      displayName: "Center Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "maxDistance",
+      displayName: "Max Distance",
+      type: "float",
+      defaultValue: 1e3
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      displayName: "Result",
+      type: "any"
+    },
+    {
+      name: "found",
+      displayName: "Found",
+      type: "bool"
+    }
+  ],
+  color: "#4a9eff"
+};
+var _FindNearestExecutor = class _FindNearestExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const centerX = ctx.evaluateInput(node.id, "centerX", 0);
+    const centerY = ctx.evaluateInput(node.id, "centerY", 0);
+    const maxDistance = ctx.evaluateInput(node.id, "maxDistance", 1e3);
+    const result = ctx.spatialQuery?.findNearest({
+      x: centerX,
+      y: centerY
+    }, maxDistance) ?? null;
+    return {
+      outputs: {
+        result,
+        found: result !== null
+      }
+    };
+  }
+};
+__name(_FindNearestExecutor, "FindNearestExecutor");
+var FindNearestExecutor = _FindNearestExecutor;
+var FindKNearestTemplate = {
+  type: "FindKNearest",
+  title: "Find K Nearest",
+  category: "entity",
+  description: "Find K nearest objects to a point / \u67E5\u627E\u8DDD\u79BB\u70B9\u6700\u8FD1\u7684 K \u4E2A\u5BF9\u8C61",
+  keywords: [
+    "spatial",
+    "find",
+    "nearest",
+    "k",
+    "query"
+  ],
+  menuPath: [
+    "Spatial",
+    "Find K Nearest"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "centerX",
+      displayName: "Center X",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "centerY",
+      displayName: "Center Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "k",
+      displayName: "K",
+      type: "int",
+      defaultValue: 5
+    },
+    {
+      name: "maxDistance",
+      displayName: "Max Distance",
+      type: "float",
+      defaultValue: 1e3
+    }
+  ],
+  outputs: [
+    {
+      name: "results",
+      displayName: "Results",
+      type: "array"
+    },
+    {
+      name: "count",
+      displayName: "Count",
+      type: "int"
+    }
+  ],
+  color: "#4a9eff"
+};
+var _FindKNearestExecutor = class _FindKNearestExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const centerX = ctx.evaluateInput(node.id, "centerX", 0);
+    const centerY = ctx.evaluateInput(node.id, "centerY", 0);
+    const k = ctx.evaluateInput(node.id, "k", 5);
+    const maxDistance = ctx.evaluateInput(node.id, "maxDistance", 1e3);
+    const results = ctx.spatialQuery?.findKNearest({
+      x: centerX,
+      y: centerY
+    }, k, maxDistance) ?? [];
+    return {
+      outputs: {
+        results,
+        count: results.length
+      }
+    };
+  }
+};
+__name(_FindKNearestExecutor, "FindKNearestExecutor");
+var FindKNearestExecutor = _FindKNearestExecutor;
+var RaycastTemplate = {
+  type: "Raycast",
+  title: "Raycast",
+  category: "entity",
+  description: "Cast a ray and get all hits / \u53D1\u5C04\u5C04\u7EBF\u5E76\u83B7\u53D6\u6240\u6709\u547D\u4E2D",
+  keywords: [
+    "spatial",
+    "raycast",
+    "ray",
+    "hit",
+    "query"
+  ],
+  menuPath: [
+    "Spatial",
+    "Raycast"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "originX",
+      displayName: "Origin X",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "originY",
+      displayName: "Origin Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "directionX",
+      displayName: "Direction X",
+      type: "float",
+      defaultValue: 1
+    },
+    {
+      name: "directionY",
+      displayName: "Direction Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "maxDistance",
+      displayName: "Max Distance",
+      type: "float",
+      defaultValue: 1e3
+    }
+  ],
+  outputs: [
+    {
+      name: "hits",
+      displayName: "Hits",
+      type: "array"
+    },
+    {
+      name: "hitCount",
+      displayName: "Hit Count",
+      type: "int"
+    },
+    {
+      name: "hasHit",
+      displayName: "Has Hit",
+      type: "bool"
+    }
+  ],
+  color: "#4a9eff"
+};
+var _RaycastExecutor = class _RaycastExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const originX = ctx.evaluateInput(node.id, "originX", 0);
+    const originY = ctx.evaluateInput(node.id, "originY", 0);
+    const directionX = ctx.evaluateInput(node.id, "directionX", 1);
+    const directionY = ctx.evaluateInput(node.id, "directionY", 0);
+    const maxDistance = ctx.evaluateInput(node.id, "maxDistance", 1e3);
+    const hits = ctx.spatialQuery?.raycast({
+      x: originX,
+      y: originY
+    }, {
+      x: directionX,
+      y: directionY
+    }, maxDistance) ?? [];
+    return {
+      outputs: {
+        hits,
+        hitCount: hits.length,
+        hasHit: hits.length > 0
+      }
+    };
+  }
+};
+__name(_RaycastExecutor, "RaycastExecutor");
+var RaycastExecutor = _RaycastExecutor;
+var RaycastFirstTemplate = {
+  type: "RaycastFirst",
+  title: "Raycast First",
+  category: "entity",
+  description: "Cast a ray and get first hit / \u53D1\u5C04\u5C04\u7EBF\u5E76\u83B7\u53D6\u7B2C\u4E00\u4E2A\u547D\u4E2D",
+  keywords: [
+    "spatial",
+    "raycast",
+    "ray",
+    "first",
+    "hit",
+    "query"
+  ],
+  menuPath: [
+    "Spatial",
+    "Raycast First"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "originX",
+      displayName: "Origin X",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "originY",
+      displayName: "Origin Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "directionX",
+      displayName: "Direction X",
+      type: "float",
+      defaultValue: 1
+    },
+    {
+      name: "directionY",
+      displayName: "Direction Y",
+      type: "float",
+      defaultValue: 0
+    },
+    {
+      name: "maxDistance",
+      displayName: "Max Distance",
+      type: "float",
+      defaultValue: 1e3
+    }
+  ],
+  outputs: [
+    {
+      name: "hit",
+      displayName: "Hit",
+      type: "object"
+    },
+    {
+      name: "target",
+      displayName: "Target",
+      type: "any"
+    },
+    {
+      name: "hitPointX",
+      displayName: "Hit Point X",
+      type: "float"
+    },
+    {
+      name: "hitPointY",
+      displayName: "Hit Point Y",
+      type: "float"
+    },
+    {
+      name: "distance",
+      displayName: "Distance",
+      type: "float"
+    },
+    {
+      name: "hasHit",
+      displayName: "Has Hit",
+      type: "bool"
+    }
+  ],
+  color: "#4a9eff"
+};
+var _RaycastFirstExecutor = class _RaycastFirstExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const originX = ctx.evaluateInput(node.id, "originX", 0);
+    const originY = ctx.evaluateInput(node.id, "originY", 0);
+    const directionX = ctx.evaluateInput(node.id, "directionX", 1);
+    const directionY = ctx.evaluateInput(node.id, "directionY", 0);
+    const maxDistance = ctx.evaluateInput(node.id, "maxDistance", 1e3);
+    const hit = ctx.spatialQuery?.raycastFirst({
+      x: originX,
+      y: originY
+    }, {
+      x: directionX,
+      y: directionY
+    }, maxDistance) ?? null;
+    return {
+      outputs: {
+        hit,
+        target: hit?.target ?? null,
+        hitPointX: hit?.point.x ?? 0,
+        hitPointY: hit?.point.y ?? 0,
+        distance: hit?.distance ?? 0,
+        hasHit: hit !== null
+      }
+    };
+  }
+};
+__name(_RaycastFirstExecutor, "RaycastFirstExecutor");
+var RaycastFirstExecutor = _RaycastFirstExecutor;
+var SpatialQueryNodeDefinitions = [
+  {
+    template: FindInRadiusTemplate,
+    executor: new FindInRadiusExecutor()
+  },
+  {
+    template: FindInRectTemplate,
+    executor: new FindInRectExecutor()
+  },
+  {
+    template: FindNearestTemplate,
+    executor: new FindNearestExecutor()
+  },
+  {
+    template: FindKNearestTemplate,
+    executor: new FindKNearestExecutor()
+  },
+  {
+    template: RaycastTemplate,
+    executor: new RaycastExecutor()
+  },
+  {
+    template: RaycastFirstTemplate,
+    executor: new RaycastFirstExecutor()
+  }
+];
+
+// src/aoi/AOINodes.ts
+var GetEntitiesInViewTemplate = {
+  type: "GetEntitiesInView",
+  title: "Get Entities In View",
+  category: "entity",
+  description: "Get all entities within view range / \u83B7\u53D6\u89C6\u91CE\u8303\u56F4\u5185\u7684\u6240\u6709\u5B9E\u4F53",
+  keywords: [
+    "aoi",
+    "view",
+    "entities",
+    "visible"
+  ],
+  menuPath: [
+    "AOI",
+    "Get Entities In View"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "observer",
+      displayName: "Observer",
+      type: "object"
+    }
+  ],
+  outputs: [
+    {
+      name: "entities",
+      displayName: "Entities",
+      type: "array"
+    },
+    {
+      name: "count",
+      displayName: "Count",
+      type: "int"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _GetEntitiesInViewExecutor = class _GetEntitiesInViewExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const observer = ctx.evaluateInput(node.id, "observer", ctx.entity);
+    const entities = ctx.aoiManager?.getEntitiesInView(observer) ?? [];
+    return {
+      outputs: {
+        entities,
+        count: entities.length
+      }
+    };
+  }
+};
+__name(_GetEntitiesInViewExecutor, "GetEntitiesInViewExecutor");
+var GetEntitiesInViewExecutor = _GetEntitiesInViewExecutor;
+var GetObserversOfTemplate = {
+  type: "GetObserversOf",
+  title: "Get Observers Of",
+  category: "entity",
+  description: "Get all observers who can see the entity / \u83B7\u53D6\u80FD\u770B\u5230\u8BE5\u5B9E\u4F53\u7684\u6240\u6709\u89C2\u5BDF\u8005",
+  keywords: [
+    "aoi",
+    "observers",
+    "watchers",
+    "visible"
+  ],
+  menuPath: [
+    "AOI",
+    "Get Observers Of"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "target",
+      displayName: "Target",
+      type: "object"
+    }
+  ],
+  outputs: [
+    {
+      name: "observers",
+      displayName: "Observers",
+      type: "array"
+    },
+    {
+      name: "count",
+      displayName: "Count",
+      type: "int"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _GetObserversOfExecutor = class _GetObserversOfExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const target = ctx.evaluateInput(node.id, "target", ctx.entity);
+    const observers = ctx.aoiManager?.getObserversOf(target) ?? [];
+    return {
+      outputs: {
+        observers,
+        count: observers.length
+      }
+    };
+  }
+};
+__name(_GetObserversOfExecutor, "GetObserversOfExecutor");
+var GetObserversOfExecutor = _GetObserversOfExecutor;
+var CanSeeTemplate = {
+  type: "CanSee",
+  title: "Can See",
+  category: "entity",
+  description: "Check if observer can see target / \u68C0\u67E5\u89C2\u5BDF\u8005\u662F\u5426\u80FD\u770B\u5230\u76EE\u6807",
+  keywords: [
+    "aoi",
+    "visibility",
+    "can",
+    "see",
+    "check"
+  ],
+  menuPath: [
+    "AOI",
+    "Can See"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "observer",
+      displayName: "Observer",
+      type: "object"
+    },
+    {
+      name: "target",
+      displayName: "Target",
+      type: "object"
+    }
+  ],
+  outputs: [
+    {
+      name: "canSee",
+      displayName: "Can See",
+      type: "bool"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _CanSeeExecutor = class _CanSeeExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const observer = ctx.evaluateInput(node.id, "observer", ctx.entity);
+    const target = ctx.evaluateInput(node.id, "target", null);
+    const canSee = ctx.aoiManager?.canSee(observer, target) ?? false;
+    return {
+      outputs: {
+        canSee
+      }
+    };
+  }
+};
+__name(_CanSeeExecutor, "CanSeeExecutor");
+var CanSeeExecutor = _CanSeeExecutor;
+var OnEntityEnterViewTemplate = {
+  type: "EventEntityEnterView",
+  title: "On Entity Enter View",
+  category: "event",
+  description: "Triggered when an entity enters view / \u5F53\u5B9E\u4F53\u8FDB\u5165\u89C6\u91CE\u65F6\u89E6\u53D1",
+  keywords: [
+    "aoi",
+    "event",
+    "enter",
+    "view",
+    "visible"
+  ],
+  menuPath: [
+    "AOI",
+    "Events",
+    "On Entity Enter View"
+  ],
+  color: "#e91e63",
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "entity",
+      displayName: "Entity",
+      type: "object"
+    },
+    {
+      name: "positionX",
+      displayName: "Position X",
+      type: "float"
+    },
+    {
+      name: "positionY",
+      displayName: "Position Y",
+      type: "float"
+    }
+  ]
+};
+var _OnEntityEnterViewExecutor = class _OnEntityEnterViewExecutor {
+  execute(_node, _context) {
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_OnEntityEnterViewExecutor, "OnEntityEnterViewExecutor");
+var OnEntityEnterViewExecutor = _OnEntityEnterViewExecutor;
+var OnEntityExitViewTemplate = {
+  type: "EventEntityExitView",
+  title: "On Entity Exit View",
+  category: "event",
+  description: "Triggered when an entity exits view / \u5F53\u5B9E\u4F53\u79BB\u5F00\u89C6\u91CE\u65F6\u89E6\u53D1",
+  keywords: [
+    "aoi",
+    "event",
+    "exit",
+    "view",
+    "invisible"
+  ],
+  menuPath: [
+    "AOI",
+    "Events",
+    "On Entity Exit View"
+  ],
+  color: "#e91e63",
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "entity",
+      displayName: "Entity",
+      type: "object"
+    },
+    {
+      name: "positionX",
+      displayName: "Position X",
+      type: "float"
+    },
+    {
+      name: "positionY",
+      displayName: "Position Y",
+      type: "float"
+    }
+  ]
+};
+var _OnEntityExitViewExecutor = class _OnEntityExitViewExecutor {
+  execute(_node, _context) {
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_OnEntityExitViewExecutor, "OnEntityExitViewExecutor");
+var OnEntityExitViewExecutor = _OnEntityExitViewExecutor;
+var AOINodeDefinitions = {
+  templates: [
+    GetEntitiesInViewTemplate,
+    GetObserversOfTemplate,
+    CanSeeTemplate,
+    OnEntityEnterViewTemplate,
+    OnEntityExitViewTemplate
+  ],
+  executors: /* @__PURE__ */ new Map([
+    [
+      "GetEntitiesInView",
+      new GetEntitiesInViewExecutor()
+    ],
+    [
+      "GetObserversOf",
+      new GetObserversOfExecutor()
+    ],
+    [
+      "CanSee",
+      new CanSeeExecutor()
+    ],
+    [
+      "EventEntityEnterView",
+      new OnEntityEnterViewExecutor()
+    ],
+    [
+      "EventEntityExitView",
+      new OnEntityExitViewExecutor()
+    ]
+  ])
+};
+export {
+  AOIManagerToken,
+  AOINodeDefinitions,
+  CanSeeExecutor,
+  CanSeeTemplate,
+  FindInRadiusExecutor,
+  FindInRadiusTemplate,
+  FindInRectExecutor,
+  FindInRectTemplate,
+  FindKNearestExecutor,
+  FindKNearestTemplate,
+  FindNearestExecutor,
+  FindNearestTemplate,
+  GetEntitiesInViewExecutor,
+  GetEntitiesInViewTemplate,
+  GetObserversOfExecutor,
+  GetObserversOfTemplate,
+  GridAOI,
+  GridSpatialIndex,
+  OnEntityEnterViewExecutor,
+  OnEntityEnterViewTemplate,
+  OnEntityExitViewExecutor,
+  OnEntityExitViewTemplate,
+  RaycastExecutor,
+  RaycastFirstExecutor,
+  RaycastFirstTemplate,
+  RaycastTemplate,
+  SpatialIndexToken,
+  SpatialQueryNodeDefinitions,
+  SpatialQueryToken,
+  boundsIntersect,
+  boundsIntersectsCircle,
+  createBounds,
+  createBoundsFromCenter,
+  createBoundsFromCircle,
+  createGridAOI,
+  createGridSpatialIndex,
+  distance,
+  distanceSquared,
+  isPointInBounds
+};
+//# sourceMappingURL=index.js.map