Add in Maze Generation and additional pathfinding

* Pathfinding has become cumbersome, working on cleaning up and refactoring visualiser code

Author: A-Georgiou

src/algorithms/mazes/DFSMazeGeneration.ts

@@ -0,0 +1,63 @@
+import { Cell } from "../utils/PathfindingUtils";
+
+function getNeighbors(maze: Cell[][], cell: Cell): Cell[] {
+    const neighbors: Cell[] = [];
+    const { row, col } = cell;
+
+    const directions = [
+        { row: -2, col: 0 },  // Up
+        { row: 2, col: 0 },   // Down
+        { row: 0, col: -2 },  // Left
+        { row: 0, col: 2 }    // Right
+    ];
+
+    for (let direction of directions) {
+        const newRow = row + direction.row;
+        const newCol = col + direction.col;
+
+        if (newRow > 0 && newRow < maze.length - 1 && newCol > 0 && newCol < maze[0].length - 1) {
+            neighbors.push(maze[newRow][newCol]);
+        }
+    }
+
+    return neighbors;
+}
+
+function initialiseAllWalls(maze: Cell[][]): void {
+    for (let row = 0; row < maze.length; row++) {
+        for (let col = 0; col < maze[row].length; col++) {
+            maze[row][col].wall = true;
+        }
+    }
+}
+
+export function dfsMazeGeneration(maze: Cell[][], startCell: Cell, endCell: Cell, setMaze: (arr: Cell[][]) => void) {
+    initialiseAllWalls(maze);
+
+    let stack = [maze[1][1]];
+    maze[1][1].wall = false;
+
+    while (stack.length > 0) {
+        let current = stack[stack.length - 1];
+        let neighbors = getNeighbors(maze, current).filter(n => n.wall);
+
+        if (neighbors.length > 0) {
+            let next = neighbors[Math.floor(Math.random() * neighbors.length)];
+            stack.push(next);
+
+            // Remove the wall between the current cell and the chosen neighbor
+            const midRow = current.row + (next.row - current.row) / 2;
+            const midCol = current.col + (next.col - current.col) / 2;
+            maze[midRow][midCol].wall = false;
+
+            // Mark the chosen neighbor as part of the maze
+            next.wall = false;
+        } else {
+            stack.pop();
+        }
+    }
+
+    maze[startCell.row][startCell.col].wall = false;
+    maze[endCell.row][endCell.col].wall = false;
+    setMaze([...maze]);
+}

src/algorithms/mazes/PrimsMazeGeneration.ts

