public static PathData FindPath(PathFinderPoint start, PathFinderPoint end)
{
var path = pathfinder.FindPath(start, end);
var pathData = new PathData(path);
return pathData;
}
public static PathData FindPath(PathFinderPoint start, PathFinderPoint end, Vector2 offset)
{
var path = pathfinder.FindPath(start, end);
var pathData = new PathData(path, offset);
return pathData;
}
private void ConnectDoors(GameObject a, GameObject b)
{
var positionA = LevelSystem.Instance.ToVec2i(
a.transform.position);
var positionB = LevelSystem.Instance.ToVec2i(
b.transform.position);
PathFinderUtil.SetMap(tileMap);
var pointA = new PathFinderPoint(positionA.x, positionA.y);
var pointB = new PathFinderPoint(positionB.x, positionB.y);
var pathData = PathFinderUtil.FindPath(pointA, pointB);
foreach (var path in pathData.path)
SetTileValue((int)path.x, (int)path.z, HALL, null, "Path");
}
public List <PathFinderNode> FindPath(PathFinderPoint start, PathFinderPoint end)
{
lock (this)
{
//HighResolutionTime.Start();
mFound = false;
mStop = false;
mStopped = false;
mCloseNodeCounter = 0;
mOpenNodeValue += 2;
mCloseNodeValue += 2;
mOpen.Clear();
mClose.Clear();
mLocation = (start.Y << mGridYLog2) + start.X;
mEndLocation = (end.Y << mGridYLog2) + end.X;
mCalcGrid[mLocation].G = 0;
mCalcGrid[mLocation].F = mHEstimate;
mCalcGrid[mLocation].PX = (ushort)start.X;
mCalcGrid[mLocation].PY = (ushort)start.Y;
mCalcGrid[mLocation].Status = mOpenNodeValue;
mOpen.Push(mLocation);
while (mOpen.Count > 0 && !mStop)
{
mLocation = mOpen.Pop();
//Is it in closed list? means this node was already processed
if (mCalcGrid[mLocation].Status == mCloseNodeValue)
{
continue;
}
mLocationX = (ushort)(mLocation & mGridXMinus1);
mLocationY = (ushort)(mLocation >> mGridYLog2);
if (mLocation == mEndLocation)
{
mCalcGrid[mLocation].Status = mCloseNodeValue;
mFound = true;
break;
}
if (mCloseNodeCounter > mSearchLimit)
{
mStopped = true;
//mCompletedTime = HighResolutionTime.GetTime();
return(null);
}
if (mPunishChangeDirection)
{
mHoriz = (mLocationX - mCalcGrid[mLocation].PX);
}
//Lets calculate each successors
for (int i = 0; i < (mDiagonals ? 8 : 4); i++)
{
mNewLocationX = (ushort)(mLocationX + mDirection[i, 0]);
mNewLocationY = (ushort)(mLocationY + mDirection[i, 1]);
mNewLocation = (mNewLocationY << mGridYLog2) + mNewLocationX;
if (mNewLocationX >= mGridX || mNewLocationY >= mGridY)
{
continue;
}
// Unbreakeable?
if (mGrid[mNewLocationX, mNewLocationY] == 0)
{
continue;
}
// TEST - kill ALL diags
if (mLocationX != mNewLocationX && mLocationY != mNewLocationY)
{
//continue;
}
// NavigateCorners conditions:
// if both new x AND y are greater: check (x+1, y), (x, y+1)
// if both new x AND y are smaller: check (x-1, y), (x, y-1)
// if new x is smaller and y are greater: check (x-1, y), (x, y+1)
// if new x is greater and y are smaller: check (x, y-1), (x+1, y)
// Corner navigation - ie. don't take diagonals across corners of occupied cells
// If new x is greater: check (x+1, y)
if (mNewLocationX > mLocationX && mGrid[mLocationX + 1, mLocationY] == 0)
{
continue;
}
// If new x is smaller: check (x-1, y)
if (mNewLocationX < mLocationX && mGrid[mLocationX - 1, mLocationY] == 0)
{
continue;
}
// If new y is greater: check (x, y+1)
if (mNewLocationY > mLocationY && mGrid[mLocationX, mLocationY + 1] == 0)
{
continue;
}
// If new y is smaller: check (x, y-1)
if (mNewLocationY < mLocationY && mGrid[mLocationX, mLocationY - 1] == 0)
{
continue;
}
///////////////
if (mHeavyDiagonals && i > 3)
{
mNewG = mCalcGrid[mLocation].G + (int)(mGrid[mNewLocationX, mNewLocationY] * 2.41);
}
else
{
mNewG = mCalcGrid[mLocation].G + mGrid[mNewLocationX, mNewLocationY];
}
if (mPunishChangeDirection)
{
if ((mNewLocationX - mLocationX) != 0)
{
if (mHoriz == 0)
{
mNewG += Math.Abs(mNewLocationX - end.X) + Math.Abs(mNewLocationY - end.Y);
}
}
if ((mNewLocationY - mLocationY) != 0)
{
if (mHoriz != 0)
{
mNewG += Math.Abs(mNewLocationX - end.X) + Math.Abs(mNewLocationY - end.Y);
}
}
}
//Is it open or closed?
if (mCalcGrid[mNewLocation].Status == mOpenNodeValue || mCalcGrid[mNewLocation].Status == mCloseNodeValue)
{
// The current node has less code than the previous? then skip this node
if (mCalcGrid[mNewLocation].G <= mNewG)
{
continue;
}
}
mCalcGrid[mNewLocation].PX = mLocationX;
mCalcGrid[mNewLocation].PY = mLocationY;
mCalcGrid[mNewLocation].G = mNewG;
switch (mFormula)
{
default:
case HeuristicFormula.Manhattan:
mH = mHEstimate * (Math.Abs(mNewLocationX - end.X) + Math.Abs(mNewLocationY - end.Y));
break;
case HeuristicFormula.MaxDXDY:
mH = mHEstimate * (Math.Max(Math.Abs(mNewLocationX - end.X), Math.Abs(mNewLocationY - end.Y)));
break;
case HeuristicFormula.DiagonalShortCut:
int h_diagonal = Math.Min(Math.Abs(mNewLocationX - end.X), Math.Abs(mNewLocationY - end.Y));
int h_straight = (Math.Abs(mNewLocationX - end.X) + Math.Abs(mNewLocationY - end.Y));
mH = (mHEstimate * 2) * h_diagonal + mHEstimate * (h_straight - 2 * h_diagonal);
break;
case HeuristicFormula.Euclidean:
mH = (int)(mHEstimate * Math.Sqrt(Math.Pow((mNewLocationY - end.X), 2) + Math.Pow((mNewLocationY - end.Y), 2)));
break;
case HeuristicFormula.EuclideanNoSQR:
mH = (int)(mHEstimate * (Math.Pow((mNewLocationX - end.X), 2) + Math.Pow((mNewLocationY - end.Y), 2)));
break;
case HeuristicFormula.Custom1:
PathFinderPoint dxy = new PathFinderPoint(Math.Abs(end.X - mNewLocationX), Math.Abs(end.Y - mNewLocationY));
int Orthogonal = Math.Abs(dxy.X - dxy.Y);
int Diagonal = Math.Abs(((dxy.X + dxy.Y) - Orthogonal) / 2);
mH = mHEstimate * (Diagonal + Orthogonal + dxy.X + dxy.Y);
break;
}
if (mTieBreaker)
{
int dx1 = mLocationX - end.X;
int dy1 = mLocationY - end.Y;
int dx2 = start.X - end.X;
int dy2 = start.Y - end.Y;
int cross = Math.Abs(dx1 * dy2 - dx2 * dy1);
mH = (int)(mH + cross * 0.001);
}
mCalcGrid[mNewLocation].F = mNewG + mH;
//It is faster if we leave the open node in the priority queue
//When it is removed, it will be already closed, it will be ignored automatically
//if (tmpGrid[newLocation].Status == 1)
//{
// //int removeX = newLocation & gridXMinus1;
// //int removeY = newLocation >> gridYLog2;
// mOpen.RemoveLocation(newLocation);
//}
//if (tmpGrid[newLocation].Status != 1)
//{
mOpen.Push(mNewLocation);
//}
mCalcGrid[mNewLocation].Status = mOpenNodeValue;
}
mCloseNodeCounter++;
mCalcGrid[mLocation].Status = mCloseNodeValue;
}
//mCompletedTime = HighResolutionTime.GetTime();
if (mFound)
{
mClose.Clear();
int posX = end.X;
int posY = end.Y;
PathFinderNodeFast fNodeTmp = mCalcGrid[(end.Y << mGridYLog2) + end.X];
PathFinderNode fNode;
fNode.F = fNodeTmp.F;
fNode.G = fNodeTmp.G;
fNode.H = 0;
fNode.PX = fNodeTmp.PX;
fNode.PY = fNodeTmp.PY;
fNode.X = end.X;
fNode.Y = end.Y;
while (fNode.X != fNode.PX || fNode.Y != fNode.PY)
{
mClose.Add(fNode);
posX = fNode.PX;
posY = fNode.PY;
fNodeTmp = mCalcGrid[(posY << mGridYLog2) + posX];
fNode.F = fNodeTmp.F;
fNode.G = fNodeTmp.G;
fNode.H = 0;
fNode.PX = fNodeTmp.PX;
fNode.PY = fNodeTmp.PY;
fNode.X = posX;
fNode.Y = posY;
}
mClose.Add(fNode);
mStopped = true;
return(mClose);
}
mStopped = true;
return(null);
}
}
public List <PathFinderNode> FindPath(PathFinderPoint start, PathFinderPoint end)
{
HighResolutionTime.Start();
PathFinderNode parentNode;
bool found = false;
int gridX = mGrid.GetUpperBound(0);
int gridY = mGrid.GetUpperBound(1);
mStop = false;
mStopped = false;
mOpen.Clear();
mClose.Clear();
#if DEBUGON
if (mDebugProgress && PathFinderDebug != null)
{
PathFinderDebug(0, 0, start.X, start.Y, PathFinderNodeType.Start, -1, -1);
}
if (mDebugProgress && PathFinderDebug != null)
{
PathFinderDebug(0, 0, end.X, end.Y, PathFinderNodeType.End, -1, -1);
}
#endif
sbyte[,] direction;
if (mDiagonals)
{
direction = new sbyte[8, 2] {
{ 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }, { 1, -1 }, { 1, 1 }, { -1, 1 }, { -1, -1 }
}
}
;
else
{
direction = new sbyte[4, 2] {
{ 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }
}
};
parentNode.G = 0;
parentNode.H = mHEstimate;
parentNode.F = parentNode.G + parentNode.H;
parentNode.X = start.X;
parentNode.Y = start.Y;
parentNode.PX = parentNode.X;
parentNode.PY = parentNode.Y;
mOpen.Push(parentNode);
while (mOpen.Count > 0 && !mStop)
{
parentNode = mOpen.Pop();
#if DEBUGON
if (mDebugProgress && PathFinderDebug != null)
{
PathFinderDebug(0, 0, parentNode.X, parentNode.Y, PathFinderNodeType.Current, -1, -1);
}
#endif
if (parentNode.X == end.X && parentNode.Y == end.Y)
{
mClose.Add(parentNode);
found = true;
break;
}
if (mClose.Count > mSearchLimit)
{
mStopped = true;
return(null);
}
if (mPunishChangeDirection)
{
mHoriz = (parentNode.X - parentNode.PX);
}
//Lets calculate each successors
for (int i = 0; i < (mDiagonals ? 8 : 4); i++)
{
PathFinderNode newNode;
newNode.X = parentNode.X + direction[i, 0];
newNode.Y = parentNode.Y + direction[i, 1];
if (newNode.X < 0 || newNode.Y < 0 || newNode.X >= gridX || newNode.Y >= gridY)
{
continue;
}
int newG;
if (mHeavyDiagonals && i > 3)
{
newG = parentNode.G + (int)(mGrid[newNode.X, newNode.Y] * 2.41);
}
else
{
newG = parentNode.G + mGrid[newNode.X, newNode.Y];
}
if (newG == parentNode.G)
{
//Unbrekeable
continue;
}
if (mPunishChangeDirection)
{
if ((newNode.X - parentNode.X) != 0)
{
if (mHoriz == 0)
{
newG += 20;
}
}
if ((newNode.Y - parentNode.Y) != 0)
{
if (mHoriz != 0)
{
newG += 20;
}
}
}
int foundInOpenIndex = -1;
for (int j = 0; j < mOpen.Count; j++)
{
if (mOpen[j].X == newNode.X && mOpen[j].Y == newNode.Y)
{
foundInOpenIndex = j;
break;
}
}
if (foundInOpenIndex != -1 && mOpen[foundInOpenIndex].G <= newG)
{
continue;
}
int foundInCloseIndex = -1;
for (int j = 0; j < mClose.Count; j++)
{
if (mClose[j].X == newNode.X && mClose[j].Y == newNode.Y)
{
foundInCloseIndex = j;
break;
}
}
if (foundInCloseIndex != -1 && mClose[foundInCloseIndex].G <= newG)
{
continue;
}
newNode.PX = parentNode.X;
newNode.PY = parentNode.Y;
newNode.G = newG;
switch (mFormula)
{
default:
case HeuristicFormula.Manhattan:
newNode.H = mHEstimate * (Math.Abs(newNode.X - end.X) + Math.Abs(newNode.Y - end.Y));
break;
case HeuristicFormula.MaxDXDY:
newNode.H = mHEstimate * (Math.Max(Math.Abs(newNode.X - end.X), Math.Abs(newNode.Y - end.Y)));
break;
case HeuristicFormula.DiagonalShortCut:
int h_diagonal = Math.Min(Math.Abs(newNode.X - end.X), Math.Abs(newNode.Y - end.Y));
int h_straight = (Math.Abs(newNode.X - end.X) + Math.Abs(newNode.Y - end.Y));
newNode.H = (mHEstimate * 2) * h_diagonal + mHEstimate * (h_straight - 2 * h_diagonal);
break;
case HeuristicFormula.Euclidean:
newNode.H = (int)(mHEstimate * Math.Sqrt(Math.Pow((newNode.X - end.X), 2) + Math.Pow((newNode.Y - end.Y), 2)));
break;
case HeuristicFormula.EuclideanNoSQR:
newNode.H = (int)(mHEstimate * (Math.Pow((newNode.X - end.X), 2) + Math.Pow((newNode.Y - end.Y), 2)));
break;
case HeuristicFormula.Custom1:
PathFinderPoint dxy = new PathFinderPoint(Math.Abs(end.X - newNode.X), Math.Abs(end.Y - newNode.Y));
int Orthogonal = Math.Abs(dxy.X - dxy.Y);
int Diagonal = Math.Abs(((dxy.X + dxy.Y) - Orthogonal) / 2);
newNode.H = mHEstimate * (Diagonal + Orthogonal + dxy.X + dxy.Y);
break;
}
if (mTieBreaker)
{
int dx1 = parentNode.X - end.X;
int dy1 = parentNode.Y - end.Y;
int dx2 = start.X - end.X;
int dy2 = start.Y - end.Y;
int cross = Math.Abs(dx1 * dy2 - dx2 * dy1);
newNode.H = (int)(newNode.H + cross * 0.001);
}
newNode.F = newNode.G + newNode.H;
#if DEBUGON
if (mDebugProgress && PathFinderDebug != null)
{
PathFinderDebug(parentNode.X, parentNode.Y, newNode.X, newNode.Y, PathFinderNodeType.Open, newNode.F, newNode.G);
}
#endif
//It is faster if we leave the open node in the priority queue
//When it is removed, all nodes around will be closed, it will be ignored automatically
//if (foundInOpenIndex != -1)
// mOpen.RemoveAt(foundInOpenIndex);
//if (foundInOpenIndex == -1)
mOpen.Push(newNode);
}
mClose.Add(parentNode);
#if DEBUGON
if (mDebugProgress && PathFinderDebug != null)
{
PathFinderDebug(0, 0, parentNode.X, parentNode.Y, PathFinderNodeType.Close, parentNode.F, parentNode.G);
}
#endif
}
mCompletedTime = HighResolutionTime.GetTime();
if (found)
{
PathFinderNode fNode = mClose[mClose.Count - 1];
for (int i = mClose.Count - 1; i >= 0; i--)
{
if (fNode.PX == mClose[i].X && fNode.PY == mClose[i].Y || i == mClose.Count - 1)
{
#if DEBUGON
if (mDebugFoundPath && PathFinderDebug != null)
{
PathFinderDebug(fNode.X, fNode.Y, mClose[i].X, mClose[i].Y, PathFinderNodeType.Path, mClose[i].F, mClose[i].G);
}
#endif
fNode = mClose[i];
}
else
{
mClose.RemoveAt(i);
}
}
mStopped = true;
return(mClose);
}
mStopped = true;
return(null);
}