@esengine/pathfinding 12.1.2 → 13.1.0

package/dist/ecs.js

@@ -5,12 +5,20 @@ import {
   IncrementalAStarPathfinder,
   LineOfSightSmoother,
   PathValidator
-} from "./chunk-TPT7Q3E3.js";
+} from "./chunk-VNC2YAAL.js";
+import {
+  PathfindingState
+} from "./chunk-YKA3PWU3.js";
+import {
+  DEFAULT_AGENT_PARAMS,
+  DEFAULT_ORCA_CONFIG,
+  createKDTree,
+  createORCASolver
+} from "./chunk-JTZP55BJ.js";
 import {
-  PathfindingState,
   __name,
   __publicField
-} from "./chunk-GTFFYRZM.js";
+} from "./chunk-T626JPC7.js";
 
 // src/ecs/PathfindingAgentComponent.ts
 import { Component, ECSComponent, Serializable, Serialize, Property } from "@esengine/ecs-framework";
@@ -1025,7 +1033,688 @@ PathfindingSystem = _ts_decorate3([
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [])
 ], PathfindingSystem);
+
+// src/ecs/AvoidanceAgentComponent.ts
+import { Component as Component3, ECSComponent as ECSComponent3, Serializable as Serializable3, Serialize as Serialize3, Property as Property3 } from "@esengine/ecs-framework";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var _AvoidanceAgentComponent = class _AvoidanceAgentComponent extends Component3 {
+  constructor() {
+    super(...arguments);
+    // =========================================================================
+    // 物理属性 | Physical Properties
+    // =========================================================================
+    /**
+     * @zh 代理半径
+     * @en Agent radius
+     *
+     * @zh 用于碰撞检测和避让计算
+     * @en Used for collision detection and avoidance computation
+     */
+    __publicField(this, "radius", DEFAULT_AGENT_PARAMS.radius);
+    /**
+     * @zh 最大速度
+     * @en Maximum speed
+     */
+    __publicField(this, "maxSpeed", DEFAULT_AGENT_PARAMS.maxSpeed);
+    // =========================================================================
+    // ORCA 参数 | ORCA Parameters
+    // =========================================================================
+    /**
+     * @zh 邻居检测距离
+     * @en Neighbor detection distance
+     *
+     * @zh 只考虑此范围内的其他代理
+     * @en Only considers other agents within this range
+     */
+    __publicField(this, "neighborDist", DEFAULT_AGENT_PARAMS.neighborDist);
+    /**
+     * @zh 最大邻居数量
+     * @en Maximum number of neighbors to consider
+     *
+     * @zh 限制计算量，优先考虑最近的邻居
+     * @en Limits computation, prioritizes closest neighbors
+     */
+    __publicField(this, "maxNeighbors", DEFAULT_AGENT_PARAMS.maxNeighbors);
+    /**
+     * @zh 代理避让时间视野（秒）
+     * @en Time horizon for agent avoidance (seconds)
+     *
+     * @zh 更大的值会让代理更早开始避让，但可能导致过于保守
+     * @en Larger values make agents start avoiding earlier, but may be too conservative
+     */
+    __publicField(this, "timeHorizon", DEFAULT_AGENT_PARAMS.timeHorizon);
+    /**
+     * @zh 障碍物避让时间视野（秒）
+     * @en Time horizon for obstacle avoidance (seconds)
+     */
+    __publicField(this, "timeHorizonObst", DEFAULT_AGENT_PARAMS.timeHorizonObst);
+    // =========================================================================
+    // 位置和速度（运行时状态）| Position & Velocity (Runtime State)
+    // =========================================================================
+    /**
+     * @zh 当前位置 X
+     * @en Current position X
+     *
+     * @zh 如果实体有 Transform 组件，系统会自动同步
+     * @en If entity has Transform component, system will sync automatically
+     */
+    __publicField(this, "positionX", 0);
+    /**
+     * @zh 当前位置 Y
+     * @en Current position Y
+     */
+    __publicField(this, "positionY", 0);
+    /**
+     * @zh 当前速度 X
+     * @en Current velocity X
+     */
+    __publicField(this, "velocityX", 0);
+    /**
+     * @zh 当前速度 Y
+     * @en Current velocity Y
+     */
+    __publicField(this, "velocityY", 0);
+    /**
+     * @zh 首选速度 X（通常指向目标方向）
+     * @en Preferred velocity X (usually towards target)
+     */
+    __publicField(this, "preferredVelocityX", 0);
+    /**
+     * @zh 首选速度 Y
+     * @en Preferred velocity Y
+     */
+    __publicField(this, "preferredVelocityY", 0);
+    /**
+     * @zh ORCA 计算的新速度 X
+     * @en New velocity X computed by ORCA
+     */
+    __publicField(this, "newVelocityX", 0);
+    /**
+     * @zh ORCA 计算的新速度 Y
+     * @en New velocity Y computed by ORCA
+     */
+    __publicField(this, "newVelocityY", 0);
+    // =========================================================================
+    // 配置选项 | Configuration Options
+    // =========================================================================
+    /**
+     * @zh 是否启用避让
+     * @en Whether avoidance is enabled
+     */
+    __publicField(this, "enabled", true);
+    /**
+     * @zh 是否自动应用新速度
+     * @en Whether to automatically apply new velocity
+     *
+     * @zh 如果为 true，系统会在计算后自动将 newVelocity 赋值给 velocity
+     * @en If true, system will automatically assign newVelocity to velocity after computation
+     */
+    __publicField(this, "autoApplyVelocity", true);
+  }
+  // =========================================================================
+  // 公共方法 | Public Methods
+  // =========================================================================
+  /**
+   * @zh 设置位置
+   * @en Set position
+   */
+  setPosition(x, y) {
+    this.positionX = x;
+    this.positionY = y;
+  }
+  /**
+   * @zh 设置当前速度
+   * @en Set current velocity
+   */
+  setVelocity(x, y) {
+    this.velocityX = x;
+    this.velocityY = y;
+  }
+  /**
+   * @zh 设置首选速度
+   * @en Set preferred velocity
+   */
+  setPreferredVelocity(x, y) {
+    this.preferredVelocityX = x;
+    this.preferredVelocityY = y;
+  }
+  /**
+   * @zh 设置首选速度朝向目标
+   * @en Set preferred velocity towards target
+   *
+   * @param targetX - @zh 目标 X @en Target X
+   * @param targetY - @zh 目标 Y @en Target Y
+   * @param currentX - @zh 当前 X（可选，默认使用 positionX）@en Current X (optional, defaults to positionX)
+   * @param currentY - @zh 当前 Y（可选，默认使用 positionY）@en Current Y (optional, defaults to positionY)
+   */
+  setPreferredVelocityTowards(targetX, targetY, currentX, currentY) {
+    const x = currentX ?? this.positionX;
+    const y = currentY ?? this.positionY;
+    const dx = targetX - x;
+    const dy = targetY - y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    if (dist > 1e-4) {
+      const speed = Math.min(this.maxSpeed, dist);
+      this.preferredVelocityX = dx / dist * speed;
+      this.preferredVelocityY = dy / dist * speed;
+    } else {
+      this.preferredVelocityX = 0;
+      this.preferredVelocityY = 0;
+    }
+  }
+  /**
+   * @zh 应用 ORCA 计算的新速度
+   * @en Apply new velocity computed by ORCA
+   */
+  applyNewVelocity() {
+    this.velocityX = this.newVelocityX;
+    this.velocityY = this.newVelocityY;
+  }
+  /**
+   * @zh 获取新速度的长度
+   * @en Get length of new velocity
+   */
+  getNewSpeed() {
+    return Math.sqrt(this.newVelocityX * this.newVelocityX + this.newVelocityY * this.newVelocityY);
+  }
+  /**
+   * @zh 获取当前速度的长度
+   * @en Get length of current velocity
+   */
+  getCurrentSpeed() {
+    return Math.sqrt(this.velocityX * this.velocityX + this.velocityY * this.velocityY);
+  }
+  /**
+   * @zh 停止代理
+   * @en Stop the agent
+   */
+  stop() {
+    this.velocityX = 0;
+    this.velocityY = 0;
+    this.preferredVelocityX = 0;
+    this.preferredVelocityY = 0;
+    this.newVelocityX = 0;
+    this.newVelocityY = 0;
+  }
+  /**
+   * @zh 重置组件状态
+   * @en Reset component state
+   */
+  reset() {
+    this.positionX = 0;
+    this.positionY = 0;
+    this.velocityX = 0;
+    this.velocityY = 0;
+    this.preferredVelocityX = 0;
+    this.preferredVelocityY = 0;
+    this.newVelocityX = 0;
+    this.newVelocityY = 0;
+  }
+  /**
+   * @zh 组件从实体移除时调用
+   * @en Called when component is removed from entity
+   */
+  onRemovedFromEntity() {
+    this.reset();
+  }
+};
+__name(_AvoidanceAgentComponent, "AvoidanceAgentComponent");
+var AvoidanceAgentComponent = _AvoidanceAgentComponent;
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "number",
+    label: "Radius",
+    min: 0.1,
+    max: 10
+  }),
+  _ts_metadata4("design:type", Number)
+], AvoidanceAgentComponent.prototype, "radius", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "number",
+    label: "Max Speed",
+    min: 0.1,
+    max: 100
+  }),
+  _ts_metadata4("design:type", Number)
+], AvoidanceAgentComponent.prototype, "maxSpeed", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "number",
+    label: "Neighbor Dist",
+    min: 1,
+    max: 100
+  }),
+  _ts_metadata4("design:type", Number)
+], AvoidanceAgentComponent.prototype, "neighborDist", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "number",
+    label: "Max Neighbors",
+    min: 1,
+    max: 50
+  }),
+  _ts_metadata4("design:type", Number)
+], AvoidanceAgentComponent.prototype, "maxNeighbors", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "number",
+    label: "Time Horizon",
+    min: 0.1,
+    max: 10
+  }),
+  _ts_metadata4("design:type", Number)
+], AvoidanceAgentComponent.prototype, "timeHorizon", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "number",
+    label: "Time Horizon Obst",
+    min: 0.1,
+    max: 10
+  }),
+  _ts_metadata4("design:type", Number)
+], AvoidanceAgentComponent.prototype, "timeHorizonObst", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "boolean",
+    label: "Enabled"
+  }),
+  _ts_metadata4("design:type", Boolean)
+], AvoidanceAgentComponent.prototype, "enabled", void 0);
+_ts_decorate4([
+  Serialize3(),
+  Property3({
+    type: "boolean",
+    label: "Auto Apply"
+  }),
+  _ts_metadata4("design:type", Boolean)
+], AvoidanceAgentComponent.prototype, "autoApplyVelocity", void 0);
+AvoidanceAgentComponent = _ts_decorate4([
+  ECSComponent3("AvoidanceAgent"),
+  Serializable3({
+    version: 1,
+    typeId: "AvoidanceAgent"
+  })
+], AvoidanceAgentComponent);
+
+// src/ecs/AvoidanceWorldComponent.ts
+import { Component as Component4, ECSComponent as ECSComponent4, Serializable as Serializable4, Serialize as Serialize4, Property as Property4 } from "@esengine/ecs-framework";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var _AvoidanceWorldComponent = class _AvoidanceWorldComponent extends Component4 {
+  constructor() {
+    super(...arguments);
+    // =========================================================================
+    // ORCA 配置 | ORCA Configuration
+    // =========================================================================
+    /**
+     * @zh 默认时间视野（代理）
+     * @en Default time horizon for agents
+     */
+    __publicField(this, "defaultTimeHorizon", DEFAULT_ORCA_CONFIG.defaultTimeHorizon);
+    /**
+     * @zh 默认时间视野（障碍物）
+     * @en Default time horizon for obstacles
+     */
+    __publicField(this, "defaultTimeHorizonObst", DEFAULT_ORCA_CONFIG.defaultTimeHorizonObst);
+    /**
+     * @zh 时间步长
+     * @en Time step
+     */
+    __publicField(this, "timeStep", DEFAULT_ORCA_CONFIG.timeStep);
+    // =========================================================================
+    // 运行时实例（不序列化）| Runtime Instances (not serialized)
+    // =========================================================================
+    /**
+     * @zh ORCA 求解器实例
+     * @en ORCA solver instance
+     */
+    __publicField(this, "solver", null);
+    /**
+     * @zh KD-Tree 实例
+     * @en KD-Tree instance
+     */
+    __publicField(this, "kdTree", null);
+    /**
+     * @zh 静态障碍物列表
+     * @en List of static obstacles
+     */
+    __publicField(this, "obstacles", []);
+    /**
+     * @zh 是否已初始化
+     * @en Whether initialized
+     */
+    __publicField(this, "initialized", false);
+    // =========================================================================
+    // 统计信息 | Statistics
+    // =========================================================================
+    /**
+     * @zh 当前代理数量
+     * @en Current agent count
+     */
+    __publicField(this, "agentCount", 0);
+    /**
+     * @zh 本帧处理的代理数
+     * @en Agents processed this frame
+     */
+    __publicField(this, "agentsProcessedThisFrame", 0);
+    /**
+     * @zh 本帧 ORCA 计算耗时（毫秒）
+     * @en ORCA computation time this frame (ms)
+     */
+    __publicField(this, "computeTimeMs", 0);
+  }
+  // =========================================================================
+  // 公共方法 | Public Methods
+  // =========================================================================
+  /**
+   * @zh 获取 ORCA 配置
+   * @en Get ORCA configuration
+   */
+  getConfig() {
+    return {
+      defaultTimeHorizon: this.defaultTimeHorizon,
+      defaultTimeHorizonObst: this.defaultTimeHorizonObst,
+      timeStep: this.timeStep
+    };
+  }
+  /**
+   * @zh 添加静态障碍物
+   * @en Add static obstacle
+   *
+   * @param obstacle - @zh 障碍物（顶点列表，逆时针顺序）@en Obstacle (vertex list, counter-clockwise)
+   */
+  addObstacle(obstacle) {
+    this.obstacles.push(obstacle);
+  }
+  /**
+   * @zh 添加矩形障碍物
+   * @en Add rectangular obstacle
+   *
+   * @param x - @zh 左下角 X @en Bottom-left X
+   * @param y - @zh 左下角 Y @en Bottom-left Y
+   * @param width - @zh 宽度 @en Width
+   * @param height - @zh 高度 @en Height
+   */
+  addRectObstacle(x, y, width, height) {
+    this.obstacles.push({
+      vertices: [
+        {
+          x,
+          y
+        },
+        {
+          x: x + width,
+          y
+        },
+        {
+          x: x + width,
+          y: y + height
+        },
+        {
+          x,
+          y: y + height
+        }
+      ]
+    });
+  }
+  /**
+   * @zh 移除所有障碍物
+   * @en Remove all obstacles
+   */
+  clearObstacles() {
+    this.obstacles = [];
+  }
+  /**
+   * @zh 重置统计信息
+   * @en Reset statistics
+   */
+  resetStats() {
+    this.agentsProcessedThisFrame = 0;
+    this.computeTimeMs = 0;
+  }
+  /**
+   * @zh 组件从实体移除时调用
+   * @en Called when component is removed from entity
+   */
+  onRemovedFromEntity() {
+    this.solver = null;
+    this.kdTree = null;
+    this.obstacles = [];
+    this.initialized = false;
+  }
+};
+__name(_AvoidanceWorldComponent, "AvoidanceWorldComponent");
+var AvoidanceWorldComponent = _AvoidanceWorldComponent;
+_ts_decorate5([
+  Serialize4(),
+  Property4({
+    type: "number",
+    label: "Time Horizon",
+    min: 0.1,
+    max: 10
+  }),
+  _ts_metadata5("design:type", Number)
+], AvoidanceWorldComponent.prototype, "defaultTimeHorizon", void 0);
+_ts_decorate5([
+  Serialize4(),
+  Property4({
+    type: "number",
+    label: "Time Horizon Obst",
+    min: 0.1,
+    max: 10
+  }),
+  _ts_metadata5("design:type", Number)
+], AvoidanceWorldComponent.prototype, "defaultTimeHorizonObst", void 0);
+_ts_decorate5([
+  Serialize4(),
+  Property4({
+    type: "number",
+    label: "Time Step",
+    min: 1e-3,
+    max: 0.1
+  }),
+  _ts_metadata5("design:type", Number)
+], AvoidanceWorldComponent.prototype, "timeStep", void 0);
+AvoidanceWorldComponent = _ts_decorate5([
+  ECSComponent4("AvoidanceWorld"),
+  Serializable4({
+    version: 1,
+    typeId: "AvoidanceWorld"
+  })
+], AvoidanceWorldComponent);
+
+// src/ecs/LocalAvoidanceSystem.ts
+import { EntitySystem as EntitySystem2, Matcher as Matcher2, ECSSystem as ECSSystem2 } from "@esengine/ecs-framework";
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var _LocalAvoidanceSystem = class _LocalAvoidanceSystem extends EntitySystem2 {
+  constructor() {
+    super(Matcher2.all(AvoidanceAgentComponent));
+    __publicField(this, "worldEntity", null);
+    __publicField(this, "worldComponent", null);
+    __publicField(this, "solver", null);
+    __publicField(this, "kdTree", null);
+  }
+  /**
+   * @zh 系统初始化
+   * @en System initialization
+   */
+  onInitialize() {
+    this.findWorldEntity();
+    this.initializeSolver();
+  }
+  /**
+   * @zh 系统激活时调用
+   * @en Called when system is enabled
+   */
+  onEnable() {
+    this.findWorldEntity();
+  }
+  /**
+   * @zh 处理实体
+   * @en Process entities
+   */
+  process(entities) {
+    if (entities.length === 0) return;
+    if (!this.solver) {
+      this.initializeSolver();
+    }
+    const startTime = performance.now();
+    const agents = this.collectAgentData(entities);
+    this.kdTree.build(agents);
+    const obstacles = this.worldComponent?.obstacles ?? [];
+    const deltaTime = this.worldComponent?.timeStep ?? 1 / 60;
+    for (let i = 0; i < entities.length; i++) {
+      const entity = entities[i];
+      const component = entity.getComponent(AvoidanceAgentComponent);
+      if (!component.enabled) continue;
+      const agent = agents[i];
+      const neighborResults = this.kdTree.queryNeighbors(agent.position, agent.neighborDist, agent.maxNeighbors, agent.id);
+      const neighbors = neighborResults.map((r) => r.agent);
+      const newVelocity = this.solver.computeNewVelocity(agent, neighbors, obstacles, deltaTime);
+      component.newVelocityX = newVelocity.x;
+      component.newVelocityY = newVelocity.y;
+      if (component.autoApplyVelocity) {
+        component.applyNewVelocity();
+      }
+    }
+    const endTime = performance.now();
+    if (this.worldComponent) {
+      this.worldComponent.agentCount = entities.length;
+      this.worldComponent.agentsProcessedThisFrame = entities.length;
+      this.worldComponent.computeTimeMs = endTime - startTime;
+    }
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  /**
+   * @zh 查找世界实体
+   * @en Find world entity
+   */
+  findWorldEntity() {
+    if (!this.scene) return;
+    const entities = this.scene.entities.findEntitiesWithComponent(AvoidanceWorldComponent);
+    if (entities.length > 0) {
+      const entity = entities[0];
+      const worldComp = entity.getComponent(AvoidanceWorldComponent);
+      if (worldComp) {
+        this.worldEntity = entity;
+        this.worldComponent = worldComp;
+        if (this.solver && !worldComp.solver) {
+          worldComp.solver = this.solver;
+        }
+        if (this.kdTree && !worldComp.kdTree) {
+          worldComp.kdTree = this.kdTree;
+        }
+        worldComp.initialized = true;
+      }
+    }
+  }
+  /**
+   * @zh 初始化求解器
+   * @en Initialize solver
+   */
+  initializeSolver() {
+    const config = this.worldComponent?.getConfig();
+    this.solver = createORCASolver(config);
+    this.kdTree = createKDTree();
+    if (this.worldComponent) {
+      this.worldComponent.solver = this.solver;
+      this.worldComponent.kdTree = this.kdTree;
+    }
+  }
+  /**
+   * @zh 收集代理数据
+   * @en Collect agent data
+   */
+  collectAgentData(entities) {
+    const agents = [];
+    for (const entity of entities) {
+      const avoidance = entity.getComponent(AvoidanceAgentComponent);
+      const pathAgent = entity.getComponent(PathfindingAgentComponent);
+      if (pathAgent) {
+        avoidance.positionX = pathAgent.x;
+        avoidance.positionY = pathAgent.y;
+        const waypoint = pathAgent.getNextWaypoint();
+        if (waypoint && avoidance.preferredVelocityX === 0 && avoidance.preferredVelocityY === 0) {
+          avoidance.setPreferredVelocityTowards(waypoint.x, waypoint.y);
+        }
+      }
+      agents.push({
+        id: entity.id,
+        position: {
+          x: avoidance.positionX,
+          y: avoidance.positionY
+        },
+        velocity: {
+          x: avoidance.velocityX,
+          y: avoidance.velocityY
+        },
+        preferredVelocity: {
+          x: avoidance.preferredVelocityX,
+          y: avoidance.preferredVelocityY
+        },
+        radius: avoidance.radius,
+        maxSpeed: avoidance.maxSpeed,
+        neighborDist: avoidance.neighborDist,
+        maxNeighbors: avoidance.maxNeighbors,
+        timeHorizon: avoidance.timeHorizon,
+        timeHorizonObst: avoidance.timeHorizonObst
+      });
+    }
+    return agents;
+  }
+};
+__name(_LocalAvoidanceSystem, "LocalAvoidanceSystem");
+var LocalAvoidanceSystem = _LocalAvoidanceSystem;
+LocalAvoidanceSystem = _ts_decorate6([
+  ECSSystem2("LocalAvoidance", {
+    updateOrder: 50
+  }),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [])
+], LocalAvoidanceSystem);
 export {
+  AvoidanceAgentComponent,
+  AvoidanceWorldComponent,
+  LocalAvoidanceSystem,
   PathfindingAgentComponent,
   PathfindingMapComponent,
   PathfindingSystem