public void Initialize(Scratch_TileData correspondingTile, Scratch_TileData destinationTile)
{
Parent = null;
Passable = (correspondingTile.Type == TileType.Floor) ? true : false;
//if (correspondingTile.Type == TileType.Door) Passable = correspondingTile.DoorOpened;
CalculateDistanceToDestination(destinationTile);
}
private void SetTileData()
{
TilesRow = areaTilesRow * areasRow;
TilesColumn = areaTilesColumn * areasColumn;
TileData = new Scratch_TileData[TilesRow, TilesColumn];
for (int z = 0; z < TilesColumn; z++)
{
for (int x = 0; x < TilesRow; x++)
{
TileData[x, z] = new Scratch_TileData(x, z);
}
}
}
private void Refresh(Scratch_TileData[,] tileData, Scratch_TileData destinationTile)
{
openList.Clear();
closedList.Clear();
FinalTrack.Clear();
currentNode = null;
for (int z = 0; z < column; z++)
{
for (int x = 0; x < row; x++)
{
node[x, z].Initialize(tileData[x, z], destinationTile);
}
}
}
private void CalculateDistanceToDestination(Scratch_TileData destinationTile)
{
int destinationX = destinationTile.X;
int destinationZ = destinationTile.Z;
int xDistance = Mathf.Abs(destinationX - X);
int zDistance = Mathf.Abs(destinationZ - Z);
if (xDistance - zDistance == 0)
{
DistanceToDestination = 14 * zDistance;
}
else
{
int linearDistance = Mathf.Abs(xDistance - zDistance);
int furtherAxis = (xDistance - zDistance > 0) ? xDistance : zDistance;
int diagonalDistance = furtherAxis - linearDistance;
DistanceToDestination = linearDistance * 10 + diagonalDistance * 14;
}
}
private Vector3 SetHighlighterPosition()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo, 100.0f, 1 << LayerMask.NameToLayer("Tile Map")) == true)
{
mouseOnTileX = (int)(hitInfo.point.x + .5f);
mouseOnTileZ = (int)(hitInfo.point.z + .5f);
HighlightDoor();
Scratch_TileData currentTile = mapData.TileData[mouseOnTileX, mouseOnTileZ];
return(new Vector3((float)currentTile.X, .0f, (float)currentTile.Z));
}
mouseOnTileX = invalidIndex;
mouseOnTileZ = invalidIndex;
return(Vector3.zero);
}
public bool FindPath(Scratch_TileData[,] tileData, Scratch_TileData startingTile, Scratch_TileData destinationTile, bool doorTile = false)
{
Refresh(tileData, destinationTile);
currentNode = node[startingTile.X, startingTile.Z];
closedList.Add(currentNode);
int failureCount = row * column;
if (doorTile == true)
{
node[destinationTile.X, destinationTile.Z].Passable = true;
}
while (true)
{
for (int z = currentNode.Z - 1; z < currentNode.Z + 2; z++)
{
for (int x = currentNode.X - 1; x < currentNode.X + 2; x++)
{
if (NodeIndexAvailable(x, z) == false)
{
continue;
}
if (node[x, z].Passable == false)
{
continue;
}
if (NodeInClosedList(node[x, z]) == true)
{
continue;
}
if (NodeInOpenList(node[x, z]) == false)
{
node[x, z].Parent = currentNode;
node[x, z].CalculateCostToDestination();
openList.Add(node[x, z]);
}
else
{
Node_AStar newData = new Node_AStar(node[x, z]);
newData.Parent = currentNode;
newData.CalculateCostToDestination();
if (newData.CostToDestination < node[x, z].CostToDestination)
{
node[x, z].Parent = currentNode;
node[x, z].CalculateCostToDestination();
}
}
}
}
int lowestCost = 99999999;
for (int i = 0; i < openList.Count; i++)
{
if (openList[i].CostToDestination < lowestCost)
{
lowestCost = openList[i].CostToDestination;
currentNode = openList[i];
}
}
if (currentNode == node[destinationTile.X, destinationTile.Z])
{
int whileBreaker = row * column;
if (doorTile == true)
{
currentNode = currentNode.Parent;
}
while (true)
{
FinalTrack.Add(currentNode);
if (currentNode == node[startingTile.X, startingTile.Z])
{
FinalTrack.Reverse();
return(true);
}
currentNode = currentNode.Parent;
whileBreaker--;
if (whileBreaker < 0)
{
return(false);
}
}
}
openList.Remove(currentNode);
closedList.Add(currentNode);
failureCount--;
if (failureCount < 0)
{
return(false);
}
}
}
public Node_AStar(Scratch_TileData correspondingTile)
{
X = correspondingTile.X;
Z = correspondingTile.Z;
}
