public static Directions_Ortho_2D AddFlag(
this Directions_Ortho_2D directions,
Directions_Ortho_2D flag
)
{
return(directions | flag);
}
public static UEdge2i FromDirection(Vec2i origin, Directions_Ortho_2D direction)
{
if (direction.IsSingle() == false)
{
throw new System.Exception("direction is not single!");
}
else if (direction == Directions_Ortho_2D.None)
{
throw new System.Exception("direction is None!");
}
if (direction == Directions_Ortho_2D.U)
{
return(new UEdge2i(origin, origin.To_Up()));
}
if (direction == Directions_Ortho_2D.D)
{
return(new UEdge2i(origin, origin.To_Down()));
}
if (direction == Directions_Ortho_2D.L)
{
return(new UEdge2i(origin, origin.To_Left()));
}
if (direction == Directions_Ortho_2D.R)
{
return(new UEdge2i(origin, origin.To_Right()));
}
return(new UEdge2i());
}
public static bool HasFlag(
this Directions_Ortho_2D directions,
Directions_Ortho_2D flag
)
{
return((directions & flag) == flag);
}
public static int Cell__Centrality(
this PM_Maze maze,
int x,
int y
)
{
int centrality = 0;
Directions_Ortho_2D cellDirections = maze.Q_Cell_Directions(x, y);
if (cellDirections.HasFlag(Directions_Ortho_2D.U))
{
centrality++;
}
if (cellDirections.HasFlag(Directions_Ortho_2D.D))
{
centrality++;
}
if (cellDirections.HasFlag(Directions_Ortho_2D.L))
{
centrality++;
}
if (cellDirections.HasFlag(Directions_Ortho_2D.R))
{
centrality++;
}
return(centrality);
}
public static Edge2i FromDirection(Directions_Ortho_2D direction)
{
if (direction.IsSingle() == false)
{
throw new System.Exception("direction is not single!");
}
else if (direction == Directions_Ortho_2D.None)
{
throw new System.Exception("direction is None!");
}
if (direction == Directions_Ortho_2D.U)
{
return(new Edge2i(new Vec2i(0, 0), Vec2i.up));
}
if (direction == Directions_Ortho_2D.D)
{
return(new Edge2i(new Vec2i(0, 0), Vec2i.down));
}
if (direction == Directions_Ortho_2D.L)
{
return(new Edge2i(new Vec2i(0, 0), Vec2i.left));
}
if (direction == Directions_Ortho_2D.R)
{
return(new Edge2i(new Vec2i(0, 0), Vec2i.right));
}
return(new Edge2i());
}
public static Directions_Ortho_2D RemoveFlag(
this Directions_Ortho_2D directions,
Directions_Ortho_2D flag
)
{
return(directions & ~flag);
}
public static List <Vec2i> Cells_Connected_To_Cell__List(
this PM_Maze maze,
Vec2i cell
)
{
List <Vec2i> neighbors = new List <Vec2i>();
Directions_Ortho_2D directions = maze.Q_Cell_Directions(cell);
if (directions.HasFlag(Directions_Ortho_2D.U))
{
neighbors.Add(cell.To_Up());
}
if (directions.HasFlag(Directions_Ortho_2D.D))
{
neighbors.Add(cell.To_Down());
}
if (directions.HasFlag(Directions_Ortho_2D.L))
{
neighbors.Add(cell.To_Left());
}
if (directions.HasFlag(Directions_Ortho_2D.R))
{
neighbors.Add(cell.To_Right());
}
return(neighbors);
}
public static double Cells_Similarity(this PM_Maze maze, Vec2i cell1, Vec2i cell2)
{
int sum = 0;
Directions_Ortho_2D dir1 = maze.Q_Cell_Directions(cell1);
Directions_Ortho_2D dir2 = maze.Q_Cell_Directions(cell2);
if (
(dir1 & dir2).HasFlag(Directions_Ortho_2D.U)
)
{
sum++;
}
if (
(dir1 & dir2).HasFlag(Directions_Ortho_2D.D)
)
{
sum++;
}
if (
(dir1 & dir2).HasFlag(Directions_Ortho_2D.L)
)
{
sum++;
}
if (
(dir1 & dir2).HasFlag(Directions_Ortho_2D.R)
)
{
sum++;
}
return((double)sum / 4.0);
}
public static int Num_T_Junctions(this PM_Maze maze)
{
int width = maze.Q_Width();
int height = maze.Q_Height();
int num = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Directions_Ortho_2D dir = maze.Q_Cell_Directions(x, y);
if (
dir == (Directions_Ortho_2D.Y | Directions_Ortho_2D.L)
||
dir == (Directions_Ortho_2D.Y | Directions_Ortho_2D.R)
||
dir == (Directions_Ortho_2D.X | Directions_Ortho_2D.U)
||
dir == (Directions_Ortho_2D.X | Directions_Ortho_2D.D)
)
{
num++;
}
}
}
return(num);
}
public static void LOP_Set_Cell_Directions(
this PM_Maze maze,
Vec2i pos,
Directions_Ortho_2D dir
)
{
maze.LOP_Set_Cell_Directions(pos.x, pos.y, dir);
}
public static void LLOP_Add_Cell_Directions(
this PM_Maze maze,
int x,
int y,
Directions_Ortho_2D dir
)
{
maze.cells[x, y] |= dir;
}
public static bool IsCell_DeadEnd(this PM_Maze maze, int x, int y)
{
Directions_Ortho_2D cellDirections = maze.Q_Cell_Directions(x, y);
if (cellDirections.IsSingle() || cellDirections == Directions_Ortho_2D.None)
{
return(true);
}
return(false);
}
public static void OP_RemoveEdge(this PM_Maze maze, UEdge2i edge)
{
if (maze.Q_Is_Edge_InBounds(edge))
{
Directions_Ortho_2D origin_direction = edge.To_Direction();
maze.LLOP_Remove_Cell_Directions(edge.origin, origin_direction);
Directions_Ortho_2D exit_direction = edge.Reverse().ToDirection();
maze.LLOP_Remove_Cell_Directions(edge.exit, exit_direction);
}
}
public static Directions_Ortho_2D[] DeepCopy(this Directions_Ortho_2D[] original_array)
{
int length = original_array.Length;
Directions_Ortho_2D[] copy_array = new Directions_Ortho_2D[length];
for (int i = 0; i < length; i++)
{
copy_array[i] = original_array[i];
}
return(copy_array);
}
public static bool IsSingle(
this Directions_Ortho_2D direction
)
{
return
(direction == Directions_Ortho_2D.U
||
direction == Directions_Ortho_2D.D
||
direction == Directions_Ortho_2D.L
||
direction == Directions_Ortho_2D.R);
}
public void Maze_Dimensions()
{
PM_Maze maze = new PM_Maze(10, 5);
Assert.IsTrue(maze.Q_Width() == 10);
Assert.IsTrue(maze.Q_Height() == 5);
Directions_Ortho_2D[,] dir = new Directions_Ortho_2D[10, 5];
maze = new PM_Maze(dir);
Assert.IsTrue(maze.Q_Width() == 10);
Assert.IsTrue(maze.Q_Height() == 5);
}
public static char[,] EncodeDirectionsTableToCharTable(Directions_Ortho_2D[,] directionsTable, char free, char blocked)
{
int width = directionsTable.GetLength(0);
int height = directionsTable.GetLength(1);
int expandedWidth = ExpandSize(width);
int expandedHeight = ExpandSize(height);
char[,] mazeChars = new char[expandedWidth, expandedHeight];
// initialize all values to blocked
for (int ex = 0; ex < expandedWidth; ex++)
{
for (int ey = 0; ey < expandedHeight; ey++)
{
mazeChars[ex, ey] = blocked;
}
}
// start freeing up values...
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
Directions_Ortho_2D dir = directionsTable[x, y];
int ex = ExpandSize(x);
int ey = ExpandSize(y);
mazeChars[ex, ey] = free;
if (dir.HasFlag(Directions_Ortho_2D.U))
{
mazeChars[ex, ey + 1] = free;
}
if (dir.HasFlag(Directions_Ortho_2D.D))
{
mazeChars[ex, ey - 1] = free;
}
if (dir.HasFlag(Directions_Ortho_2D.L))
{
mazeChars[ex - 1, ey] = free;
}
if (dir.HasFlag(Directions_Ortho_2D.R))
{
mazeChars[ex + 1, ey] = free;
}
}
}
return(mazeChars);
}
public static PM_Maze DecodeMazeFromString(string encodedMaze, char free, char blocked)
{
char[,] charTable = CharTableFromString(encodedMaze);
int encodedWidth = charTable.GetLength(0);
int encodedHeight = charTable.GetLength(1);
int width = ShrinkSize(encodedWidth);
int height = ShrinkSize(encodedHeight);
Directions_Ortho_2D[,] directionsTable = new Directions_Ortho_2D[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
directionsTable[x, y] = Directions_Ortho_2D.ORTHO;
}
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
int ex = ExpandSize(x);
int ey = ExpandSize(y);
if (charTable[ex, ey + 1] == blocked)
{
directionsTable[x, y] = directionsTable[x, y].RemoveFlag(Directions_Ortho_2D.U);
}
if (charTable[ex, ey - 1] == blocked)
{
directionsTable[x, y] = directionsTable[x, y].RemoveFlag(Directions_Ortho_2D.D);
}
if (charTable[ex - 1, ey] == blocked)
{
directionsTable[x, y] = directionsTable[x, y].RemoveFlag(Directions_Ortho_2D.L);
}
if (charTable[ex + 1, ey] == blocked)
{
directionsTable[x, y] = directionsTable[x, y].RemoveFlag(Directions_Ortho_2D.R);
}
}
}
PM_Maze maze = new PM_Maze(directionsTable);
return(maze);
}
public static bool IsCell_Corner(this PM_Maze maze, Vec2i cellPosition)
{
Directions_Ortho_2D directions = maze.Q_Cell_Directions(cellPosition);
return
(directions == (Directions_Ortho_2D.R | Directions_Ortho_2D.U)
||
directions == (Directions_Ortho_2D.U | Directions_Ortho_2D.L)
||
directions == (Directions_Ortho_2D.L | Directions_Ortho_2D.D)
||
directions == (Directions_Ortho_2D.D | Directions_Ortho_2D.R)
);
}
public static HashSet <Vec2i> GeometricNeighbors_WithinRect(
Rect2i rect,
Vec2i point,
Directions_Ortho_2D directions
)
{
var neighbors = point.Geometric_Neighbors(directions);
neighbors.RemoveWhere(
x =>
rect.Contains(x) == false
);
return(neighbors);
}
public static double Cells__Symmetry_X_Axis(this PM_Maze maze, Vec2i cell1, Vec2i cell2)
{
double sum = 0;
Directions_Ortho_2D dir1 = maze.Q_Cell_Directions(cell1);
Directions_Ortho_2D dir2 = maze.Q_Cell_Directions(cell2);
// left
if (dir1.HasFlag(Directions_Ortho_2D.L) && dir2.HasFlag(Directions_Ortho_2D.L))
{
sum++;
}
else if (dir1.HasFlag(Directions_Ortho_2D.L) == false && dir2.HasFlag(Directions_Ortho_2D.L) == false)
{
sum++;
}
// right
if (dir1.HasFlag(Directions_Ortho_2D.R) && dir2.HasFlag(Directions_Ortho_2D.R))
{
sum++;
}
else if (dir1.HasFlag(Directions_Ortho_2D.R) == false && dir2.HasFlag(Directions_Ortho_2D.R) == false)
{
sum++;
}
// up vs down
if (dir1.HasFlag(Directions_Ortho_2D.U) && dir2.HasFlag(Directions_Ortho_2D.D))
{
sum++;
}
else if (dir1.HasFlag(Directions_Ortho_2D.U) == false && dir2.HasFlag(Directions_Ortho_2D.D) == false)
{
sum++;
}
// down vs up
if (dir1.HasFlag(Directions_Ortho_2D.D) && dir2.HasFlag(Directions_Ortho_2D.U))
{
sum++;
}
else if (dir1.HasFlag(Directions_Ortho_2D.D) == false && dir2.HasFlag(Directions_Ortho_2D.U) == false)
{
sum++;
}
return(sum / 4.0);
}
public static Directions_Ortho_2D[,] DeepCopy(this Directions_Ortho_2D[,] originalArray)
{
int width = originalArray.GetLength(0);
int height = originalArray.GetLength(1);
Directions_Ortho_2D[,] arrayCopy = new Directions_Ortho_2D[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
arrayCopy[x, y] = originalArray[x, y];
}
}
return(arrayCopy);
}
public static HashSet <Vec2i> GeometricNeighbors_WithinRect(
Rect2i rect,
HashSet <Vec2i> points,
Directions_Ortho_2D directions
)
{
var neighbors = new HashSet <Vec2i>();
foreach (var point in points)
{
neighbors.UnionWith(GeometricNeighbors_WithinRect(rect, point, directions));
}
neighbors.ExceptWith(points);
return(neighbors);
}
public static int NumLeafNodes(this PM_Maze maze)
{
int width = maze.Q_Width();
int height = maze.Q_Height();
int num = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Directions_Ortho_2D dir = maze.Q_Cell_Directions(x, y);
if (dir.IsSingle())
{
num++;
}
}
}
return(num);
}
public static int Num_Cells_HorizontalCorridors(this PM_Maze maze)
{
int width = maze.Q_Width();
int height = maze.Q_Height();
int num = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Directions_Ortho_2D dir = maze.Q_Cell_Directions(x, y);
if (dir == Directions_Ortho_2D.X)
{
num++;
}
}
}
return(num);
}
public static int Num_Cells_Crosses(this PM_Maze maze)
{
int width = maze.Q_Width();
int height = maze.Q_Height();
int num = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Vec2i cell = new Vec2i(x, y);
Directions_Ortho_2D dir = maze.Q_Cell_Directions(cell);
if (dir == Directions_Ortho_2D.ORTHO)
{
num++;
}
}
}
return(num);
}
public static int NumCells__IncludingDirections(
this PM_Maze maze,
Directions_Ortho_2D directions
)
{
int width = maze.Q_Width();
int height = maze.Q_Height();
int numCellsIncludingDirections = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (maze.Q_Cell_Directions(x, y).HasFlag(directions))
{
numCellsIncludingDirections++;
}
}
}
return(numCellsIncludingDirections);
}
public HashSet <Vec2i> Geometric_Neighbors(Directions_Ortho_2D directions)
{
HashSet <Vec2i> geometric_neighbors = new HashSet <Vec2i>();
if (directions.HasFlag(Directions_Ortho_2D.L))
{
geometric_neighbors.Add(To_Left());
}
if (directions.HasFlag(Directions_Ortho_2D.R))
{
geometric_neighbors.Add(To_Right());
}
if (directions.HasFlag(Directions_Ortho_2D.U))
{
geometric_neighbors.Add(To_Up());
}
if (directions.HasFlag(Directions_Ortho_2D.D))
{
geometric_neighbors.Add(To_Down());
}
return(geometric_neighbors);
}
public static int NumCells__OfSpecificDirections(
this PM_Maze maze,
Directions_Ortho_2D directions
)
{
int width = maze.Q_Width();
int height = maze.Q_Height();
int numCellsOfSpecificDirections = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (maze.Q_Cell_Directions(x, y) == directions)
{
numCellsOfSpecificDirections++;
}
}
}
return(numCellsOfSpecificDirections);
}
private static double Directions_Similarity_Score(Directions_Ortho_2D dir1, Directions_Ortho_2D dir2)
{
double score = 0;
if (
(dir1.HasFlag(Directions_Ortho_2D.U) && dir2.HasFlag(Directions_Ortho_2D.U))
||
(dir1.HasFlag(Directions_Ortho_2D.U) == false && dir2.HasFlag(Directions_Ortho_2D.U) == false)
)
{
score++;
}
if (
(dir1.HasFlag(Directions_Ortho_2D.D) && dir2.HasFlag(Directions_Ortho_2D.D))
||
(dir1.HasFlag(Directions_Ortho_2D.D) == false && dir2.HasFlag(Directions_Ortho_2D.D) == false)
)
{
score++;
}
if (
(dir1.HasFlag(Directions_Ortho_2D.L) && dir2.HasFlag(Directions_Ortho_2D.L))
||
(dir1.HasFlag(Directions_Ortho_2D.L) == false && dir2.HasFlag(Directions_Ortho_2D.L) == false)
)
{
score++;
}
if (
(dir1.HasFlag(Directions_Ortho_2D.R) && dir2.HasFlag(Directions_Ortho_2D.R))
||
(dir1.HasFlag(Directions_Ortho_2D.R) == false && dir2.HasFlag(Directions_Ortho_2D.R) == false)
)
{
score++;
}
return(score / 4.0);
}
