/// <summary>
    /// Pahtfinding using A*
    /// </summary>
    /// <returns>an arraylist with all the nodes to get to the target</returns>
    private ArrayList NavigateToTarget()
    {
        if (target == null)
        {
            return(new ArrayList());
        }

        ArrayList closed = new ArrayList();
        ArrayList open   = new ArrayList();

        NodeScript start = currentStartNode;

        start.gScore = 0;
        start.fScore = start.DistanceEstimate(start, target);
        open.Add(start.gameObject);

        while (open.Count > 0)
        {
            NodeScript currentNode;
            float      shortestDistance       = float.MaxValue;
            int        shortestNeighbourIndex = 0;
            for (int i = 0; i < open.Count; i++)
            {
                GameObject nodeEval = open[i] as GameObject;
                nodeEval.GetComponent <NodeScript>().fScore = nodeEval.GetComponent <NodeScript>().DistanceEstimate(nodeEval.GetComponent <NodeScript>(), target);
                if (nodeEval.GetComponent <NodeScript>().fScore < shortestDistance)
                {
                    shortestDistance       = nodeEval.GetComponent <NodeScript>().fScore;
                    shortestNeighbourIndex = i;
                }
            }
            GameObject node = (GameObject)open[shortestNeighbourIndex] as GameObject;
            currentNode = node.GetComponent <NodeScript>();

            if (currentNode == target)
            {
                ArrayList path = ReconstructPath(currentNode);
                //Restoring the infinity values to be better
                for (int i = 0; i < game.nodes.Count; i++)
                {
                    GameObject nodeEval = (GameObject)game.nodes[i] as GameObject;
                    nodeEval.GetComponent <NodeScript>().fScore       = float.MaxValue;
                    nodeEval.GetComponent <NodeScript>().gScore       = float.MaxValue;
                    nodeEval.GetComponent <NodeScript>().previousNode = null;
                }

                return(path);
            }
            open.Remove(currentNode.gameObject);
            closed.Add(currentNode.gameObject);

            for (int i = 0; i < currentNode.neighbours.Length; i++)
            {
                NodeScript neighbour = currentNode.neighbours[i].GetComponent <NodeScript>();
                if (closed.Contains(neighbour.gameObject))
                {
                    continue;
                }
                float tenativeGScore = currentNode.gScore + currentNode.distances[i];
                if (!open.Contains(neighbour.gameObject))
                {
                    open.Add(neighbour.gameObject);
                }
                else if (tenativeGScore >= neighbour.gScore)
                {
                    continue;
                }

                neighbour.previousNode = currentNode;
                neighbour.gScore       = tenativeGScore;
                neighbour.fScore       = neighbour.gScore + neighbour.DistanceEstimate(neighbour, target);
            }
        }
        return(new ArrayList()); //FAILURE
    }