Пример #1
0
        /** Opens the nodes connected to this node. This is a base call and can be called by node classes overriding the Open function to open all connections in the #connections array.
         * \see #connections
         * \see Open */
        public void BaseOpen(NodeRunData nodeRunData, NodeRun nodeR, Int3 targetPosition, Path path)
        {
            if (connections == null)
            {
                return;
            }

            for (int i = 0; i < connections.Length; i++)
            {
                Node node = connections[i];

                if (!path.CanTraverse(node))
                {
                    continue;
                }

                NodeRun nodeR2 = node.GetNodeRun(nodeRunData);

                if (nodeR2.pathID != nodeRunData.pathID)
                {
                    nodeR2.parent = nodeR;
                    nodeR2.pathID = nodeRunData.pathID;

                    nodeR2.cost = (uint)connectionCosts[i];

                    node.UpdateH(targetPosition, path.heuristic, path.heuristicScale, nodeR2);
                    node.UpdateG(nodeR2, nodeRunData);

                    nodeRunData.open.Add(nodeR2);

                    //Debug.DrawLine (position,node.position,Color.cyan);
                    //Debug.Log ("Opening	Node "+node.position.ToString ()+" "+g+" "+node.cost+" "+node.g+" "+node.f);
                }
                else
                {
                    //If not we can test if the path from the current node to this one is a better one then the one already used
                    uint tmpCost = (uint)connectionCosts[i];

                    if (nodeR.g + tmpCost + node.penalty
#if !NoTagPenalty
                        + path.GetTagPenalty(node.tags)
#endif
                        < nodeR2.g)
                    {
                        nodeR2.cost   = tmpCost;
                        nodeR2.parent = nodeR;

                        //TODO!!!!! ??
                        node.UpdateAllG(nodeR2, nodeRunData);

                        nodeRunData.open.Add(nodeR2);
                    }

                    else if (nodeR2.g + tmpCost + penalty
#if !NoTagPenalty
                             + path.GetTagPenalty(tags)
#endif
                             < nodeR.g)                      //Or if the path from this node ("node") to the current ("current") is better

                    {
                        bool contains = node.ContainsConnection(this);

                        //Make sure we don't travel along the wrong direction of a one way link now, make sure the Current node can be moved to from the other Node.

                        /*if (node.connections != null) {
                         *      for (int y=0;y<node.connections.Length;y++) {
                         *              if (node.connections[y] == this) {
                         *                      contains = true;
                         *                      break;
                         *              }
                         *      }
                         * }*/

                        if (!contains)
                        {
                            continue;
                        }

                        nodeR.parent = nodeR2;
                        nodeR.cost   = tmpCost;

                        //TODO!!!!!!! ??
                        UpdateAllG(nodeR, nodeRunData);

                        nodeRunData.open.Add(nodeR);
                    }
                }
            }
        }