public void Enqueue(List <MiniMapSector> queue, MiniMapSector sector)
{
if (!queue.Find((sec) => sector.Equals(sec)))
{
queue.Add(sector);
}
}
public MiniMapSector AcquireSector(int x, int y, int z, bool forceCache)
{
x = System.Math.Max(Constants.MapMinX, System.Math.Min(x, Constants.MapMaxX));
y = System.Math.Max(Constants.MapMinY, System.Math.Min(y, Constants.MapMaxY));
z = System.Math.Max(Constants.MapMinZ, System.Math.Min(z, Constants.MapMaxZ));
x = x / Constants.MiniMapSectorSize * Constants.MiniMapSectorSize;
y = y / Constants.MiniMapSectorSize * Constants.MiniMapSectorSize;
MiniMapSector sector = _sectorCache.Find((sec) => sec.Equals(x, y, z));
if (sector)
{
return(sector);
}
else
if (!sector)
{
sector = new MiniMapSector(x, y, z);
if (forceCache)
{
// load it right now
sector.LoadSharedObject();
// if it exists in the load queue, then remove it
Dequeue(_loadQueue, sector);
}
else
{
// don't load cache, it ain't really needed
Enqueue(_loadQueue, sector);
}
}
// pop the oldest sector
if (_sectorCache.Count >= Constants.MiniMapCacheSize)
{
_sectorCache.RemoveAt(0);
}
_sectorCache.Add(sector);
return(sector);
}
private PathState CalculateAStartPath(int startX, int startY, int startZ, int targetX, int targetY, int targetZ, int searchLimit, List <int> steps)
{
MiniMapSector[] sectors = new MiniMapSector[4];
sectors[0] = AcquireSector(startX - Constants.PathMatrixCenter, startY - Constants.PathMatrixCenter, startZ, false);
sectors[1] = AcquireSector(startX - Constants.PathMatrixCenter, startY + Constants.PathMatrixCenter, startZ, false);
sectors[2] = AcquireSector(startX + Constants.PathMatrixCenter, startY + Constants.PathMatrixCenter, startZ, false);
sectors[3] = AcquireSector(startX + Constants.PathMatrixCenter, startY - Constants.PathMatrixCenter, startZ, false);
// initial sector position (start position in minimap storage)
var sectorMaxX = sectors[0].SectorX + Constants.MiniMapSectorSize;
var sextorMaxY = sectors[0].SectorY + Constants.MiniMapSectorSize;
var closedList = new Dictionary <int, PathItem>();
var openList = new Utils.PriorityQueue <KeyValuePair <PathItem, int> >(Comparer <KeyValuePair <PathItem, int> > .Create(ComparePathNodes));
PathItem currentNode = new PathItem(startX, startY);
closedList.Add(Hash2DPosition(startX, startY), currentNode);
PathItem foundNode = null;
PathState ret = PathState.PathErrorInternal;
while (currentNode != null)
{
if (closedList.Count > searchLimit)
{
ret = PathState.PathErrorTooFar;
break;
}
if (currentNode.X == targetX && currentNode.Y == targetY && (foundNode == null || currentNode.PathCost < foundNode.PathCost))
{
foundNode = currentNode;
}
if (foundNode != null && (currentNode.PathHeuristic >= foundNode.PathCost))
{
break;
}
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
if (i == 0 && j == 0)
{
continue;
}
int currentPosX = currentNode.X + i;
int currentPosY = currentNode.Y + j;
int sectorIndex;
if (currentPosX < sectorMaxX)
{
sectorIndex = currentPosY < sextorMaxY ? 0 : 1;
}
else
{
sectorIndex = currentPosY < sextorMaxY ? 3 : 2;
}
int cost = sectors[sectorIndex].GetCost(currentPosX, currentPosY, startZ);
if (cost >= Constants.PathCostObstacle)
{
continue;
}
int modifier = 1;
if ((i * j) != 0)
{
modifier = 3;
}
int pathCost = currentNode.PathCost + modifier * cost;
var direction = DirectionFromPosToPos(currentNode.X, currentNode.Y, currentPosX, currentPosY);
PathItem neighborNode;
if (closedList.TryGetValue(Hash2DPosition(currentPosX, currentPosY), out PathItem handledNode))
{
neighborNode = handledNode;
if (neighborNode.PathCost <= pathCost)
{
continue;
}
}
else
{
neighborNode = new PathItem(currentPosX, currentPosY);
closedList.Add(Hash2DPosition(currentPosX, currentPosY), neighborNode);
}
neighborNode.Predecessor = currentNode;
neighborNode.Cost = cost;
neighborNode.PathCost = pathCost;
neighborNode.PathHeuristic = neighborNode.PathCost + Distance(currentPosX, currentPosY, targetX, targetY);
neighborNode.Direction = direction;
openList.Push(new KeyValuePair <PathItem, int>(neighborNode, neighborNode.PathHeuristic));
}
}
if (openList.Count > 0)
{
currentNode = openList.Pop().Key;
}
else
{
currentNode = null;
}
}
if (foundNode != null)
{
currentNode = foundNode;
while (currentNode != null)
{
steps.Add((int)currentNode.Direction | currentNode.Cost << 16);
if (steps.Count + 1 >= Constants.PathMaxSteps)
{
break;
}
currentNode = currentNode.Predecessor;
}
steps.RemoveAt(steps.Count - 1);
steps.Reverse();
ret = PathState.PathExists;
}
return(ret);
}
public void Dequeue(List <MiniMapSector> queue, MiniMapSector sector)
{
queue.Remove(sector);
}
public bool Equals(MiniMapSector sector)
{
return(Equals(sector.SectorX, sector.SectorY, sector.SectorZ));
}
public MiniMapSector AcquireSector(int x, int y, int z, bool cache)
{
x = System.Math.Max(Constants.MapMinX, System.Math.Min(x, Constants.MapMaxX));
y = System.Math.Max(Constants.MapMinY, System.Math.Min(y, Constants.MapMaxY));
z = System.Math.Max(Constants.MapMinZ, System.Math.Min(z, Constants.MapMaxZ));
int sectorX = x / Constants.MiniMapSectorSize * Constants.MiniMapSectorSize;
int sectorY = y / Constants.MiniMapSectorSize * Constants.MiniMapSectorSize;
int sectorZ = z;
MiniMapSector sector = null;
int it = _sectorCache.Count - 1;
while (it > 0)
{
var tmpSector = _sectorCache[it];
if (tmpSector.Equals(sectorX, sectorY, sectorZ))
{
sector = tmpSector;
_sectorCache.RemoveAt(it);
break;
}
it--;
}
if (!sector)
{
it = _saveQueue.Count - 1;
while (it >= 0)
{
var tmpSector = _saveQueue[it];
if (tmpSector.Equals(sectorX, sectorY, sectorZ))
{
sector = tmpSector;
break;
}
it--;
}
}
if (!sector)
{
sector = new MiniMapSector(sectorX, sectorY, sectorZ);
if (cache)
{
sector.LoadSharedObject();
Dequeue(_loadQueue, sector);
}
}
if (_sectorCache.Count >= Constants.MiniMapSectorSize)
{
MiniMapSector tmpSector = null;
foreach (var sec in _sectorCache)
{
if (!sec.Dirty)
{
tmpSector = sec;
_sectorCache.Remove(sec);
break;
}
}
if (!tmpSector)
{
tmpSector = _sectorCache[0];
_sectorCache.RemoveAt(0);
}
Dequeue(_loadQueue, tmpSector);
if (tmpSector.Dirty)
{
Enqueue(_saveQueue, tmpSector);
}
}
_sectorCache.Add(sector);
return(sector);
}
public PathState CalculatePath(int startX, int startY, int startZ, int targetX, int targetY, int targetZ, bool forceDiagonal, bool forceExact, List <int> steps)
{
int dX = targetX - startX;
int dY = targetY - startY;
if (steps == null)
{
return(PathState.PathErrorpublic);
}
else if (targetZ > startZ)
{
return(PathState.PathErrorGoDownstairs);
}
else if (targetZ < startZ)
{
return(PathState.PathErrorGoUpstairs);
}
else if (dX == 0 && dY == 0)
{
return(PathState.PathEmpty);
}
else if (System.Math.Abs(dX) >= Constants.PathMaxDistance || System.Math.Abs(dY) > Constants.PathMaxDistance)
{
return(PathState.PathErrorTooFar);
}
// check if this tile is known to be obstacle
// simple case, adjacent square
if (System.Math.Abs(dX) + System.Math.Abs(dY) == 1)
{
int cost = GetFieldCost(targetX, targetY, targetZ);
if (forceExact || cost < Constants.PathCostObstacle)
{
if (dX == 1 && dY == 0)
{
steps.Add((int)PathDirection.East);
}
else if (dX == 0 && dY == -1)
{
steps.Add((int)PathDirection.North);
}
else if (dX == -1 && dY == 0)
{
steps.Add((int)PathDirection.West);
}
else if (dX == 0 && dY == 1)
{
steps.Add((int)PathDirection.South);
}
steps[0] = steps[0] | cost << 16;
return(PathState.PathExists);
}
return(PathState.PathEmpty);
}
// simple case, adjacent diagonal square (while diagonal is actually allowed)
if (forceDiagonal && System.Math.Abs(dX) == 1 && System.Math.Abs(dY) == 1)
{
int cost = GetFieldCost(targetX, targetY, targetZ);
if (forceExact || cost < Constants.PathCostObstacle)
{
if (dX == 1 && dY == -1)
{
steps.Add((int)PathDirection.NorthEast);
}
else if (dX == -1 && dY == -1)
{
steps.Add((int)PathDirection.NorthWest);
}
else if (dX == -1 && dY == 1)
{
steps.Add((int)PathDirection.SouthWest);
}
else if (dX == 1 && dY == 1)
{
steps.Add((int)PathDirection.SouthEast);
}
steps[0] = steps[0] | cost << 16;
return(PathState.PathExists);
}
return(PathState.PathEmpty);
}
// A* Algorithm
// acquiring 4 directional sectors
MiniMapSector[] tmpSectors = new MiniMapSector[4];
tmpSectors[0] = AcquireSector(startX - Constants.PathMatrixCenter, startY - Constants.PathMatrixCenter, startZ, false);
tmpSectors[1] = AcquireSector(startX - Constants.PathMatrixCenter, startY + Constants.PathMatrixCenter, startZ, false);
tmpSectors[2] = AcquireSector(startX + Constants.PathMatrixCenter, startY + Constants.PathMatrixCenter, startZ, false);
tmpSectors[3] = AcquireSector(startX + Constants.PathMatrixCenter, startY - Constants.PathMatrixCenter, startZ, false);
// obtain local variables of constants
int matrixCenter = Constants.PathMatrixCenter;
int matrixSize = Constants.PathMatrixSize;
// heuristic multiplier
var minCost = int.MaxValue;
foreach (var sector in tmpSectors)
{
minCost = System.Math.Min(minCost, sector.MinCost);
}
// initial sector position (start position in minimap storage)
var sectorMaxX = tmpSectors[0].SectorX + Constants.MiniMapSectorSize;
var sextorMaxY = tmpSectors[0].SectorY + Constants.MiniMapSectorSize;
// obtain the center of the grid, and resetting it
// the center of the grid is matchin our initial position, so we will use MatrixCenter with offset as a workaround
PathItem pathItem = _pathMatrix[matrixCenter * matrixSize + matrixCenter];
pathItem.Reset();
pathItem.Predecessor = null;
pathItem.Cost = int.MaxValue;
pathItem.PathCost = int.MaxValue;
pathItem.PathHeuristic = 0;
_pathDirty.Add(pathItem); // push the initial position to the closed list
// obtain the final position at our grid
PathItem lastPathNode = _pathMatrix[(matrixCenter + dY) * Constants.PathMatrixSize + (matrixCenter + dX)];
lastPathNode.Predecessor = null;
lastPathNode.Reset();
int tmpIndex;
if (targetX < sectorMaxX)
{
tmpIndex = targetY < sextorMaxY ? 0 : 1;
}
else
{
tmpIndex = targetY < sextorMaxY ? 3 : 2;
}
lastPathNode.Cost = tmpSectors[tmpIndex].GetCost(targetX, targetY, targetZ);
lastPathNode.PathCost = 0;
// from the constructor, the distance is the manhattan distance from start_pos to target_pos
lastPathNode.PathHeuristic = lastPathNode.Cost + (lastPathNode.Distance - 1) * minCost;
// now add that to our closed list
_pathDirty.Add(lastPathNode);
// clear our heap and push the current node to it.
_pathHeap.Clear(false);
_pathHeap.AddItem(lastPathNode, lastPathNode.PathHeuristic);
PathItem currentPathItem = null;
PathItem tmpPathItem = null;
// looping through the very first SQM in the heap
while ((currentPathItem = _pathHeap.ExtractMinItem() as PathItem) != null)
{
// check if the current move won't exceed our current shortest path, otherwise end it up
// if it exceeds, then we will loop again through our heap, if exists
// if not, then we are done searching if the current path is undefined that means we can't
// reach that field
if (currentPathItem.HeapKey < pathItem.PathCost)
{
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
if (i != 0 || j != 0)
{
int gridX = currentPathItem.X + i;
int gridY = currentPathItem.Y + j;
// check if that grid is in the range or validity
if (!(gridX < -matrixCenter || gridX > matrixCenter || gridY < -matrixCenter || gridY > matrixCenter))
{
int currentPathCost;
if (i * j == 0) // straight movement (not diagonal)
{
currentPathCost = currentPathItem.PathCost + currentPathItem.Cost;
}
else // diagonal movements worth as 3 as a normal movement;
{
currentPathCost = currentPathItem.PathCost + 3 * currentPathItem.Cost;
}
tmpPathItem = _pathMatrix[(matrixCenter + gridY) * matrixSize + (matrixCenter + gridX)];
if (tmpPathItem.PathCost > currentPathCost)
{
tmpPathItem.Predecessor = currentPathItem;
tmpPathItem.PathCost = currentPathCost;
if (tmpPathItem.Cost == int.MaxValue)
{
int currentPosX = startX + tmpPathItem.X;
int currentPosY = startY + tmpPathItem.Y;
if (currentPosX < sectorMaxX)
{
tmpIndex = currentPosY < sextorMaxY ? 0 : 1;
}
else
{
tmpIndex = currentPosY < sextorMaxY ? 3 : 2;
}
tmpPathItem.Cost = tmpSectors[tmpIndex].GetCost(currentPosX, currentPosY, startZ);
tmpPathItem.PathHeuristic = tmpPathItem.Cost + (tmpPathItem.Distance - 1) * minCost;
_pathDirty.Add(tmpPathItem);
}
if (!(tmpPathItem == pathItem || tmpPathItem.Cost >= Constants.PathCostObstacle))
{
if (tmpPathItem.HeapParent != null)
{
_pathHeap.UpdateKey(tmpPathItem, currentPathCost + tmpPathItem.PathHeuristic);
}
else
{
tmpPathItem.Reset();
_pathHeap.AddItem(tmpPathItem, currentPathCost + tmpPathItem.PathHeuristic);
}
}
}
}
}
}
}
}
}
var ret = PathState.PathErrorpublic;
if (pathItem.PathCost < int.MaxValue)
{
currentPathItem = pathItem;
tmpPathItem = null;
while (currentPathItem != null)
{
if (!forceExact && currentPathItem.X == lastPathNode.X && currentPathItem.Y == lastPathNode.Y && lastPathNode.Cost >= Constants.PathCostObstacle)
{
currentPathItem = null;
break;
}
if (currentPathItem.Cost == Constants.PathCostUndefined)
{
break;
}
if (tmpPathItem != null)
{
dX = currentPathItem.X - tmpPathItem.X;
dY = currentPathItem.Y - tmpPathItem.Y;
if (dX == 1 && dY == 0)
{
steps.Add((int)PathDirection.East);
}
else if (dX == 1 && dY == -1)
{
steps.Add((int)PathDirection.NorthEast);
}
else if (dX == 0 && dY == -1)
{
steps.Add((int)PathDirection.North);
}
else if (dX == -1 && dY == -1)
{
steps.Add((int)PathDirection.NorthWest);
}
else if (dX == -1 && dY == 0)
{
steps.Add((int)PathDirection.West);
}
else if (dX == -1 && dY == 1)
{
steps.Add((int)PathDirection.SouthWest);
}
else if (dX == 0 && dY == 1)
{
steps.Add((int)PathDirection.South);
}
else if (dX == 1 && dY == 1)
{
steps.Add((int)PathDirection.SouthEast);
}
steps[steps.Count - 1] = steps[steps.Count - 1] | currentPathItem.Cost << 16;
if (steps.Count + 1 >= Constants.PathMaxSteps)
{
break;
}
}
tmpPathItem = currentPathItem;
currentPathItem = currentPathItem.Predecessor;
}
if (steps.Count == 0)
{
ret = PathState.PathEmpty;
}
else
{
ret = PathState.PathExists;
}
}
else
{
ret = PathState.PathErrorUnreachable;
}
foreach (var tmp in _pathDirty)
{
tmp.Cost = int.MaxValue;
tmp.PathCost = int.MaxValue;
}
_pathDirty.Clear();
return(ret);
}
public PathState CalculatePath(int startX, int startY, int startZ, int targetX, int targetY, int targetZ, bool forceDiagonal, bool forceExact, List <int> steps)
{
int dX = targetX - startX;
int dY = targetY - startY;
if (steps == null)
{
return(PathState.PathErrorInternal);
}
else if (targetZ > startZ)
{
return(PathState.PathErrorGoUpstairs);
}
else if (targetZ < startZ)
{
return(PathState.PathErrorGoDownstairs);
}
else if (dX == 0 && dY == 0)
{
return(PathState.PathEmpty);
}
else if (System.Math.Abs(dX) >= Constants.PathMaxDistance || System.Math.Abs(dY) > Constants.PathMaxDistance)
{
return(PathState.PathErrorTooFar);
}
// check if this tile is known to be obstacle
// simple case, adjacent square
if (System.Math.Abs(dX) + System.Math.Abs(dY) == 1)
{
int cost = GetFieldCost(targetX, targetY, targetZ);
if (forceExact || cost < Constants.PathCostObstacle)
{
if (dX == 1 && dY == 0)
{
steps.Add((int)PathDirection.East);
}
else if (dX == 0 && dY == -1)
{
steps.Add((int)PathDirection.North);
}
else if (dX == -1 && dY == 0)
{
steps.Add((int)PathDirection.West);
}
else if (dX == 0 && dY == 1)
{
steps.Add((int)PathDirection.South);
}
steps[0] = steps[0] | cost << 16;
return(PathState.PathExists);
}
return(PathState.PathEmpty);
}
// simple case, adjacent diagonal square (while diagonal is actually allowed)
if (forceDiagonal && System.Math.Abs(dX) == 1 && System.Math.Abs(dY) == 1)
{
int cost = GetFieldCost(targetX, targetY, targetZ);
if (forceExact || cost < Constants.PathCostObstacle)
{
if (dX == 1 && dY == -1)
{
steps.Add((int)PathDirection.NorthEast);
}
else if (dX == -1 && dY == -1)
{
steps.Add((int)PathDirection.NorthWest);
}
else if (dX == -1 && dY == 1)
{
steps.Add((int)PathDirection.SouthWest);
}
else if (dX == 1 && dY == 1)
{
steps.Add((int)PathDirection.SouthEast);
}
steps[0] = steps[0] | cost << 16;
return(PathState.PathExists);
}
return(PathState.PathEmpty);
}
// A* Algorithm
// acquiring 4 directional sectors
MiniMapSector[] tmpSectors = new MiniMapSector[4];
tmpSectors[0] = AcquireSector(startX - Constants.PathMatrixCenter, startY - Constants.PathMatrixCenter, startZ, false);
tmpSectors[1] = AcquireSector(startX - Constants.PathMatrixCenter, startY + Constants.PathMatrixCenter, startZ, false);
tmpSectors[2] = AcquireSector(startX + Constants.PathMatrixCenter, startY + Constants.PathMatrixCenter, startZ, false);
tmpSectors[3] = AcquireSector(startX + Constants.PathMatrixCenter, startY - Constants.PathMatrixCenter, startZ, false);
// obtain local variables of constants
int matrixCenter = Constants.PathMatrixCenter;
int matrixSize = Constants.PathMatrixSize;
// heuristic multiplier
var overallMinCost = int.MaxValue;
foreach (var sector in tmpSectors)
{
overallMinCost = System.Math.Min(overallMinCost, sector.MinCost);
}
// initial sector position (start position in minimap storage)
var sectorMaxX = tmpSectors[0].SectorX + Constants.MiniMapSectorSize;
var sextorMaxY = tmpSectors[0].SectorY + Constants.MiniMapSectorSize;
// obtain the center of the grid, and resetting it
// the center of the grid is matchin our initial position, so we will use MatrixCenter with offset as a workaround
PathQueueNode pathNode = m_PathMatrix[matrixCenter * matrixSize + matrixCenter];
pathNode.Reset();
pathNode.Predecessor = null;
pathNode.Cost = pathNode.PathCost = int.MaxValue;
pathNode.PathHeuristic = 0;
m_PathDirty.Add(pathNode); // push the initial position to the closed list
// obtain the final position at our grid
PathQueueNode lastPathNode = m_PathMatrix[(matrixCenter + dY) * Constants.PathMatrixSize + (matrixCenter + dX)];
lastPathNode.Predecessor = null;
lastPathNode.Reset();
int tmpIndex;
if (targetX < sectorMaxX)
{
if (targetY < sextorMaxY)
{
tmpIndex = (int)Directions.North;
}
else
{
tmpIndex = (int)Directions.East;
}
}
else if (targetY < sextorMaxY)
{
tmpIndex = (int)Directions.West;
}
else
{
tmpIndex = (int)Directions.South;
}
lastPathNode.Cost = tmpSectors[tmpIndex].GetCost(targetX, targetY, targetZ);
lastPathNode.PathCost = 0;
// from the constructor, the distance is the manhattan distance from start_pos to target_pos
lastPathNode.PathHeuristic = lastPathNode.Cost + (lastPathNode.Distance - 1) * overallMinCost;
// now add that to our closed list
m_PathDirty.Add(lastPathNode);
// clear our heap and push the current node to it.
m_PathPriorityQueue = new Priority_Queue.FastPriorityQueue <PathQueueNode>(50000);
m_PathPriorityQueue.Enqueue(lastPathNode, lastPathNode.PathHeuristic);
PathQueueNode currentPathNode = null;
PathQueueNode tmpPathNode = null;
uint s = 0, s2 = 0;
// looping through the very first SQM in the heap
while (m_PathPriorityQueue.Count > 0)
{
s++;
currentPathNode = m_PathPriorityQueue.Dequeue();
// check if the current move won't exceed our current shortest path, otherwise end it up
// if it exceeds, then we will loop again through our heap, if exists
// if not, then we are done searching if the current path is undefined that means we can't
// reach that field
if (currentPathNode.Priority >= pathNode.PathCost)
{
break;
}
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
if (i == 0 && j == 0)
{
continue;
}
int gridX = currentPathNode.x + i;
int gridY = currentPathNode.y + j;
// check if that grid is in the range or validity
if (gridX < -matrixCenter || gridX > matrixCenter || gridY < -matrixCenter || gridY > matrixCenter)
{
continue;
}
int currentPathCost;
if (i * j == 0) // straight movement (not diagonal)
{
currentPathCost = currentPathNode.PathCost + currentPathNode.Cost;
}
else // diagonal movements worth as 3 as a normal movement;
{
currentPathCost = currentPathNode.PathCost + 3 * currentPathNode.Cost;
}
tmpPathNode = m_PathMatrix[(matrixCenter + gridY) * matrixSize + (matrixCenter + gridX)];
if (tmpPathNode.PathCost > currentPathCost)
{
tmpPathNode.Predecessor = currentPathNode;
tmpPathNode.PathCost = currentPathCost;
if (tmpPathNode.Cost == int.MaxValue)
{
int currentPosX = startX + tmpPathNode.x;
int currentPosY = startY + tmpPathNode.y;
if (currentPosX < sectorMaxX)
{
if (currentPosY < sextorMaxY)
{
tmpIndex = (int)Directions.North;
}
else
{
tmpIndex = (int)Directions.East;
}
}
else if (currentPosY < sextorMaxY)
{
tmpIndex = (int)Directions.West;
}
else
{
tmpIndex = (int)Directions.South;
}
tmpPathNode.Cost = tmpSectors[tmpIndex].GetCost(currentPosX, currentPosY, startZ);
tmpPathNode.PathHeuristic = tmpPathNode.Cost + (tmpPathNode.Distance - 1) * overallMinCost;
m_PathDirty.Add(tmpPathNode);
}
if (tmpPathNode == pathNode || tmpPathNode.Cost >= Constants.PathCostObstacle)
{
continue;
}
s2++;
if (tmpPathNode.Queue == m_PathPriorityQueue)
{
m_PathPriorityQueue.UpdatePriority(tmpPathNode, currentPathCost + tmpPathNode.PathHeuristic);
}
else
{
tmpPathNode.Reset();
m_PathPriorityQueue.Enqueue(tmpPathNode, currentPathCost + tmpPathNode.PathHeuristic);
}
}
}
}
}
//Debug.Log("Recuresive Count: " + s + ", " + s2);
var ret = PathState.PathErrorInternal;
if (pathNode.PathCost < int.MaxValue)
{
currentPathNode = pathNode;
tmpPathNode = null;
while (currentPathNode != null)
{
if (!forceExact && currentPathNode.x == lastPathNode.x && currentPathNode.y == lastPathNode.y && lastPathNode.Cost >= Constants.PathCostObstacle)
{
currentPathNode = null;
break;
}
if (currentPathNode.Cost == Constants.PathCostUndefined)
{
break;
}
if (tmpPathNode != null)
{
dX = currentPathNode.x - tmpPathNode.x;
dY = currentPathNode.y - tmpPathNode.y;
if (dX == 1 && dY == 0)
{
steps.Add((int)PathDirection.East);
}
else if (dX == 1 && dY == -1)
{
steps.Add((int)PathDirection.NorthEast);
}
else if (dX == 0 && dY == -1)
{
steps.Add((int)PathDirection.North);
}
else if (dX == -1 && dY == -1)
{
steps.Add((int)PathDirection.NorthWest);
}
else if (dX == -1 && dY == 0)
{
steps.Add((int)PathDirection.West);
}
else if (dX == -1 && dY == 1)
{
steps.Add((int)PathDirection.SouthWest);
}
else if (dX == 0 && dY == 1)
{
steps.Add((int)PathDirection.South);
}
else if (dX == 1 && dY == 1)
{
steps.Add((int)PathDirection.SouthEast);
}
steps[steps.Count - 1] = steps[steps.Count - 1] | currentPathNode.Cost << 16;
if (steps.Count + 1 >= Constants.PathMaxSteps)
{
break;
}
}
tmpPathNode = currentPathNode;
currentPathNode = currentPathNode.Predecessor;
}
if (steps.Count == 0)
{
ret = PathState.PathEmpty;
}
else
{
ret = PathState.PathExists;
}
}
else
{
ret = PathState.PathErrorUnreachable;
}
foreach (var tmp in m_PathDirty)
{
tmp.Cost = int.MaxValue;
tmp.PathCost = int.MaxValue;
}
m_PathDirty.Clear();
return(ret);
}
internal void Dequeue(List <MiniMapSector> queue, MiniMapSector sector)
{
queue.Remove(sector);
}