@2112-lab/central-plant 0.1.0

package/dist/esm/src/pathfindingManager.js

@@ -0,0 +1,295 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import Pathfinder from './Pathfinder.js';
+import { pathfinderLogger } from './debugLogger.js';
+
+var PathfindingManager = /*#__PURE__*/function () {
+  function PathfindingManager(component) {
+    _classCallCheck(this, PathfindingManager);
+    this.component = component;
+    this.crosscubeTextureSet = null;
+    this.pathfinderVersionInfo = null;
+
+    // Initialize pathfinder
+    this.pathfinder = new Pathfinder(component === null || component === void 0 ? void 0 : component.sceneData);
+  }
+
+  /**
+   * Get pathfinder version information
+   */
+  return _createClass(PathfindingManager, [{
+    key: "getPathfinderVersionInfo",
+    value: (function () {
+      var _getPathfinderVersionInfo = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var versionInfo;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!this.pathfinderVersionInfo) {
+                _context.n = 1;
+                break;
+              }
+              return _context.a(2, this.pathfinderVersionInfo);
+            case 1:
+              versionInfo = {
+                version: '1.0.15',
+                detectionMethod: 'hardcoded-fallback',
+                timestamp: new Date().toISOString()
+              };
+              this.pathfinderVersionInfo = versionInfo;
+              return _context.a(2, versionInfo);
+          }
+        }, _callee, this);
+      }));
+      function getPathfinderVersionInfo() {
+        return _getPathfinderVersionInfo.apply(this, arguments);
+      }
+      return getPathfinderVersionInfo;
+    }()
+    /**
+     * Log pathfinder version information
+     */
+    )
+  }, {
+    key: "logPathfinderVersion",
+    value: (function () {
+      var _logPathfinderVersion = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var context,
+          versionInfo,
+          _args2 = arguments,
+          _t;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              context = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : 'Unknown Context';
+              _context2.p = 1;
+              _context2.n = 2;
+              return this.getPathfinderVersionInfo();
+            case 2:
+              versionInfo = _context2.v;
+              pathfinderLogger.info("[".concat(context, "] Pathfinder Module Information:"), {
+                version: versionInfo.version,
+                detectionMethod: versionInfo.detectionMethod,
+                context: context,
+                timestamp: versionInfo.timestamp,
+                pathfinderInstance: !!this.pathfinder
+              });
+              _context2.n = 4;
+              break;
+            case 3:
+              _context2.p = 3;
+              _t = _context2.v;
+              pathfinderLogger.error("[".concat(context, "] Failed to get pathfinder version:"), _t);
+            case 4:
+              return _context2.a(2);
+          }
+        }, _callee2, this, [[1, 3]]);
+      }));
+      function logPathfinderVersion() {
+        return _logPathfinderVersion.apply(this, arguments);
+      }
+      return logPathfinderVersion;
+    }()
+    /**
+     * Get path colors for visual distinction
+     */
+    )
+  }, {
+    key: "getPathColor",
+    value: function getPathColor(index) {
+      var colors = ['#468e49', '#245e29', '#2e80d2', '#1d51a1'];
+      return colors[index % colors.length];
+    }
+
+    /**
+     * Initialize pathfinder and create paths
+     */
+  }, {
+    key: "initializePathfinder",
+    value: (function () {
+      var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(data, crosscubeTextureSet) {
+        var _data$scene;
+        var component, paths;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (Pathfinder) {
+                _context3.n = 1;
+                break;
+              }
+              _context3.n = 1;
+              return importPathfinder();
+            case 1:
+              component = this.component;
+              this.crosscubeTextureSet = crosscubeTextureSet;
+
+              // Log pathfinder version information
+              _context3.n = 2;
+              return this.logPathfinderVersion('Scene Loading');
+            case 2:
+              this.pathfinder = new Pathfinder(data);
+              if (component) component.pathfinder = this.pathfinder;
+
+              // Add debugging for pathfinder input
+              console.log('🔍 PATHFINDER DEBUGGING:');
+              console.log('🔗 Connections:', data.connections);
+              console.log('🏗️ Scene structure:', JSON.parse(JSON.stringify((_data$scene = data.scene) === null || _data$scene === void 0 ? void 0 : _data$scene.object)));
+
+              // Ensure connections exist before finding paths
+              if (!(!data.connections || !Array.isArray(data.connections))) {
+                _context3.n = 3;
+                break;
+              }
+              console.warn('⚠️ No connections found in scene data, skipping path finding');
+              return _context3.a(2, []);
+            case 3:
+              paths = this.pathfinder.findPaths();
+              console.log('Found paths:', paths);
+
+              // Create pipe paths with materials
+              return _context3.a(2, this.createPipePaths(paths, crosscubeTextureSet));
+          }
+        }, _callee3, this);
+      }));
+      function initializePathfinder(_x, _x2) {
+        return _initializePathfinder.apply(this, arguments);
+      }
+      return initializePathfinder;
+    }()
+    /**
+     * Remove all existing paths from the scene
+     */
+    )
+  }, {
+    key: "removeAllPaths",
+    value: function removeAllPaths() {
+      var component = this.component;
+      if (!component || !component.scene) {
+        return;
+      }
+      console.log("removeAllPaths started");
+      var objectsToRemove = [];
+
+      // Find all path objects in the scene
+      component.scene.traverse(function (child) {
+        if (child.userData && child.userData.isPathObject) {
+          objectsToRemove.push(child);
+        }
+      });
+
+      // Remove all found path objects
+      objectsToRemove.forEach(function (object) {
+        object.parent.remove(object);
+
+        // Dispose of geometries and materials
+        if (object.geometry) {
+          object.geometry.dispose();
+        }
+        if (object.material) {
+          if (Array.isArray(object.material)) {
+            object.material.forEach(function (material) {
+              return material.dispose();
+            });
+          } else {
+            object.material.dispose();
+          }
+        }
+      });
+      console.log("Removed ".concat(objectsToRemove.length, " path objects"));
+    }
+
+    /**
+     * Material factory function to reduce duplication
+     */
+  }, {
+    key: "createPipeMaterial",
+    value: function createPipeMaterial(crosscubeTextureSet, pathIndex) {
+      var color = this.getPathColor(pathIndex);
+      var material = new THREE.MeshStandardMaterial({
+        color: new THREE.Color(color),
+        roughness: 0.3,
+        metalness: 0.8,
+        envMap: crosscubeTextureSet ? crosscubeTextureSet.envMap : null
+      });
+      return material;
+    }
+
+    /**
+     * Helper function to create pipe paths
+     */
+  }, {
+    key: "createPipePaths",
+    value: function createPipePaths(paths, crosscubeTextureSet) {
+      var _this = this;
+      var component = this.component;
+      if (!component || !component.scene) {
+        console.warn('Cannot create pipe paths: component or scene not available');
+        return [];
+      }
+
+      // Remove existing paths before creating new ones
+      this.removeAllPaths();
+      var pipeObjects = [];
+      paths.forEach(function (path, pathIndex) {
+        if (!path || !path.points || path.points.length < 2) {
+          console.warn('Invalid path data, skipping:', path);
+          return;
+        }
+        try {
+          var material = _this.createPipeMaterial(crosscubeTextureSet, pathIndex);
+
+          // Create a path from the points
+          var points = path.points.map(function (point) {
+            return new THREE.Vector3(point.x, point.y, point.z);
+          });
+          var curve = new THREE.CatmullRomCurve3(points);
+
+          // Create the pipe geometry
+          var pipeRadius = 0.15;
+          var radialSegments = 8;
+          var tubularSegments = points.length * 3;
+          var geometry = new THREE.TubeGeometry(curve, tubularSegments, pipeRadius, radialSegments, false);
+
+          // Create the mesh
+          var pipe = new THREE.Mesh(geometry, material);
+
+          // Add metadata
+          pipe.userData = {
+            isPathObject: true,
+            pathIndex: pathIndex,
+            connectionId: path.connectionId,
+            startComponentId: path.startComponentId,
+            endComponentId: path.endComponentId
+          };
+
+          // Add to scene
+          component.scene.add(pipe);
+          pipeObjects.push(pipe);
+        } catch (error) {
+          console.error('Error creating pipe for path:', path, error);
+        }
+      });
+      return pipeObjects;
+    }
+  }]);
+}();
+
+// Create a singleton instance
+var pathfindingManager = null;
+
+/**
+ * Get the global pathfinding manager instance
+ */
+function getPathfindingManager() {
+  var component = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  if (!pathfindingManager || component && pathfindingManager.component !== component) {
+    pathfindingManager = new PathfindingManager(component);
+  }
+  return pathfindingManager;
+}
+var pathfindingManager$1 = {
+  PathfindingManager: PathfindingManager,
+  getPathfindingManager: getPathfindingManager
+};
+
+export { PathfindingManager, pathfindingManager$1 as default, getPathfindingManager };