public IActionResult Index(int size, string algo, MazeColor color)
{
int mazeSize = 15;
if (size > 0)
{
mazeSize = size;
}
IMazeAlgorithm algorithm = new RecursiveBacktracker();
if (!string.IsNullOrEmpty(algo))
{
Assembly assembly = Assembly.GetAssembly(typeof(RecursiveBacktracker));
Type algoType = assembly.GetType($"Algorithms.{algo}", false, true);
if (algoType != null)
{
algorithm = Activator.CreateInstance(algoType) as IMazeAlgorithm;
}
}
Bitmap mazeImage = Generate(mazeSize, algorithm, color);
byte[] byteArray = ConvertToByteArray(mazeImage);
return(File(byteArray, "image/png"));
}
/**
* \brief Function to generate the maze
*
* Uses the appropriate algorithm according to
* the selected option in the UI and applies it to the 2d
* array. Disposes the old maze.
*
* \return null
*/
public void GenerateNewMaze(int sizeR, int sizeC)
{
//Better mazes are produced if number of rows and columns are odd
if (sizeR % 2 == 0)
{
sizeR += 1;
}
if (sizeC % 2 == 0)
{
sizeC += 1;
}
//Destroy the old maze
DisposeOldMaze();
if (dropdown.value == 0)
{
backtracker = new RecursiveBacktracker();
data = backtracker.GenerateMaze(sizeR, sizeC);
}
else if (dropdown.value == 1)
{
prims = new Prims();
data = prims.Mazer(sizeR, sizeC);
}
else if (dropdown.value == 2)
{
krusk = new Kruskalls();
data = krusk.Mazer(sizeR, sizeC);
}
DisplayMaze();
}
void Start()
{
UIIM = GetComponent <UIInfoManager>();
BorderParent = new GameObject("BorderParent");
PointsOnThePlane = this.GetComponent <ObjectPoints>();
RB = new RecursiveBacktracker();
CreateNewMaze();
}
public void TestRecursiveBacktrackerColored()
{
var coloredGrid = new ColoredGrid(25, 25);
RecursiveBacktracker.On(coloredGrid);
coloredGrid.Distances = coloredGrid.GetCenterCell().Distances;
coloredGrid.ToBitmap().Save("recursivebacktracker-colored.png");
}
private static void PolarMaze()
{
var grid = new PolarGrid(10);
RecursiveBacktracker.Maze(grid, 0);
var img = grid.ToImg();
img.Save("polarGrid.png");
Process.Start("polarGrid.png");
}
private static void MakeTriangleDeltaMaze()
{
var grid = new TriangleGrid(11);
RecursiveBacktracker.Maze(grid, startAt: null);
var img = grid.ToImg();
img.Save("triGrid.png");
Process.Start("triGrid.png");
}
private static void ColorizeThetaMazes()
{
var grid = new ColoredPolarGrid(100);
BinaryTree.Maze(grid);
var start = grid[0, 0];
grid.Distances = start.Distances;
var img = grid.ToImg(25);
img.Save("binaryTheta.png");
grid = new ColoredPolarGrid(100);
Sidewinder.Maze(grid);
start = grid[0, 0];
grid.Distances = start.Distances;
img = grid.ToImg(25);
img.Save("sidewinderTheta.png");
grid = new ColoredPolarGrid(100);
AldousBroder.Maze(grid);
start = grid[0, 0];
grid.Distances = start.Distances;
img = grid.ToImg(25);
img.Save("aldousBroderTheta.png");
grid = new ColoredPolarGrid(100);
HuntAndKill.Maze(grid);
start = grid[0, 0];
grid.Distances = start.Distances;
img = grid.ToImg(25);
img.Save("huntAndKillTheta.png");
grid = new ColoredPolarGrid(100);
RecursiveBacktracker.Maze(grid, startAt: null);
start = grid[0, 0];
grid.Distances = start.Distances;
img = grid.ToImg(25);
img.Save("recursiveBacktrackerTheta.png");
grid = new ColoredPolarGrid(100);
Wilsons.Maze(grid);
start = grid[0, 0];
grid.Distances = start.Distances;
img = grid.ToImg(25);
img.Save("wilsonsTheta.png");
Process.Start("binaryTheta.png");
Process.Start("sidewinderTheta.png");
Process.Start("aldousBroderTheta.png");
Process.Start("huntAndKillTheta.png");
Process.Start("recursiveBacktrackerTheta.png");
Process.Start("wilsonsTheta.png");
}
public void GeneratingTwiceShouldYieldSameResult()
{
Vector2Int size = new Vector2Int(20, 20);
var mapGenerator = new RecursiveBacktracker();
var map = mapGenerator.GenerateMap(size, randomMock.Object);
string str = GridMapHelper.ToString(map);
var map2 = mapGenerator.GenerateMap(size, randomMock.Object);
string str2 = GridMapHelper.ToString(map2);
Assert.AreEqual(str, str2);
}
public void PrimsSolvableTest()
{
for (int setNumber = 0; setNumber < TEST_SET_SIZE; setNumber++)
{
PrimsAlgorithm pa = new PrimsAlgorithm();
IMazeFactory factory = pa;
ISolver solver = new RecursiveBacktracker();
Maze prismMaze = factory.generate(ROWS_COUNT, COLUMNSCOUNT);
Assert.IsTrue(solver.IsSolvable(prismMaze));
}
}
public MainViewModel()
{
Size = 20;
MazeCanvasSize = 400;
GenerateMazeCommand = new RelayCommand(GenerateMaze);
MazeGeneratorChoices = new ObservableCollection <IMazeFactory>()
{
new RecursiveBacktracker(),
new PrimsAlgorithm()
};
MazeSolver = new RecursiveBacktracker();
}
public void RecursiveBacktrackerSolvableTest()
{
for (int setNumber = 0; setNumber < TEST_SET_SIZE; setNumber++)
{
RecursiveBacktracker rb = new RecursiveBacktracker();
IMazeFactory factory = rb;
ISolver solver = rb;
Maze recursiveBacktracerMaze = factory.generate(ROWS_COUNT, COLUMNSCOUNT);
Assert.IsTrue(solver.IsSolvable(recursiveBacktracerMaze));
}
}
public void RecursiveBacktrackerGenerateTest()
{
int rowCount = 10;
int columnCount = 10;
IMazeFactory rb = new RecursiveBacktracker();
Maze maze = rb.generate(rowCount, columnCount);
Assert.IsInstanceOfType(maze, typeof(Maze));
Assert.IsNotNull(maze.Entrance);;
Assert.IsNotNull(maze.Exit);
Assert.AreEqual(rowCount, maze.RowsCount);
Assert.AreEqual(columnCount, maze.ColumnsCount);
}
public IMazeAlgorithm GetAlgorithm(string algo)
{
IMazeAlgorithm algorithm = new RecursiveBacktracker();
if (!string.IsNullOrEmpty(algo))
{
Assembly assembly = Assembly.GetAssembly(typeof(RecursiveBacktracker));
Type algoType = assembly.GetType($"maze_library.{algo}", false, true);
if (algoType != null)
{
algorithm = Activator.CreateInstance(algoType) as IMazeAlgorithm;
}
}
return(algorithm);
}
protected override void UpdateAlgorithm()
{
switch (algorithmType)
{
case Algo.BinaryTree:
MyGrid = new BinaryTree(width, height);
break;
case Algo.SideWinder:
MyGrid = new SideWinder(width, height);
break;
case Algo.AldousBroder:
MyGrid = new AldousBroder(width, height);
break;
case Algo.HuntAndKill:
MyGrid = new HuntAndKill(width, height);
break;
case Algo.RecursiveBacktracker:
MyGrid = new RecursiveBacktracker(width, height);
break;
default:
throw new ArgumentOutOfRangeException();
}
IWallInstantiable wall;
if (is3d)
{
wall = new WallPrefab3d {
WallPrefab = wallPrefab3d
}
}
;
else
{
wall = new WallPrefab2d {
WallPrefab = wallPrefab2d
}
};
GridRenderer.Instance.SetGrid(MyGrid).ParentToTransform(parent).RenderWithPrefab(wall);
MyGrid.Execute(this);
}
private static void MaskedMazes()
{
var mask = new Mask(5, 5);
mask[0, 0] = false;
mask[2, 2] = false;
mask[4, 4] = false;
var grid = new MaskedGrid(mask);
RecursiveBacktracker.Maze(grid, 0);
Console.WriteLine(grid);
var maskStr = new List <string> {
"X........X",
"....XX....",
"...XXXX...",
"....XX....",
"X........X",
"X........X",
"....XX....",
"...XXXX...",
"....XX....",
"X........X"
};
mask = Mask.FromString(maskStr);
grid = new MaskedGrid(mask);
RecursiveBacktracker.Maze(grid, 0);
Console.WriteLine(grid);
var img = grid.ToImg();
img.Save("masked.png");
Process.Start("masked.png");
mask = Mask.FromImageFile("maze_text.png");
grid = new MaskedGrid(mask);
RecursiveBacktracker.Maze(grid, 0);
img = grid.ToImg();
img.Save("masked2.png");
Process.Start("masked2.png");
}
static void Main(string[] args)
{
// Choose grid
//var grid = new Grid(15, 15); // plain grid, no annotations
//var grid = new DistanceGrid(15, 15); // "path" on text grid
//var grid = new ColoredGrid(15, 15); // heat-map on graphical grid
var grid = new ColoredDistanceGrid(15, 15); // "path" and heat-map
// Choose maze algorithm
// var maze = Sidewinder.CreateMaze(grid); // vertical bias
// var maze = BinaryTree.CreateMaze(grid); // diagonal bias
// var maze = AldousBroder.CreateMaze(grid); // non-biases (slow)
// var maze = HuntAndKill.CreateMaze(grid); // some bias (twistier paths)
var maze = RecursiveBacktracker.CreateMaze(grid); // some bias (longer paths)
// Locate "start" cell in the center (for distances)
var start = maze.GetCell(grid.Rows / 2, grid.Columns / 2);
// For text-based maze, use "Path" distance (one path)
maze.distances = start.distances().PathTo(grid.GetCell(grid.Rows - 1, 0));
// Draw text-based maze
Console.WriteLine(maze);
// For graphical maze, use all distances (heat map)
maze.distances = start.distances();
// Draw graphical maze
Bitmap img = maze.ToPng(30);
img.Save("maze.png");
// Show saved maze image
Process p = new Process();
p.StartInfo.FileName = "maze.png";
p.Start();
Console.ReadLine();
}
static void Main(string[] args)
{
Console.CursorVisible = false;
r = new Random((int)DateTime.Now.Ticks);
maze = new Maze(mazeWidth, mazeHeight);
display = new char[mazeWidth * offset, mazeHeight *offset];
Console.WriteLine("Choose a type of maze to generate:\n");
Console.WriteLine("1: Recursive Backtracker");
Console.WriteLine("2: Randomised Prim's Algorithm");
var mazeOption = Console.ReadKey().Key;
IMazeGenerator generator;
switch (mazeOption)
{
case ConsoleKey.D2:
generator = new PrimsAlgorithm(r);
break;
case ConsoleKey.D1:
default:
generator = new RecursiveBacktracker(r);
break;
}
Console.Clear();
Console.WriteLine("Choose a type of solver, if any:\n");
Console.WriteLine("0: No solver");
Console.WriteLine("1: Recursive Solver");
Console.Write("2: A* Solver");
var solverOption = Console.ReadKey().Key;
ISolver solver;
switch (solverOption)
{
case ConsoleKey.D1:
solver = new RecursiveSolver(maze);
break;
case ConsoleKey.D2:
solver = new AStar(maze);
break;
default:
solver = null;
break;
}
while (true)
{
maze.InitialiseNodes();
generator.Generate(maze);
Console.Clear();
for (int h = 0; h < mazeHeight; h++)
{
for (int w = 0; w < mazeWidth; w++)
{
WriteNodeChar(w, h, maze[(uint)w, (uint)h].Walls);
}
}
if (solver != null)
{
Random r = new Random();
NodePtr startPoint = new NodePtr((uint)maze.Width + 1, (uint)maze.Height + 1); // Purposefully not valid
NodePtr endPoint = new NodePtr((uint)maze.Width + 1, (uint)maze.Height + 1);
while (true)
{
//TODO: Probably refactor
var startPointIsValid = maze.IsPointValid(startPoint);
var endPointIsValid = maze.IsPointValid(endPoint);
if (startPointIsValid && endPointIsValid)
{
break;
}
if (!startPointIsValid)
{
startPoint = new NodePtr((uint)r.Next(maze.Width), (uint)r.Next(maze.Height));
}
if (!endPointIsValid)
{
endPoint = new NodePtr((uint)r.Next(maze.Width), (uint)r.Next(maze.Height));
}
}
var solution = solver.Solve(startPoint, endPoint);
if (solution != null)
{
WriteSolution(startPoint, endPoint, solution);
Console.WriteLine(string.Format("Solving for: Start - {0}x, {1}y; End - {2}x, {3}y",
startPoint.x, startPoint.y,
endPoint.x, endPoint.y));
}
else
{
Console.WriteLine("Cannot find a Solution.....");
}
}
DrawDisplay();
Console.WriteLine();
Console.WriteLine("Press any key to regenerate, or Escape to exit....");
if (Console.ReadKey().Key == ConsoleKey.Escape)
{
break;
}
}
}
public void TestRecursiveBacktracker()
{
var grid = new Grid(5, 5);
RecursiveBacktracker.On(grid).ToBitmap().Save("recursivebacktracker.png");
}
