@esengine/pathfinding 12.0.0 → 12.1.2

package/dist/nodes.js

@@ -0,0 +1,1174 @@
+import {
+  PathfindingState,
+  __name
+} from "./chunk-GTFFYRZM.js";
+
+// src/nodes/PathfindingNodes.ts
+var FindPathTemplate = {
+  type: "FindPath",
+  title: "Find Path",
+  category: "custom",
+  description: "Find path from start to end / \u4ECE\u8D77\u70B9\u5230\u7EC8\u70B9\u5BFB\u8DEF",
+  keywords: [
+    "path",
+    "pathfinding",
+    "astar",
+    "navigate",
+    "route"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Find Path"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "startX",
+      displayName: "Start X",
+      type: "float"
+    },
+    {
+      name: "startY",
+      displayName: "Start Y",
+      type: "float"
+    },
+    {
+      name: "endX",
+      displayName: "End X",
+      type: "float"
+    },
+    {
+      name: "endY",
+      displayName: "End Y",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "found",
+      displayName: "Found",
+      type: "bool"
+    },
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    },
+    {
+      name: "cost",
+      displayName: "Cost",
+      type: "float"
+    }
+  ],
+  color: "#4caf50"
+};
+var _FindPathExecutor = class _FindPathExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const startX = ctx.evaluateInput(node.id, "startX", 0);
+    const startY = ctx.evaluateInput(node.id, "startY", 0);
+    const endX = ctx.evaluateInput(node.id, "endX", 0);
+    const endY = ctx.evaluateInput(node.id, "endY", 0);
+    const result = ctx.findPath(startX, startY, endX, endY);
+    return {
+      outputs: {
+        found: result.found,
+        path: result.path,
+        cost: result.cost
+      },
+      nextExec: "exec"
+    };
+  }
+};
+__name(_FindPathExecutor, "FindPathExecutor");
+var FindPathExecutor = _FindPathExecutor;
+var FindPathSmoothTemplate = {
+  type: "FindPathSmooth",
+  title: "Find Path (Smooth)",
+  category: "custom",
+  description: "Find path with smoothing / \u5BFB\u8DEF\u5E76\u5E73\u6ED1\u8DEF\u5F84",
+  keywords: [
+    "path",
+    "pathfinding",
+    "smooth",
+    "navigate"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Find Path (Smooth)"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "startX",
+      displayName: "Start X",
+      type: "float"
+    },
+    {
+      name: "startY",
+      displayName: "Start Y",
+      type: "float"
+    },
+    {
+      name: "endX",
+      displayName: "End X",
+      type: "float"
+    },
+    {
+      name: "endY",
+      displayName: "End Y",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "found",
+      displayName: "Found",
+      type: "bool"
+    },
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    },
+    {
+      name: "cost",
+      displayName: "Cost",
+      type: "float"
+    }
+  ],
+  color: "#4caf50"
+};
+var _FindPathSmoothExecutor = class _FindPathSmoothExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const startX = ctx.evaluateInput(node.id, "startX", 0);
+    const startY = ctx.evaluateInput(node.id, "startY", 0);
+    const endX = ctx.evaluateInput(node.id, "endX", 0);
+    const endY = ctx.evaluateInput(node.id, "endY", 0);
+    const result = ctx.findPathSmooth(startX, startY, endX, endY);
+    return {
+      outputs: {
+        found: result.found,
+        path: result.path,
+        cost: result.cost
+      },
+      nextExec: "exec"
+    };
+  }
+};
+__name(_FindPathSmoothExecutor, "FindPathSmoothExecutor");
+var FindPathSmoothExecutor = _FindPathSmoothExecutor;
+var IsWalkableTemplate = {
+  type: "IsWalkable",
+  title: "Is Walkable",
+  category: "custom",
+  description: "Check if position is walkable / \u68C0\u67E5\u4F4D\u7F6E\u662F\u5426\u53EF\u901A\u884C",
+  keywords: [
+    "walkable",
+    "obstacle",
+    "blocked",
+    "terrain"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Is Walkable"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "x",
+      displayName: "X",
+      type: "float"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "walkable",
+      displayName: "Walkable",
+      type: "bool"
+    }
+  ],
+  color: "#4caf50"
+};
+var _IsWalkableExecutor = class _IsWalkableExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const x = ctx.evaluateInput(node.id, "x", 0);
+    const y = ctx.evaluateInput(node.id, "y", 0);
+    const walkable = ctx.isWalkable(x, y);
+    return {
+      outputs: {
+        walkable
+      }
+    };
+  }
+};
+__name(_IsWalkableExecutor, "IsWalkableExecutor");
+var IsWalkableExecutor = _IsWalkableExecutor;
+var GetPathLengthTemplate = {
+  type: "GetPathLength",
+  title: "Get Path Length",
+  category: "custom",
+  description: "Get the number of points in path / \u83B7\u53D6\u8DEF\u5F84\u70B9\u6570\u91CF",
+  keywords: [
+    "path",
+    "length",
+    "count",
+    "waypoints"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Get Path Length"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    }
+  ],
+  outputs: [
+    {
+      name: "length",
+      displayName: "Length",
+      type: "int"
+    }
+  ],
+  color: "#4caf50"
+};
+var _GetPathLengthExecutor = class _GetPathLengthExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const path = ctx.evaluateInput(node.id, "path", []);
+    return {
+      outputs: {
+        length: path.length
+      }
+    };
+  }
+};
+__name(_GetPathLengthExecutor, "GetPathLengthExecutor");
+var GetPathLengthExecutor = _GetPathLengthExecutor;
+var GetPathDistanceTemplate = {
+  type: "GetPathDistance",
+  title: "Get Path Distance",
+  category: "custom",
+  description: "Get total path distance / \u83B7\u53D6\u8DEF\u5F84\u603B\u8DDD\u79BB",
+  keywords: [
+    "path",
+    "distance",
+    "length",
+    "travel"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Get Path Distance"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    }
+  ],
+  outputs: [
+    {
+      name: "distance",
+      displayName: "Distance",
+      type: "float"
+    }
+  ],
+  color: "#4caf50"
+};
+var _GetPathDistanceExecutor = class _GetPathDistanceExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const path = ctx.evaluateInput(node.id, "path", []);
+    const distance = ctx.getPathDistance(path);
+    return {
+      outputs: {
+        distance
+      }
+    };
+  }
+};
+__name(_GetPathDistanceExecutor, "GetPathDistanceExecutor");
+var GetPathDistanceExecutor = _GetPathDistanceExecutor;
+var GetPathPointTemplate = {
+  type: "GetPathPoint",
+  title: "Get Path Point",
+  category: "custom",
+  description: "Get point at index in path / \u83B7\u53D6\u8DEF\u5F84\u4E2D\u6307\u5B9A\u7D22\u5F15\u7684\u70B9",
+  keywords: [
+    "path",
+    "point",
+    "waypoint",
+    "index"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Get Path Point"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    },
+    {
+      name: "index",
+      displayName: "Index",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "x",
+      displayName: "X",
+      type: "float"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "float"
+    },
+    {
+      name: "valid",
+      displayName: "Valid",
+      type: "bool"
+    }
+  ],
+  color: "#4caf50"
+};
+var _GetPathPointExecutor = class _GetPathPointExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const path = ctx.evaluateInput(node.id, "path", []);
+    const index = ctx.evaluateInput(node.id, "index", 0);
+    if (index >= 0 && index < path.length) {
+      return {
+        outputs: {
+          x: path[index].x,
+          y: path[index].y,
+          valid: true
+        }
+      };
+    }
+    return {
+      outputs: {
+        x: 0,
+        y: 0,
+        valid: false
+      }
+    };
+  }
+};
+__name(_GetPathPointExecutor, "GetPathPointExecutor");
+var GetPathPointExecutor = _GetPathPointExecutor;
+var MoveAlongPathTemplate = {
+  type: "MoveAlongPath",
+  title: "Move Along Path",
+  category: "custom",
+  description: "Get position along path at progress / \u83B7\u53D6\u8DEF\u5F84\u4E0A\u6307\u5B9A\u8FDB\u5EA6\u7684\u4F4D\u7F6E",
+  keywords: [
+    "path",
+    "move",
+    "lerp",
+    "progress",
+    "interpolate"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Move Along Path"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    },
+    {
+      name: "progress",
+      displayName: "Progress (0-1)",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "x",
+      displayName: "X",
+      type: "float"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "float"
+    }
+  ],
+  color: "#4caf50"
+};
+var _MoveAlongPathExecutor = class _MoveAlongPathExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const path = ctx.evaluateInput(node.id, "path", []);
+    let progress = ctx.evaluateInput(node.id, "progress", 0);
+    if (path.length === 0) {
+      return {
+        outputs: {
+          x: 0,
+          y: 0
+        }
+      };
+    }
+    if (path.length === 1) {
+      return {
+        outputs: {
+          x: path[0].x,
+          y: path[0].y
+        }
+      };
+    }
+    progress = Math.max(0, Math.min(1, progress));
+    let totalDistance = 0;
+    const segmentDistances = [];
+    for (let i = 1; i < path.length; i++) {
+      const dx = path[i].x - path[i - 1].x;
+      const dy = path[i].y - path[i - 1].y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      segmentDistances.push(dist);
+      totalDistance += dist;
+    }
+    if (totalDistance === 0) {
+      return {
+        outputs: {
+          x: path[0].x,
+          y: path[0].y
+        }
+      };
+    }
+    const targetDistance = progress * totalDistance;
+    let accumulatedDistance = 0;
+    for (let i = 0; i < segmentDistances.length; i++) {
+      const segmentDist = segmentDistances[i];
+      if (accumulatedDistance + segmentDist >= targetDistance) {
+        const segmentProgress = (targetDistance - accumulatedDistance) / segmentDist;
+        const x = path[i].x + (path[i + 1].x - path[i].x) * segmentProgress;
+        const y = path[i].y + (path[i + 1].y - path[i].y) * segmentProgress;
+        return {
+          outputs: {
+            x,
+            y
+          }
+        };
+      }
+      accumulatedDistance += segmentDist;
+    }
+    const last = path[path.length - 1];
+    return {
+      outputs: {
+        x: last.x,
+        y: last.y
+      }
+    };
+  }
+};
+__name(_MoveAlongPathExecutor, "MoveAlongPathExecutor");
+var MoveAlongPathExecutor = _MoveAlongPathExecutor;
+var HasLineOfSightTemplate = {
+  type: "HasLineOfSight",
+  title: "Has Line of Sight",
+  category: "custom",
+  description: "Check if there is a clear line between two points / \u68C0\u67E5\u4E24\u70B9\u4E4B\u95F4\u662F\u5426\u6709\u6E05\u6670\u7684\u89C6\u7EBF",
+  keywords: [
+    "line",
+    "sight",
+    "los",
+    "visibility",
+    "raycast"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Has Line of Sight"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "startX",
+      displayName: "Start X",
+      type: "float"
+    },
+    {
+      name: "startY",
+      displayName: "Start Y",
+      type: "float"
+    },
+    {
+      name: "endX",
+      displayName: "End X",
+      type: "float"
+    },
+    {
+      name: "endY",
+      displayName: "End Y",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "hasLOS",
+      displayName: "Has LOS",
+      type: "bool"
+    }
+  ],
+  color: "#4caf50"
+};
+var _HasLineOfSightExecutor = class _HasLineOfSightExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const startX = ctx.evaluateInput(node.id, "startX", 0);
+    const startY = ctx.evaluateInput(node.id, "startY", 0);
+    const endX = ctx.evaluateInput(node.id, "endX", 0);
+    const endY = ctx.evaluateInput(node.id, "endY", 0);
+    const hasLOS = ctx.hasLineOfSight?.(startX, startY, endX, endY) ?? true;
+    return {
+      outputs: {
+        hasLOS
+      }
+    };
+  }
+};
+__name(_HasLineOfSightExecutor, "HasLineOfSightExecutor");
+var HasLineOfSightExecutor = _HasLineOfSightExecutor;
+var PathfindingNodeDefinitions = {
+  templates: [
+    FindPathTemplate,
+    FindPathSmoothTemplate,
+    IsWalkableTemplate,
+    GetPathLengthTemplate,
+    GetPathDistanceTemplate,
+    GetPathPointTemplate,
+    MoveAlongPathTemplate,
+    HasLineOfSightTemplate
+  ],
+  executors: /* @__PURE__ */ new Map([
+    [
+      "FindPath",
+      new FindPathExecutor()
+    ],
+    [
+      "FindPathSmooth",
+      new FindPathSmoothExecutor()
+    ],
+    [
+      "IsWalkable",
+      new IsWalkableExecutor()
+    ],
+    [
+      "GetPathLength",
+      new GetPathLengthExecutor()
+    ],
+    [
+      "GetPathDistance",
+      new GetPathDistanceExecutor()
+    ],
+    [
+      "GetPathPoint",
+      new GetPathPointExecutor()
+    ],
+    [
+      "MoveAlongPath",
+      new MoveAlongPathExecutor()
+    ],
+    [
+      "HasLineOfSight",
+      new HasLineOfSightExecutor()
+    ]
+  ])
+};
+
+// src/nodes/IncrementalPathfindingNodes.ts
+var RequestPathAsyncTemplate = {
+  type: "RequestPathAsync",
+  title: "Request Path (Async)",
+  category: "custom",
+  description: "Request incremental pathfinding / \u8BF7\u6C42\u589E\u91CF\u5BFB\u8DEF",
+  keywords: [
+    "path",
+    "pathfinding",
+    "async",
+    "incremental",
+    "request"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Request Path (Async)"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "startX",
+      displayName: "Start X",
+      type: "float"
+    },
+    {
+      name: "startY",
+      displayName: "Start Y",
+      type: "float"
+    },
+    {
+      name: "endX",
+      displayName: "End X",
+      type: "float"
+    },
+    {
+      name: "endY",
+      displayName: "End Y",
+      type: "float"
+    },
+    {
+      name: "priority",
+      displayName: "Priority",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "requestId",
+      displayName: "Request ID",
+      type: "int"
+    }
+  ],
+  color: "#4caf50"
+};
+var _RequestPathAsyncExecutor = class _RequestPathAsyncExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const startX = ctx.evaluateInput(node.id, "startX", 0);
+    const startY = ctx.evaluateInput(node.id, "startY", 0);
+    const endX = ctx.evaluateInput(node.id, "endX", 0);
+    const endY = ctx.evaluateInput(node.id, "endY", 0);
+    const priority = ctx.evaluateInput(node.id, "priority", 50);
+    const requestId = ctx.requestPath(startX, startY, endX, endY, priority);
+    return {
+      outputs: {
+        requestId
+      },
+      nextExec: "exec"
+    };
+  }
+};
+__name(_RequestPathAsyncExecutor, "RequestPathAsyncExecutor");
+var RequestPathAsyncExecutor = _RequestPathAsyncExecutor;
+var StepPathTemplate = {
+  type: "StepPath",
+  title: "Step Path",
+  category: "custom",
+  description: "Execute one step of pathfinding / \u6267\u884C\u4E00\u6B65\u5BFB\u8DEF",
+  keywords: [
+    "path",
+    "pathfinding",
+    "step",
+    "iterate",
+    "incremental"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Step Path"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "requestId",
+      displayName: "Request ID",
+      type: "int"
+    },
+    {
+      name: "maxIterations",
+      displayName: "Max Iterations",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "state",
+      displayName: "State",
+      type: "string"
+    },
+    {
+      name: "progress",
+      displayName: "Progress",
+      type: "float"
+    },
+    {
+      name: "nodesSearched",
+      displayName: "Nodes Searched",
+      type: "int"
+    }
+  ],
+  color: "#4caf50"
+};
+var _StepPathExecutor = class _StepPathExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const requestId = ctx.evaluateInput(node.id, "requestId", -1);
+    const maxIterations = ctx.evaluateInput(node.id, "maxIterations", 100);
+    const progress = ctx.stepPath(requestId, maxIterations);
+    return {
+      outputs: {
+        state: progress.state,
+        progress: progress.estimatedProgress,
+        nodesSearched: progress.nodesSearched
+      },
+      nextExec: "exec"
+    };
+  }
+};
+__name(_StepPathExecutor, "StepPathExecutor");
+var StepPathExecutor = _StepPathExecutor;
+var GetPathProgressTemplate = {
+  type: "GetPathProgress",
+  title: "Get Path Progress",
+  category: "custom",
+  description: "Get incremental pathfinding progress / \u83B7\u53D6\u589E\u91CF\u5BFB\u8DEF\u8FDB\u5EA6",
+  keywords: [
+    "path",
+    "progress",
+    "status",
+    "state"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Get Path Progress"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "requestId",
+      displayName: "Request ID",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "state",
+      displayName: "State",
+      type: "string"
+    },
+    {
+      name: "progress",
+      displayName: "Progress (0-1)",
+      type: "float"
+    },
+    {
+      name: "nodesSearched",
+      displayName: "Nodes Searched",
+      type: "int"
+    },
+    {
+      name: "isComplete",
+      displayName: "Is Complete",
+      type: "bool"
+    },
+    {
+      name: "isInProgress",
+      displayName: "Is In Progress",
+      type: "bool"
+    }
+  ],
+  color: "#4caf50"
+};
+var _GetPathProgressExecutor = class _GetPathProgressExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const requestId = ctx.evaluateInput(node.id, "requestId", -1);
+    const progress = ctx.getPathProgress(requestId);
+    if (!progress) {
+      return {
+        outputs: {
+          state: PathfindingState.Idle,
+          progress: 0,
+          nodesSearched: 0,
+          isComplete: false,
+          isInProgress: false
+        }
+      };
+    }
+    return {
+      outputs: {
+        state: progress.state,
+        progress: progress.estimatedProgress,
+        nodesSearched: progress.nodesSearched,
+        isComplete: progress.state === PathfindingState.Completed,
+        isInProgress: progress.state === PathfindingState.InProgress
+      }
+    };
+  }
+};
+__name(_GetPathProgressExecutor, "GetPathProgressExecutor");
+var GetPathProgressExecutor = _GetPathProgressExecutor;
+var GetPathResultTemplate = {
+  type: "GetPathResult",
+  title: "Get Path Result",
+  category: "custom",
+  description: "Get completed path result / \u83B7\u53D6\u5DF2\u5B8C\u6210\u7684\u5BFB\u8DEF\u7ED3\u679C",
+  keywords: [
+    "path",
+    "result",
+    "get",
+    "output"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Get Path Result"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "requestId",
+      displayName: "Request ID",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "found",
+      displayName: "Found",
+      type: "bool"
+    },
+    {
+      name: "path",
+      displayName: "Path",
+      type: "array"
+    },
+    {
+      name: "cost",
+      displayName: "Cost",
+      type: "float"
+    },
+    {
+      name: "framesUsed",
+      displayName: "Frames Used",
+      type: "int"
+    }
+  ],
+  color: "#4caf50"
+};
+var _GetPathResultExecutor = class _GetPathResultExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const requestId = ctx.evaluateInput(node.id, "requestId", -1);
+    const result = ctx.getPathResult(requestId);
+    if (!result) {
+      return {
+        outputs: {
+          found: false,
+          path: [],
+          cost: 0,
+          framesUsed: 0
+        }
+      };
+    }
+    return {
+      outputs: {
+        found: result.found,
+        path: result.path,
+        cost: result.cost,
+        framesUsed: result.framesUsed
+      }
+    };
+  }
+};
+__name(_GetPathResultExecutor, "GetPathResultExecutor");
+var GetPathResultExecutor = _GetPathResultExecutor;
+var CancelPathTemplate = {
+  type: "CancelPath",
+  title: "Cancel Path",
+  category: "custom",
+  description: "Cancel ongoing pathfinding / \u53D6\u6D88\u6B63\u5728\u8FDB\u884C\u7684\u5BFB\u8DEF",
+  keywords: [
+    "path",
+    "cancel",
+    "stop",
+    "abort"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Cancel Path"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "requestId",
+      displayName: "Request ID",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    }
+  ],
+  color: "#f44336"
+};
+var _CancelPathExecutor = class _CancelPathExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const requestId = ctx.evaluateInput(node.id, "requestId", -1);
+    ctx.cancelPath(requestId);
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_CancelPathExecutor, "CancelPathExecutor");
+var CancelPathExecutor = _CancelPathExecutor;
+var SetObstacleTemplate = {
+  type: "SetObstacle",
+  title: "Set Obstacle",
+  category: "custom",
+  description: "Set or remove obstacle / \u8BBE\u7F6E\u6216\u79FB\u9664\u969C\u788D\u7269",
+  keywords: [
+    "obstacle",
+    "block",
+    "walkable",
+    "terrain"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Set Obstacle"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    },
+    {
+      name: "x",
+      displayName: "X",
+      type: "int"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "int"
+    },
+    {
+      name: "blocked",
+      displayName: "Blocked",
+      type: "bool"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      displayName: "",
+      type: "exec"
+    }
+  ],
+  color: "#ff9800"
+};
+var _SetObstacleExecutor = class _SetObstacleExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const x = ctx.evaluateInput(node.id, "x", 0);
+    const y = ctx.evaluateInput(node.id, "y", 0);
+    const blocked = ctx.evaluateInput(node.id, "blocked", true);
+    ctx.setObstacle(x, y, blocked);
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_SetObstacleExecutor, "SetObstacleExecutor");
+var SetObstacleExecutor = _SetObstacleExecutor;
+var IsPathCompleteTemplate = {
+  type: "IsPathComplete",
+  title: "Is Path Complete",
+  category: "custom",
+  description: "Check if pathfinding is complete / \u68C0\u67E5\u5BFB\u8DEF\u662F\u5426\u5B8C\u6210",
+  keywords: [
+    "path",
+    "complete",
+    "done",
+    "finished"
+  ],
+  menuPath: [
+    "Pathfinding",
+    "Incremental",
+    "Is Path Complete"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "requestId",
+      displayName: "Request ID",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "isComplete",
+      displayName: "Is Complete",
+      type: "bool"
+    },
+    {
+      name: "found",
+      displayName: "Found",
+      type: "bool"
+    }
+  ],
+  color: "#4caf50"
+};
+var _IsPathCompleteExecutor = class _IsPathCompleteExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const requestId = ctx.evaluateInput(node.id, "requestId", -1);
+    const progress = ctx.getPathProgress(requestId);
+    const isComplete = progress?.state === PathfindingState.Completed || progress?.state === PathfindingState.Failed;
+    const result = ctx.getPathResult(requestId);
+    const found = result?.found ?? false;
+    return {
+      outputs: {
+        isComplete,
+        found
+      }
+    };
+  }
+};
+__name(_IsPathCompleteExecutor, "IsPathCompleteExecutor");
+var IsPathCompleteExecutor = _IsPathCompleteExecutor;
+var IncrementalPathfindingNodeDefinitions = {
+  templates: [
+    RequestPathAsyncTemplate,
+    StepPathTemplate,
+    GetPathProgressTemplate,
+    GetPathResultTemplate,
+    CancelPathTemplate,
+    SetObstacleTemplate,
+    IsPathCompleteTemplate
+  ],
+  executors: /* @__PURE__ */ new Map([
+    [
+      "RequestPathAsync",
+      new RequestPathAsyncExecutor()
+    ],
+    [
+      "StepPath",
+      new StepPathExecutor()
+    ],
+    [
+      "GetPathProgress",
+      new GetPathProgressExecutor()
+    ],
+    [
+      "GetPathResult",
+      new GetPathResultExecutor()
+    ],
+    [
+      "CancelPath",
+      new CancelPathExecutor()
+    ],
+    [
+      "SetObstacle",
+      new SetObstacleExecutor()
+    ],
+    [
+      "IsPathComplete",
+      new IsPathCompleteExecutor()
+    ]
+  ])
+};
+export {
+  CancelPathExecutor,
+  CancelPathTemplate,
+  FindPathExecutor,
+  FindPathSmoothExecutor,
+  FindPathSmoothTemplate,
+  FindPathTemplate,
+  GetPathDistanceExecutor,
+  GetPathDistanceTemplate,
+  GetPathLengthExecutor,
+  GetPathLengthTemplate,
+  GetPathPointExecutor,
+  GetPathPointTemplate,
+  GetPathProgressExecutor,
+  GetPathProgressTemplate,
+  GetPathResultExecutor,
+  GetPathResultTemplate,
+  HasLineOfSightExecutor,
+  HasLineOfSightTemplate,
+  IncrementalPathfindingNodeDefinitions,
+  IsPathCompleteExecutor,
+  IsPathCompleteTemplate,
+  IsWalkableExecutor,
+  IsWalkableTemplate,
+  MoveAlongPathExecutor,
+  MoveAlongPathTemplate,
+  PathfindingNodeDefinitions,
+  RequestPathAsyncExecutor,
+  RequestPathAsyncTemplate,
+  SetObstacleExecutor,
+  SetObstacleTemplate,
+  StepPathExecutor,
+  StepPathTemplate
+};
+//# sourceMappingURL=nodes.js.map