GetTagPenalty() public method

public GetTagPenalty ( int tag ) : uint
tag int
return uint
 static int GetTagPenalty(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 2);
         Pathfinding.Path obj = (Pathfinding.Path)ToLua.CheckObject <Pathfinding.Path>(L, 1);
         int  arg0            = (int)LuaDLL.luaL_checknumber(L, 2);
         uint o = obj.GetTagPenalty(arg0);
         LuaDLL.lua_pushnumber(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
        public new override void Open(NodeRunData nodeRunData, NodeRun nodeR, Int3 targetPosition, Path path)
        {
            BaseOpen (nodeRunData, nodeR, targetPosition, path);

            LayerGridGraph graph = gridGraphs[indices >> 24];
            int[] neighbourOffsets = graph.neighbourOffsets;
            int[] neighbourCosts = graph.neighbourCosts;
            Node[] nodes = graph.nodes;

            int index = GetIndex();//indices & 0xFFFFFF;

            for (int i=0;i<4;i++) {
                int conn = GetConnectionValue(i);//(gridConnections >> i*4) & 0xF;
                if (conn != LevelGridNode.NoConnection) {

                    Node node = nodes[index+neighbourOffsets[i] + graph.width*graph.depth*conn];

                    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)neighbourCosts[i];

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

                        nodeRunData.open.Add (nodeR2);

                    } 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)neighbourCosts[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);
                        }
                    }
                }
            }
        }
Exemplo n.º 3
0
Arquivo: Node.cs Projeto: klobodnf/st1
		/** 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 conNode = connections[i];
				
				if (!path.CanTraverse (conNode)) {
					continue;
				}
				
				NodeRun nodeR2 = conNode.GetNodeRun (nodeRunData);
				
				if (nodeR2.pathID != nodeRunData.pathID) {
					
					nodeR2.parent = nodeR;
					nodeR2.pathID = nodeRunData.pathID;
					
					nodeR2.cost = (uint)connectionCosts[i];
					
					conNode.UpdateH (targetPosition, path.heuristic, path.heuristicScale, nodeR2);
					conNode.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+conNode.penalty
#if !ASTAR_NoTagPenalty
				+ path.GetTagPenalty(conNode.tags)
#endif
					    	< nodeR2.g) {
						
						nodeR2.cost = tmpCost;
						nodeR2.parent = nodeR;
						
						conNode.UpdateAllG (nodeR2,nodeRunData);
						
						nodeRunData.open.Add (nodeR2);
					}
					
					 else if (nodeR2.g+tmpCost+penalty
#if !ASTAR_NoTagPenalty
				+ path.GetTagPenalty(tags)
#endif
					         < nodeR.g) {//Or if the path from this node ("node") to the current ("current") is better
						
						bool contains = conNode.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;
						
						UpdateAllG (nodeR,nodeRunData);
						
						nodeRunData.open.Add (nodeR);
					}
				}
			}
		}
Exemplo n.º 4
0
 public static uint GetTraversalCost(Path path, GraphNode node)
 {
     return(path.GetTagPenalty((int)node.Tag) + node.Penalty);
 }
Exemplo n.º 5
0
		public override void Open (NodeRunData nodeRunData, NodeRun nodeR, Int3 targetPosition, Path path) {
			
			BaseOpen (nodeRunData, nodeR, targetPosition, path);
			
			GridGraph graph = gridGraphs[indices >> 24];
			
			int[] neighbourOffsets = graph.neighbourOffsets;
			int[] neighbourCosts = graph.neighbourCosts;
			Node[] nodes = graph.nodes;
			
			int index = GetIndex ();//indices & 0xFFFFFF;
			
			for (int i=0;i<8;i++) {
				if (GetConnection (i)) {
				//if (((flags >> i) & 1) == 1) {
					
					Node node = nodes[index+neighbourOffsets[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)neighbourCosts[i];
						
						node.UpdateH (targetPosition,path.heuristic,path.heuristicScale, nodeR2);
						node.UpdateG (nodeR2,nodeRunData);
						
						nodeRunData.open.Add (nodeR2);
					
					} 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)neighbourCosts[i];//(current.costs == null || current.costs.Length == 0 ? costs[current.neighboursKeys[i]] : current.costs[current.neighboursKeys[i]]);
						
						if (nodeR.g+tmpCost+node.penalty
				+ path.GetTagPenalty(node.tags)
						  		< nodeR2.g) {
							nodeR2.cost = tmpCost;
							
							nodeR2.parent = nodeR;
							
							node.UpdateAllG (nodeR2,nodeRunData);
							
						}
						
						 else if (nodeR2.g+tmpCost+penalty
				+ path.GetTagPenalty(tags)
						         < nodeR.g) {//Or if the path from this node ("node") to the current ("current") is better
							/*bool contains = false;
							
							//[Edit, no one-way links between nodes in a single grid] Make sure we don't travel along the wrong direction of a one way link now, make sure the Current node can be accesed from the Node.
							/*for (int y=0;y<node.connections.Length;y++) {
								if (node.connections[y].endNode == this) {
									contains = true;
									break;
								}
							}
							
							if (!contains) {
								continue;
							}*/
							
							nodeR.parent = nodeR2;
							nodeR.cost = tmpCost;
							
							UpdateAllG (nodeR,nodeRunData);
						}
					}
				}
			}
			
		}
 public uint GetTraversalCost(Path path, GraphNode node)
 {
     // Same as default implementation
     return(path.GetTagPenalty((int)node.Tag) + node.Penalty);
 }
Exemplo n.º 7
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);
                    }
                }
            }
        }