public static HashSet <Point> generateMaze(int width, int height)
{
var V = new HashSet <Point>();
var discovered = RecursiveBacktrackerAlgorithm.ReturnDict(width, height);
var maze = new HashSet <Point>();
var weights = returnWeights(discovered.Keys.ToList());
var startV = new Point(5, 3);
var currentV = startV;
discovered[startV] = true;
var r = new Random();
var mazeEntry = new Point(5, 2);
maze.Add(mazeEntry);
maze.Add(currentV);
while (true)
{
var availableVertices = Program.returnUnvisitedNeighbours(discovered, currentV);
foreach (var vertex in availableVertices.Where(vertex => !V.Contains(vertex)))
{
V.Add(vertex);
}
if (V.Count == 0)
{
break;
}
var lowestWeightVertex = ExtractMinV(V, weights);
var visitedNeighbours = returnVisitedNeighbours(discovered, lowestWeightVertex);
var newVertex = visitedNeighbours[r.Next(visitedNeighbours.Count)];
var wallV = RecursiveBacktrackerAlgorithm.pointMidPoint(newVertex, lowestWeightVertex);
maze.Add(wallV);
maze.Add(lowestWeightVertex);
currentV = lowestWeightVertex;
V.Remove(currentV);
discovered[currentV] = true;
}
var mazeExit = RecursiveBacktrackerAlgorithm.returnExit(width, height);
maze.Add(mazeExit);
return(maze);
}
public static HashSet <Point> generateMaze(int width, int height)
{
var startV = new Point(5, 3);
var currentV = startV;
var prev = startV;
var maze = new HashSet <Point>
{
new Point(5, 2),
currentV
};
var r = new Random();
var visited = RecursiveBacktrackerAlgorithm.ReturnDict(width, height);
Program.setBothColours(ConsoleColor.White);
visited[currentV] = true;
while (unvisitedVertices(visited))
{
var surroundingVertices = returnNeighbours(visited, currentV);
var temporaryVertex = surroundingVertices[r.Next(surroundingVertices.Count)];
if (!visited[temporaryVertex])
{
var wallV = RecursiveBacktrackerAlgorithm.pointMidPoint(currentV, temporaryVertex);
visited[temporaryVertex] = true;
maze.Add(wallV);
maze.Add(temporaryVertex);
}
currentV = temporaryVertex;
}
var mazeExit = RecursiveBacktrackerAlgorithm.returnExit(width, height);
maze.Add(mazeExit);
return(maze);
}
public static HashSet <Point> generateMaze(int width, int height)
{
var startV = new Point(5, 3);
var currentV = startV;
var visited = RecursiveBacktrackerAlgorithm.ReturnDict(width, height);
var maze = new HashSet <Point>();
var mazeEntry = new Point(5, 2);
maze.Add(mazeEntry);
visited[startV] = true;
maze.Add(startV);
var r = new Random();
while (unvisitedVertices(visited))
{
var availableVertices = Program.returnUnvisitedNeighbours(visited, currentV);
if (availableVertices.Count > 0)
{
var temporaryV = availableVertices[r.Next(availableVertices.Count)];
visited[temporaryV] = true;
var wallV = RecursiveBacktrackerAlgorithm.pointMidPoint(currentV, temporaryV);
maze.Add(wallV);
maze.Add(temporaryV);
currentV = temporaryV;
}
else
{
foreach (Point v in visited.Keys)
{
var visitedNeighbours = PrimsAlgorithm.returnVisitedNeighbours(visited, v);
if (visitedNeighbours.Count == 0 || visited[v])
{
continue;
}
else
{
var newVertex = visitedNeighbours[r.Next(visitedNeighbours.Count)];
var wallV = RecursiveBacktrackerAlgorithm.pointMidPoint(newVertex, v);
maze.Add(wallV);
maze.Add(v);
currentV = v;
break;
}
}
visited[currentV] = true;
}
}
var mazeExit = RecursiveBacktrackerAlgorithm.returnExit(width, height);
maze.Add(mazeExit);
return(maze);
}
public static HashSet <Point> generateMaze(int width, int height)
{
var availableVertices = RecursiveBacktrackerAlgorithm.ReturnDict(width, height).Keys.ToList();
var maze = new HashSet <Point>();
var usedVertices = new HashSet <Point>();
var weights = BoruvkasAlgorithm.returnEdgeWeights(width, height, availableVertices);
var V = BoruvkasAlgorithm.assignInitialSetNumbers(availableVertices);
var mazeEntry = new Point(5, 2);
maze.Add(mazeEntry);
//pick random edge/lowest weight edge
//combine set of connected trees IF NOT IN THE SAME SET
//remove edge
//repeat
while (!BoruvkasAlgorithm.singleSet(V))
{
foreach (Point v in availableVertices)
{
var lowestWeightEdge = BoruvkasAlgorithm.returnLowestWeightEdge(weights);
if (lowestWeightEdge.IsEmpty)
{
continue;
}
var connectedVertices = BoruvkasAlgorithm.returnNodes(availableVertices, lowestWeightEdge);
var setNumber1 = V[connectedVertices.First()];
var setNumber2 = V[connectedVertices.Last()];
if (setNumber1 != setNumber2)
{
V = BoruvkasAlgorithm.assignSetNumber(V, setNumber1, setNumber2);
weights.Remove(lowestWeightEdge);
if (!maze.Contains(connectedVertices.First()))
{
maze.Add(connectedVertices.First());
}
if (!maze.Contains(connectedVertices.Last()))
{
maze.Add(connectedVertices.Last());
}
maze.Add(lowestWeightEdge);
}
weights.Remove(lowestWeightEdge);
}
}
var mazeExit = RecursiveBacktrackerAlgorithm.returnExit(width, height);
maze.Add(mazeExit);
return(maze);
}
public static HashSet <Point> generateMaze(int width, int height)
{
var r = new Random();
var visited = RecursiveBacktrackerAlgorithm.ReturnDict(width, height);
var cameFrom = resetCameFrom(visited);
//Choose any vertex at random and add it to the UST.
//Select any vertex that is not already in the UST and perform a random walk until you encounter a vertex that is in the UST.
//Add the vertices and edges touched in the random walk to the UST.
//Repeat 2 and 3 until all vertices have been added to the UST.
var UST = new HashSet <Point>();
var currentV = visited.Keys.ToList()[r.Next(visited.Keys.Count)];
var prev = currentV;
visited[currentV] = true;
var maze = new HashSet <Point>
{
new Point(5, 2),
currentV
};
UST.Add(currentV);
currentV = getUnvisitedVertex(visited);
var firstCell = currentV;
while (unvisitedVertices(visited))
{
var surroundingVertices = returnNeighbours(visited, currentV);
var temporaryVertex = surroundingVertices[r.Next(surroundingVertices.Count)];
cameFrom[prev] = temporaryVertex;
if (UST.Contains(temporaryVertex))
{
temporaryVertex = firstCell;
var verticesToBeAdded = new List <Point>
{
temporaryVertex
};
do
{
if (!cameFrom.ContainsKey(temporaryVertex))
{
break;
}
temporaryVertex = cameFrom[temporaryVertex];
verticesToBeAdded.Add(temporaryVertex);
} while (!UST.Contains(temporaryVertex));
for (int i = 0; i < verticesToBeAdded.Count - 1; i++)
{
var v1 = verticesToBeAdded[i];
var v2 = verticesToBeAdded[i + 1];
var wall = RecursiveBacktrackerAlgorithm.pointMidPoint(v1, v2);
visited[v1] = true;
maze.Add(wall);
maze.Add(v1);
UST.Add(v1);
}
cameFrom = resetCameFrom(visited);
if (!unvisitedVertices(visited))
{
break;
}
currentV = getUnvisitedVertex(visited);
prev = currentV;
firstCell = currentV;
}
else
{
currentV = temporaryVertex;
cameFrom[prev] = currentV;
prev = currentV;
}
}
var mazeExit = RecursiveBacktrackerAlgorithm.returnExit(width, height);
maze.Add(mazeExit);
return(maze);
}
