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