@hayro_o7/labyrinth 0.0.5 → 0.0.7

package/dist/components/GraphVisualizer.svelte

@@ -8,9 +8,6 @@
 		goalNodes?: string[];
 		nodeRadius?: number;
 		autoPlay?: boolean;
-		buttons?: boolean;
-		legend?: boolean;
-		stepCount?: boolean;
 		animationSpeed?: number;
 		colors?: ColorScheme;
 		showMultiGoal?: boolean;
@@ -23,9 +20,6 @@
 		goalNodes = [],
 		nodeRadius = 20,
 		autoPlay = false,
-		buttons = true,
-		legend = true,
-		stepCount = true,
 		animationSpeed = 100,
 		colors,
 		showMultiGoal = false,
@@ -134,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]);
@@ -246,8 +243,12 @@
 		onControls?.(controlApi);
 	});
 
-	const svgWidth = 650;
-	const svgHeight = 650;
+	const svgWidth = $derived(
+		Math.max(...Array.from(graph.nodes.values()).map(n => n.x)) + 100
+	);
+	const svgHeight = $derived(
+		Math.max(...Array.from(graph.nodes.values()).map(n => n.y)) + 100
+	);
 </script>
 
 <div class="graph-container" style={cssVars}>
@@ -306,69 +307,6 @@
 		{/each}
 	</svg>
 
