//This method is supposed to provide any character with coordinates to the next step
    //The method is based on Breath First Search method
    //In short: it puts a node into the queue and starts a loop. It then dequeues a node from the queue, check it's neighbours and puts it into the queue. Then it marks the node as visited, to ignore it in the future.
    //The node that followed the node is added to list of previous nodes. Each node on the grid has its entry on that list.
    //In following loop iterations it then dequeues subsequent nodes and repeats the steps.
    //Once node that's supposed to be the end of the path is reached, the loop is stopped.
    //Then, based on the previous list, the path is recreated, from the end
    //Last node of the path is then provided back to the asking character.

    public static GridField GetNextStep(GridField startField, GridField targetField, GridScript grid)
    {
        #region properties
        Queue <GridField> queue    = new Queue <GridField>(); //The queue that's the base of the first part of the method.
        List <GridField>  visited  = new List <GridField>();  //List of nodes that were already handled.
        List <GridField>  previous = new List <GridField>();  //List in which a node prior for each node can be found. For example node previous to node "1,0" can be found in this list's index 10.
        List <GridField>  path     = new List <GridField>();  //This is the path to the final node. Since it's always writen backwards, ending node is already added to it. Subsequent nodes are separated with a ;. It's important that after split(), last element will be empty, so the actual first step is 2nd to last.

        GridScript gameGrid = grid;                           //Grid is necessary to calculate surrounding nodes and to get field information.

        float stime = Time.realtimeSinceStartup;
        queue.Enqueue(startField);     //Enqueueing the 1st node - start - to kickstart the loop.
        visited.Add(startField);       //s node is immediately marked as visited.
        #endregion

        //This loop adds initially empty strings to 'previous' list, for each node on the grid.
        #region fill 'previous' list with empty strings
        for (int i = 0; i < (gameGrid.rows * gameGrid.columns); i++)
        {
            previous.Add(null);
        }
        #endregion

        //This loop is ultimately responssible for filling the 'previous' list with proper data, up to the end node.
        #region 1st loop filling in previous list
        int loop1c = 0;                                     //This is just a safety check. If loop takes too many iterations, we break out of it, based on this value.
        while (queue.Count > 0)
        {
            loop1c++;
            bool          foundEnd        = false;                                      //This is set to true when found neighbour turns out to be the ending node.
            GridField     field           = queue.Dequeue();                            //Dequeueing node from queue. Initially it's the 's' node.
            List <string> nodesNeighbours = GetSurroundingNodes(field, gameGrid);       //Getting surrounding nodes for currently processed node.
            foreach (string z in nodesNeighbours)                                       //Loop within a loop could be dangerous. Luckily, it's 4 iterations at most, in theory.
            {
                if (z == targetField.stringRepresentation)                              //Handling case in which found neighbour turns out to bbe the ending node
                {
                    string[] split = z.Split(',');                                      //Temprorary solution since node handling is a mix of processing a string and two ints. To be changed to a unified format.
                    int      x = int.Parse(split[0]); int y = int.Parse(split[1]);
                    previous[int.Parse(x.ToString() + y.ToString())] = field;           //Replacing empty string in 'previous' for the found NEIGHBOUR list with currently handled (dequeued) node.
                    foundEnd = true;                                                    //Finding the ending node ends the loop.
                    break;
                }
                if (!grid.isFieldWalkable(z))                                           //If field is not walkable, we simply don't process it.
                {
                    visited.Add(grid.GetFieldByCoord(z));
                }
                if (!visited.Contains(grid.GetFieldByCoord(z)))                         //This part of the loop only executes if found neighbour wasn't already processed.
                {
                    queue.Enqueue(grid.GetFieldByCoord(z));                             //Each found neighbour is put to the queue.
                    visited.Add(grid.GetFieldByCoord(z));                               //It's also marked as visited, to not revisit it in the future.

                    string[] split = z.Split(',');
                    int      x = int.Parse(split[0]); int y = int.Parse(split[1]);      //Temprorary solution since node handling is a mix of processing a string and two ints. To be changed to a unified format.
                    previous[int.Parse(x.ToString() + y.ToString())] = field;           //Replacing empty string in 'previous' for the found NEIGHBOUR list with currently handled (dequeued) node.
                }
            }
            if (foundEnd)                                                               //If we've found the end node, not only foreach (inner) loop is ended, but the whole while (outer) loop as well.
            {
                break;
            }
            if (loop1c > 100)                                                           //If the loop has reached 100 iterations we crash.
            {
                throw new Exception("Breaking out of 1st loop of GetNextStep() method as it reached more than 100 iterations, suggesting an infinite loop.");
                break; //Probably unnecessary.
            }
        }
        #endregion

        //This loop recreates the path based on 'previous' list and puts it to a string.
        #region 2nd loop creating path string
        GridField previousField = previous[int.Parse(targetField.intRepresentationX.ToString() + targetField.intRepresentationY.ToString())]; //previousNode represents the previous node of currently handled node. Since we have to start somewhere, we're initially assigning it to the end node.
        int       loop2c        = 0;                                                                                                          //As with the first loop, we also break out of this one if it reaches 100 iterations.
        while (true)
        {
            loop2c++;
            if (previous[int.Parse(previousField.intRepresentationX.ToString() + previousField.intRepresentationY.ToString())] != startField)   //Unless the previousNode is the starting node, we process it.
            {
                path.Add(previous[int.Parse(previousField.intRepresentationX.ToString() + previousField.intRepresentationY.ToString())]);       //We add the the node that's in the 'previous' list in the index reserved for previousNode, so we add previous node of previousNode. Previousception.
                previousField = previous[int.Parse(previousField.intRepresentationX.ToString() + previousField.intRepresentationY.ToString())]; //Then we replace previousNode with previous node of current previousNode. Names are stupid.
            }
            else                                                                                                                                //If previous node turns out to be starting node, we break out of the loop.
            {
                break;
            }
            if (loop2c > 100)                                                                       //If the loop has reached 100 iterations, we crash.
            {
                throw new Exception("Breaking out of 2nd loop of GetNextStep() method as it reached more than 100 iterations, suggesting an infinite loop.");
                break;
            }
        }
        #endregion

        float etime = Time.realtimeSinceStartup;
        Debug.Log("Calculating path fromm " + startField.stringRepresentation + " to " + targetField.stringRepresentation + " took " + ((etime - stime) * 1000).ToString() + "ms.");
        return(path[path.Count - 1]);     //
    }