@@ -0,0 +1,88 @@
+import { Cell } from '../utils/PathfindingUtils';
+
+type Maze = Cell[][];
+
+function isInsideMaze(maze: Maze, row: number, col: number): boolean {
+    return row > 0 && row < maze.length -1  && col > 0 && col < maze[0].length -1;
+}
+
+function getWalls(maze: Maze, row: number, col: number): [number, number][] {
+    const frontier: [number, number][] = [];
+    if (isInsideMaze(maze, row - 2, col) && maze[row - 2][col].wall) {
+        frontier.push([row - 2, col]);
+    }
+    if (isInsideMaze(maze, row + 2, col) && maze[row + 2][col].wall) {
+        frontier.push([row + 2, col]);
+    }
+    if (isInsideMaze(maze, row, col - 2) && maze[row][col - 2].wall) {
+        frontier.push([row, col - 2]);
+    }
+    if (isInsideMaze(maze, row, col + 2) && maze[row][col + 2].wall) {
+        frontier.push([row, col + 2]);
+    }
+    return frontier;
+}
+
+function getNeighbors(maze: Maze, row: number, col: number): [number, number][] {
+    const neighbors: [number, number][] = [];
+    if (isInsideMaze(maze, row - 2, col) && !maze[row - 2][col].wall) {
+        neighbors.push([row - 2, col]);
+    }
+    if (isInsideMaze(maze, row + 2, col) && !maze[row + 2][col].wall) {
+        neighbors.push([row + 2, col]);
+    }
+    if (isInsideMaze(maze, row, col - 2) && !maze[row][col - 2].wall) {
+        neighbors.push([row, col - 2]);
+    }
+    if (isInsideMaze(maze, row, col + 2) && !maze[row][col + 2].wall) {
+        neighbors.push([row, col + 2]);
+    }
+    return neighbors;
+}
+
+function initialiseAllWalls(maze: Maze): void {
+    for (let row = 0; row < maze.length; row++) {
+        for (let col = 0; col < maze[row].length; col++) {
+            maze[row][col].wall = true;
+        }
+    }
+}
+
+function connectCells(maze: Maze, cell1: { row: number, col: number }, cell2: { row: number, col: number }): void {
+    const betweenRow = Math.floor((cell1.row + cell2.row) / 2);
+    const betweenCol = Math.floor((cell1.col + cell2.col) / 2);
+    maze[betweenRow][betweenCol].wall = false;
+}
+
+export function primsMazeGeneration(maze: Maze, startCell: Cell, endCell: Cell, setMaze: (arr: Maze) => void): void {
+    if (maze.length < 3 || maze[0].length < 3) {
+        return;
+    }
+    initialiseAllWalls(maze);
+    maze[1][1].wall = false;
+
+    let frontier = getWalls(maze, 1,1);
+
+    while (frontier.length > 0) {
+        const randomIndex = Math.floor(Math.random() * frontier.length);
+        const [row, col] = frontier[randomIndex];
+        frontier.splice(randomIndex, 1);
+
+        const neighbors = getNeighbors(maze, row, col);
+        if (neighbors.length > 0) {
+            const [neighborRow, neighborCol] = neighbors[Math.floor(Math.random() * neighbors.length)];
+            maze[row][col].wall = false;
+            connectCells(maze, { row, col }, { row: neighborRow, col: neighborCol });
+
+            const newFrontier = getWalls(maze, row, col);
+            for (const cell of newFrontier) {
+                if (!frontier.some(([fr, fc]) => fr === cell[0] && fc === cell[1])) {
+                    frontier.push(cell);
+                }
+            }
+        }
+    }   
+    maze[startCell.row][startCell.col].wall = false;
+    maze[endCell.row][endCell.col].wall = false;
+    setMaze([...maze]);
+}

src/algorithms/pathfinding/BreadthFirstSearch.ts

@@ -1,33 +1,33 @@
-import { Cell } from "../utils/PathfindingUtils";
+import { Cell, getNeighbors, getOptimalPath } from "../utils/PathfindingUtils";
+import { sleep } from '../utils/SleepTime';
 
 // Define a function to perform breadth-first search on the maze
