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