public void Split()
{
if (NodeCount != 4)
{
Debugger.Break();
}
float Value = 0;
float BestValue = 0;
PathfinderNode BestNodeA = null;
PathfinderNode BestNodeB = null;
PathfinderNode BestNodeC = null;
PathfinderNode BestNodeD = null;
var A = 0;
var B = 0;
var tmpNodeA = default(PathfinderNode);
var tmpNodeB = default(PathfinderNode);
var tmpNodeC = default(PathfinderNode);
var tmpNodeD = default(PathfinderNode);
PathfinderConnection tmpConnectionA = null;
PathfinderConnection tmpConnectionB = null;
var C = 0;
var D = 0;
var Children = new PathfinderNode[NodeCount];
for (A = 0; A <= NodeCount - 1; A++)
{
Children[A] = Nodes[A];
}
var ChildCount = NodeCount;
var ThisLayer = Layer;
Disband();
BestValue = float.MaxValue;
for (A = 0; A <= ChildCount - 1; A++)
{
tmpNodeA = Children[A];
for (B = A + 1; B <= ChildCount - 1; B++)
{
tmpNodeB = Children[B];
for (C = 0; C <= ChildCount - 1; C++)
{
if (Children[C] != tmpNodeA && Children[C] != tmpNodeB)
{
break;
}
}
tmpNodeC = Children[C];
for (D = C + 1; D <= ChildCount - 1; D++)
{
if (Children[D] != tmpNodeA && Children[D] != tmpNodeB)
{
break;
}
}
tmpNodeD = Children[D];
for (C = 0; C <= tmpNodeA.ConnectionCount - 1; C++)
{
tmpConnectionA = tmpNodeA.Connections[C];
if (tmpConnectionA.GetOtherNode(tmpNodeA) == tmpNodeB)
{
break;
}
}
for (D = 0; D <= tmpNodeC.ConnectionCount - 1; D++)
{
tmpConnectionB = tmpNodeC.Connections[D];
if (tmpConnectionB.GetOtherNode(tmpNodeC) == tmpNodeD)
{
break;
}
}
if (C < tmpNodeA.ConnectionCount & D < tmpNodeC.ConnectionCount)
{
Value = tmpConnectionA.Value + tmpConnectionB.Value;
if (Value < BestValue)
{
BestValue = Value;
BestNodeA = tmpNodeA;
BestNodeB = tmpNodeB;
BestNodeC = tmpNodeC;
BestNodeD = tmpNodeD;
}
}
}
}
if (BestNodeA != null)
{
if (ParentNode != null)
{
tmpNodeA = ParentNode;
tmpNodeA.Node_Remove(ParentNode_NodeNum);
}
else
{
tmpNodeA = null;
}
if (tmpNodeA != null)
{
tmpNodeA.CheckIntegrity();
}
var NewNodeA = new PathfinderNode(ThisLayer);
var NewNodeB = new PathfinderNode(ThisLayer);
NewNodeA.Node_Add(BestNodeA);
NewNodeA.Node_Add(BestNodeB);
NewNodeA.SpanCalc();
BestNodeA.RaiseConnections();
BestNodeB.RaiseConnections();
NewNodeA.Layer.Network.FindParentNode_Add(NewNodeA);
NewNodeB.Node_Add(BestNodeC);
NewNodeB.Node_Add(BestNodeD);
NewNodeB.SpanCalc();
BestNodeC.RaiseConnections();
BestNodeD.RaiseConnections();
NewNodeB.Layer.Network.FindParentNode_Add(NewNodeB);
}
else
{
Debugger.Break();
}
}
public void FindParent()
{
var tmpNodeA = default(PathfinderNode);
float BestScore = 0;
PathfinderNode BestNode = null;
float Score = 0;
var A = 0;
var MakeNew = default(bool);
var B = 0;
var Count = 0;
var C = 0;
var Allow = default(bool);
var tmpConnection = default(PathfinderConnection);
var DestNode = default(PathfinderNode);
if (NodeCount == 0 & Layer.Network_LayerNum > 0)
{
Debugger.Break();
return;
}
if (ParentNode != null)
{
Debugger.Break();
return;
}
BestScore = float.MaxValue;
for (A = 0; A <= ConnectionCount - 1; A++)
{
tmpConnection = Connections[A];
DestNode = tmpConnection.GetOtherNode(this);
tmpNodeA = DestNode.ParentNode;
if (tmpNodeA == null)
{
tmpNodeA = tmpConnection.GetOtherNode(this);
Score = tmpConnection.Value * (0.98F + App.Random.Next() * 0.04F);
if (Score < BestScore)
{
BestScore = Score;
BestNode = tmpNodeA;
MakeNew = true;
}
}
else
{
//dont allow this to join to another when the other has 3 nodes and they only have one connection
if (tmpNodeA.NodeCount == 3)
{
Count = 0;
Allow = false;
for (B = 0; B <= tmpNodeA.NodeCount - 1; B++)
{
for (C = 0; C <= tmpNodeA.Nodes[B].ConnectionCount - 1; C++)
{
if (tmpNodeA.Nodes[B].Connections[C].GetOtherNode(tmpNodeA.Nodes[B]) == this)
{
Count++;
if (Count >= 2)
{
Allow = true;
goto CountFinished;
}
break;
}
}
}
CountFinished:
1.GetHashCode(); //TODO: cleanup this loop
}
else
{
Allow = true;
}
if (Allow)
{
Score = (DestNode.SiblingSpan + tmpConnection.Value) * (0.98F + App.Random.Next() * 0.04F);
if (Score < BestScore)
{
BestScore = Score;
BestNode = tmpNodeA;
MakeNew = false;
}
}
}
}
if (BestNode != null)
{
if (MakeNew)
{
var tmpLayer = default(PathfinderLayer);
if (Layer.ParentLayer == null)
{
tmpLayer = new PathfinderLayer(Layer.Network);
}
else
{
tmpLayer = Layer.ParentLayer;
}
var NewNode = new PathfinderNode(tmpLayer);
NewNode.Node_Add(this);
NewNode.Node_Add(BestNode);
NewNode.SpanCalc();
RaiseConnections();
BestNode.RaiseConnections();
NewNode.Layer.Network.FindParentNode_Add(NewNode);
}
else
{
if (BestNode != null)
{
BestNode.Node_Add(this);
if (BestNode.NodeCount >= 4)
{
BestNode.Split();
}
else
{
BestNode.SpanCalc();
RaiseConnections();
if (BestNode.ParentNode == null)
{
BestNode.Layer.Network.FindParentNode_Add(BestNode);
}
}
}
}
}
else if (ConnectionCount > 0)
{
//it is part of a network but there is no suitable parent to join, so make a new isolated parent
var tmpLayer = default(PathfinderLayer);
if (Layer.ParentLayer == null)
{
tmpLayer = new PathfinderLayer(Layer.Network);
}
else
{
tmpLayer = Layer.ParentLayer;
}
var NewNode = new PathfinderNode(tmpLayer);
NewNode.Node_Add(this);
NewNode.SpanCalc();
RaiseConnections();
NewNode.Layer.Network.FindParentNode_Add(NewNode);
}
}
