Pathfinding.Path.GetTraversalCost C# (CSharp) Method

		public uint GetTraversalCost (GraphNode node) {
			unchecked { return GetTagPenalty ((int)node.Tag ) + node.Penalty ; }
		}

        public override void Open(Path path, PathNode pathNode, PathHandler handler)
        {
            GridGraph gridGraph = GridNode.GetGridGraph(base.GraphIndex);
            ushort    pathID    = handler.PathID;

            int[]      neighbourOffsets = gridGraph.neighbourOffsets;
            uint[]     neighbourCosts   = gridGraph.neighbourCosts;
            GridNode[] nodes            = gridGraph.nodes;
            int        nodeInGridIndex  = base.NodeInGridIndex;

            for (int i = 0; i < 8; i++)
            {
                if (this.HasConnectionInDirection(i))
                {
                    GridNode gridNode = nodes[nodeInGridIndex + neighbourOffsets[i]];
                    if (path.CanTraverse(gridNode))
                    {
                        PathNode pathNode2 = handler.GetPathNode(gridNode);
                        uint     num       = neighbourCosts[i];
                        if (pathNode2.pathID != pathID)
                        {
                            pathNode2.parent = pathNode;
                            pathNode2.pathID = pathID;
                            pathNode2.cost   = num;
                            pathNode2.H      = path.CalculateHScore(gridNode);
                            gridNode.UpdateG(path, pathNode2);
                            handler.heap.Add(pathNode2);
                        }
                        else if (pathNode.G + num + path.GetTraversalCost(gridNode) < pathNode2.G)
                        {
                            pathNode2.cost   = num;
                            pathNode2.parent = pathNode;
                            gridNode.UpdateRecursiveG(path, pathNode2, handler);
                        }
                        else if (pathNode2.G + num + path.GetTraversalCost(this) < pathNode.G)
                        {
                            pathNode.parent = pathNode2;
                            pathNode.cost   = num;
                            this.UpdateRecursiveG(path, pathNode, handler);
                        }
                    }
                }
            }
            base.Open(path, pathNode, handler);
        }