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