@hayro_o7/labyrinth 0.0.6 → 0.0.7

package/dist/components/GraphVisualizer.svelte

@@ -128,10 +128,13 @@
 			const result = findOptimalMultiGoalPath(graph, computedStartNode, computedGoalNodes);
 			optimalPath = result.optimalPath;
 			
-			// Generate visualization steps for the optimal path
+			// Generate visualization steps by running BFS for each segment
 			steps = [];
-			for (const nodeId of optimalPath) {
-				steps.push({ nodeId, type: 'path' });
+			const tour = [computedStartNode, ...computedGoalNodes];
+			
+			for (let i = 0; i < tour.length - 1; i++) {
+				const segmentResult = bidirectionalBFS(graph, tour[i], tour[i + 1]);
+				steps.push(...segmentResult.steps);
 			}
 		} else {
 			const result = bidirectionalBFS(graph, computedStartNode, computedGoalNodes[0]);

package/dist/graph-generator.d.ts

@@ -5,6 +5,7 @@ export interface GraphGeneratorOptions {
     height?: number;
     maxConnectionsPerNode?: number;
     connectionRadius?: number;
+    minNodeDistance?: number;
     seed?: number;
 }
 export declare function generateRandomGraph(options: GraphGeneratorOptions): GeneralGraph;

package/dist/graph-generator.js

@@ -6,14 +6,31 @@ function seededRandom(seed) {
     };
 }
 export function generateRandomGraph(options) {
-    const { nodeCount, width = 600, height = 600, maxConnectionsPerNode = 5, connectionRadius = 150, seed } = options;
+    const { nodeCount, width = 600, height = 600, maxConnectionsPerNode = 5, connectionRadius = 150, minNodeDistance = 30, seed } = options;
     const random = seed !== undefined ? seededRandom(seed) : Math.random;
     const nodes = new Map();
     const padding = 50;
-    // Generate node positions in a rectangular cloud
+    const nodePositions = [];
+    // Generate node positions with minimum distance constraint
     for (let i = 0; i < nodeCount; i++) {
-        const x = padding + random() * (width - 2 * padding);
-        const y = padding + random() * (height - 2 * padding);
+        let x, y;
+        let attempts = 0;
+        const maxAttempts = 100;
+        do {
+            x = padding + random() * (width - 2 * padding);
+            y = padding + random() * (height - 2 * padding);
+            attempts++;
+            // Check if position is far enough from existing nodes
+            const tooClose = nodePositions.some(pos => {
+                const dx = pos.x - x;
+                const dy = pos.y - y;
+                return Math.sqrt(dx * dx + dy * dy) < minNodeDistance;
+            });
+            if (!tooClose || attempts >= maxAttempts) {
+                break;
+            }
+        } while (true);
+        nodePositions.push({ x, y });
         nodes.set(`n${i}`, {
             id: `n${i}`,
             x,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hayro_o7/labyrinth",
-	"version": "0.0.6",
+	"version": "0.0.7",
 	"type": "module",
 	"scripts": {
 		"dev": "vite dev",