public Direction AdjacentPointsFlag(MazePoint p, MazeSize size)
{
//return AdjacentPoints(p, size).Aggregate(Direction.None, (seed, item) => _flagParser.AddDirectionsToFlag(seed, item));
var flag = Direction.None;
if (p.X < size.X - 1)
{
flag = _flagParser.AddDirectionsToFlag(flag, Direction.Right);
}
if (p.X > 0)
{
flag = _flagParser.AddDirectionsToFlag(flag, Direction.Left);
}
if (p.Y < size.Y - 1)
{
flag = _flagParser.AddDirectionsToFlag(flag, Direction.Forward);
}
if (p.Y > 0)
{
flag = _flagParser.AddDirectionsToFlag(flag, Direction.Back);
}
if (p.Z < size.Z - 1)
{
flag = _flagParser.AddDirectionsToFlag(flag, Direction.Up);
}
if (p.Z > 0)
{
flag = _flagParser.AddDirectionsToFlag(flag, Direction.Down);
}
return(flag);
}
public IEnumerable <T> GetForEachZ <T>(MazeSize size, int z, Func <MazePoint, T> function)
{
var xValues = Enumerable.Range(0, size.X).ToList();
var yValues = Enumerable.Range(0, size.Y).ToList();
return(xValues.SelectMany(x => yValues.Select(y => _pointFactory.MakePoint(x, y, z))).Select(point => function(point)));
}
public IEnumerable <Direction> AdjacentPoints(MazePoint p, MazeSize size)
{
if (p.X < size.X - 1)
{
yield return(Direction.Right);
}
if (p.X > 0)
{
yield return(Direction.Left);
}
if (p.Y < size.Y - 1)
{
yield return(Direction.Forward);
}
if (p.Y > 0)
{
yield return(Direction.Back);
}
if (p.Z < size.Z - 1)
{
yield return(Direction.Up);
}
if (p.Z > 0)
{
yield return(Direction.Down);
}
}
public MazePoint Move(MazePoint start, MazePoint final, MazeSize size)
{
if (CanMove(start, final, size))
{
return(final);
}
throw new ArgumentException("Invalid Point to move to");
}
public void DoForEachZ(MazeSize size, int z, Action <MazePoint> action)
{
var points = GetForEachZ(size, z, x => x);
foreach (var point in points)
{
action(point);
}
}
public Maze BuildMaze(MazeSize size)
{
Maze maze = new Maze(size);
List <MazeWall> mazeWalls = new List <MazeWall>();
MazeCell current = new MazeCell()
{
X = 0, Y = Utlity.GetRandom(maze.Size - 1, DateTime.Now.Millisecond)
};
maze.StartPoint = current;
maze[current] = 1;
mazeWalls.AddRange(GetCellWalls(current));
int i = 0;
while (mazeWalls.Any())
{
int count = mazeWalls.Count;
int nextIndex = Utlity.GetRandom(count - 1, count * count + i * (i++));;
//if (!mazeWalls.Exists(mw=>mw.Cell.X != current.X || mw.Cell.Y != current.Y))
//{
// nextIndex = Utlity.GetRandom(count - 1, count * count + i * (i++));
//}else
//{
// nextIndex = mazeWalls.FindIndex(mw => mw.Cell.X != current.X || mw.Cell.Y != current.Y);
//}
var currentCell = mazeWalls[nextIndex].Cell;
var neighborCell = GetNeighborCell(mazeWalls[nextIndex], maze.Size);
if (neighborCell.HasValue)
{
var cell = neighborCell.Value;
if (maze[cell] == 0)
{
mazeWalls.AddRange(GetCellWalls(cell, mazeWalls[nextIndex].Wall));
maze[cell] = 1;
maze.AddPassage(currentCell, cell);
//mazeWalls.RemoveAll(wall => { return wall.Cell.X == currentCell.X && wall.Cell.Y == currentCell.Y; });
}
mazeWalls.RemoveAt(nextIndex);
}
else
{
mazeWalls.RemoveAt(nextIndex);
}
}
//for (i = 0; i < maze.Size; i++)
//{
// for (int j = 0; j < maze.Size; j++)
// {
// Console.Write(maze[i, j]);
// Console.Write(" ");
// }
// Console.Write("\r\n");
//}
return(maze);
}
public MazePoint Move(MazePoint start, Direction d, MazeSize size)
{
MazePoint final;
if (CanMove(start, d, size, out final))
{
return(final);
}
throw new ArgumentException("Cannot move in direction");
}
public void OneCell_PassInAInvalidCellTooHigh_CellIsInvalid()
{
//Arrange
var point = new MazePoint(1, 0, 0);
var size = new MazeSize {
Z = 1, Y = 1, X = 1
};
//Act
var valid = _pointValidity.ValidPoint(point, size);
//Assert
Assert.That(valid, Is.False);
}
public void OneCell_GetAdjacentPoints_NoneDirectionReturned()
{
//Arrange
var point = new MazePoint(0, 0, 0);
var size = new MazeSize {
Z = 1, Y = 1, X = 1
};
//Act
var direction = _movementHelper.AdjacentPointsFlag(point, size);
//Assert
Assert.That(direction, Is.EqualTo(Direction.None));
}
public void OneCell_GetAdjacentPoints_NoDirectionsReturned()
{
//Arrange
var point = new MazePoint(0, 0, 0);
var size = new MazeSize {
Z = 1, Y = 1, X = 1
};
//Act
var directions = _movementHelper.AdjacentPoints(point, size).ToList();
//Assert
Assert.That(directions.Count, Is.EqualTo(0));
}
public void TwoCells_GetAdjacentPointsToRightCell_OneDirectionsReturned()
{
//Arrange
var point = new MazePoint(1, 0, 0);
var size = new MazeSize {
Z = 1, Y = 1, X = 2
};
//Act
var directions = _movementHelper.AdjacentPoints(point, size).ToList();
//Assert
Assert.That(directions.Count, Is.EqualTo(1));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Left));
}
public void SingleRandomPoint_GenerateRandomPointFromSize_IsRandomPoint()
{
//Arrange
var size = new MazeSize
{
X = 10, Z = 11, Y = 12
};
//Act
var point = _randomPoint.RandomPoint(size, PickType.Random);
//Assert
Assert.That(point.X, Is.InRange(1, 10));
Assert.That(point.Z, Is.InRange(1, 11));
Assert.That(point.Y, Is.InRange(1, 12));
}
public MazeCell[,,] Build(MazeSize size)
{
var maze = new MazeCell[size.X, size.Y, size.Z];
var xValues = Enumerable.Range(0, size.X).ToList();
var yValues = Enumerable.Range(0, size.Y).ToList();
var zValues = Enumerable.Range(0, size.Z).ToList();
foreach (var point in xValues.SelectMany(x => yValues.SelectMany(y => zValues.Select(z => _pointFactory.MakePoint(x, y, z)))))
{
maze[point.X, point.Y, point.Z] = new MazeCell
{
Directions = Direction.None
};
}
return(maze);
}
public void EightCells_GetAdjacentPointsToRightUpForwardCell_ThreeDirectionsReturned()
{
//Arrange
var point = new MazePoint(1, 1, 1);
var size = new MazeSize {
Z = 2, Y = 2, X = 2
};
//Act
var directions = _movementHelper.AdjacentPoints(point, size).ToList();
//Assert
Assert.That(directions.Count, Is.EqualTo(3));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Left));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Down));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Back));
}
public Maze BuildMaze(MazeSize size)
{
Maze maze = new Maze(size);
var mazeStack = new Stack <MazeCell>();
MazeCell current = new MazeCell()
{
X = 0, Y = Utlity.GetRandom(maze.Size - 1, DateTime.Now.Millisecond)
};
maze.StartPoint = current;
int step = 1;
maze[current] = step++;
mazeStack.Push(current);
while (mazeStack.Count > 0)
{
var neighbors = maze.GetNeighbors(current);
if (neighbors != null && neighbors.Count > 0)
{
mazeStack.Push(current);
step = maze[current];
var start = current;
current = neighbors[Utlity.GetRandom(neighbors.Count, current.X * current.X + current.Y * current.Y)];
maze[current] = 1;
mazeStack.Push(current);
maze.AddPassage(start, current);
}
else
{
current = mazeStack.Pop();
}
}
//for (int i = 0; i < maze.Size; i++)
//{
// for (int j = 0; j < maze.Size; j++)
// {
// Console.Write(maze[i, j]);
// Console.Write(" ");
// }
// Console.Write("\r\n");
//}
return(maze);
}
public bool ValidPoint(MazePoint p, MazeSize size)
{
if (p.X < 0 || p.X > size.X - 1)
{
return(false);
}
if (p.Y < 0 || p.Y > size.Y - 1)
{
return(false);
}
if (p.Z < 0 || p.Z > size.Z - 1)
{
return(false);
}
return(true);
}
public void TwentySevenCells_GetAdjacentPointsToCentreCell_SixDirectionsReturned()
{
//Arrange
var point = new MazePoint(1, 1, 1);
var size = new MazeSize {
Z = 3, Y = 3, X = 3
};
//Act
var directions = _movementHelper.AdjacentPoints(point, size).ToList();
//Assert
Assert.That(directions.Count, Is.EqualTo(6));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Left));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Right));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Forward));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Back));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Up));
Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Down));
}
public void TwentySevenCells_GetAdjacentPointsToCentreCell_AllDirectionReturned()
{
//Arrange
_flagParser.Setup(x => x.AddDirectionsToFlag(It.IsAny <Direction>(), It.IsAny <Direction>())).Returns(
(Direction seed, Direction d) =>
{
var flag = seed | d;
return(flag);
});
var point = new MazePoint(1, 1, 1);
var size = new MazeSize {
Z = 3, Y = 3, X = 3
};
//Act
var direction = _movementHelper.AdjacentPointsFlag(point, size);
//Assert
Assert.That(direction, Is.EqualTo(Direction.All));
}
public void HundredRandomPoint_GenerateRandomPointsFromSize_IsRandomPoint()
{
//Arrange
var size = new MazeSize
{
X = 10,
Z = 11,
Y = 12
};
//Act
var points = Enumerable.Range(0, 100).Select(x => _randomPoint.RandomPoint(size, PickType.Random));
//Assert
foreach (var point in points)
{
Assert.That(point.X, Is.InRange(0, 9));
Assert.That(point.Z, Is.InRange(0, 10));
Assert.That(point.Y, Is.InRange(0, 11));
}
}
public MazePoint RandomPoint(MazeSize size, PickType type)
{
var x = _randomValueGenerator.GetNext(0, size.X - 1);
var y = _randomValueGenerator.GetNext(0, size.Y - 1);
var z = _randomValueGenerator.GetNext(0, size.Z - 1);
if (type == PickType.RandomEdge)
{
switch ((RandomEdgeOptions)_randomValueGenerator.GetNext(1, 6))
{
case RandomEdgeOptions.MinX:
x = 0;
break;
case RandomEdgeOptions.MaxX:
x = size.X - 1;
break;
case RandomEdgeOptions.MinY:
y = 0;
break;
case RandomEdgeOptions.MaxY:
y = size.Y - 1;
break;
case RandomEdgeOptions.MinZ:
z = 0;
break;
case RandomEdgeOptions.MaxZ:
z = size.Z - 1;
break;
}
}
return(_mazePointFactory.MakePoint(x, y, z));
}
public bool CanMove(MazePoint start, Direction d, MazeSize size, out MazePoint final)
{
switch (d)
{
case Direction.None:
final = start;
break;
case Direction.Right:
final = _pointFactory.MakePoint(start.X + 1, start.Y, start.Z);
break;
case Direction.Left:
final = _pointFactory.MakePoint(start.X - 1, start.Y, start.Z);
break;
case Direction.Forward:
final = _pointFactory.MakePoint(start.X, start.Y + 1, start.Z);
break;
case Direction.Back:
final = _pointFactory.MakePoint(start.X, start.Y - 1, start.Z);
break;
case Direction.Up:
final = _pointFactory.MakePoint(start.X, start.Y, start.Z + 1);
break;
case Direction.Down:
final = _pointFactory.MakePoint(start.X, start.Y, start.Z - 1);
break;
default:
throw new ArgumentException("Unsupported movement direction");
}
return(_pointValidity.ValidPoint(final, size));
}
public int Calulate(MazeSize size)
{
return((int)Math.Floor(Math.Sqrt(size.X * size.Y * size.Z) / 2));
}
public bool CanMove(MazePoint start, MazePoint final, MazeSize size)
{
return(_pointValidity.ValidPoint(final, size));
}
private int GetTotalSize(MazeSize size)
{
return(size.X * size.Y * size.Z);
}
private void DrawMaze(MazeSize size)
{
MazeGrid.Children.Clear();
MazeGrid.RowDefinitions.Clear();
MazeGrid.ColumnDefinitions.Clear();
IMazeFactory mazefactory = MazeFactoryStratigy.GetMazeFactory(MazeStratigy.WidthFirst);
Maze maze = mazefactory.BuildMaze(size);
int mazeSize = maze.Size;
double height = MazeGrid.Height / mazeSize;
for (int i = 0; i < mazeSize; i++)
{
MazeGrid.RowDefinitions.Add(new RowDefinition());
MazeGrid.ColumnDefinitions.Add(new ColumnDefinition());
}
DrawingBrush _gridBrush;
_gridBrush = new DrawingBrush(new GeometryDrawing(
new SolidColorBrush(Colors.Red),
new Pen(new SolidColorBrush(Colors.Black), 1.0),
new EllipseGeometry(new Rect(0, 0, height / 2, height / 2))));
_gridBrush.Stretch = Stretch.None;
_gridBrush.TileMode = TileMode.Tile;
_gridBrush.Viewport = new Rect(0.0, 0.0, height, height);
_gridBrush.ViewportUnits = BrushMappingMode.Absolute;
DrawingBrush _gridBrushEndPoint;
_gridBrushEndPoint = new DrawingBrush(new GeometryDrawing(
new SolidColorBrush(Colors.Black),
new Pen(new SolidColorBrush(Colors.Black), 1.0),
new EllipseGeometry(new Rect(0, 0, height / 2, height / 2))));
_gridBrushEndPoint.Stretch = Stretch.None;
_gridBrushEndPoint.TileMode = TileMode.Tile;
_gridBrushEndPoint.Viewport = new Rect(0.0, 0.0, height, height);
_gridBrushEndPoint.ViewportUnits = BrushMappingMode.Absolute;
int borderthickness = 2;
for (int i = 0; i < mazeSize; i++)
{
for (int j = 0; j < mazeSize; j++)
{
Border bd = new Border();
bd.Background = Brushes.Black;
bd.BorderBrush = Brushes.Black;
if (i == 0 && j < mazeSize - 1)
{
bd.BorderThickness = new Thickness(borderthickness, borderthickness, 0, borderthickness);
}
else
{
bd.BorderThickness = new Thickness(borderthickness, 0, 0, borderthickness);
}
if (j == mazeSize - 1 && i > 0)
{
bd.BorderThickness = new Thickness(borderthickness, 0, borderthickness, borderthickness);
}
else if (i > 0)
{
bd.BorderThickness = new Thickness(borderthickness, 0, 0, borderthickness);
}
if (i == 0 && j == mazeSize - 1)
{
bd.BorderThickness = new Thickness(borderthickness);
}
Grid.SetColumn(bd, j);
Grid.SetRow(bd, i);
MazeGrid.Children.Add(bd);
}
}
for (int row = 0; row < mazeSize; row++)
{
for (int col = 0; col < mazeSize; col++)
{
var bd = GetGridBorder(row, col);
bd.Background = Brushes.White;
var nbs = maze.GetPassedNeighbors(new MazeCell()
{
X = row, Y = col
});
for (int b = 0; b < nbs.Count; b++)
{
var border = GetGridBorder(nbs[b].X, nbs[b].Y);
border.Background = Brushes.White;
if (row == nbs[b].X && col < nbs[b].Y) //right
{
border.BorderThickness = new Thickness(0, border.BorderThickness.Top, border.BorderThickness.Right, border.BorderThickness.Bottom);
bd.BorderThickness = new Thickness(bd.BorderThickness.Left, bd.BorderThickness.Top, 0, bd.BorderThickness.Bottom);
}
if (row == nbs[b].X && col > nbs[b].Y) //Left
{
border.BorderThickness = new Thickness(border.BorderThickness.Left, border.BorderThickness.Top, 0, border.BorderThickness.Bottom);
bd.BorderThickness = new Thickness(0, bd.BorderThickness.Top, bd.BorderThickness.Right, bd.BorderThickness.Bottom);
}
if (row < nbs[b].X && col == nbs[b].Y) //bottom
{
border.BorderThickness = new Thickness(border.BorderThickness.Left, 0, border.BorderThickness.Right, border.BorderThickness.Bottom);
bd.BorderThickness = new Thickness(bd.BorderThickness.Left, bd.BorderThickness.Top, bd.BorderThickness.Right, 0);
}
if (row > nbs[b].X && col == nbs[b].Y)//top
{
border.BorderThickness = new Thickness(border.BorderThickness.Left, border.BorderThickness.Top, border.BorderThickness.Right, 0);
bd.BorderThickness = new Thickness(bd.BorderThickness.Left, 0, bd.BorderThickness.Right, bd.BorderThickness.Bottom);
}
}
}
}
var startPoint = GetGridBorder(maze.StartPoint.X, maze.StartPoint.Y);
startPoint.Background = _gridBrush;
startPoint.BorderThickness = new Thickness(startPoint.BorderThickness.Left, 0, startPoint.BorderThickness.Right, startPoint.BorderThickness.Bottom);
var exitPoint = GetGridBorder(maze.Size - 1, maze.Size - 1);
exitPoint.Background = _gridBrushEndPoint;
exitPoint.BorderThickness = new Thickness(exitPoint.BorderThickness.Left, exitPoint.BorderThickness.Top, exitPoint.BorderThickness.Right, 0);
}
internal Maze(MazeSize mazeSize)
{
this.Size = (int)mazeSize;
maze = new int[this.Size, this.Size];
Passages = new List <MazePassage>();
}
public Maze(MazeSize mazeSize)
{
this.Size = (int)mazeSize;
maze = new int[this.Size, this.Size];
}
public IEnumerable <MazePoint> GetPoints(MazeSize size, Func <MazePoint, bool> function)
{
var points = GetForEachPoint(size, x => x);
return(points.Where(function));
}
public IEnumerable <MazePoint> GetForEachZ <T>(MazeSize size, int z, Func <MazePoint, bool> func)
{
return(GetForEachZ <MazePoint>(size, z, x => x).Where(func));
}
