private void GenerateNeighbors()
{
for (i = -1; i <= 1; i++)
{
checkX = gridX + i;
if (checkX >= 0 && checkX < GridManager.NodeCount)
{
for (j = -1; j <= 1; j++)
{
checkY = gridY + j;
if (checkY >= 0 && checkY < GridManager.NodeCount)
{
GridNode checkNode = GridManager.Grid [GridManager.GetGridIndex(checkX, checkY)];
if (i == 0 && j == 0)
{
continue;
}
if (checkNode.Unwalkable)
{
Obstructed = true;
}
//if ((i != 0 && j != 0)) continue;
NeighborNodes [GetNeighborIndex(i, j)] = checkNode;
}
}
}
}
}
public void Setup(int _x, int _y)
{
gridX = _x;
gridY = _y;
gridIndex = GridManager.GetGridIndex(gridX, gridY);
WorldPos.x = gridX * FixedMath.One + GridManager.OffsetX;
WorldPos.y = gridY * FixedMath.One + GridManager.OffsetY;
}
public void Setup(int _x, int _y)
{
if (_x < 0 || _y < 0)
{
Debug.LogError("Cannot be negative!");
}
gridX = _x;
gridY = _y;
gridIndex = GridManager.GetGridIndex(gridX, gridY);
WorldPos.x = gridX * FixedMath.One + GridManager.OffsetX;
WorldPos.y = gridY * FixedMath.One + GridManager.OffsetY;
}
private void GenerateNeighbors()
{
//0-3 = sides, 4-7 = diagonals
//0 = (-1, 0)
//1 = (0,-1)
//2 = (0,1)
//3 = (1,0)
//4 = (-1,-1)
//5 = (-1,1)
//6 = (1,-1)
//7 = (1,1)
int sideIndex = 0;
int diagonalIndex = 4; //I learned how to spell [s]diagnal[/s] diagonal!!!
for (i = -1; i <= 1; i++)
{
checkX = gridX + i;
for (j = -1; j <= 1; j++)
{
if (i == 0 && j == 0) //Don't do anything for the same node
{
continue;
}
checkY = gridY + j;
if (GridManager.ValidateCoordinates(checkX, checkY))
{
int neighborIndex;
if ((i != 0 && j != 0))
{
//Diagonal
if (GridManager.UseDiagonalConnections)
{
neighborIndex = diagonalIndex++;
}
else
{
continue;
}
}
else
{
neighborIndex = sideIndex++;
}
GridNode checkNode = GridManager.Grid [GridManager.GetGridIndex(checkX, checkY)];
NeighborNodes [neighborIndex] = checkNode;
}
}
}
}
private void GenerateNeighbors()
{
for (i = -1; i <= 1; i++)
{
checkX = gridX + i;
if (checkX >= 0 && checkX < GridManager.NodeCount)
{
for (j = -1; j <= 1; j++)
{
if (i == 0 && j == 0)
{
continue;
}
//if (i != 0 && j != 0) continue;
checkY = gridY + j;
if (checkY >= 0 && checkY < GridManager.NodeCount)
{
GridNode checkNode = GridManager.Grid [GridManager.GetGridIndex(checkX, checkY)];
if (checkNode.Unwalkable)
{
Obstructed = true;
}
GetNeighborIndex(i, j);
if (i != 0)
{
if (j != 0)
{
NeighborDiagnal[leIndex] = (true);
}
else
{
NeighborDiagnal[leIndex] = (false);
}
}
else
{
NeighborDiagnal[leIndex] = (false);
}
NeighborNodes[leIndex] = checkNode;
NeighborCount++;
}
}
}
}
}
public bool UnpassableLarge()
{
int half = (CachedSize + 1) / 2;
for (int x = -half; x <= half; x++)
{
for (int y = -half; y <= half; y++)
{
int index = GridManager.GetGridIndex(gridX + x, gridY + y);
if (GridManager.ValidateIndex(index))
{
if (GridManager.Grid[index].Unwalkable)
{
return(true);
}
}
}
}
return(false);
}
public static bool NeedsPath(GridNode startNode, GridNode endNode, int unitSize)
{
//Tests if there is a direct path. If there is, no need to run AStar.
x0 = startNode.gridX;
y0 = startNode.gridY;
x1 = endNode.gridX;
y1 = endNode.gridY;
if (y1 > y0)
{
compare1 = y1 - y0;
}
else
{
compare1 = y0 - y1;
}
if (x1 > x0)
{
compare2 = x1 - x0;
}
else
{
compare2 = x0 - x1;
}
steep = compare1 > compare2;
if (steep)
{
t = x0; // swap x0 and y0
x0 = y0;
y0 = t;
t = x1; // swap x1 and y1
x1 = y1;
y1 = t;
}
if (x0 > x1)
{
t = x0; // swap x0 and x1
x0 = x1;
x1 = t;
t = y0; // swap y0 and y1
y0 = y1;
y1 = t;
}
dx = x1 - x0;
dy = (y1 - y0);
if (dy < 0)
{
dy = -dy;
}
error = dx / 2;
ystep = (y0 < y1) ? 1 : -1;
y = y0;
GridNode.PrepareUnpassableCheck(unitSize);
for (x = x0; x <= x1; x++)
{
retX = (steep ? y : x);
retY = (steep ? x : y);
currentNode = GridManager.Grid[GridManager.GetGridIndex(retX, retY)];
if (currentNode != null && currentNode.Unpassable())
{
break;
}
else if (x == x1)
{
return(false);
}
error = error - dy;
if (error < 0)
{
y += ystep;
error += dx;
}
}
return(true);
}
