"Too Many Heap Sections" Building A*Pathfinding

OK, here's the code for my AStar implementation. A few notes, this is recursive and may be cryptic to some, but is based largely on the blog post above if you have questions. This is a very clean way to do it, so I decided to use it rather than impl my own.

I haven't tweaked it yet, just wanted something that works then move on. I later plan to store the entire grid, since i always use it to get the optimal path from one point, and there can be many points checked using the same starting node. Tho on on pc it's not necessary, dunno about ios/android, probably ok.

I haven't looked at this in awhile, but i remember my original intention was to make it flexible enough for 4 major kinds of grid searches - triangle grid, square grid with corners and ignoring corners, and a hex grid. (for future games). It has a couple small data structures I use for nodes, and a quick priorityqueue impl in the same file.

Example usage: I have the calling code in a coroutine. Basically, I have an army on a square grid of various terrain types (each with it's own move cost). I Use Manhattan distance based on this cost. the my_i and my_j are grid positions. the m_iMoveCost is the cost of moving through that terrain square (forest may have a cost of 3, where dirt may be 1).. Example calling code:

 public IEnumerator MoveArmy() {
 ...
 ...
 BoardNode startNode = new BoardNode( sugp.my_i, sugp.my_j, sugp.m_iMoveCost );
 float moveStep = 25.0f; 
 Vector3 startPos = sugp.GetGameObject().transform.position +(SUUniversal.m_fArmyHeight* sugp.GetGameObject().transform.TransformDirection(Vector3.forward ));
  AStarPath<BoardNode> aPath = null;
         sugpl.SU_G.ActivateMouseText(true);
         sugpl.SU_G.TextBoxPosition(DIRECTION.D_LOWERMIDDLE);
 
         while ( Input.GetMouseButton( 0 ) ) {
             try {
             float scaleStep = Time.deltaTime * 19.0f;
             Vector3 mousePos = Input.mousePosition;
             mousePos.z = 2.0f;
             Vector3 tempP = Camera.main.ViewportToWorldPoint( Input.mousePosition );
             Vector3 awayFromCam = Camera.main.ScreenToWorldPoint( mousePos );
 
             if ( CheckTileEnter( true ) ) { //m_moPieceX >= 0)
 
                 GameObject go = GameObject.Find( "gamePiece_" + m_moPieceX + "_" + m_moPieceY );
                 if ( go != null && m_goArmy != null ) {
                     
                     Vector3 newPos = go.transform.position + (SUUniversal.m_fArmyHeight * go.transform.TransformDirection( Vector3.forward ));
                     m_goArmy.transform.position = Vector3.MoveTowards( m_goArmy.transform.position, newPos, moveStep * Time.deltaTime );
                     m_goArmy.transform.rotation = go.transform.rotation;
                     
                     BoardNode endNode    = new BoardNode( m_moPieceX, m_moPieceY, m_moValue );
                     //Debug.Log("Startnode: " + startNode.x + "," + startNode.y + " -- and endNOde is; " + m_moPieceX + "," + m_moPieceY);
                     
                     aPath = (AStarPath<BoardNode>) AStarPath<BoardNode>.FindPath < BoardNode >( startNode, endNode, 8, BoardNode.EstimateDistance, 
                             BoardNode.GetCost, sugpl.SU_GB.GetNodeNeighbor );
 ... //more stuff
 }//end while
 Debug.Log("Total move cost: " + APath.TotalCost());
 ...

} //end IEnumerator

I just put it here to see how to call it and how I use my boardnodes (found in the next file along with the AStar alg and PriorityQueue). You can just copy this and throw it in a file with any file name, it doesn't use Monobehaviour. You can implement your own node class for your grid or use the boardnode inside. The AStar can take any node, and any distance function you wish. If you have questions, i'll comment back. Note: The smallVec2i type is just a Vector2 that is strictly int.

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
 // SUAstar - A* Pathfinding 
 // **** Based on Eric Lippert C# code ****
 
 //---------------------------------------------------------------//---------------------------------------------------------------
 public interface IHasNeighbors<N> {
     IEnumerable<N> Neighbors { get; }
 }
 public interface GenericNode {
     bool IsNull { get; }
 
 }
 //---------------------------------------------------------------//---------------------------------------------------------------
 /* unused :
  * public enum NEIGHBOR_NODE_TYPE {
     POINT_3 = 3,    //equilateral triangle
     POINT_4 = 4,    //square grid ignore corners
     POINT_6 = 6,    //hex grid
     POINT_8 = 8,    // square grid using corners    
 }*/
 //---------------------------------------------------------------//---------------------------------------------------------------
 //[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack=2)]
     public class BoardNode { 
     
     //public smallVec2i svTile;
     public int                        x { get; private set; }
     public int                        y { get; private set; }
     public int                        iNodeCost { get; private set; }
     public bool                        bReachable { get; private set; }
     //public smallVec2i[]                svNeighbors { get; private set; } //Left, Right, Up, Down, UpperLeft, UpperRight, LowerLeft, LowerRight;
     const int                        iMaxCost = 9999999;
     
     public BoardNode( int inX = -1, int inY = -1, int cost = iMaxCost ) { //, smallVec2i[] inEdges) {
         x = inX;
         y = inY;
         iNodeCost = cost;
         if ( iNodeCost == iMaxCost || x < 0 || y < 0 ) {
             bReachable = false;
         } else {
             bReachable = true;
         }    
     }
     public BoardNode( smallVec2i svTile, int cost = iMaxCost ) { //, smallVec2i[] inEdges) {
         x = svTile.x;
         y = svTile.y;
         iNodeCost = cost;
         if ( iNodeCost == iMaxCost || x < 0 || y < 0) {
             bReachable = false;
         } else {
             bReachable = true;
         }
     }
     public override bool Equals( System.Object obj) {
         // If parameter is null return false.
         BoardNode bnObj = obj as BoardNode;
         if ( bnObj == null ) {
             return false;
         }
         return ( (bnObj.x == x) && (bnObj.y == y) );
     }
 
     static public int EstimateDistance( BoardNode bn1, BoardNode bn2 ) { //NOTE: minimal estimate is 1 per square/straightest line. cannot have < 1 squares!
         int i = (Mathf.Max( Mathf.Abs( bn1.x - bn2.x ), Mathf.Abs( bn1.y - bn2.y ) ));
         //Debug.Log( "Estimate distace is: " + i + " for: " + bn1.x + "," + bn1.y + " and " + bn2.x + "," + bn2.y );
         return i;
     }
     static public int GetCost( BoardNode ingoreNode, BoardNode getCostNode ) {
         int i = getCostNode.iNodeCost;
         //Debug.Log( "Getcost is: " + i );
         if (getCostNode.bReachable && i != 0) {  
             return i;
         } else {
             return iMaxCost;
         }
     }
     public bool IsNull() {
         return (bReachable && x >= 0 && y >= 0);
     }
 
 }
 //---------------------------------------------------------------//---------------------------------------------------------------
 //---------------------------------------------------------------//---------------------------------------------------------------
 class AStarPath<Node> : IEnumerable<Node> {
 
     #region Declarations
     public Node LastNode { get; private set; }
     public AStarPath<Node> PreviousSteps { get; private set; }
     public int TotalCost { get; private set; }
     public const int iMaxCost = 9999999;
     #endregion
     //---------------------------------------------------------------
     private AStarPath( Node lastN, AStarPath<Node> previousSteps, int totalCost ) {
         LastNode = lastN;
         PreviousSteps = previousSteps;
         TotalCost = totalCost;
     }
     //---------------------------------------------------------------
     public AStarPath( Node startNode ) : this( startNode, null, 0 ) { }
     //---------------------------------------------------------------
     public AStarPath<Node> AddStep( Node stepNode, int stepCost ) 
     {
         return new AStarPath<Node>( stepNode, this, TotalCost + stepCost );
     }
     //---------------------------------------------------------------
     public IEnumerator<Node> GetEnumerator() {
         for ( AStarPath<Node> p = this; p != null; p = p.PreviousSteps )
             yield return p.LastNode;
     }
     //---------------------------------------------------------------
     IEnumerator IEnumerable.GetEnumerator() {
         return this.GetEnumerator();
     }
     //---------------------------------------------------------------
     public int GetMaxCost() {
         return iMaxCost;
     }
     //---------------------------------------------------------------//---------------------------------------------------------------
     static public AStarPath<Node> FindPath<Node>(    Node startNode, 
                                                     Node destNode, 
                                                     int iEdges,
                                                     System.Func<Node,Node,int> estDistFunc,
                                                     System.Func<Node, Node, int> distFunc, 
                                                     System.Func<Node,int,int,Node> getNeighbor
                                                 )
     {
         var closed    = new HashSet<Node>();
         var queue    = new PriorityQueue<int, AStarPath<Node> >();
         
         queue.Enqueue( 0, new AStarPath<Node>( startNode ) );
         
         while ( !queue.IsEmpty ) {
             var path = queue.Dequeue();
             if ( closed.Contains( path.LastNode ) ) {continue;}
             if ( path.LastNode.Equals( destNode ) ) {return path;}
 
             closed.Add( path.LastNode );
 
             //foreach ( Node neighNode in path.LastNode.Neighbors ) {
             for (int i=0; i <= iEdges; ++i) {
                 Node NeiNode = getNeighbor( path.LastNode, i, iEdges );    //should be able to do equi-tris/squares/hexs/squares with corners
                 if (NeiNode == null) { //default(Node)) {
                     //Debug.Log("Neinode was null for i: " + i + " edgtes: " + iEdges + " pathLaststp: " + path.LastNode);
                     //var newPath = path.AddStep( NeiNode, iMaxCost );
                     //queue.Enqueue( iMaxCost, newPath );
                     continue;
                 } else {
                     int d = distFunc( path.LastNode, NeiNode ); //Since i'm sending in a Generic 'Node' type, have to send a distance Func<>
                     var newPath = path.AddStep( NeiNode, d );
                     queue.Enqueue( newPath.TotalCost + estDistFunc( NeiNode, destNode ), newPath );
                 }
             }
         }
         return null;
     }
     //---------------------------------------------------------------//---------------------------------------------------------------
     static public void PrintPath<Node> (AStarPath<Node> apath) {
         //string sNodes = "";
         //foreach (Node n in apath) {
             //sNodes += " " + ;
         //}
         Debug.Log("total path cost: " + apath.TotalCost);
     }
 }
 //---------------------------------------------------------------//---------------------------------------------------------------
 //---------------------------------------------------------------//---------------------------------------------------------------
 public class Neighborly : MonoBehaviour {
     public List<smallVec2i> GetNeighbors<Node>(smallVec2i sv) {
         return new List<smallVec2i>();
     }
 
     IEnumerator _GetNeighbors(smallVec2i sv) {
         yield return null;
     }
 
 }    
 //---------------------------------------------------------------//---------------------------------------------------------------
 //---------------------------------------------------------------//---------------------------------------------------------------
 public class PriorityQueue<P, V> {
     private SortedDictionary<P, Queue<V>> list = new SortedDictionary<P, Queue<V>>();
     public void Enqueue( P priority, V value ) {
         Queue<V> q;
         if ( !list.TryGetValue( priority, out q ) ) {
             q = new Queue<V>();
             list.Add( priority, q );
         }
         q.Enqueue( value );
     }
     public V Dequeue() {
         // will throw if there isn’t any first element!
         var pair = list.First();
         var v = pair.Value.Dequeue();
         if ( pair.Value.Count == 0 ) // nothing left of the top priority.
             list.Remove( pair.Key );
         return v;
     }
     public bool IsEmpty {
         get { return !list.Any(); }
     }
 }
 //---------------------------------------------------------------