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);
}
}
}
}
}
/** 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);
}
}
}
}
public static uint GetTraversalCost(Path path, GraphNode node)
{
return(path.GetTagPenalty((int)node.Tag) + node.Penalty);
}
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);
}
/** 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);
}
}
}
}
