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); }