public void DoWork()
{
path = new Queue <T>();
HashSet <T> closedSet = new HashSet <T>();
PathfindingPriorityQueue <T> openSet = new PathfindingPriorityQueue <T>();
openSet.Enqueue(startTile, 0);
Dictionary <T, T> cameFrom = new Dictionary <T, T>();
Dictionary <T, float> g_score = new Dictionary <T, float>();
g_score[startTile] = 0;
Dictionary <T, float> f_score = new Dictionary <T, float>();
f_score[startTile] = costEstimateFunc(startTile, endTile);
// Debug.Log("AStar Doing Something!");
//List<T> currentNeighbors;
while (openSet.Count > 0)
{
T current = openSet.Dequeue();
if (System.Object.ReferenceEquals(current, endTile))
{
Reconstuct_path(cameFrom, current);
return;
}
closedSet.Add(current);
// Debug.Log("Neighbor Count: " + current.GetNeighbors().Length);
foreach (T neighbor in current.GetNeighbors())
{
if (closedSet.Contains(neighbor))
{
continue;
}
// doing something weird
float total_pathfinding_cost_to_neighbor =
current.AggregateTileCostToEnter(g_score[current], neighbor, theUnit);
//
if (total_pathfinding_cost_to_neighbor < 0)
{
// Less than zero value; Impassable by this unit!
// Debug.Log("Imapssable Terrain!");
continue;
}
// Debug.Log("total_pathfinding_cost_to_neighbor : " + total_pathfinding_cost_to_neighbor);
float tentative_g_score = total_pathfinding_cost_to_neighbor;
////
//// something strange going on here
if (openSet.Contains(neighbor) && tentative_g_score >= g_score[neighbor])
{
continue; // not a better path, move along
}
// this is either a new tile or just found a cheaper route to it
cameFrom[neighbor] = current;
g_score[neighbor] = tentative_g_score;
// figure cost from neighbor to destination
f_score[neighbor] = g_score[neighbor] + costEstimateFunc(neighbor, endTile);
openSet.EnqueueOrUpdate(neighbor, f_score[neighbor]);
} // foreach neighbor
} // while
}
public void DoWork()
{
//Debug.Log("QPath_AStar::DoWork");
path = new Queue <T>();
pathList = new Dictionary <IQPathTile, IQPathTile>();
//twins = new Queue<IQPathTile>();
HashSet <T> closedSet = new HashSet <T>();
PathfindingPriorityQueue <T> openSet = new PathfindingPriorityQueue <T>();
openSet.Enqueue(startTile, 0);
Dictionary <T, T> came_From = new Dictionary <T, T>();
Dictionary <T, float> g_score = new Dictionary <T, float>();
g_score[startTile] = 0;
Dictionary <T, float> f_score = new Dictionary <T, float>();
f_score[startTile] = CostEstimate(startTile, endTile);
while (openSet.Count > 0)
{
T current = openSet.Dequeue();
// Check to see if we are there.
if (System.Object.ReferenceEquals(current, endTile))
{
Reconstruct_path(came_From, current);
return;
}
closedSet.Add(current);
foreach (T edge_neighbour in current.GetNeighbours())
{
T neighbour = edge_neighbour;
if (closedSet.Contains(neighbour))
{
continue; // ignore this already completed neighbor
}
float total_pathfinding_cost_to_neighbor =
neighbour.AggregateCostToEnter(g_score[current], current, LastTwoTiles(null), unit);
if (total_pathfinding_cost_to_neighbor < 0)
{
// Values less than zero represent an invalid/impassable tile
continue;
}
float tentative_g_score = total_pathfinding_cost_to_neighbor;
// Is the neighbour already in the open set?
// If so, and if this new score is worse than the old score,
// discard this new result.
if (openSet.Contains(neighbour) && tentative_g_score >= g_score[neighbour])
{
continue;
}
// This is either a new tile or we just found a cheaper route to it
came_From[neighbour] = current;
//pathList[neighbour] = current;
g_score[neighbour] = tentative_g_score;
f_score[neighbour] = g_score[neighbour] + CostEstimate(neighbour, endTile);
LastTwoTiles(neighbour);
openSet.EnqueueOrUpdate(neighbour, f_score[neighbour]);
} // foreach neighbour
} // while
}
public void DoWork()
{
path = new Queue <T>();
Util.WriteDebugLog(string.Format("QPath_AStar::DoWork() run"), GameManager.LogLevel_Error, GameManager.instance.debug, GameManager.instance.LogLevel);
//List for all our nodes
HashSet <T> closedSet = new HashSet <T>();
PathfindingPriorityQueue <T> openSet = new PathfindingPriorityQueue <T>();
openSet.Enqueue(startTile, 0);
Dictionary <T, T> came_From = new Dictionary <T, T>();
//Includes real cost
Dictionary <T, float> g_score = new Dictionary <T, float>();
g_score[startTile] = 0;
//Includes estimated cost
Dictionary <T, float> f_score = new Dictionary <T, float>();
f_score[startTile] = costEstimateFunc(startTile, endTile);
//Main loop
while (openSet.Count > 0)
{
T current = openSet.Dequeue();
//Check to see if we are there -- see if they are the same object in memory
if (Object.ReferenceEquals(current, endTile))
{
Reconstruct_path(came_From, current);
return;
}
closedSet.Add(current);
foreach (T edge_neighbor in current.GetNeighbors())
{
T neighbor = edge_neighbor;
if (closedSet.Contains(neighbor))
{
continue; //ignore this already completed neighbor
}
//float pathfinding_cost_to_neighbor = neighbor. ;
float total_pathfinding_cost_to_neighbor = neighbor.AggregateCostToEnter(g_score[current], current, unit);
//Check for impassible terrain - Less then 0 is impassible terrain
if (total_pathfinding_cost_to_neighbor < 0)
{
continue;
}
float tentative_g_score = total_pathfinding_cost_to_neighbor;
/*
* Is the neighbor already in the open set?
* If so , and if this new score is worse than the old score
* discard this new result
*/
if (openSet.Contains(neighbor) && tentative_g_score >= g_score[neighbor])
{
continue;
}
//This is either a new tile or we just found a cheaper route to it
came_From[neighbor] = current;
g_score[neighbor] = tentative_g_score;
f_score[neighbor] = g_score[neighbor] + costEstimateFunc(neighbor, endTile);
openSet.EnqueueOrUpdate(neighbor, f_score[neighbor]);
} //foreach neighbor
}
}
public void DoWork()
{
path = new Queue <T>();
HashSet <T> closedset = new HashSet <T>();
PathfindingPriorityQueue <T> openSet = new PathfindingPriorityQueue <T>();
openSet.Enqueue(starttile, 0);
Dictionary <T, T> came_From = new Dictionary <T, T>();
Dictionary <T, float> g_score = new Dictionary <T, float>();
g_score[starttile] = 0;
Dictionary <T, float> f_score = new Dictionary <T, float>();
f_score[starttile] = CostEstimateFunc(starttile, endtile);
while (openSet.Count > 0)
{
T current = openSet.Dequeue();
if (System.Object.ReferenceEquals(current, endtile))
{
reconstruct_path(came_From, current);
return;
}
closedset.Add(current);
foreach (T edge_neighbour in current.GetNeighbours())
{
T neighbour = edge_neighbour;
if (closedset.Contains(neighbour))
{
continue;
}
float total_pathfinding_cost_to_neighbor =
neighbour.AggregateCostToEnter(g_score[current], current, unit);
if (total_pathfinding_cost_to_neighbor < 0)
{
continue;
}
float tentative_g_score = total_pathfinding_cost_to_neighbor;
if (openSet.Contains(neighbour) && tentative_g_score >= g_score[neighbour])
{
continue;
}
came_From[neighbour] = current;
g_score[neighbour] = tentative_g_score;
f_score[neighbour] = g_score[neighbour] + CostEstimateFunc(neighbour, endtile);
openSet.EnqueueOrUpdate(neighbour, f_score[neighbour]);
}
}
}
public void DoWork()
{
Debug.Log("QPath_AStar::DoWork");
path = new Queue <T>();
HashSet <T> closedSet = new HashSet <T>();//an array that is guaranteed to be unique
//for openset use quill18's pathfinding priority queue
PathfindingPriorityQueue <T> openSet = new PathfindingPriorityQueue <T>();
//openSet of all our tiles is organized based on shortest distance first
openSet.Enqueue(startTile, 0);
Dictionary <T, T> came_From = new Dictionary <T, T>();
Dictionary <T, float> g_score = new Dictionary <T, float>();
g_score[startTile] = 0; //cost to get to our start tile is 0
Dictionary <T, float> f_score = new Dictionary <T, float>();
f_score[startTile] = costEstimateFunc(startTile, endTile); //includes the estimated cost of getting to that tile
while (openSet.Count > 0)
{
T current = openSet.Dequeue();
//are these referencing the same object in memory?
if (System.Object.ReferenceEquals(current, endTile))
{
Reconstruct_path(came_From, current);
return;
}
closedSet.Add(current);
foreach (T edge_neighbour in current.GetNeighbours())
{
T neighbour = edge_neighbour;
if (closedSet.Contains(neighbour))
{
continue; //ignore this already completed neighbor
}
float total_pathfinding_cost_to_neighbor =
neighbour.AggregateCostToEnter(g_score[current], current, unit);
//check if terrain is impassable
if (total_pathfinding_cost_to_neighbor < 0)
{
//Values less than zero represent an invalid/impassable tile
continue;
}
float tentative_g_score = g_score[current] + total_pathfinding_cost_to_neighbor;
//Is the neighbour already in the open set?
// If so, and if this new score is worse than the old: discard this new result
if (openSet.Contains(neighbour) && tentative_g_score >= g_score[neighbour])
{
continue;
}
//This is either a new tile or a cheaper route to it
came_From[neighbour] = current;
g_score[neighbour] = tentative_g_score;
f_score[neighbour] = g_score[neighbour] + costEstimateFunc(neighbour, endTile);
openSet.EnqueueOrUpdate(neighbour, f_score[neighbour]);
} //foreach neighbour
} //while
}
