public static void Apply(MazeModel mazeData)
{
if (DifficultyModel.Instance().hidersCount == 0)
{
return;
}
for (int i = 0; i < mazeData.deadEnds.Count; i++)
{
if (i >= DifficultyModel.Instance().hidersCount)
{
break;
}
int distance = (int)mazeData.deadEnds [i].GetDistance();
if (distance < 4)
{
return;
}
int showIndex = _rnd.Next((int)distance / 4, (int)distance / 2);
int hideIndex = _rnd.Next(showIndex + 2, showIndex + (int)Math.Min((int)(distance / 2), 8));
NodeVO node = mazeData.deadEnds [i].previousNode;
int index = 0;
while (node != null)
{
index++;
if (index == showIndex)
{
node.AddFlag(NodeVO.SPECIALS_SHOW_WALLS);
}
if (index == hideIndex)
{
node.AddFlag(NodeVO.SPECIALS_HIDE_WALLS);
}
node = node.previousNode;
}
}
}
public void Recreate(int size, int startX, int startY)
{
this.size = size;
_data = new NodeVO[size * size];
deadEnds = new List <NodeVO> ();
crossRoads = new List <NodeVO> ();
for (int j = 0; j < size; j++)
{
for (int i = 0; i < size; i++)
{
_data [i + j * size] = new NodeVO(i, j);
}
}
//1. get starting point
startingNode = GetNode(startX, startY);
startingNode.AddFlag(NodeVO.PROCESSED);
//2. init edge nodes from its neighbours
List <NodeVO> edgeNodes = GetNotProcessedNeighboursOf(startingNode);
foreach (NodeVO nodeData in edgeNodes)
{
Link(startingNode, nodeData);
}
//3. create branches from edge nodes
while (edgeNodes.Count > 0)
{
//3.1 find a random edge node and remove it from array
int idx = _rnd.Next(0, edgeNodes.Count);
NodeVO edgeNode = edgeNodes [idx];
edgeNodes.RemoveAt(idx);
if (!edgeNode.HasFlag(NodeVO.PROCESSED))
{
//3.2 attach it to current tree
NodeVO processedNeighbour = GetRandomNeighbour(edgeNode, true);
if (processedNeighbour != null)
{
Merge(processedNeighbour, edgeNode);
Link(processedNeighbour, edgeNode);
if (!crossRoads.Contains(processedNeighbour))
{
crossRoads.Add(processedNeighbour);
}
}
//3.3 create the branch
CreateBranch(edgeNode, edgeNodes);
}
}
}
private void CreateBranch(NodeVO startNode, List <NodeVO> edgeNodes)
{
NodeVO randomNeighbour;
NodeVO currentNode = startNode;
do
{
//1. if node exists in edge nodes, remove it
if (edgeNodes.Contains(currentNode))
{
edgeNodes.Remove(currentNode);
}
//1.1 append new edge nodes
List <NodeVO> notProcessedNeighbours = GetNotProcessedNeighboursOf(currentNode);
foreach (NodeVO nodeData in notProcessedNeighbours)
{
if (!edgeNodes.Contains(nodeData))
{
edgeNodes.Add(nodeData);
}
}
currentNode.AddFlag(NodeVO.PROCESSED);
//2. go to random direction and get a neighbour
randomNeighbour = GetRandomNeighbour(currentNode, false);
//3. if it exists (didn't got a dead end) - expand the maze
if (randomNeighbour != null)
{
Link(currentNode, randomNeighbour);
//3.1 attach it to tree
Merge(currentNode, randomNeighbour);
//3.2 process it on next loop entry
currentNode = randomNeighbour;
}
else
{
if (deadEnds.Count > 0 && (currentNode.GetDistance() > deadEnds [0].GetDistance()))
{
deadEnds.Insert(0, currentNode);
}
else
{
deadEnds.Add(currentNode);
}
}
} while (randomNeighbour != null);
}
