void FindPath(Vector3 startPos, Vector3 targetPos)
{
NodeScript startNode = grid.NodeFromWorldPoint(startPos);
NodeScript targetNode = grid.NodeFromWorldPoint(targetPos);
List <NodeScript> openSet = new List <NodeScript>();
HashSet <NodeScript> closedSet = new HashSet <NodeScript>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
NodeScript node = openSet[0];
for (int i = 1; i < openSet.Count; i++)
{
if (openSet[i].fCost < node.fCost || openSet[i].fCost == node.fCost)
{
if (openSet[i].hCost < node.hCost)
{
node = openSet[i];
}
}
}
openSet.Remove(node);
closedSet.Add(node);
if (node == targetNode)
{
RetracePath(startNode, targetNode);
return;
}
foreach (NodeScript neighbour in grid.GetNeighbours(node))
{
if (!neighbour.walkable || closedSet.Contains(neighbour))
{
continue;
}
int newCostToNeighbour = node.gCost + GetDistance(node, neighbour);
if (newCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newCostToNeighbour;
neighbour.hCost = GetDistance(neighbour, targetNode);
neighbour.parent = node;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
}
}
}
}
public Node[] PathFinding(Node startNode, Node targetNode)
{
Node[] waypoints = new Node[0];
bool pathSuccess = false;
if ((startNode.walkable && targetNode.walkable) || (!startNode.walkable && targetNode.walkable))
{
Heap <Node> openSet = new Heap <Node>(grid.MaxSize);
HashSet <Node> closedSet = new HashSet <Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node currentNode = openSet.RemoveFirst();
closedSet.Add(currentNode);
if (currentNode == targetNode)
{
pathSuccess = true;
break;
}
foreach (Node neighbour in grid.GetNeighbours(currentNode))
{
if (closedSet.Contains(neighbour))
{
continue;
}
int newMovementCostToNeighbour = currentNode.gCost + GetManhattanDistance(currentNode, neighbour);
if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newMovementCostToNeighbour;
neighbour.hCost = GetManhattanDistance(neighbour, targetNode);
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
else
{
openSet.UpdateItem(neighbour);
}
}
}
}
}
if (pathSuccess)
{
waypoints = RetracePath(startNode, targetNode);
}
return(waypoints);
}
//FindPath() is going to be the function you use to calculate the distance between two points on the grid. This is important though, before you use it make sure you're
//passing it in NODE classes and not vectors. If you need to convert a vector3 for it pass that into the gridFromWorldPoint() function on the gridscript.
void FindPath(Node startNode, Node targetNode)
{
//Node startNode = grid.NodeFromWorldPoint(startPos);
//Node targetNode = grid.NodeFromWorldPoint(targetPos);
List <Node> openSet = new List <Node>(); //List of nodes from "OpenSet" which are nodes that have not been checked yet
HashSet <Node> closedSet = new HashSet <Node>(); //HashSet of nodes from "ClosedSet" which are nodes that have already been checked
openSet.Add(startNode); //Adds the first node
while (openSet.Count > 0)
{
Node currentNode = openSet[0];
for (int i = 1; i < openSet.Count; i++)
{
//Checks the node being evalutated to see if it's fCost is lower or if the fCost is the same AND the hCost is lower
//if so switches to that node
if (openSet[i].fCost < currentNode.fCost || openSet[i].fCost == currentNode.fCost && openSet[i].hCost < currentNode.hCost)
{
currentNode = openSet[i];
}
}
//Remove Current from the openset and add to the closed set
openSet.Remove(currentNode);
closedSet.Add(currentNode);
//If destination is found runs RetracePath function passing in both the start and target node
if (currentNode == targetNode)
{
RetracePath(startNode, targetNode);
return;
}
foreach (Node neighbour in grid.GetNeighbours(currentNode))
{
if (!neighbour.walkable || closedSet.Contains(neighbour))
{
continue;
}
//Calculates movement cost to neighbour using the gCost and GetDistance function
int newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour);
if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newMovementCostToNeighbour; //Set new g cost
neighbour.hCost = GetDistance(neighbour, targetNode); //Calculates hCost with GetDistance function
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
}
}
}
}
public List <Node> FindPath(Node startNode, Node destinationNode)
{
Heap <Node> openSet = new Heap <Node>(gridScript.MaxGridSize);
HashSet <Node> closedSet = new HashSet <Node>();
int defaultMoveCost = Mathf.RoundToInt(gridScript.hexSize);
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node currentNode = openSet.RemoveFirst();
if (currentNode == destinationNode)
{
return(RetracePath(startNode, destinationNode));
}
closedSet.Add(currentNode);
foreach (Node neighbour in gridScript.GetNeighbours(currentNode))
{
if (neighbour.traversable == false || closedSet.Contains(neighbour))
{
continue;
}
int newGCost = currentNode.gCost + defaultMoveCost;
if (newGCost < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newGCost;
//neighbour.hCost = GetHeuristicDistance(neighbour, destinationNode);
neighbour.hCost = Mathf.RoundToInt(Vector3.Distance(neighbour.position, destinationNode.position));
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
else
{
openSet.UpdateItem(neighbour);
}
}
}
}
Debug.Log("incompleet path given");
return(new List <Node>());
}
IEnumerator FindPath(Vector3 startPos, Vector3 targetPos)
{
Stopwatch sw = new Stopwatch();
sw.Start();
Vector3[] waypoints = new Vector3[0];
bool pathSuccess = false;
Node startNode = grid.NodeFromWorldPoint(startPos);
Node targetNode = grid.NodeFromWorldPoint(targetPos);
if (startNode.walkable && targetNode.walkable)
{
Heap <Node> openSet = new Heap <Node>(grid.MaxSize);
HashSet <Node> closedSet = new HashSet <Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node currentNode = openSet.RemoveFirst();
closedSet.Add(currentNode);
if (currentNode == targetNode)
{
sw.Stop();
print("Path found: " + sw.ElapsedMilliseconds + " ms");
pathSuccess = true;
break;
}
foreach (Node neighbour in grid.GetNeighbours(currentNode))
{
if (!neighbour.walkable || closedSet.Contains(neighbour))
{
continue;
}
int newCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour);
if (newCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newCostToNeighbour;
neighbour.hCost = GetDistance(neighbour, targetNode);
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
else
{
openSet.UpdateItem(neighbour);
}
}
}
}
}
yield return(null);
if (pathSuccess)
{
waypoints = RetracePath(startNode, targetNode);
}
requestManager.FinishedProcessingPath(waypoints, pathSuccess);
}
//This function calculates the shortest path using A*
void FindPath(Vector3 startPos, Vector3 targetPos)
{
// Get the start node and end node from their world position.
Node startNode = grid.NodeFromWorldPoint(startPos);
Node targetNode = grid.NodeFromWorldPoint(targetPos);
List <Node> openSet = new List <Node>();
HashSet <Node> closedSet = new HashSet <Node>();
//Add the start node to the openset
openSet.Add(startNode);
//Loop until the openset is empty
while (openSet.Count > 0)
{
Node currentNode = openSet[0];
//Find the node with the lowest cost
for (int i = 1; i < openSet.Count; i++)
{
if (openSet[i].fCost < currentNode.fCost || openSet[i].fCost == currentNode.fCost && openSet[i].hCost < currentNode.hCost)
{
currentNode = openSet[i];
}
}
//Remove the node from the openset to the closed set.
openSet.Remove(currentNode);
closedSet.Add(currentNode);
//If the current node it the end
if (currentNode == targetNode)
{
RetracePath(startNode, targetNode);
return;
}
// Add the neighbours to the openset
foreach (Node neighbour in grid.GetNeighbours(currentNode))
{
if (!neighbour.walkable || closedSet.Contains(neighbour))
{
continue;
}
//Make the node not go diagonaly when a neighbour is unwalkable "this is code by me".
if (GetDistance(currentNode, neighbour) > 10)
{
int a = neighbour.gridX - currentNode.gridX;
int b = neighbour.gridY - currentNode.gridY;
if (!grid.getNode(neighbour.gridX - a, neighbour.gridY).walkable || !grid.getNode(neighbour.gridX, neighbour.gridY - b).walkable)
{
continue;
}
}
int newMocementCOstToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour);
//Update H and G costs
if (newMocementCOstToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newMocementCOstToNeighbour;
neighbour.hCost = GetDistance(neighbour, targetNode);
neighbour.parent = currentNode;
//Add the neighbours to the openset
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
}
}
}
}
public override void Action(GameManagerScript gameManager, GridScript grid, TileInformation tile)
{
if (_tile.BonusReceived) return;
var neighbours = grid.GetNeighbours(grid.TileList.First(t => t.TileInformation == _tile));
var influenceCount = 0;
foreach (var neighbour in neighbours)
{
influenceCount += neighbour.TileInformation.DeltaInf;
influenceCount -= neighbour.TileInformation.DeltaNot;
}
if (influenceCount >= 10)
{
Debug.Log("Got Bonus!!!!");
_tile.BonusReceived = true;
gameManager.People += 10;
}
}
public void OnMouseOver()
{
List <Node> neighbours = grid.GetNeighbours(grid.NodeFromWorldPoint(grid.player.position));
Debug.Log(neighbours[0].worldPosition);
}
/*
* bool stallBool = false;
* void HandlePathfindingLOD()
* {
* float dst = Vector2.Distance(seeker.position, target.position);
* if(dst > 7)
* {
* if (!stallBool)
* {
* stallBool = true;
* StopAllCoroutines();
* //StartCoroutine(FindPathAfterDelay(0.5f));
* }
* }
* if(dst > 3 && dst <= 7)
* {
* if (!stallBool)
* {
* stallBool = true;
* StopAllCoroutines();
* //StartCoroutine(FindPathAfterDelay(0.3f));
* }
* }
* if(dst <= 3)
* {
* if (!stallBool)
* {
* stallBool = true;
* StopAllCoroutines();
* //StartCoroutine(FindPathAfterDelay(0.1f));
* }
* }
* }
*/
#endregion
IEnumerator FindPath(Vector3 startPos, Vector3 targetPos)
{
Vector2[] waypoints = new Vector2[0];
bool pathSuccess = false;
Node startNode = grid.NodeFromWorldPoint(startPos);
Node targetNode = grid.NodeFromWorldPoint(targetPos);
Debug.Log("Start Node worldPos: " + startNode.worldPos + ", Target Node worldPos:" + targetNode.worldPos);
if (startNode.walkable && targetNode.walkable)
{
Heap <Node> openSet = new Heap <Node>(grid.MaxSize);
HashSet <Node> closedSet = new HashSet <Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node curNode = openSet.RemoveFirst();
closedSet.Add(curNode);
if (curNode == targetNode)
{
pathSuccess = true;
break;
}
foreach (Node neighbour in grid.GetNeighbours(curNode))
{
if (!neighbour.walkable || closedSet.Contains(neighbour))
{
continue;
}
int newCostToNeighbour = curNode.GCost + GetDistance(curNode, neighbour);
if (newCostToNeighbour < neighbour.GCost || !openSet.Contains(neighbour))
{
neighbour.GCost = newCostToNeighbour;
neighbour.HCost = GetDistance(neighbour, targetNode);
neighbour.parent = curNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
else
{
openSet.UpdateItem(neighbour);
}
}
}
}
}
yield return(null);
if (pathSuccess)
{
waypoints = RetracePath(startNode, targetNode);
}
if (waypoints.Length == 0)
{
pathSuccess = false;
}
requestManager.FinishProcessingPath(waypoints, pathSuccess);
}
void FindPath(Vector3 start_position, Vector3 target_position)
{
Node start_node = grid.NodeFromWoldPoint(start_position);
Node target_node = grid.NodeFromWoldPoint(target_position);
List <Node> open_list = new List <Node>();
HashSet <Node> closed_list = new HashSet <Node>();
open_list.Add(start_node);
while (open_list.Count > 0)
{
Node current_node = open_list[0];
for (int i = 1; i < open_list.Count; i++)
{
if (open_list[i].f_cost < current_node.f_cost || open_list[i].f_cost == current_node.f_cost && open_list[i].h_cost < current_node.h_cost)
{
current_node = open_list[i];
}
}
open_list.Remove(current_node);
closed_list.Add(current_node);
if (current_node == target_node)
{
ShowPath(start_node, target_node);
return;
}
foreach (Node neighbour in grid.GetNeighbours(current_node))
{
if (!neighbour.walkable || closed_list.Contains(neighbour))
{
continue;
}
int distance_to_neighbor = current_node.g_cost + GetDistance(current_node, neighbour);
if (distance_to_neighbor < neighbour.g_cost || !open_list.Contains(neighbour))
{
neighbour.g_cost = distance_to_neighbor;
neighbour.h_cost = GetDistance(neighbour, target_node);
neighbour.parent = current_node;
if (!open_list.Contains(neighbour))
{
open_list.Add(neighbour);
}
}
}
}
int GetDistance(Node node1, Node node2)
{
int distance_x = Mathf.Abs(node1.grid_x - node2.grid_x);
int distance_y = Mathf.Abs(node1.grid_y - node2.grid_y);
if (distance_x > distance_y)
{
return(14 * distance_y + 10 * (distance_x - distance_y));
}
return(14 * distance_x + 10 * (distance_y - distance_x));
}
}
