ai-control-center 1.15.2

package/lib/web/public/office/js/pathfinding.js

@@ -0,0 +1,144 @@
+/**
+ * A* Pathfinding on tile grid
+ * Characters walk naturally around furniture
+ */
+
+const TILE = 32;
+
+class PriorityQueue {
+  constructor() { this.items = []; }
+  push(item, priority) {
+    this.items.push({ item, priority });
+    this.items.sort((a, b) => a.priority - b.priority);
+  }
+  pop() { return this.items.shift()?.item; }
+  get length() { return this.items.length; }
+}
+
+/**
+ * A* pathfinder for office grid
+ */
+export class Pathfinder {
+  constructor() {
+    this.grids = new Map(); // projectName -> 2D walkability grid
+  }
+
+  /**
+   * Build walkability grid for a team zone
+   * @param {string} projectName
+   * @param {object} origin - {x, y} world position of team zone
+   * @param {number} width - tiles
+   * @param {number} height - tiles
+   * @param {Array} obstacles - [{x, y, w, h}] in tile coords
+   */
+  buildGrid(projectName, origin, width, height, obstacles = []) {
+    const grid = [];
+    for (let y = 0; y < height; y++) {
+      grid[y] = [];
+      for (let x = 0; x < width; x++) {
+        grid[y][x] = 1; // walkable
+      }
+    }
+    // Mark obstacles
+    for (const obs of obstacles) {
+      for (let dy = 0; dy < obs.h; dy++) {
+        for (let dx = 0; dx < obs.w; dx++) {
+          const gy = obs.y + dy;
+          const gx = obs.x + dx;
+          if (gy >= 0 && gy < height && gx >= 0 && gx < width) {
+            grid[gy][gx] = 0; // blocked
+          }
+        }
+      }
+    }
+    // Ensure edges of furniture are walkable (adjacent tiles)
+    this.grids.set(projectName, { grid, origin, width, height });
+  }
+
+  /**
+   * Find path between two world positions
+   * @returns {Array<{x, y}>} path in world coordinates, or empty if no path
+   */
+  findPath(projectName, startX, startY, endX, endY) {
+    const gridData = this.grids.get(projectName);
+    if (!gridData) {
+      // No grid — just return direct path
+      return [{ x: endX, y: endY }];
+    }
+
+    const { grid, origin, width, height } = gridData;
+
+    // Convert world to grid coords
+    const sx = Math.floor((startX - origin.x) / TILE);
+    const sy = Math.floor((startY - origin.y) / TILE);
+    const ex = Math.floor((endX - origin.x) / TILE);
+    const ey = Math.floor((endY - origin.y) / TILE);
+
+    // Clamp to grid bounds
+    const clamp = (v, max) => Math.max(0, Math.min(max - 1, v));
+    const gsx = clamp(sx, width);
+    const gsy = clamp(sy, height);
+    const gex = clamp(ex, width);
+    const gey = clamp(ey, height);
+
+    // If start == end, no path needed
+    if (gsx === gex && gsy === gey) return [{ x: endX, y: endY }];
+
+    // A* search
+    const open = new PriorityQueue();
+    const cameFrom = {};
+    const gScore = {};
+    const key = (x, y) => `${x},${y}`;
+
+    gScore[key(gsx, gsy)] = 0;
+    open.push({ x: gsx, y: gsy }, 0);
+
+    const heuristic = (x, y) => Math.abs(x - gex) + Math.abs(y - gey);
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]]; // 4-directional
+
+    while (open.length > 0) {
+      const curr = open.pop();
+      if (curr.x === gex && curr.y === gey) {
+        // Reconstruct path
+        const path = [];
+        let node = key(gex, gey);
+        while (node && node !== key(gsx, gsy)) {
+          const [nx, ny] = node.split(',').map(Number);
+          path.unshift({
+            x: origin.x + nx * TILE + TILE / 2,
+            y: origin.y + ny * TILE + TILE / 2
+          });
+          node = cameFrom[node];
+        }
+        return path.length > 0 ? path : [{ x: endX, y: endY }];
+      }
+
+      for (const [dx, dy] of dirs) {
+        const nx = curr.x + dx;
+        const ny = curr.y + dy;
+        if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+        if (!grid[ny][nx]) continue; // blocked
+
+        const nk = key(nx, ny);
+        const tentG = (gScore[key(curr.x, curr.y)] || 0) + 1;
+        if (gScore[nk] === undefined || tentG < gScore[nk]) {
+          gScore[nk] = tentG;
+          cameFrom[nk] = key(curr.x, curr.y);
+          open.push({ x: nx, y: ny }, tentG + heuristic(nx, ny));
+        }
+      }
+    }
+
+    // No path found — fallback to direct
+    return [{ x: endX, y: endY }];
+  }
+}
+
+// Singleton
+let _instance = null;
+export function getPathfinder() {
+  if (!_instance) _instance = new Pathfinder();
+  return _instance;
+}
+
+export { TILE };