-	<div class="controls">
-		{#if buttons}
-			<button onclick={play} disabled={isPlaying}>Play</button>
-			<button onclick={pause} disabled={!isPlaying}>Pause</button>
-			<button onclick={reset}>Reset</button>
-			<button onclick={stepBackward} disabled={isPlaying || currentStepIndex === 0}>
-				Step Back
-			</button>
-			<button onclick={stepForward} disabled={isPlaying || currentStepIndex === steps.length}>
-				Step Forward
-			</button>
-		{/if}
-		{#if stepCount}
-			<span class="step-counter">
-				Step: {currentStepIndex} / {steps.length}
-			</span>
-		{/if}
-	</div>
-
-	{#if legend}
-		<div class="legend">
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: {colorScheme.start};"></div>
-				<span>Start</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: {colorScheme.end};"></div>
-				<span>Goal{computedGoalNodes.length > 1 ? 's' : ''}</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: {colorScheme.current};"></div>
-				<span>Forward</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: #f97316;"></div>
-				<span>Backward</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: {colorScheme.visiting};"></div>
-				<span>Forward Frontier</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: #fed7aa;"></div>
-				<span>Backward Frontier</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: {colorScheme.visited};"></div>
-				<span>Forward Visited</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: #fecaca;"></div>
-				<span>Backward Visited</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: #a855f7;"></div>
-				<span>Intersection</span>
-			</div>
-			<div class="legend-item">
-				<div class="legend-color" style="background-color: {colorScheme.path};"></div>
-				<span>Path</span>
-			</div>
-		</div>
-	{/if}
 </div>
 
 <style>
@@ -377,7 +315,6 @@
 		flex-direction: column;
 		gap: 1rem;
 		align-items: center;
-		padding: 1rem;
 	}
 
 	.graph-svg {
@@ -386,64 +323,4 @@
 		border: 2px solid #e5e7eb;
 		border-radius: 0.5rem;
 	}
-
-	.controls {
-		display: flex;
-		gap: 0.5rem;
-		align-items: center;
-		flex-wrap: wrap;
-	}
-
-	.controls button {
-		padding: 0.5rem 1rem;
-		border: none;
-		border-radius: 0.375rem;
-		cursor: pointer;
-		font-weight: 500;
-		transition: background-color 0.2s;
-		background-color: var(--graph-buttons);
-		color: var(--graph-buttonstext);
-	}
-
-	.controls button:hover:not(:disabled) {
-		background-color: var(--graph-buttonshover);
-	}
-
-	.controls button:disabled {
-		background-color: var(--graph-buttonsdisabled);
-		cursor: not-allowed;
-	}
-
-	.step-counter {
-		padding: 0.5rem 1rem;
-		border-radius: 0.375rem;
-		font-weight: 500;
-		background-color: var(--graph-legend);
-		color: var(--graph-legend-text);
-	}
-
-	.legend {
-		display: flex;
-		gap: 1rem;
-		flex-wrap: wrap;
-		padding: 0.75rem;
-		border-radius: 0.5rem;
-		background-color: var(--graph-legend);
-		color: var(--graph-legend-text);
-		max-width: 650px;
-	}
-
-	.legend-item {
-		display: flex;
-		align-items: center;
-		gap: 0.5rem;
-		font-size: 0.875rem;
-	}
-
-	.legend-color {
-		width: 1.5rem;
-		height: 1.5rem;
-		border-radius: 0.25rem;
-		border: 1px solid var(--graph-legend-text);
-	}
 </style>

package/dist/components/GraphVisualizer.svelte.d.ts

@@ -5,9 +5,6 @@ interface Props {
     goalNodes?: string[];
     nodeRadius?: number;
     autoPlay?: boolean;
-    buttons?: boolean;
-    legend?: boolean;
-    stepCount?: boolean;
     animationSpeed?: number;
     colors?: ColorScheme;
     showMultiGoal?: boolean;

package/dist/graph-generator.d.ts

@@ -1,7 +1,15 @@
 import type { GeneralGraph } from './types';
 export interface GraphGeneratorOptions {
     nodeCount: number;
-    avgDegree: number;
+    width?: number;
+    height?: number;
+    maxConnectionsPerNode?: number;
+    connectionRadius?: number;
+    minNodeDistance?: number;
     seed?: number;
 }
 export declare function generateRandomGraph(options: GraphGeneratorOptions): GeneralGraph;
+export declare function findOppositeCornerNodes(graph: GeneralGraph): {
+    topLeft: string;
+    bottomRight: string;
+};

package/dist/graph-generator.js

@@ -6,17 +6,31 @@ function seededRandom(seed) {
     };
 }
 export function generateRandomGraph(options) {
-    const { nodeCount, avgDegree, 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();
-    // Create nodes in a circular layout for better visualization
-    const radius = 200;
-    const centerX = 300;
-    const centerY = 300;
+    const padding = 50;
+    const nodePositions = [];
+    // Generate node positions with minimum distance constraint
     for (let i = 0; i < nodeCount; i++) {
-        const angle = (i / nodeCount) * 2 * Math.PI;
-        const x = centerX + radius * Math.cos(angle);
-        const y = centerY + radius * Math.sin(angle);
+        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,
@@ -24,34 +38,88 @@ export function generateRandomGraph(options) {
             neighbors: []
         });
     }
-    // Connect nodes to create a connected graph
-    // First, create a spanning tree to ensure connectivity
-    const nodeIds = Array.from(nodes.keys());
-    const connected = new Set([nodeIds[0]]);
-    const unconnected = new Set(nodeIds.slice(1));
-    while (unconnected.size > 0) {
-        const connectedNode = Array.from(connected)[Math.floor(random() * connected.size)];
-        const unconnectedNode = Array.from(unconnected)[Math.floor(random() * unconnected.size)];
-        nodes.get(connectedNode).neighbors.push(unconnectedNode);
-        nodes.get(unconnectedNode).neighbors.push(connectedNode);
-        connected.add(unconnectedNode);
-        unconnected.delete(unconnectedNode);
-    }
-    // Add additional edges to reach target average degree
-    const targetEdges = Math.floor((nodeCount * avgDegree) / 2);
-    const currentEdges = nodeCount - 1; // from spanning tree
-    const edgesToAdd = targetEdges - currentEdges;
-    for (let i = 0; i < edgesToAdd; i++) {
-        const node1Id = nodeIds[Math.floor(random() * nodeIds.length)];
-        const node2Id = nodeIds[Math.floor(random() * nodeIds.length)];
-        if (node1Id === node2Id)
+    // Connect nodes based on proximity
+    const nodeArray = Array.from(nodes.values());
+    for (let i = 0; i < nodeArray.length; i++) {
+        const node = nodeArray[i];
+        // Skip if already at max connections
+        if (node.neighbors.length >= maxConnectionsPerNode)
             continue;
-        const node1 = nodes.get(node1Id);
-        const node2 = nodes.get(node2Id);
-        if (!node1.neighbors.includes(node2Id)) {
-            node1.neighbors.push(node2Id);
-            node2.neighbors.push(node1Id);
+        // Find nearby nodes
+        const distances = [];
+        for (let j = 0; j < nodeArray.length; j++) {
+            if (i === j)
+                continue;
+            const other = nodeArray[j];
+            // Skip if other node is at max connections
+            if (other.neighbors.length >= maxConnectionsPerNode)
+                continue;
+            // Skip if already connected
+            if (node.neighbors.includes(other.id))
+                continue;
+            const dx = node.x - other.x;
+            const dy = node.y - other.y;
+            const distance = Math.sqrt(dx * dx + dy * dy);
+            if (distance <= connectionRadius) {
+                distances.push({ nodeId: other.id, distance });
+            }
+        }
+        // Sort by distance and connect to closest nodes
+        distances.sort((a, b) => a.distance - b.distance);
+        const connectionsNeeded = Math.min(maxConnectionsPerNode - node.neighbors.length, distances.length);
+        for (let k = 0; k < connectionsNeeded; k++) {
+            const targetId = distances[k].nodeId;
+            const targetNode = nodes.get(targetId);
+            // Only connect if target isn't at max
+            if (targetNode.neighbors.length < maxConnectionsPerNode) {
+                node.neighbors.push(targetId);
+                targetNode.neighbors.push(node.id);
+            }
+        }
+    }
+    // Ensure all nodes have at least one connection
+    for (const node of nodeArray) {
+        if (node.neighbors.length === 0) {
+            // Find closest node that can accept a connection
+            let closestNode = null;
+            let closestDistance = Infinity;
+            for (const other of nodeArray) {
+                if (other.id === node.id)
+                    continue;
+                if (other.neighbors.length >= maxConnectionsPerNode)
+                    continue;
+                const dx = node.x - other.x;
+                const dy = node.y - other.y;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                if (distance < closestDistance) {
+                    closestDistance = distance;
+                    closestNode = other;
+                }
+            }
+            if (closestNode) {
+                node.neighbors.push(closestNode.id);
+                closestNode.neighbors.push(node.id);
+            }
         }
     }
     return { nodes };
 }
+export function findOppositeCornerNodes(graph) {
+    const nodeArray = Array.from(graph.nodes.values());
+    let topLeftNode = nodeArray[0];
+    let bottomRightNode = nodeArray[0];
+    for (const node of nodeArray) {
+        // Top-left: minimize x + y
+        if (node.x + node.y < topLeftNode.x + topLeftNode.y) {
+            topLeftNode = node;
+        }
+        // Bottom-right: maximize x + y
+        if (node.x + node.y > bottomRightNode.x + bottomRightNode.y) {
+            bottomRightNode = node;
+        }
+    }
+    return {
+        topLeft: topLeftNode.id,
+        bottomRight: bottomRightNode.id
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { generateLabyrinth } from './labyrinth-generator';
-export { generateRandomGraph } from './graph-generator';
+export { generateRandomGraph, findOppositeCornerNodes } from './graph-generator';
 export { dijkstra } from './algorithms/dijkstra';
 export { astar } from './algorithms/astar';
 export { bidirectionalBFS, findOptimalMultiGoalPath } from './algorithms/bidirectional-bfs';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { generateLabyrinth } from './labyrinth-generator';
-export { generateRandomGraph } from './graph-generator';
+export { generateRandomGraph, findOppositeCornerNodes } from './graph-generator';
 export { dijkstra } from './algorithms/dijkstra';
 export { astar } from './algorithms/astar';
 export { bidirectionalBFS, findOptimalMultiGoalPath } from './algorithms/bidirectional-bfs';

package/package.json

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