@2112-lab/central-plant 0.1.30 → 0.1.32

package/dist/bundle/index.js

@@ -18183,7 +18183,7 @@ var PathManager = /*#__PURE__*/function () {
   }
 
   /**
-   * A* pathfinding algorithm
+   * A* pathfinding algorithm with bend minimization
    * @private
    * @param {string} start - Start voxel key
    * @param {string} goal - Goal voxel key
@@ -18242,7 +18242,11 @@ var PathManager = /*#__PURE__*/function () {
             var _gScore$neighbor;
             var neighbor = _step2.value;
             if (occupied.has(neighbor)) continue;
-            var tentativeG = gScore[current] + 1;
+
+            // Calculate cost with bend penalty
+            var tentativeG = this.calculateGScore(current, neighbor, cameFrom[current], gScore[current]);
+            // const tentativeG = gScore[current] + 1;
+
             if (tentativeG < ((_gScore$neighbor = gScore[neighbor]) !== null && _gScore$neighbor !== void 0 ? _gScore$neighbor : Infinity)) {
               cameFrom[neighbor] = current;
               gScore[neighbor] = tentativeG;
@@ -18259,6 +18263,59 @@ var PathManager = /*#__PURE__*/function () {
       return null;
     }
 
+    /**
+     * Calculate G score with bend penalty
+     * @private
+     * @param {string} current - Current voxel key
+     * @param {string} neighbor - Neighbor voxel key
+     * @param {string} parent - Parent voxel key (null if current is start)
+     * @param {number} currentG - Current G score
+     * @returns {number} G score with bend penalty
+     */
+  }, {
+    key: "calculateGScore",
+    value: function calculateGScore(current, neighbor, parent, currentG) {
+      var cost = currentG + 1; // Base movement cost
+
+      if (parent) {
+        // Check if this move creates a bend
+        var _parent$split$map = parent.split(',').map(Number),
+          _parent$split$map2 = _slicedToArray(_parent$split$map, 3),
+          px = _parent$split$map2[0],
+          py = _parent$split$map2[1],
+          pz = _parent$split$map2[2];
+        var _current$split$map = current.split(',').map(Number),
+          _current$split$map2 = _slicedToArray(_current$split$map, 3),
+          cx = _current$split$map2[0],
+          cy = _current$split$map2[1],
+          cz = _current$split$map2[2];
+        var _neighbor$split$map = neighbor.split(',').map(Number),
+          _neighbor$split$map2 = _slicedToArray(_neighbor$split$map, 3),
+          nx = _neighbor$split$map2[0],
+          ny = _neighbor$split$map2[1],
+          nz = _neighbor$split$map2[2];
+
+        // Direction from parent to current
+        var prevDir = {
+          x: cx - px,
+          y: cy - py,
+          z: cz - pz
+        };
+        // Direction from current to neighbor
+        var nextDir = {
+          x: nx - cx,
+          y: ny - cy,
+          z: nz - cz
+        };
+
+        // If directions are different, add bend penalty
+        if (prevDir.x !== nextDir.x || prevDir.y !== nextDir.y || prevDir.z !== nextDir.z) {
+          cost += 0.00001; // Bend penalty - adjust this value to control how much bends are avoided
+        }
+      }
+      return cost;
+    }
+
     /**
      * Find a path respecting virtual segments
      * @private
@@ -19356,6 +19413,9 @@ var PathfindingManager = /*#__PURE__*/function () {
               console.log('Generated gateways:', JSON.parse(JSON.stringify(pathfindingResult.gateways)));
               console.log('Rewired connections:', JSON.parse(JSON.stringify(pathfindingResult.rewiredConnections)));
 
+              // Check for duplicate direction vectors going into the same gateways
+              this.checkForDuplicateGatewayDirections(pathfindingResult, sceneData, connections);
+
               // Create gateways in the scene if requested
               if (createGateways && pathfindingResult.gateways) {
                 pathfindingResult.gateways.forEach(function (gateway) {
@@ -20607,6 +20667,130 @@ var PathfindingManager = /*#__PURE__*/function () {
       });
       return optimizedPaths;
     }
+
+    /**
+     * Check for duplicate direction vectors going into the same gateways
+     * This helps diagnose path overlapping issues caused by incorrect connector directions after rotation
+     * @param {Object} pathfindingResult - Result from pathfinder.findPaths()
+     * @param {Object} sceneData - Scene data used for pathfinding
+     * @param {Array} connections - Original connections array
+     */
+  }, {
+    key: "checkForDuplicateGatewayDirections",
+    value: function checkForDuplicateGatewayDirections(pathfindingResult, sceneData, connections) {
+      var _this4 = this;
+      if (!pathfindingResult.gateways || !pathfindingResult.rewiredConnections) {
+        return; // No gateways or rewired connections to check
+      }
+      console.log('🔍 Checking for duplicate direction vectors going into gateways...');
+
+      // Group connections by gateway
+      var gatewayConnections = new Map();
+      pathfindingResult.rewiredConnections.forEach(function (conn) {
+        // Check if this connection goes TO a gateway
+        var toGateway = pathfindingResult.gateways.find(function (gw) {
+          return gw.id === conn.to;
+        });
+        if (toGateway) {
+          if (!gatewayConnections.has(conn.to)) {
+            gatewayConnections.set(conn.to, []);
+          }
+          gatewayConnections.get(conn.to).push({
+            connection: conn,
+            gateway: toGateway
+          });
+        }
+      });
+
+      // Check each gateway for duplicate direction vectors
+      var hasErrors = false;
+      gatewayConnections.forEach(function (connectionsToGateway, gatewayId) {
+        if (connectionsToGateway.length < 2) {
+          return; // Need at least 2 connections to have duplicates
+        }
+        console.log("\uD83D\uDD0D Checking gateway ".concat(gatewayId, " with ").concat(connectionsToGateway.length, " incoming connections"));
+
+        // Get direction vectors for each connection going into this gateway
+        var directionVectors = [];
+        connectionsToGateway.forEach(function (_ref) {
+          var connection = _ref.connection;
+          // Find the connector object in the scene data
+          var connectorObj = _this4.findObjectInSceneData(sceneData, connection.from);
+          if (connectorObj && connectorObj.userData && connectorObj.userData.direction) {
+            var direction = connectorObj.userData.direction;
+            directionVectors.push({
+              connectionFrom: connection.from,
+              direction: direction,
+              directionString: "[".concat(direction[0], ", ").concat(direction[1], ", ").concat(direction[2], "]")
+            });
+            console.log("  \uD83D\uDCCD Connector ".concat(connection.from, " direction: [").concat(direction[0], ", ").concat(direction[1], ", ").concat(direction[2], "]"));
+          } else {
+            console.warn("  \u26A0\uFE0F Could not find direction for connector ".concat(connection.from));
+          }
+        });
+
+        // Check for duplicate directions
+        var directionMap = new Map();
+        directionVectors.forEach(function (_ref2) {
+          var connectionFrom = _ref2.connectionFrom;
+            _ref2.direction;
+            var directionString = _ref2.directionString;
+          if (!directionMap.has(directionString)) {
+            directionMap.set(directionString, []);
+          }
+          directionMap.get(directionString).push(connectionFrom);
+        });
+
+        // Find duplicates
+        directionMap.forEach(function (connectors, directionString) {
+          if (connectors.length > 1) {
+            hasErrors = true;
+            console.error("\u274C DUPLICATE DIRECTION VECTORS DETECTED!\n" + "   Gateway: ".concat(gatewayId, "\n") + "   Direction: ".concat(directionString, "\n") + "   Connectors with same direction: ".concat(connectors.join(', '), "\n") + "   This will cause path overlapping! The connectors going into the same gateway should have different direction vectors after component rotation.");
+          }
+        });
+      });
+      if (!hasErrors) {
+        console.log('✅ No duplicate direction vectors detected in gateway connections');
+      } else {
+        console.error("\u274C PATHFINDING DIAGNOSTIC: Found duplicate direction vectors going into gateways.\n" + "   This is likely caused by connector direction vectors not being properly updated after component rotation.\n" + "   The rotation code should transform the connector userData.direction arrays to reflect the new orientation.");
+      }
+    }
+
+    /**
+     * Helper method to find an object in scene data by UUID
+     * @param {Object} sceneData - Scene data to search
+     * @param {string} uuid - UUID to find
+     * @returns {Object|null} Found object or null
+     */
+  }, {
+    key: "findObjectInSceneData",
+    value: function findObjectInSceneData(sceneData, uuid) {
+      var _searchChildren = function searchChildren(children) {
+        var _iterator2 = _createForOfIteratorHelper(children),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var child = _step2.value;
+            if (child.uuid === uuid) {
+              return child;
+            }
+            if (child.children) {
+              var found = _searchChildren(child.children);
+              if (found) return found;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return null;
+      };
+      if (sceneData.object && sceneData.object.children) {
+        return _searchChildren(sceneData.object.children);
+      }
+      return null;
+    }
   }]);
 }();
 
@@ -26055,6 +26239,9 @@ var CentralPlant = /*#__PURE__*/function () {
       // Update the Three.js object position
       component.position[axis] += value;
 
+      // Update world bounding boxes for the component and its children
+      this.updateWorldBoundingBoxes(component);
+
       // Update the associated JSON object in currentSceneData if it exists
       if (this.sceneViewer.currentSceneData && this.sceneViewer.currentSceneData.scene) {
         if (component.userData.associatedJsonObject) {
@@ -26168,6 +26355,14 @@ var CentralPlant = /*#__PURE__*/function () {
       // Apply the rotation
       component.rotation[axis] += radians;
 
+      // Update direction vectors for connectors if this is a 90-degree rotation
+      if (value % 90 === 0) {
+        this.updateDirectionAfterRotation(component, axis, value);
+      }
+
+      // Update world bounding boxes for the component and its children
+      this.updateWorldBoundingBoxes(component);
+
       // Update the associated JSON object in currentSceneData if it exists
       if (this.sceneViewer.currentSceneData && this.sceneViewer.currentSceneData.scene) {
         if (component.userData.associatedJsonObject) {
@@ -26215,6 +26410,173 @@ var CentralPlant = /*#__PURE__*/function () {
       return true;
     }
 
+    /**
+     * Update userData.direction for components after 90-degree rotation
+     * This method handles the direction vector transformation for connectors when their parent component is rotated
+     * 
+     * @param {THREE.Object3D} component - The component that was rotated
+     * @param {string} axis - The axis of rotation ('x', 'y', or 'z')
+     * @param {number} degrees - The rotation angle in degrees (should be multiple of 90)
+     * @private
+     */
+  }, {
+    key: "updateDirectionAfterRotation",
+    value: function updateDirectionAfterRotation(component, axis, degrees) {
+      var _this = this;
+      if (!component) {
+        console.warn('⚠️ updateDirectionAfterRotation: No component provided');
+        return;
+      }
+
+      // Only handle 90-degree increments
+      if (degrees % 90 !== 0) {
+        console.warn('⚠️ updateDirectionAfterRotation: Only 90-degree increments are supported');
+        return;
+      }
+
+      // Normalize degrees to 0-360 range
+      var normalizedDegrees = (degrees % 360 + 360) % 360;
+      console.log("\uD83D\uDD04 Updating direction vectors for ".concat(component.name || component.uuid, " after ").concat(degrees, "\xB0 rotation around ").concat(axis, " axis"));
+
+      // Traverse all children (connectors) and update their direction vectors
+      component.traverse(function (child) {
+        if (child.userData && Array.isArray(child.userData.direction) && child.userData.componentType === 'connector') {
+          var originalDirection = _toConsumableArray(child.userData.direction);
+          var newDirection = _this.rotateDirectionVector(originalDirection, axis, normalizedDegrees);
+
+          // Update the direction
+          child.userData.direction = newDirection;
+          console.log("\uD83D\uDCCD Updated connector ".concat(child.name || child.uuid, " direction:"), {
+            original: originalDirection,
+            new: newDirection,
+            rotationAxis: axis,
+            rotationDegrees: degrees
+          });
+        }
+      });
+    }
+
+    /**
+     * Rotate a direction vector by 90-degree increments around a specific axis
+     * 
+     * @param {Array<number>} direction - The original direction vector [x, y, z]
+     * @param {string} axis - The axis of rotation ('x', 'y', or 'z')
+     * @param {number} degrees - The rotation angle in degrees (must be multiple of 90)
+     * @returns {Array<number>} The new direction vector [x, y, z]
+     * @private
+     */
+  }, {
+    key: "rotateDirectionVector",
+    value: function rotateDirectionVector(direction, axis, degrees) {
+      if (!Array.isArray(direction) || direction.length !== 3) {
+        console.warn('⚠️ rotateDirectionVector: Invalid direction vector');
+        return direction;
+      }
+      var _direction = _slicedToArray(direction, 3),
+        x = _direction[0],
+        y = _direction[1],
+        z = _direction[2];
+      var steps = degrees / 90; // Number of 90-degree steps
+
+      for (var i = 0; i < steps; i++) {
+        var newX = x,
+          newY = y,
+          newZ = z;
+        switch (axis) {
+          case 'x':
+            // Rotation around X-axis: Y becomes -Z, Z becomes Y
+            newY = -z;
+            newZ = y;
+            break;
+          case 'y':
+            // Rotation around Y-axis: X becomes Z, Z becomes -X
+            newX = z;
+            newZ = -x;
+            break;
+          case 'z':
+            // Rotation around Z-axis: X becomes -Y, Y becomes X
+            newX = -y;
+            newY = x;
+            break;
+          default:
+            console.warn("\u26A0\uFE0F rotateDirectionVector: Invalid axis '".concat(axis, "'"));
+            return direction;
+        }
+        x = newX;
+        y = newY;
+        z = newZ;
+      }
+      return [x, y, z];
+    }
+
+    /**
+     * Update world bounding boxes for a component and its children after transformation
+     * This method recalculates bounding boxes based on the new position/rotation
+     * 
+     * @param {THREE.Object3D} component - The component that was transformed
+     * @private
+     */
+  }, {
+    key: "updateWorldBoundingBoxes",
+    value: function updateWorldBoundingBoxes(component) {
+      var _this$sceneViewer, _this$sceneViewer2;
+      if (!component) {
+        console.warn('⚠️ updateWorldBoundingBoxes: No component provided');
+        return;
+      }
+      console.log("\uD83D\uDCE6 Updating world bounding boxes for ".concat(component.name || component.uuid));
+
+      // Update bounding box for the main component and all its children
+      component.traverse(function (child) {
+        if (child.isMesh || child.userData.componentType) {
+          try {
+            // Force matrix updates to ensure accurate bounding box calculation
+            child.updateMatrix();
+            child.updateMatrixWorld(true);
+
+            // Calculate new world bounding box
+            var boundingBox = new THREE__namespace.Box3().setFromObject(child);
+
+            // Update userData.worldBoundingBox if it exists
+            if (child.userData) {
+              child.userData.worldBoundingBox = {
+                min: boundingBox.min.toArray(),
+                max: boundingBox.max.toArray()
+              };
+              console.log("\uD83D\uDCE6 Updated bounding box for ".concat(child.name || child.uuid, ":"), {
+                min: boundingBox.min.toArray(),
+                max: boundingBox.max.toArray()
+              });
+            }
+
+            // Update associated JSON object if it exists
+            if (child.userData.associatedJsonObject) {
+              if (!child.userData.associatedJsonObject.userData) {
+                child.userData.associatedJsonObject.userData = {};
+              }
+              child.userData.associatedJsonObject.userData.worldBoundingBox = {
+                min: boundingBox.min.toArray(),
+                max: boundingBox.max.toArray()
+              };
+              console.log("\uD83D\uDCE6 Updated JSON bounding box for ".concat(child.name || child.uuid));
+            }
+          } catch (error) {
+            console.warn("\u26A0\uFE0F Error updating bounding box for ".concat(child.name || child.uuid, ":"), error);
+          }
+        }
+      });
+
+      // Also trigger the pathfinding manager's recompute method for consistency
+      if ((_this$sceneViewer = this.sceneViewer) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.pathfindingManager && (_this$sceneViewer2 = this.sceneViewer) !== null && _this$sceneViewer2 !== void 0 && _this$sceneViewer2.currentSceneData && typeof this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes === 'function') {
+        try {
+          this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes(this.sceneViewer.currentSceneData);
+          console.log('📦 Triggered pathfinding manager bounding box recompute');
+        } catch (error) {
+          console.warn('⚠️ Error triggering pathfinding bounding box recompute:', error);
+        }
+      }
+    }
+
     /**
      * Update paths in the scene
      * @returns {boolean} True if paths were updated successfully, false otherwise
@@ -26268,7 +26630,7 @@ var CentralPlant = /*#__PURE__*/function () {
   }, {
     key: "syncSceneData",
     value: function syncSceneData() {
-      var _this = this;
+      var _this2 = this;
       // Check if scene viewer and currentSceneData are available
       if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
         console.warn('⚠️ syncSceneData(): Scene viewer or current scene data not available');
@@ -26293,7 +26655,7 @@ var CentralPlant = /*#__PURE__*/function () {
         currentSceneData.scene.object.children.forEach(function (sceneDataChild, index) {
           // Find matching Three.js object
           var matchingThreeObject = null;
-          _this.sceneViewer.scene.traverse(function (threeObject) {
+          _this2.sceneViewer.scene.traverse(function (threeObject) {
             var _sceneDataChild$userD, _threeObject$userData, _threeObject$userData2;
             // Check various UUID matching strategies
             if (threeObject.uuid === sceneDataChild.uuid || threeObject.uuid === ((_sceneDataChild$userD = sceneDataChild.userData) === null || _sceneDataChild$userD === void 0 ? void 0 : _sceneDataChild$userD.originalUuid) || ((_threeObject$userData = threeObject.userData) === null || _threeObject$userData === void 0 ? void 0 : _threeObject$userData.originalUuid) === sceneDataChild.uuid || ((_threeObject$userData2 = threeObject.userData) === null || _threeObject$userData2 === void 0 ? void 0 : _threeObject$userData2.hardcodedUuid) === sceneDataChild.uuid) {
@@ -26400,7 +26762,7 @@ var CentralPlant = /*#__PURE__*/function () {
   }, {
     key: "forceSyncSceneData",
     value: function forceSyncSceneData() {
-      var _this2 = this;
+      var _this3 = this;
       // Check if scene viewer and sceneOperationsManager are available
       if (!this.sceneViewer || !this.sceneViewer.sceneOperationsManager) {
         console.warn('⚠️ forceSyncSceneData(): Scene viewer or scene operations manager not available');
@@ -26426,7 +26788,7 @@ var CentralPlant = /*#__PURE__*/function () {
             console.log("\uD83D\uDD04 Syncing object: ".concat(threeObject.uuid, " (").concat(threeObject.userData.componentType || 'unknown', ")"));
 
             // Use the existing updateSceneDataAfterTransform method
-            var success = _this2.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(threeObject, currentSceneData);
+            var success = _this3.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(threeObject, currentSceneData);
             if (success) {
               syncedCount++;
             } else {

package/dist/cjs/pathfinder/src/PathManager.js

@@ -27,7 +27,7 @@ var PathManager = /*#__PURE__*/function () {
   }
 
   /**
-   * A* pathfinding algorithm
+   * A* pathfinding algorithm with bend minimization
    * @private
    * @param {string} start - Start voxel key
    * @param {string} goal - Goal voxel key
@@ -86,7 +86,11 @@ var PathManager = /*#__PURE__*/function () {
             var _gScore$neighbor;
             var neighbor = _step2.value;
             if (occupied.has(neighbor)) continue;
-            var tentativeG = gScore[current] + 1;
+
+            // Calculate cost with bend penalty
+            var tentativeG = this.calculateGScore(current, neighbor, cameFrom[current], gScore[current]);
+            // const tentativeG = gScore[current] + 1;
+
             if (tentativeG < ((_gScore$neighbor = gScore[neighbor]) !== null && _gScore$neighbor !== void 0 ? _gScore$neighbor : Infinity)) {
               cameFrom[neighbor] = current;
               gScore[neighbor] = tentativeG;
@@ -103,6 +107,59 @@ var PathManager = /*#__PURE__*/function () {
       return null;
     }
 
+    /**
+     * Calculate G score with bend penalty
+     * @private
+     * @param {string} current - Current voxel key
+     * @param {string} neighbor - Neighbor voxel key
+     * @param {string} parent - Parent voxel key (null if current is start)
+     * @param {number} currentG - Current G score
+     * @returns {number} G score with bend penalty
+     */
+  }, {
+    key: "calculateGScore",
+    value: function calculateGScore(current, neighbor, parent, currentG) {
+      var cost = currentG + 1; // Base movement cost
+
+      if (parent) {
+        // Check if this move creates a bend
+        var _parent$split$map = parent.split(',').map(Number),
+          _parent$split$map2 = _rollupPluginBabelHelpers.slicedToArray(_parent$split$map, 3),
+          px = _parent$split$map2[0],
+          py = _parent$split$map2[1],
+          pz = _parent$split$map2[2];
+        var _current$split$map = current.split(',').map(Number),
+          _current$split$map2 = _rollupPluginBabelHelpers.slicedToArray(_current$split$map, 3),
+          cx = _current$split$map2[0],
+          cy = _current$split$map2[1],
+          cz = _current$split$map2[2];
+        var _neighbor$split$map = neighbor.split(',').map(Number),
+          _neighbor$split$map2 = _rollupPluginBabelHelpers.slicedToArray(_neighbor$split$map, 3),
+          nx = _neighbor$split$map2[0],
+          ny = _neighbor$split$map2[1],
+          nz = _neighbor$split$map2[2];
+
+        // Direction from parent to current
+        var prevDir = {
+          x: cx - px,
+          y: cy - py,
+          z: cz - pz
+        };
+        // Direction from current to neighbor
+        var nextDir = {
+          x: nx - cx,
+          y: ny - cy,
+          z: nz - cz
+        };
+
+        // If directions are different, add bend penalty
+        if (prevDir.x !== nextDir.x || prevDir.y !== nextDir.y || prevDir.z !== nextDir.z) {
+          cost += 0.00001; // Bend penalty - adjust this value to control how much bends are avoided
+        }
+      }
+      return cost;
+    }
+
     /**
      * Find a path respecting virtual segments
      * @private