-export function BreadthFirstSearch(maze: Cell[][], startCell: Cell, endCell: Cell): boolean[][] | null {
+export async function BreadthFirstSearch(maze: Cell[][], startCell: Cell, endCell: Cell, setMaze: (arr: Cell[][]) => void ): Promise<Cell[] | null> {
     const queue: Cell[] = [];
     const visited: boolean[][] = [];
 
     // Initialize the visited array
     for (let row = 0; row < maze.length; row++) {
         visited[row] = [];
         for (let col = 0; col < maze[row].length; col++) {
-            visited[row][col] = true;
+            visited[row][col] = false;
         }
     }
 
     // Add the start cell to the queue
     queue.push(startCell);
     visited[startCell.row][startCell.col] = true;
+    maze[startCell.row][startCell.col].visited = true;
 
     // Perform breadth-first search
     while (queue.length > 0) {
         const currentCell = queue.shift();
-
         if (!currentCell) {
             continue;
         }
-
         // Check if we have reached the end cell
         if (currentCell.row === endCell.row && currentCell.col === endCell.col) {
-            return visited;
+            return getOptimalPath(maze, startCell, endCell);
         }
 
         // Get the neighbors of the current cell
@@ -38,38 +38,14 @@ export function BreadthFirstSearch(maze: Cell[][], startCell: Cell, endCell: Cel
             if (!visited[neighbor.row][neighbor.col]) {
                 queue.push(neighbor);
                 visited[neighbor.row][neighbor.col] = true;
+                maze[neighbor.row][neighbor.col].visited = true;
+                maze[neighbor.row][neighbor.col].prev = currentCell;
             }
         }
+        await sleep(10);
+        setMaze([...maze]);
     }
 
     // If we reach here, there is no path from start to end
     return null;
-}
-
-// Define a function to get the neighbors of a cell
-function getNeighbors(maze: Cell[][], cell: Cell): Cell[] {
-    const neighbors: Cell[] = [];
-    const { row, col } = cell;
-
-    // Check the top neighbor
-    if (row > 0 && !maze[row - 1][col].wall) {
-        neighbors.push(maze[row - 1][col]);
-    }
-
-    // Check the right neighbor
-    if (col < maze[row].length - 1 && !maze[row][col + 1].wall) {
-        neighbors.push(maze[row][col + 1]);
-    }
-
-    // Check the bottom neighbor
-    if (row < maze.length - 1 && !maze[row + 1][col].wall) {
-        neighbors.push(maze[row + 1][col]);
-    }
-
-    // Check the left neighbor
-    if (col > 0 && !maze[row][col - 1].wall) {
-        neighbors.push(maze[row][col - 1]);
-    }
-
-    return neighbors;
 }

src/algorithms/pathfinding/DepthFirstSearch.ts

@@ -0,0 +1,64 @@
+import { Cell, getOptimalPath } from '../utils/PathfindingUtils';
+import { sleep } from '../utils/SleepTime';
+
+export async function DepthFirstSearch(maze: Cell[][], startCell: Cell, endCell: Cell, setMaze: (arr: Cell[][]) => void ): Promise<Cell[] | null> {
+    const stack: Cell[] = [];
+    const visited: boolean[][] = [];
+    for (let row = 0; row < maze.length; row++) {
+        visited[row] = [];
+        for (let col = 0; col < maze[row].length; col++) {
+            visited[row][col] = false;
+        }
+    }
+
+    stack.push(startCell);
+    visited[startCell.row][startCell.col] = true;
+    maze[startCell.row][startCell.col].visited = true;
+
+    while (stack.length > 0) {
+        const currentCell = stack.pop();
+        if (!currentCell) {
+            continue;
+        }
+
+        currentCell.visited = true;
+        
+        if (currentCell.row === endCell.row && currentCell.col === endCell.col) {
+            return getOptimalPath(maze, startCell, endCell);
+        }
+
+        let neighbors = getNeighbors(maze, currentCell);
+
+        for (let neighbor of neighbors) {
+            if (neighbor.visited) {
+                continue;
+            }
+            neighbor.prev = currentCell;
+            stack.push(neighbor);
+        }
+        await sleep(10);
+        setMaze([...maze]);
+    }
+
+    return null;
+}
+
+export function getNeighbors(cells: Cell[][], cell: Cell): Cell[] {
+    const neighbors: Cell[] = [];
+    const { row, col } = cell;
+    
+    if (row > 0 && !cells[row - 1][col].wall) {
+        neighbors.push(cells[row - 1][col]);
+    }
+    if (col > 0 && !cells[row][col - 1].wall) {
+        neighbors.push(cells[row][col - 1]);
+    }
+    if (row < cells.length - 1 && !cells[row + 1][col].wall) {
+        neighbors.push(cells[row + 1][col]);
+    }
+    if (col < cells[0].length - 1 && !cells[row][col + 1].wall) {
+        neighbors.push(cells[row][col + 1]);
+    }
+    
+    return neighbors;
+}

src/algorithms/pathfinding/Dijkstra.ts

@@ -0,0 +1,44 @@
+import { Cell, getNeighbors} from '../utils/PathfindingUtils';
+import { sleep } from '../utils/SleepTime';
+
+export async function Dijkstra(cells: Cell[][], startCell: Cell, endCell: Cell, setMaze: (arr: Cell[][]) => void ): Promise<Cell[]> {
+    const queue: Cell[] = [];
+    startCell.visited = true;
+    queue.push(startCell);
+
+    while (queue.length > 0) {
+        const currentCell = queue.shift()!;
+        if (currentCell === endCell) {
+            return getPath(endCell);
+        }
+
+        const neighbors = getNeighbors(cells, currentCell);
+        for (const neighbor of neighbors) {
+            const newDistance = currentCell.distance + 1;
+            if (!neighbor.visited || newDistance < neighbor.distance) {
+                neighbor.distance = newDistance;
+                neighbor.prev = currentCell;
+                if (!neighbor.visited) {
+                    neighbor.visited = true;
+                    queue.push(neighbor);
+                }
+            }
+        }
+        await sleep(10);
+        setMaze([...cells]);
+    }
+
+    return [];
+}
+
+function getPath(endCell: Cell): Cell[] {
+    const path: Cell[] = [];
+    let currentCell: Cell | null = endCell;
+
+    while (currentCell !== null) {
+        path.unshift(currentCell);
+        currentCell = currentCell.prev;
+    }
+
+    return path;
+}