24: Generating maze using depth-first

Author: Morasiu

challenges/24_Maze/Maze.cs

@@ -1,18 +1,35 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
 
 class Maze {
+  private const string WallWithLeftSideEmpty = "    ";
+
+  private delegate void Go();
+
+  private const string WallWithLeftSideEmptyAndCursor = "  ■ ";
+
+  private const string WallWithLeftSideFull = "|   ";
+
+  private const string WallWithLeftSideFullAndCursor = "| ■ ";
 
-  private const string WallWithLeftSideEmpty = "=   ";
-  private const string WallWithLeftSideFull =  "|   ";
   private const string FloorWithHole = "+   ";
+
   private const string FloorWithoutHole = "+---";
+
   private const string WallEnd = "|\n";
-  private const string WallEndWithExit = "=\n";
+
+  private const string WallEndWithExit = " \n";
+
   private const string FloorCorner = "+\n";
+
   private static Cell[][] _maze;
 
-  static void Main(string[] args){
+  private static (int, int) _cursor;
+
+
+  static void Main(string[] args) {
     Console.ForegroundColor = ConsoleColor.Green;
     Console.CursorVisible = false;
     Console.Title = "Maze";
@@ -68,39 +85,174 @@ private static void GenerateMaze(bool showAnimation) {
     Console.WriteLine("Generating maze " + width + "x" + height);
     GenerateEmptyMaze(width, height);
 
-    MazeGeneratingAlgorithm();
+    MazeGeneratingAlgorithm(showAnimation);
 
-    PrintMaze();
+    PrintMaze(false);
+    Console.WriteLine("Press any key to Quit");
     Console.ReadKey();
   }
 
-  private static void MazeGeneratingAlgorithm() {
+  private static void MazeGeneratingAlgorithm(bool showAnimation) {
+    var random = new Random();
     // Starting point at (0, 0)
     _maze[0][0].Left = true;
-    var cursor = (0, 0);
+
+    // Pick random place (why not?)
+    _cursor = (random.Next(0, _maze.Length), random.Next(0, _maze[0].Length));
+    _maze[_cursor.Item1][_cursor.Item2].Visited = true;
+
+    // Add first item to stack
     var logStack = new Stack<(int, int)>();
+    logStack.Push(_cursor);
+    
+    // Delegate to store method. I just wanted to try it...
+    Go go = null;
+
     // Depth-first search algorithm
 
     do {
-      _maze[cursor.Item1][cursor.Item2].Visited = true;
-      logStack.Push(cursor);
-
-      if (IsDeadEnd(cursor)) {
+      if (IsDeadEnd(_cursor)) {
+        if (logStack.Count <= 1) break;
         logStack.Pop();
-        if(logStack.Count == 0) break;
+        _cursor = logStack.Peek();
+        if (showAnimation) {
+          Thread.Sleep(100);
+          PrintMaze(true);
+        }
+        continue;
       }
 
+      if (IsBottomCellNotVisited(_cursor))
+        go += GoBottom;
+      
+      if (IsTopCellNotVisited(_cursor))
+        go += GoTop;
+
+      if (IsLeftCellNotVisited(_cursor))
+        go += GoLeft;
+
+      if (IsRightCellNotVisited(_cursor))
+        go += GoRight;
+
+      go = (Go) go.GetInvocationList()[random.Next(0, go.GetInvocationList().Length)];
+      go();
+      go = null;
+      logStack.Push(_cursor);
+      if (showAnimation) {
+        Thread.Sleep(300);
+        PrintMaze(true);
+      }
 
+    } while (logStack.Count > 0);
 
-    } while (cursor.Equals((0, 0)));
+    // Exit at bottom right corner
+    _maze[_maze.Length - 1][_maze[0].Length - 1].Right = true;
+  }
+  private static void GoBottom() {
+    _maze[_cursor.Item1][_cursor.Item2].Bottom = true;
+    _cursor.Item1 += 1;
+    _cursor.Item2 += 0;
+    _maze[_cursor.Item1][_cursor.Item2].Visited = true;
+    _maze[_cursor.Item1][_cursor.Item2].Top = true;
+  }  
+  
+  private static void GoTop() {
+    _maze[_cursor.Item1][_cursor.Item2].Top = true;
+    _cursor.Item1 += -1;
+    _cursor.Item2 += 0;
+    _maze[_cursor.Item1][_cursor.Item2].Visited = true;
+    _maze[_cursor.Item1][_cursor.Item2].Bottom = true;
+  }
 
+  private static void GoLeft() {
+    _maze[_cursor.Item1][_cursor.Item2].Left = true;
+    _cursor.Item1 += 0;
+    _cursor.Item2 += -1;
+    _maze[_cursor.Item1][_cursor.Item2].Visited = true;
+    _maze[_cursor.Item1][_cursor.Item2].Right = true;
+  }
 
-    // Exit at bottom right corner
-    _maze[_maze.Length-1][_maze[0].Length-1].Right = true;
+  private static void GoRight() {
+    _maze[_cursor.Item1][_cursor.Item2].Right = true;
+    _cursor.Item1 += 0;
+    _cursor.Item2 += 1;
+    _maze[_cursor.Item1][_cursor.Item2].Visited = true;
+    _maze[_cursor.Item1][_cursor.Item2].Left = true;
   }
 
-  private static bool IsDeadEnd((int, int) cursor) {
+  private static void PrintMaze(bool printCursor) {
+    Console.Clear();
+    PrintTitle();
+
+    //+---+
+    //|   | 1x1 block
+    //+---+
+
+    var board = "";
+    // Add first line
+    board = AddOneLine(board);
+
+    // Crate one maze in one string
+    for (var row = 0; row < _maze.Length; row++) {
+      for (var k = 1; k <= 2; k++) {
+        for (var column = 0; column < _maze[row].Length; column++) {
+          board = AddMazeFragment(printCursor, board, row, k, column);
+        }
+        board = AddEndLines(board, k, row);
+      }
+    }
+
+    // Print maze
+    Console.WriteLine(board);
+  }
+
+  private static string AddMazeFragment(bool printCursor, string board, int row, int k, int column) {
+    if (ShouldPrintVertical(k)) {
+      board = AddWall(printCursor, board, row, column);
+    } else {
+      board = AddFloor(board, row, column);
+    }
+
+    return board;
+  }
+
+  private static string AddWall(bool printCursor, string board, int row, int column) {
+    if (ShouldPrintWall(row, column))
+      board = AddWallWithFullSideAndCursor(printCursor, board, row, column);
+    else {
+      board = AddWallWithFullSide(printCursor, board, row, column);
+    }
 
+    return board;
+  }
+
+  private static string AddFloor(string board, int row, int column) {
+    if (ShouldPrintFloor(row, column))
+      board += FloorWithoutHole;
+    else {
+      board += FloorWithHole;
+    }
+
+    return board;
+  }
+
+  private static string AddWallWithFullSide(bool printCursor, string board, int row, int column) {
+    if (printCursor && CursorIsAtPosition(row, column))
+      board += WallWithLeftSideEmptyAndCursor;
+    else
+      board += WallWithLeftSideEmpty;
+    return board;
+  }
+
+  private static string AddWallWithFullSideAndCursor(bool printCursor, string board, int row, int column) {
+    if (printCursor && CursorIsAtPosition(row, column))
+      board += WallWithLeftSideFullAndCursor;
+    else
+      board += WallWithLeftSideFull;
+    return board;
+  }
+
+  private static bool IsDeadEnd((int, int) cursor) {
     // Cell that has no unvisited neighbors being considered a dead-end ~ Wikipedia
 
     // cursor.Item1 - Row (Y)
@@ -117,7 +269,7 @@ private static bool IsDeadEnd((int, int) cursor) {
     }
 
     // Left
-    if (IsLeftCellNotVisisted(cursor)) {
+    if (IsLeftCellNotVisited(cursor)) {
       return false;
     }
 
@@ -133,7 +285,7 @@ private static bool IsRightCellNotVisited((int, int) cursor) {
     return IsCellOnRight(cursor) && !_maze[cursor.Item1][cursor.Item2 + 1].Visited;
   }
 
-  private static bool IsLeftCellNotVisisted((int, int) cursor) {
+  private static bool IsLeftCellNotVisited((int, int) cursor) {
     return IsCellOnLeft(cursor) && !_maze[cursor.Item1][cursor.Item2 - 1].Visited;
   }
 
@@ -146,19 +298,19 @@ private static bool IsTopCellNotVisited((int, int) cursor) {
   }
 
   private static bool IsCellOnRight((int, int) cursor) {
-    return cursor.Item2 + 1 <= _maze[0].Length;
+    return cursor.Item2 + 1 < _maze[0].Length;
   }
 
   private static bool IsCellOnLeft((int, int) cursor) {
-    return cursor.Item2 - 1 > 0;
+    return cursor.Item2 - 1 >= 0;
   }
 
   private static bool IsCellBelowCursor((int, int) cursor) {
-    return cursor.Item1 + 1 <= _maze.Length;
+    return cursor.Item1 + 1 < _maze.Length;
   }
 
   private static bool IsCellAboveCursor((int, int) cursor) {
-    return cursor.Item1 - 1 > 0;
+    return cursor.Item1 - 1 >= 0;
   }
 
   private static bool CursorIsCorrect((int, int) cursor) {
@@ -168,41 +320,8 @@ private static bool CursorIsCorrect((int, int) cursor) {
            cursor.Item2 + 1 < _maze[0].Length;
   }
 
-  private static void PrintMaze() {
-    Console.Clear();
-    PrintTitle();
-    
-    //+---+
-    //|   | 1x1 block
-    //+---+
-
-    var board = "";
-    // Add first line
-    board = AddOneLine(board);
-
-    // Add all maze
-    for (var row = 0; row < _maze.Length; row++) {
-      for (var k = 1; k <= 2; k++) {
-        for (var column = 0; column < _maze[row].Length; column++) {
-          if (ShouldPrintVertical(k)) {
-            if (ShouldPrintWall(row, column))
-              board += WallWithLeftSideFull;
-            else {
-              board += WallWithLeftSideEmpty;
-            }
-          } else {
-            if (ShouldPrintFloor(row, column))
-              board += FloorWithoutHole;
-            else {
-              board += FloorWithHole;
-            }
-          }
-        }
-        board = AddEndLines(board, k, row);
-      }
-    }
-    // Print maze
-    Console.WriteLine(board);
+  private static bool CursorIsAtPosition(int row, int column) {
+    return _cursor.Item1 == row && _cursor.Item2 == column;
   }
 
   private static bool ShouldPrintFloor(int row, int column) {
@@ -215,7 +334,7 @@ private static bool ShouldPrintWall(int row, int column) {
 
   private static string AddEndLines(string board, int k, int row) {
     if (ShouldPrintVertical(k)) {
-      if (_maze[row][_maze.Length-1].Right) {
+      if (_maze[row][_maze[0].Length - 1].Right) {
         board += WallEndWithExit;
       } else {
         board += WallEnd;
@@ -253,7 +372,7 @@ private static void GenerateEmptyMaze(int width, int height) {
   private static int GetWidthFromPlayer() {
     int width;
     Console.Write("\bEnter width: ");
-    while (!int.TryParse(Console.ReadLine(), out width) || width < 2 || width > 100) {
+    while (!int.TryParse(Console.ReadLine(), out width) || width < 1 || width > 100) {
       Console.WriteLine("Wrong value");
       Console.Write("\bEnter width: ");
     }
@@ -264,7 +383,7 @@ private static int GetWidthFromPlayer() {
   private static int GetHeightFromPlayer() {
     int height;
     Console.Write("\bEnter height: ");
-    while (!int.TryParse(Console.ReadLine(), out height) || height < 2  || height > 100) {
+    while (!int.TryParse(Console.ReadLine(), out height) || height < 1 || height > 100) {
       Console.WriteLine("Wrong value");
       Console.Write("\bEnter height: ");
     }