public PathObject(Grid2DObject grid, Coord2DObject point1, Coord2DObject point2, int thickness)
{
this.grid = grid;
joints = new List <Coord2DObject>();
this.thickness = thickness;
populateBestPath(point1, point2);
}
public Grid2DObject(Grid2DObject other)
{
this.dimensions = new Coord2DObject(other.dimensions);
grid = new TileObject[dimensions.x, dimensions.y];
for (int i = 0; i < dimensions.x; i++)
{
for (int j = 0; j < dimensions.y; j++)
{
Coord2DObject thisCoord2D = new Coord2DObject(i, j);
TileObject thisOtherTile = other.getTile(thisCoord2D);
setTile(thisOtherTile.type, thisCoord2D);
}
}
}
public PathObject(Grid2DObject grid)
{
this.grid = grid;
joints = new List <Coord2DObject>();
this.thickness = 0;
}
public PathObject(Grid2DObject grid, List <Coord2DObject> joints, int thickness)
{
this.grid = grid;
this.joints = new List <Coord2DObject>(joints);
this.thickness = thickness;
}
/// <summary>
/// Populates this Path's "joints" list with the best path between point1 and point2.
/// This is accomplished by implementing Dijkstra's algorithm.
/// This path's grid and joints MUST be initialized before this method is called.
/// Algorithm adopted from the pseudocode found here:
/// https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode
/// </summary>
/// <param name="src">The coordinate that the path should start from</param>
/// <param name="dest">The coordinate that the path should start from</param>
private void populateBestPath(Coord2DObject src, Coord2DObject dest)
{
Grid2DObject tempGrid = new Grid2DObject(grid); // generate copy, maintaining tile types
TileObject srcTile = tempGrid.getTile(src);
TileObject destTile = tempGrid.getTile(dest);
srcTile.distance = 0;
// Do some error checking
Assert.raiseExceptions = true;
Assert.IsTrue(!src.Equals(dest), "Attempted autopath to the same tile " + src.ToString());
Assert.IsTrue(srcTile.type != TileObject.TileType.NON_TRAVERSABLE,
"Path attempted on srcTile non-traversable tile " + srcTile.ToString() + " to destTile " + destTile.ToString());
Assert.IsTrue(destTile.type != TileObject.TileType.NON_TRAVERSABLE,
"Path attempted on destTile non-traversable tile " + destTile.ToString() + " from srcTile " + srcTile.ToString());
// Populate set Q
HashSet <TileObject> setQ = new HashSet <TileObject>();
foreach (TileObject t in tempGrid)
{
if (t.type != TileObject.TileType.NON_TRAVERSABLE)
{
setQ.Add(t);
}
}
List <TileObject> listQ = new List <TileObject>(setQ);
shuffleList <TileObject>(listQ);
TileObject uTile = null;
while (listQ.Count > 0)
{
// Get tile with minimum distance from setQ
int runningMin = System.Int32.MaxValue;
foreach (TileObject t in listQ)
{
if (t.distance < runningMin)
{
runningMin = t.distance;
uTile = t;
}
}
// Make sure uTile is properly set,
// then remove it from setQ
Assert.IsTrue(uTile != null, "Minimum distance tile uTile not properly set");
Assert.IsTrue(listQ.Contains(uTile), "setQ doesn't contain uTile " + uTile.ToString());
listQ.Remove(uTile);
// Break out if we've reached the destination,
// we now need to construct the path via reverse iteration
if (uTile == destTile) // check for identity, not just equivalence
{
break;
}
// Update distances of all uTile's current neighbors
HashSet <TileObject> uNeighbors = tempGrid.getTraversableNeighbors(uTile.location);
foreach (TileObject thisNeighbor in uNeighbors)
{
int currentDist = uTile.distance + 1;
if (currentDist < thisNeighbor.distance)
{
thisNeighbor.distance = currentDist;
thisNeighbor.prev = uTile;
}
}
}
// Ensure that uTile is actually usable
Assert.IsTrue(uTile.prev != null || uTile == srcTile,
"Condition specified by Dijkstra's not met");
// Populate joints by backtracing
while (uTile != null)
{
joints.Add(uTile.location);
uTile = uTile.prev;
// Make sure if we're about to break out,
// that we have enough joints to do so
// (i.e. that we have at least 2 joints)
Assert.IsTrue(!(uTile == null && joints.Count < 2),
"Not enough prev's? For sure not enough joints\n"
+ "Perhaps src and dest are the same?\n"
+ "src: " + srcTile.ToString() + '\n'
+ "dest: " + destTile.ToString() + '\n'
+ "src.equals(dest)? " + src.Equals(dest));
}
}
public GameGrid2DObject(Grid2DObject other)
: base(other)
{
init(4, 8, 8);
}