public void RenderStep(MazeGenerationResults results)
{
if (RenderEveryStep || results.ResultsType == GenerationResultsType.GenerationCompleted)
{
InstantMapRenderer.RenderMap();
}
}
public void RenderStep(MazeGenerationResults results)
{
foreach (var renderer in Renderers)
{
renderer?.RenderStep(results);
}
}
public override void RenderStep(MazeGenerationResults results)
{
Polygons = new List <ColoredPolygon>();
base.RenderStep(results);
var allPoints = Polygons.SelectMany(x => x.Points).ToArray();
var commonPolygon = new Polygon(allPoints);
var boundingRectangle = commonPolygon.GetBoundingRectangle();
var bmp = new Bitmap(boundingRectangle.Width, boundingRectangle.Height);
var graphics = Graphics.FromImage(bmp);
foreach (var polygon in Polygons)
{
var adjustedPoints = polygon.Points.Select(x => new System.Drawing.Point(x.X - boundingRectangle.X, x.Y - boundingRectangle.Y)).ToArray();
graphics.FillPolygon(Brushes[polygon.Color], adjustedPoints);
}
GifImage.AddFrame(bmp, FrameDelay, boundingRectangle.X, boundingRectangle.Y);
if (results.ResultsType == GenerationResultsType.GenerationCompleted)
{
GifImage.Complete();
GifImage.OutStream.Position = 0;
using (var fs = new FileStream(FilePath, FileMode.Create))
{
GifImage.OutStream.CopyTo(fs);
}
}
}
public override void RenderStep(MazeGenerationResults results)
{
if (RefreshAsyncResult?.IsCompleted ?? true)
{
RefreshAsyncResult = Control.BeginInvoke(new MethodInvoker(() => Control.Refresh()));
}
}
public override void RenderStep(MazeGenerationResults results)
{
base.RenderStep(results);
if (results.ResultsType == GenerationResultsType.GenerationCompleted && SaveImageOnCompletion)
{
SaveImage(false);
}
}
protected void ChangeCell(MazeGenerationResults results, Point point, ICell cell, CellState state, CellDisplayState displayState)
{
cell.State = state;
cell.DisplayState = displayState;
var result = new MazeGenerationResult(point, state, displayState);
results?.Add(result);
}
protected void RenderResults(MazeGenerationResults results)
{
foreach (var result in results.Results)
{
var displayState = result.DisplayState;
var color = Colors[displayState];
DrawCell(result.Point, color);
}
}
private void A(MazeGenerationResults results, int x, int y, CellState state = CellState.Empty, CellDisplayState displayState = CellDisplayState.Path)
{
var point = new Point(x, y);
//var cell = Map.GetCell(point);
//cell.State = state;
//cell.DisplayState = displayState;
var result = new MazeGenerationResult(point, state, displayState);
results.Add(result);
}
public virtual void RenderStep(MazeGenerationResults results)
{
if (ForceRerender)
{
RenderMap();
}
else
{
RenderResults(results);
}
}
public override void RenderStep(MazeGenerationResults results)
{
base.RenderStep(results);
// TODO: fix ugly casting later.
var bmp = (Bitmap)Image;
Video.WriteVideoFrame(bmp);
if (results.ResultsType == GenerationResultsType.GenerationCompleted)
{
Video.Close();
}
}
private MazeGenerationResults CompleteTree(int treeIndex, MazeGenerationResults results)
{
var tree = RunningTrees[treeIndex];
RunningTrees.RemoveAt(treeIndex);
StoppedTrees.Add(tree);
if (RunningTrees.Count == 0)
{
// TODO: Doesn't generate a full-braid map if nothing looped into the start point before. Fix to have full-braid maps in the future.
return(new MazeGenerationResults(GenerationResultsType.GenerationCompleted));
}
return(results);
}
public override void RenderStep(MazeGenerationResults results)
{
base.RenderStep(results);
GifImage.AddFrame(Image, FrameDelay);
if (results.ResultsType == GenerationResultsType.GenerationCompleted)
{
GifImage.Complete();
GifImage.OutStream.Position = 0;
using (var fs = new FileStream(FilePath, FileMode.Create))
{
GifImage.OutStream.CopyTo(fs);
}
}
}
private MazeGenerationResults InitializeMap()
{
var results = new MazeGenerationResults();
for (var i = 1; i < Map.Size[0] - 1; i++)
{
for (var j = 1; j < Map.Size[1] - 1; j++)
{
var point = new Point(i, j);
ChangeCell(results, point, CellState.Empty, CellDisplayState.Path);
}
}
return(results);
}
private MazeGenerationResults InitializeTree(ICollection <Point> path, MazeGenerationResults results, Tree tree)
{
Point startingPoint;
ICell startingCell;
do
{
// TODO: This one is retarded. Need to think of a better way.
startingPoint = MazeGenerationUtils.PickStartingPoint(Map, RNG);
startingCell = Map.GetCell(startingPoint);
} while (startingCell.State == CellState.Empty);
path.Add(startingPoint);
ChangeCell(results, startingPoint, CellState.Empty, CellDisplayState.Path);
CellsTreeDict.Add(startingPoint, tree);
return(results);
}
public MazeGenerationResults Generate()
{
var results = new MazeGenerationResults();
var targets = new Dictionary <Point, bool>();
var offsets = new Point(new int[2]).GetAllOffsets();
foreach (var cell in InnerMap.Cells)
{
var cellNeighbors = offsets.Select(x => x + cell.Key);
foreach (var cellNeighbor in cellNeighbors)
{
var neighborIsAlive = Map.CellExists(cellNeighbor);
targets[cellNeighbor] = neighborIsAlive;
}
targets[cell.Key] = true;
}
foreach (var target in targets)
{
var targetNeighbours = offsets.Select(x => x + target.Key);
var aliveTargetNeighbours = offsets.Where(x => Map.CellExists(x));
var aliveNeighbourCount = aliveTargetNeighbours.Count();
if (target.Value) // Alive
{
if (DieIf.Contains(aliveNeighbourCount))
{
InnerMap.RemoveCell(target.Key);
results.Results.Add(new MazeGenerationResult(target.Key, CellState.Empty, CellDisplayState.Path));
}
}
else // Dead
{
if (BornIf.Contains(aliveNeighbourCount))
{
InnerMap.SetCell(new Cell(CellState.Filled, CellDisplayState.Wall), target.Key);
results.Results.Add(new MazeGenerationResult(target.Key, CellState.Filled, CellDisplayState.Wall));
}
}
}
return(results);
}
public void Awake()
{
//_generateTestCase.Run();
_mazeResults = _currentMazeHolder.Results;
_cameraManagement.Init(CameraTransform, Camera, _mazeResults.MazeJumper);
_inputHandler.Init(_cameraManagement, new InputHandlerOptions
{
MoveDown = () => {
if (_currentLevel > 0)
{
_currentLevel -= 1;
BuildUi();
}
},
MoveUp = () => {
if (_currentLevel < _mazeResults.MazeJumper.Size.Z - 1)
{
_currentLevel += 1;
BuildUi();
}
},
ToggleDeadEnds = () => {
if (_uiModeSwitcher.Mode != UiMode.Agent)
{
_modelStateHelper.SetNextModelState(_mazeResults.MazeJumper);
BuildUi();
}
},
ReturnToMazeLoading = needsRegenerating =>
{
_mazeNeedsGenerating.Generate = needsRegenerating;
_sceneLoader.LoadMazeLoader();
},
ToggleUI = () =>
{
TrySwitch();
}
});
BuildUi();
}
public TestMazeGenerator(IMap map, Random random = null) : base(map, random)
{
ResultsQueue = new Queue <MazeGenerationResults>();
//var results = new MazeGenerationResults();
MazeGenerationResults results;
results = new MazeGenerationResults();
A(results, 5, 4);
ResultsQueue.Enqueue(results);
results = new MazeGenerationResults();
A(results, 5, 5);
A(results, 5, 6);
ResultsQueue.Enqueue(results);
results = new MazeGenerationResults();
A(results, 5, 7);
A(results, 5, 8);
ResultsQueue.Enqueue(results);
results = new MazeGenerationResults();
A(results, 5, 7);
A(results, 5, 6);
ResultsQueue.Enqueue(results);
results = new MazeGenerationResults();
//A(results, 6, 6);
//A(results, 7, 6);
A(results, 5, 7);
A(results, 5, 8);
ResultsQueue.Enqueue(results);
results = new MazeGenerationResults();
A(results, 5, 9);
A(results, 5, 10);
ResultsQueue.Enqueue(results);
}
public void BuildMazeUI(Transform mazeField, MazeGenerationResults results, int z, UiMode mode)
{
mazeField.Clear();
var maze = results.MazeJumper;
switch (mode)
{
case UiMode.ShortestPath:
maze.JumpToPoint(maze.StartPoint);
foreach (var direction in results.HeuristicsResults.ShortestPathResult.ShortestPathDirections)
{
_lineDrawer.DrawLine(mazeField, maze.CurrentPoint, direction, z, LineColour.Yellow);
maze.MoveInDirection(direction);
}
break;
case UiMode.DeadEndLess:
foreach (var node in results.HeuristicsResults.ShortestPathResult.Graph.Nodes)
{
var point = node.Key;
if (point.Z == z && !_pointsAndDirectionsRetriever.PointIsStartOrEnd(point, results.MazeJumper.StartPoint, results.MazeJumper.EndPoint))
{
BuildAndAttachCircle(mazeField, "blue", point.X, point.Y);
}
maze.JumpToPoint(point);
foreach (var edge in node.Value.Edges)
{
maze.JumpToPoint(node.Key);
foreach (var direction in edge.DirectionsToPoint)
{
_lineDrawer.DrawLine(mazeField, maze.CurrentPoint, direction, z, LineColour.Blue);
maze.MoveInDirection(direction);
}
}
}
break;
case UiMode.Agent:
foreach (var directionAndPoint in results.AgentResults.Movements)
{
maze.JumpToPoint(directionAndPoint.MazePoint);
_lineDrawer.DrawLine(mazeField, maze.CurrentPoint, directionAndPoint.Direction, z, LineColour.Green);
maze.MoveInDirection(directionAndPoint.Direction);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
var points = _mazeHelper.GetForEachZ(maze.Size, z, x => x);
foreach (var point in points)
{
maze.JumpToPoint(point);
var directions = maze.GetFlagFromPoint();
BuildAndAttachCell(mazeField, directions, point.X, point.Y);
}
if (maze.StartPoint.Z == z)
{
BuildAndAttachDoor(mazeField, DoorType.Entrance, maze.StartPoint.X, maze.StartPoint.Y);
}
if (maze.EndPoint.Z == z)
{
BuildAndAttachDoor(mazeField, DoorType.Exit, maze.EndPoint.X, maze.EndPoint.Y);
}
}
public override void RenderStep(MazeGenerationResults results)
{
base.RenderStep(results);
UpdateTarget();
}
protected void ChangeCell(MazeGenerationResults results, Point point, CellState state, CellDisplayState displayState)
{
var cell = Map.GetCell(point);
ChangeCell(results, point, cell, state, displayState);
}
public override MazeGenerationResults Generate()
{
var results = new MazeGenerationResults();
if (!Map.Infinite)
{
// TODO: Ending generation sometimes ends prematurely. Find out why and fix.
if (RemainingPoints.Count == 0)
{
results.ResultsType = GenerationResultsType.GenerationCompleted;
return(results);
}
}
if (CurrentPoint == null)
{
CurrentPoint = MazeGenerationUtils.PickStartingPoint(Map, RNG);
var cell = Map.GetCell(CurrentPoint);
cell.State = CellState.Empty;
cell.DisplayState = CellDisplayState.Path;
results.Add(new MazeGenerationResult(CurrentPoint, cell.State, cell.DisplayState));
return(results);
}
var doLooping = RNG.NextDouble() < Looping;
var offsets = CurrentPoint.GetAxisOffsets();
Point pathToCellPoint = null;
Point otherCellPoint = null;
while (offsets.Count > 0)
{
var offsetIndex = RNG.Next(0, offsets.Count);
var offset = offsets[offsetIndex];
pathToCellPoint = CurrentPoint + offset;
otherCellPoint = CurrentPoint + offset * 2;
var cellExists = Map.CellExists(otherCellPoint);
if (cellExists)
{
break;
}
offsets.RemoveAt(offsetIndex);
}
var otherCell = Map.GetCell(otherCellPoint);
var pathToCell = Map.GetCell(pathToCellPoint);
if (doLooping || otherCell.State == CellState.Filled)
{
otherCell.State = CellState.Empty;
pathToCell.State = CellState.Empty;
}
RemainingPoints.Remove(otherCellPoint);
otherCell.DisplayState = otherCell.State == CellState.Empty ? CellDisplayState.Path : CellDisplayState.Wall;
pathToCell.DisplayState = pathToCell.State == CellState.Empty ? CellDisplayState.Path : CellDisplayState.Wall;
var otherResult = new MazeGenerationResult(otherCellPoint, otherCell.State, otherCell.DisplayState);
var pathResult = new MazeGenerationResult(pathToCellPoint, pathToCell.State, pathToCell.DisplayState);
results.Results.Add(otherResult);
results.Results.Add(pathResult);
CurrentPoint = otherCellPoint;
return(results);
}
public override MazeGenerationResults Generate()
{
var results = new MazeGenerationResults();
var currentCoords = (int[])CurrentPoint.Coordinates.Clone();
currentCoords[0] += 2;
if (currentCoords[0] >= Map.Size[0])
{
currentCoords[0] = 1;
currentCoords[1] += 2;
CurrentSetLength = 0;
}
if (currentCoords[1] >= Map.Size[1])
{
results.ResultsType = GenerationResultsType.GenerationCompleted;
return(results);
}
CurrentPoint = new Point(currentCoords);
bool digHorizontal;
var useBinaryTree = RNG.NextDouble() > UseSidewinder;
//var dirX = binaryTreeValue == 0 && (NWBiasRadioButton.Checked || SWBiasRadioButton.Checked) ? -1 : 1;
//var dirY = binaryTreeValue == 0 && (SWBiasRadioButton.Checked || SEBiasRadioButton.Checked) ? 1 : -1;
var dirX = useBinaryTree && (Bias == BinaryTreeBias.NorthWest || Bias == BinaryTreeBias.SouthWest) ? -1 : 1;
var dirY = Bias == BinaryTreeBias.SouthWest || Bias == BinaryTreeBias.SouthEast ? 1 : -1;
var horizontalPoint = new Point(currentCoords[0] + dirX * 2, currentCoords[1]);
var verticalPoint = new Point(currentCoords[0], currentCoords[1] + dirY * 2);
//var canGoHorizontal = _mazeRectangle.Contains(i + dirX * 2, j);
//var canGoVertical = _mazeRectangle.Contains(i, j + dirY * 2);
var canGoHorizontal = Map.CellExists(horizontalPoint);
var canGoVertical = Map.CellExists(verticalPoint);
if (!canGoHorizontal && !canGoVertical)
{
return(results);
//continue;
}
if (canGoHorizontal && canGoVertical)
{
digHorizontal = RNG.NextDouble() * 2 - 1 > VerticalBias;
}
else
{
digHorizontal = canGoHorizontal;
}
if (digHorizontal)
{
CurrentSetLength++;
var horizontalPathPoint = new Point(currentCoords[0] + dirX, currentCoords[1]);
ChangeCell(results, horizontalPathPoint, CellState.Empty, CellDisplayState.Path);
ChangeCell(results, horizontalPoint, CellState.Empty, CellDisplayState.Path);
//_mazeMatrix[i + dirX, j] = CellState.Walkway;
//_mazeMatrix[i + dirX * 2, j] = CellState.Walkway;
}
else
{
var rand = useBinaryTree ? 0 : RNG.Next(0, CurrentSetLength) * 2;
CurrentSetLength = 1;
var verticalPathPoint = new Point(currentCoords[0] - rand, currentCoords[1] + dirY);
ChangeCell(results, verticalPathPoint, CellState.Empty, CellDisplayState.Path);
//_mazeMatrix[i - rand, j + dirY] = CellState.Walkway;
}
ChangeCell(results, CurrentPoint, CellState.Empty, CellDisplayState.Path);
//_mazeMatrix[i, j] = CellState.Walkway;
return(results);
}
public void RenderStep(MazeGenerationResults results)
{
RenderMap();
}
private void ReloadUiAndRegenerateMaze()
{
startButton.enabled = false;
restartButton.enabled = false;
regenerateButton.enabled = false;
if (_mazeNeedsGenerating.Generate)
{
_results = _generationFactory.GenerateMaze(_currentSettingsHolder.Settings);
_currentMazeHolder.Results = _results;
//var validation = _validator.EveryPointHasDirection(_currentMazeHolder.MazeJumper);
_mazeNeedsGenerating.Generate = false;
}
else
{
_results = _currentMazeHolder.Results;
}
leftPanel.Clear();
rightPanel.Clear();
var controlStrings = new List <string>()
{
"Controls",
"WASD: Move the camera",
"Z: Zoom in",
"X: Zoom out",
"C: Remove dead ends",
"ESC: Return to menu",
"V: Return to menu and regenerate maze",
"F: Toggle UI mode between shortest path, paths without dead ends, Agent pfath"
};
foreach (var controlString in controlStrings)
{
_resourceLoader.InstantiateControl <TextControl>(rightPanel).Initialize(controlString);
}
var heuristicsStrings = new List <string>()
{
"Heuristics",
string.Format("Total cells: {0}", _results.HeuristicsResults.TotalCells),
string.Format("Cells down dead end: {0}", _results.DeadEndFillerResults.TotalCellsFilledIn),
string.Format("Shortest path: {0}", _results.HeuristicsResults.ShortestPathResult.ShortestPath),
"Directions Carved"
};
var directionStats =
_results.HeuristicsResults.Stats.DirectionsUsed.Select(x => string.Format("{0} - {1}", x.Key, x.Value));
var heuristicsStrings2 = new List <string>()
{
string.Format("Model Generation Time: {0}", _timeRecorder.GetStringFromTime(_results.ModelTime)),
string.Format("Maze Generation Time: {0}", _timeRecorder.GetStringFromTime(_results.GenerationTime)),
string.Format("Dead End Filling Time: {0}", _timeRecorder.GetStringFromTime(_results.DeadEndFillerTime)),
string.Format("Agent Run Time: {0}", _timeRecorder.GetStringFromTime(_results.AgentGenerationTime)),
string.Format("Heauristics Time: {0}", _timeRecorder.GetStringFromTime(_results.HeuristicsTime)),
string.Format("Total Time: {0}", _timeRecorder.GetStringFromTime(_results.TotalTime)),
};
foreach (var heuristicsString in heuristicsStrings.Concat(directionStats).Concat(heuristicsStrings2))
{
_resourceLoader.InstantiateControl <TextControl>(leftPanel).Initialize(heuristicsString);
}
startButton.enabled = true;
restartButton.enabled = true;
regenerateButton.enabled = true;
}
public override MazeGenerationResults Generate()
{
var results = new MazeGenerationResults();
if (CurrentIteration == 0)
{
InitializeMap();
}
var treeIndex = CurrentIteration % RunningTrees.Count;
var tree = RunningTrees[treeIndex];
var path = tree.Path;
CurrentIteration++;
if (path.Count == 0)
{
return(InitializeTree(path, results, tree));
}
var doBreadth = RNG.NextDouble() < Breadth;
var doFirstChanceLooping = RNG.NextDouble() < FirstChanceLooping;
var doLastChanceLooping = RNG.NextDouble() < LastChanceLooping;
var dontGoBackAfterLooping = RNG.NextDouble() < DontGoBackAfterLooping;
var doBlocking = RNG.NextDouble() < Blocking;
var currentCoordinateIndex = doBreadth && path.Count > 1 ? RNG.Next(1, path.Count / Sparseness + 1) * Sparseness : path.Count - 1;
var currentPoint = path[currentCoordinateIndex];
var offsets = currentPoint.GetAxisOffsets();
var biases = GetCurrentOffsetProbabilities(tree.LastOffset);
var lastChanceLooping = false;
while (offsets.Count > 0)
{
var offsetIndex = PickNextDirection(biases, offsets);
var offset = offsets[offsetIndex];
var points = new List <Point>(Sparseness);
{
for (var i = 1; i <= Sparseness; i++)
{
var point = currentPoint + (offset * i);
points.Add(point);
}
}
var firstPoint = points[0];
var lastPoint = points[points.Count - 1];
var lastCellExists = Map.CellExists(lastPoint);
var testCell = lastCellExists ? Map.GetCell(lastChanceLooping ? firstPoint : lastPoint) : null;
if (testCell == null || doBlocking || (!doFirstChanceLooping && testCell.State != CellState.Filled))
{
offsets.RemoveAt(offsetIndex);
biases.RemoveAt(offsetIndex);
if (!lastChanceLooping && offsets.Count == 0)
{
offsets = currentPoint.GetAxisOffsets();
biases = Biases.ToList();
lastChanceLooping = true;
}
continue;
}
var cells = points.Select(x => Map.GetCell(x)).ToList();
var lastCell = cells[cells.Count - 1];
var wouldLoop = lastCell.State == CellState.Empty;
Tree otherTree;
var treeJoinForceConnect = CellsTreeDict.TryGetValue(lastPoint, out otherTree) && TreeTree.Connect(tree, otherTree);
if (wouldLoop)
{
if (!doLastChanceLooping && !treeJoinForceConnect)
{
break;
}
}
tree.LastOffset = offset;
if (!dontGoBackAfterLooping && LastLooped && wouldLoop)
{
// TODO: Fix going back with first chance looping.
break;
}
if (!treeJoinForceConnect && !wouldLoop)
{
CellsTreeDict.Add(lastPoint, tree);
}
LastLooped = wouldLoop;
for (var i = 0; i < points.Count; i++)
{
var point = points[i];
var cell = cells[i];
cell.State = CellState.Empty;
if (wouldLoop)
{
cell.DisplayState = CellDisplayState.Path;
}
else
{
cell.DisplayState = CellDisplayState.PathWillReturn;
path.Push(point);
}
var result = new MazeGenerationResult(point, cell.State, cell.DisplayState);
results.Add(result);
}
return(results);
}
if (path.Count <= 1)
{
return(CompleteTree(treeIndex, results));
}
if (currentCoordinateIndex != 0)
{
for (var i = 0; i < Sparseness; i++)
{
var coord = path[currentCoordinateIndex - i];
path.RemoveAt(currentCoordinateIndex - i);
var lastCell = Map.GetCell(coord);
lastCell.DisplayState = CellDisplayState.Path;
var lastResult = new MazeGenerationResult(coord, lastCell.State, lastCell.DisplayState);
results.Results.Add(lastResult);
}
}
return(results);
}
public override MazeGenerationResults Generate()
{
if (CurrentIteration++ == 0)
{
var mapInitializationResults = InitializeMap();
var pointFrom = Point.CreateSameAllDimensions(Map.Dimensions, 0);
var mapRect = new Rectangle(pointFrom + 1, Map.Size - 1);
Rectangles.Add(mapRect);
if (ShowMapInitializationStep)
{
return(mapInitializationResults);
}
}
if (CurrentRectangle == null)
{
if (Rectangles.Count != 0)
{
BeginNewRectangle();
}
else
{
return(new MazeGenerationResults(GenerationResultsType.GenerationCompleted));
}
}
var results = new MazeGenerationResults();
var offset = Vertical ? new Point(1, 0) : new Point(0, 1);
var currentPoint = LastPoint + offset;
if (!CurrentRectangle.Contains(currentPoint))
{
var rects = new List <Rectangle>
{
new Rectangle(CurrentRectangle.From, currentPoint)
};
Point path;
Point newRectFrom;
if (Vertical)
{
newRectFrom = new Point(CurrentRectangle.From[0], LastPoint[1] + 1);
var pathCoord = RNG.Next(InitialPoint[0] / 2, LastPoint[0] / 2) * 2 + 1;
path = new Point(pathCoord, InitialPoint[1]);
}
else
{
newRectFrom = new Point(LastPoint[0] + 1, CurrentRectangle.From[1]);
var pathCoord = RNG.Next(InitialPoint[1] / 2, LastPoint[1] / 2) * 2 + 1;
path = new Point(InitialPoint[0], pathCoord);
}
ChangeCell(results, path, CellState.Empty, CellDisplayState.Path);
var newRect = new Rectangle(newRectFrom, CurrentRectangle.To);
rects.Add(newRect);
var doReverseRecursionOrder = ReverseRecursionOrder > RNG.NextDouble();
if (doReverseRecursionOrder)
{
rects.Reverse();
}
foreach (var rect in rects)
{
if (rect.Size[0] > 2 || rect.Size[1] > 2)
{
if (ProcessSingleCellBlocks || (rect.Size[0] > 1 && rect.Size[1] > 1))
{
Rectangles.Add(rect);
}
}
}
CurrentRectangle = null;
}
else
{
ChangeCell(results, currentPoint, CellState.Filled, CellDisplayState.Wall);
LastPoint = currentPoint;
}
return(results);
}
public override MazeGenerationResults Generate()
{
var results = new MazeGenerationResults(GenerationResultsType.Success);
if (Walls.Count == 0)
{
results.ResultsType = GenerationResultsType.GenerationCompleted;
return(results);
}
var wall = Walls.First.Value;
Walls.RemoveFirst();
var x = 0;
var y = 0;
if (wall[0] % 2 == 0 && wall[1] % 2 == 1)
{
x = 1;
}
else if (wall[0] % 2 == 1 && wall[1] % 2 == 0)
{
y = 1;
}
var wallA = new Point(wall[0] - x, wall[1] - y);
var wallB = new Point(wall[0] + x, wall[1] + y);
var connected = Tree.AreConnected(wallA, wallB);
var loop = RNG.NextDouble() < Looping;
var wallPoint = new Point(wall[0], wall[1]);
var wallCell = Map.GetCell(wallPoint);
if (loop || !connected)
{
var sidePoint1 = new Point(wall[0] - x, wall[1] - y);
var sidePoint2 = new Point(wall[0] + x, wall[1] + y);
var sideCell1 = Map.GetCell(sidePoint1);
var sideCell2 = Map.GetCell(sidePoint2);
wallCell.State = CellState.Empty;
sideCell1.State = CellState.Empty;
sideCell2.State = CellState.Empty;
wallCell.DisplayState = CellDisplayState.Path;
sideCell1.DisplayState = CellDisplayState.Path;
sideCell2.DisplayState = CellDisplayState.Path;
results.Add(new MazeGenerationResult(wallPoint, wallCell.State, wallCell.DisplayState));
results.Add(new MazeGenerationResult(sidePoint1, sideCell1.State, sideCell1.DisplayState));
results.Add(new MazeGenerationResult(sidePoint2, sideCell2.State, sideCell2.DisplayState));
if (!connected)
{
Tree.Connect(wallA, wallB);
}
}
else
{
if (ShowAllWallChecking)
{
results.Add(new MazeGenerationResult(wallPoint, wallCell.State, wallCell.DisplayState));
}
else
{
return(Generate());
}
}
return(results);
}
