private void ComputeValues(GridWorldSpace space, int g) { space.G = g; space.H = ComputeH(space); space.F = space.G + space.H; }
// Populate the GridWorldSpace 2D array // Make the Grid UIElement private void MakeGrid() { grid = GridControl; grid.HorizontalAlignment = HorizontalAlignment.Left; grid.VerticalAlignment = VerticalAlignment.Top; for (int i = 0; i < columns; i++) { ColumnDefinition colDef = new ColumnDefinition(); grid.ColumnDefinitions.Add(colDef); } for (int i = 0; i < rows; i++) { RowDefinition rowDef = new RowDefinition(); grid.RowDefinitions.Add(rowDef); } for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { GridWorldSpace space = new GridWorldSpace(i, j); spaces[i, j] = space; Grid.SetRow(spaces[i, j], i); Grid.SetColumn(spaces[i, j], j); grid.Children.Add(spaces[i, j]); } } grid.Width = width; grid.Height = height; }
// Returns the node with the least F value public GridWorldSpace GetLeastF() { GridWorldSpace leastSpace = items.First(); for (int i = 0; i < items.Count; i++) { if (leastSpace.F > items[i].F) { leastSpace = items[i]; } } return(leastSpace); }
// Check if the space is traversible public bool IsTraversible(GridWorldSpace space, CardinalDir dir) { int[] coord = { space.Row, space.Column }; switch (dir) { case CardinalDir.UP: if (coord[0] - 1 < 0) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } case CardinalDir.DOWN: if (coord[0] + 1 > rows - 1) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } case CardinalDir.LEFT: if (coord[1] - 1 < 0) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } case CardinalDir.RIGHT: if (coord[1] + 1 > columns - 1) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } default: return(false); } }
//Random map generation private void MakeGrid(double p) { grid = GridControl; p = p * 100; grid.HorizontalAlignment = HorizontalAlignment.Left; grid.VerticalAlignment = VerticalAlignment.Top; for (int i = 0; i < columns; i++) { ColumnDefinition colDef = new ColumnDefinition(); grid.ColumnDefinitions.Add(colDef); } for (int i = 0; i < rows; i++) { RowDefinition rowDef = new RowDefinition(); grid.RowDefinitions.Add(rowDef); } for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { GridWorldSpace space = new GridWorldSpace(i, j); spaces[i, j] = space; Grid.SetRow(spaces[i, j], i); Grid.SetColumn(spaces[i, j], j); grid.Children.Add(spaces[i, j]); int tmp = rand.Next(0, 100); if (tmp < (int)p) { spaces[i, j].SetTraversible(false); } } } spaces[0, 0].SetTraversible(true); spaces[rows - 1, columns - 1].SetTraversible(true); spaces[0, 0].SetStart(true); spaces[rows - 1, columns - 1].SetGoal(true); grid.Width = width; grid.Height = height; }
private int ComputeH(GridWorldSpace space) { int[] currCoord = { space.Row, space.Column }; int[] goalCoord = world.GetGoalCoord(); switch (heuristic) { case Heuristic.Euclidean: return(EuclideanDistance(currCoord, goalCoord)); case Heuristic.Manhattan: return(ManhattanDistance(currCoord, goalCoord)); case Heuristic.Chebyshev: return(ChebyshevDistance(currCoord, goalCoord)); default: return(ManhattanDistance(currCoord, goalCoord)); } }
// Uses a map to determine if spaces should be traversible or not private void MakeGrid(int[] initmap) { grid = GridControl; grid.HorizontalAlignment = HorizontalAlignment.Left; grid.VerticalAlignment = VerticalAlignment.Top; for (int i = 0; i < columns; i++) { ColumnDefinition colDef = new ColumnDefinition(); grid.ColumnDefinitions.Add(colDef); } for (int i = 0; i < rows; i++) { RowDefinition rowDef = new RowDefinition(); grid.RowDefinitions.Add(rowDef); } for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { GridWorldSpace space = new GridWorldSpace(i, j); spaces[i, j] = space; for (int k = 0; k < initmap.Length; k++) { if (i * columns + j == initmap[k]) { spaces[i, j].SetTraversible(false); } } Grid.SetRow(spaces[i, j], i); Grid.SetColumn(spaces[i, j], j); grid.Children.Add(spaces[i, j]); } } grid.Width = width; grid.Height = height; }
private GridWorldSpace GetAdjacentSpace(GridWorldSpace space, CardinalDir dir) { int[] coord = { space.Row, space.Column }; switch (dir) { case CardinalDir.UP: coord[0] = coord[0] - 1; break; case CardinalDir.DOWN: coord[0] = coord[0] + 1; break; case CardinalDir.LEFT: coord[1] = coord[1] - 1; break; case CardinalDir.RIGHT: coord[1] = coord[1] + 1; break; } return(world.GetSpaceByCoord(coord)); }
private List <GridWorldSpace> GetPath(GridWorld currWorld) { int timeSteps = 0; CoordHeap openList = new CoordHeap(); List <GridWorldSpace> closedList = new List <GridWorldSpace>(); List <Node> backTrack = new List <Node>(); GridWorldSpace currSpace = currWorld.GetSpaceByCoord(currWorld.GetStartCoord()); GridWorldSpace goalSpace = currWorld.GetSpaceByCoord(currWorld.GetGoalCoord()); Node starting = new Node(currSpace); backTrack.Add(starting); openList.Insert(currSpace); ComputeValues(currSpace, timeSteps); while (!openList.isEmpty() && currSpace != goalSpace) { CardinalDir[] cardinals = { CardinalDir.UP, CardinalDir.DOWN, CardinalDir.LEFT, CardinalDir.RIGHT }; int isBlocked = 0; for (int i = 0; i < cardinals.Length; i++) { if (currWorld.IsTraversible(currSpace, cardinals[i])) { GridWorldSpace tmpSpace = GetAdjacentSpace(currSpace, cardinals[i]); bool tmpbool = tmpSpace.isTraversible(); leastSpace = backTrack.First(); for (int it = 0; it < backTrack.Count; it++) { if (leastSpace.key.F > backTrack[it].key.F) { leastSpace.key = backTrack[it].key; } } Node parent1 = leastSpace; ComputeValues(tmpSpace, timeSteps); if (tmpbool && !openList.Contains(tmpSpace) && !closedList.Contains(tmpSpace)) { ComputeValues(tmpSpace, timeSteps); openList.Insert(tmpSpace); //Initialized a Node Object for tmpSpace child = new Node(tmpSpace); TT.Insert(parent1, child); backTrack.Add(child); if (child.key == goalSpace) { break; } } if (tmpbool && openList.Contains(tmpSpace) && (tmpSpace.F < openList.SpaceF(tmpSpace.Id))) { child = new Node(tmpSpace); openList.RemoveSpecific(tmpSpace.Id); //Remove anything with this ID openList.Insert(tmpSpace); for (int x = 0; x < backTrack.Count; x++) { if (tmpSpace.Id == backTrack[x].key.Id) { backTrack.Remove(child); //Remove anything with this ID } } backTrack.Add(child); TT.Insert(parent1, child); if (child.key == goalSpace) { break; } } else { isBlocked++; } } else { isBlocked++; } if (isBlocked == 4) { currSpace.Blocked = true; } } openList.Remove(currSpace); closedList.Add(currSpace); if (!openList.isEmpty()) { currSpace = openList.GetLeastF(); } backTrack.Remove(leastSpace); timeSteppedPaths[timeSteps] = new List <GridWorldSpace>(); foreach (GridWorldSpace tmp in closedList) { timeSteppedPaths[timeSteps].Add(tmp); } timeStepStrings[timeSteps] = ""; Debug.WriteLine(""); Debug.WriteLine("Timestep: " + timeSteps); Debug.WriteLine("Current Node: " + currSpace.Id); Debug.WriteLine("Closed List:"); foreach (GridWorldSpace tmp in closedList) { Debug.Write(tmp.Id); timeStepStrings[timeSteps] += tmp.Id; timeStepStrings[timeSteps] += "->"; Debug.Write("->"); } Debug.WriteLine(""); openList.PrintHeap(); timeSteps++; } if (currSpace.isGoal()) { timeStepStrings[timeSteps] += timeStepStrings[timeSteps - 1]; timeStepStrings[timeSteps] += currSpace.Id; timeSteppedPaths[timeSteps] = new List <GridWorldSpace>(); foreach (GridWorldSpace tmp in closedList) { timeSteppedPaths[timeSteps].Add(tmp); } solvable = true; } else { timeSteps = timeSteps - 1; solvable = false; } List <GridWorldSpace> finalPath = new List <GridWorldSpace>(); //track parent pointers all the way up to Start Node curr = child; //Go to Goal, where child = goal while (curr != null) { finalPath.Add(curr.key); curr = curr.parent; } finalPath.Reverse(); Debug.WriteLine("Final list: "); foreach (GridWorldSpace tmp in finalPath) { Debug.Write(tmp.Id); path_string += tmp.Id; if (tmp.isGoal()) { Debug.Write("(GOAL)"); path_string += "(GOAL)"; } else { Debug.Write("->"); path_string += "->"; } } cost = timeSteps; return(finalPath); }
//Constructer public Node(GridWorldSpace item) { this.key = item; this.parent = null; }
// Returns whether the given space is in the heap or not public bool Contains(GridWorldSpace space) { return(items.Contains(space)); }
// Removes the given space from the heap public void Remove(GridWorldSpace space) { items.Remove(space); }
// Inserts the given space in the heap public void Insert(GridWorldSpace space) { items.Add(space); Debug.WriteLine("Inserted: " + space.Id); }