@hayro_o7/labyrinth 0.0.4 → 0.0.6

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,
@@ -246,8 +240,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 +304,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 +312,6 @@
 		flex-direction: column;
 		gap: 1rem;
 		align-items: center;
-		padding: 1rem;
 	}
 
 	.graph-svg {
@@ -386,64 +320,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,14 @@
 import type { GeneralGraph } from './types';
 export interface GraphGeneratorOptions {
     nodeCount: number;
-    avgDegree: number;
+    width?: number;
+    height?: number;
+    maxConnectionsPerNode?: number;
+    connectionRadius?: 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,14 @@ function seededRandom(seed) {
     };
 }
 export function generateRandomGraph(options) {
-    const { nodeCount, avgDegree, seed } = options;
+    const { nodeCount, width = 600, height = 600, maxConnectionsPerNode = 5, connectionRadius = 150, 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;
+    // Generate node positions in a rectangular cloud
     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);
+        const x = padding + random() * (width - 2 * padding);
+        const y = padding + random() * (height - 2 * padding);
         nodes.set(`n${i}`, {
             id: `n${i}`,
             x,
@@ -24,34 +21,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/dist/labyrinth-generator.d.ts

@@ -1,2 +1,2 @@
 import type { Graph } from './types';
-export declare function generateLabyrinth(width: number, height: number): Graph;
+export declare function generateLabyrinth(width: number, height: number, wallRemovalPercent?: number): Graph;

package/dist/labyrinth-generator.js

@@ -5,7 +5,7 @@ function parseKey(key) {
     const [x, y] = key.split(',').map(Number);
     return { x, y };
 }
-export function generateLabyrinth(width, height) {
+export function generateLabyrinth(width, height, wallRemovalPercent = 25) {
     const cells = [];
     for (let y = 0; y < height; y++) {
         cells[y] = [];
@@ -40,6 +40,10 @@ export function generateLabyrinth(width, height) {
             stack.pop();
         }
     }
+    // Remove additional walls randomly to create multiple paths
+    if (wallRemovalPercent > 0) {
+        removeRandomWalls(cells, width, height, wallRemovalPercent);
+    }
     return cellsToGraph(cells, width, height);
 }
 function getUnvisitedNeighbors(cell, cells, width, height) {
@@ -75,6 +79,50 @@ function removeWall(cell1, cell2) {
         cell2.walls.bottom = false;
     }
 }
+function removeRandomWalls(cells, width, height, removalPercent) {
+    const allWalls = [];
+    // Collect all existing walls
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const cell = cells[y][x];
+            if (cell.walls.top && y > 0)
+                allWalls.push({ cell, direction: 'top' });
+            if (cell.walls.right && x < width - 1)
+                allWalls.push({ cell, direction: 'right' });
+            if (cell.walls.bottom && y < height - 1)
+                allWalls.push({ cell, direction: 'bottom' });
+            if (cell.walls.left && x > 0)
+                allWalls.push({ cell, direction: 'left' });
+        }
+    }
+    // Calculate how many walls to remove
+    const wallsToRemove = Math.floor(allWalls.length * (removalPercent / 100));
+    // Shuffle and remove random walls
+    for (let i = 0; i < wallsToRemove; i++) {
+        const randomIndex = Math.floor(Math.random() * allWalls.length);
+        const { cell, direction } = allWalls[randomIndex];
+        // Remove wall from both sides
+        const { x, y } = cell;
+        if (direction === 'top' && y > 0) {
+            cell.walls.top = false;
+            cells[y - 1][x].walls.bottom = false;
+        }
+        else if (direction === 'right' && x < width - 1) {
+            cell.walls.right = false;
+            cells[y][x + 1].walls.left = false;
+        }
+        else if (direction === 'bottom' && y < height - 1) {
+            cell.walls.bottom = false;
+            cells[y + 1][x].walls.top = false;
+        }
+        else if (direction === 'left' && x > 0) {
+            cell.walls.left = false;
+            cells[y][x - 1].walls.right = false;
+        }
+        // Remove this wall from the array to avoid removing it twice
+        allWalls.splice(randomIndex, 1);
+    }
+}
 function cellsToGraph(cells, width, height) {
     const nodes = new Map();
     for (let y = 0; y < height; y++) {

package/package.json

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