scr_findPath

///scr_findPath(startNode, endNode, ds_list<obj_node>, max range)

var startNode = argument0;
var endNode = argument1;
var pathNodes = argument2;
var maxRange = argument3;

var openSet = ds_list_create(); //create open set
var closedSet = ds_list_create(); //create closed set

ds_list_add(openSet,startNode); //add starting node to open set

//while there are nodes in the open set, do the algorithm
//otherwise return false (path not found)

while(ds_list_size(openSet) > 0)
{
    //here we get the node with the lowest F cost (G cost + H cost)
    //from all the nodes in the open set
    //and remove it from the open set and
    //add it to the closed set
    var currentNode = ds_list_find_value(openSet,0);
    var index = 0;
    for (var i=0;i<ds_list_size(openSet);++i)
    {
        var tmpNode = ds_list_find_value(openSet,i);
        if (tmpNode.fCost < currentNode.fCost)
        {
            currentNode = tmpNode;
            index = i;
        }
    }
    ds_list_delete(openSet,index);
    ds_list_add(closedSet,currentNode);

    //if our current node (from the open set) is our end node
    //return true (path found) and retrace path from end to start
    //and add nodes to the list
    if (currentNode == endNode)
    {
        ds_list_destroy(openSet);
        ds_list_destroy(closedSet);

        var currentNode = endNode;

        while (currentNode != startNode)
        {
            ds_list_insert(pathNodes,0,currentNode);
            currentNode = currentNode.parent;
        }
        ds_list_insert(pathNodes,0,startNode);
        return true;
    }

    //get neighbour nodes from current node
    var neighbours = scr_getNeighbours(currentNode,maxRange);

    //for each neighbour
    for (var i=0;i<ds_list_size(neighbours);++i)
    {
        var neighbourNode = ds_list_find_value(neighbours,i);

        //if the neighbour nodes is in the closed set
        //set the boolean closedSetContains to true, else false
        var closedSetContains = false;
        for (var j=0;j<ds_list_size(closedSet);++j)
        {
            var tmpNode = ds_list_find_value(closedSet,j);
            if (tmpNode == neighbourNode)
            {
                closedSetContains = true;
                break;
            }
        }

        //if the neighbour node isn't in the closed set
        if (!closedSetContains)
        {
            //calculates new distance for the node
            var newMovementCost = currentNode.gCost + scr_getDistance(currentNode,neighbourNode);

            //if the neighbour nodes is in the open set
            //set the boolean openSetContains to true, else false
            var openSetContains = false;
            for (var j=0;j<ds_list_size(openSet);++j)
            {
                var tmpNode = ds_list_find_value(openSet,j);
                if (tmpNode == neighbourNode)
                {
                    openSetContains = true;
                    break;
                }
            }

            //if our new calculated movement cost is smaller than
            //the neighbour node G cost, OR the neighbour node is not
            //in the open set, then
            if (newMovementCost < neighbourNode.gCost || !openSetContains)
            {
                //recalculate all the costs
                neighbourNode.gCost = newMovementCost;
                neighbourNode.hCost = scr_getDistance(neighbourNode,endNode);
                neighbourNode.fCost = neighbourNode.gCost + neighbourNode.hCost;

                //set the parent to our current node (so we can retrace later)
                neighbourNode.parent = currentNode;

                //and finally, if the neighbour node is not in the open set
                //add it to the open set
                if (!openSetContains)
                    ds_list_add(openSet,neighbourNode);
            }
        }
    }

    //destroying temporary ds_list otherwise we will get a memory leak
    ds_list_destroy(neighbours);
}

//destroying temporary ds_lists otherwise we will get a memory leak
ds_list_destroy(openSet);
ds_list_destroy(closedSet);

//if our code doesn't return in the while statement,
//a path has not been found - return false;
return false;