public clsResult GenerateRamps()
{
int num;
int num6;
int num7;
int num9;
clsResult result2 = new clsResult("Ramps");
int num13 = this.ConnectionCount - 1;
for (num = 0; num <= num13; num++)
{
this.Connections[num].IsRamp = false;
}
clsPassageNodeNework nework = this.MakePassageNodeNetwork();
PathfinderNode[,] passageNodePathNodes = nework.PassageNodePathNodes;
clsConnection[] connectionArray = new clsConnection[(this.ConnectionCount - 1) + 1];
PathfinderNode[] startNodes = new PathfinderNode[1];
bool[] flagArray = new bool[(this.ConnectionCount - 1) + 1];
int num14 = this.ConnectionCount - 1;
int index = 0;
while (index <= num14)
{
if (Math.Abs((int) (this.Connections[index].PassageNodeA.Level - this.Connections[index].PassageNodeB.Level)) == 1)
{
if ((!(this.Connections[index].PassageNodeA.IsOnBorder | this.Connections[index].PassageNodeB.IsOnBorder) & (this.Connections[index].PassageNodeA.MirrorNum == 0)) & (this.Connections[index].PassageNodeA.Num != this.Connections[index].PassageNodeB.Num))
{
flagArray[index] = true;
}
else
{
flagArray[index] = false;
}
}
else
{
flagArray[index] = false;
}
index++;
}
clsNodeConnectedness connectedness = new clsNodeConnectedness {
NodeConnectedness = new float[(this.PassageNodeCount - 1) + 1],
PassageNodeVisited = new bool[(this.SymmetryBlockCount - 1) + 1, (this.PassageNodeCount - 1) + 1],
PassageNodePathNodes = passageNodePathNodes,
PassageNodePathMap = nework.Network
};
PathfinderConnection[] connectionArray2 = new PathfinderConnection[4];
clsUpdateNodeConnectednessArgs args3 = new clsUpdateNodeConnectednessArgs();
clsUpdateNetworkConnectednessArgs args2 = new clsUpdateNetworkConnectednessArgs();
args3.Args = connectedness;
args2.Args = connectedness;
args2.PassageNodeUpdated = new bool[(this.PassageNodeCount - 1) + 1];
args2.SymmetryBlockCount = this.SymmetryBlockCount;
int num15 = this.PassageNodeCount - 1;
for (num = 0; num <= num15; num++)
{
connectedness.NodeConnectedness[num] = 0f;
int num16 = this.PassageNodeCount - 1;
for (index = 0; index <= num16; index++)
{
int num17 = this.SymmetryBlockCount - 1;
num7 = 0;
while (num7 <= num17)
{
connectedness.PassageNodeVisited[num7, index] = false;
num7++;
}
}
args3.OriginalNode = this.PassageNodes[0, num];
this.UpdateNodeConnectedness(args3, this.PassageNodes[0, num]);
}
Label_0269:
num6 = -1;
double num4 = 1.0;
double num5 = 0.0;
int num10 = 0;
int num18 = this.ConnectionCount - 1;
index = 0;
while (index <= num18)
{
if (flagArray[index] & !this.Connections[index].IsRamp)
{
if (this.CheckRampAngles(this.Connections[index], 1.3962634015954636, 2.0943951023931953, 0.0))
{
modMath.sXY_int _int;
startNodes[0] = passageNodePathNodes[this.Connections[index].PassageNodeA.MirrorNum, this.Connections[index].PassageNodeA.Num];
PathfinderNetwork.PathList[] listArray = nework.Network.GetPath(startNodes, passageNodePathNodes[this.Connections[index].PassageNodeB.MirrorNum, this.Connections[index].PassageNodeB.Num], -1, 0);
double maxValue = double.MaxValue;
_int.X = (int) Math.Round((double) (((double) (this.Connections[index].PassageNodeA.Pos.X + this.Connections[index].PassageNodeB.Pos.X)) / 2.0));
_int.Y = (int) Math.Round((double) (((double) (this.Connections[index].PassageNodeA.Pos.Y + this.Connections[index].PassageNodeB.Pos.Y)) / 2.0));
int num19 = this.TotalPlayerCount - 1;
num9 = 0;
while (num9 <= num19)
{
modMath.sXY_int _int2 = this.PlayerBases[num9].Pos - _int;
double magnitude = _int2.ToDoubles().GetMagnitude();
if (magnitude < maxValue)
{
maxValue = magnitude;
}
num9++;
}
double num11 = Math.Max((double) (this.MaxDisconnectionDist * Math.Pow(this.RampBase, maxValue / 1024.0)), (double) 1.0);
if (listArray == null)
{
double num12 = connectedness.NodeConnectedness[this.Connections[index].PassageNodeA.Num] + connectedness.NodeConnectedness[this.Connections[index].PassageNodeB.Num];
if (double.MaxValue > num4)
{
num4 = double.MaxValue;
num5 = num12;
connectionArray[0] = this.Connections[index];
num10 = 1;
}
else if (num12 < num5)
{
num5 = num12;
connectionArray[0] = this.Connections[index];
num10 = 1;
}
else if (num12 == num5)
{
connectionArray[num10] = this.Connections[index];
num10++;
}
}
else
{
if (listArray[0].PathCount != 1)
{
result2.ProblemAdd("Error: Invalid number of routes returned.");
goto Label_088A;
}
if ((((double) listArray[0].Paths[0].Value) / num11) > num4)
{
num4 = ((double) listArray[0].Paths[0].Value) / num11;
connectionArray[0] = this.Connections[index];
num10 = 1;
}
else if ((((double) listArray[0].Paths[0].Value) / num11) == num4)
{
connectionArray[num10] = this.Connections[index];
num10++;
}
else if (listArray[0].Paths[0].Value <= num11)
{
flagArray[index] = false;
}
}
}
else
{
flagArray[index] = false;
}
}
else
{
flagArray[index] = false;
}
index++;
}
if (num10 > 0)
{
num6 = (int) Math.Round((double) ((float) (App.Random.Next() * num10)));
connectionArray[num6].IsRamp = true;
clsPassageNode passageNodeA = connectionArray[num6].PassageNodeA;
clsPassageNode passageNodeB = connectionArray[num6].PassageNodeB;
PathfinderNode nodeA = passageNodePathNodes[passageNodeA.MirrorNum, passageNodeA.Num];
PathfinderNode otherNode = passageNodePathNodes[passageNodeB.MirrorNum, passageNodeB.Num];
PathfinderConnection connection = nodeA.CreateConnection(otherNode, this.GetNodePosDist(nodeA, otherNode));
int num20 = connectionArray[num6].ReflectionCount - 1;
for (num7 = 0; num7 <= num20; num7++)
{
connectionArray[num6].Reflections[num7].IsRamp = true;
passageNodeA = connectionArray[num6].Reflections[num7].PassageNodeA;
passageNodeB = connectionArray[num6].Reflections[num7].PassageNodeB;
nodeA = passageNodePathNodes[passageNodeA.MirrorNum, passageNodeA.Num];
otherNode = passageNodePathNodes[passageNodeB.MirrorNum, passageNodeB.Num];
connection = nodeA.CreateConnection(otherNode, this.GetNodePosDist(nodeA, otherNode));
}
nework.Network.FindCalc();
int num21 = this.PassageNodeCount - 1;
for (num9 = 0; num9 <= num21; num9++)
{
args2.PassageNodeUpdated[num9] = false;
}
if (connectionArray[num6].PassageNodeA.MirrorNum == 0)
{
this.UpdateNetworkConnectedness(args2, connectionArray[num6].PassageNodeA);
goto Label_0269;
}
if (connectionArray[num6].PassageNodeB.MirrorNum == 0)
{
this.UpdateNetworkConnectedness(args2, connectionArray[num6].PassageNodeB);
goto Label_0269;
}
result2.ProblemAdd("Error: Initial ramp not in area 0.");
}
else
{
PathfinderNetwork.sFloodProximityArgs args;
args.StartNode = nework.PassageNodePathNodes[0, 0];
args.NodeValues = nework.Network.NetworkLargeArrays.Nodes_ValuesA;
int num22 = this.PassageNodeCount - 1;
for (num = 0; num <= num22; num++)
{
int num23 = this.SymmetryBlockCount - 1;
index = 0;
while (index <= num23)
{
args.NodeValues[nework.PassageNodePathNodes[index, num].Layer_NodeNum] = float.MaxValue;
index++;
}
}
nework.Network.FloodProximity(ref args);
int num24 = this.PassageNodeCount - 1;
for (num = 0; num <= num24; num++)
{
int num25 = this.SymmetryBlockCount - 1;
for (index = 0; index <= num25; index++)
{
if (!this.PassageNodes[index, num].IsWater && (args.NodeValues[nework.PassageNodePathNodes[index, num].Layer_NodeNum] == float.MaxValue))
{
result2.ProblemAdd("Land is unreachable. Reduce variation or retry.");
break;
}
}
}
}
Label_088A:
nework.Network.Deallocate();
return result2;
}
public clsResult GenerateRamps()
{
clsResult ReturnResult = new clsResult("Ramps");
int A = 0;
int B = 0;
int C = 0;
int E = 0;
double BestDist = 0;
int BestNum = 0;
sXY_int XY_int = new sXY_int();
clsPassageNode tmpPassageNodeA = default(clsPassageNode);
clsPassageNode tmpPassageNodeB = default(clsPassageNode);
double Dist = 0;
//make ramps
for ( A = 0; A <= ConnectionCount - 1; A++ )
{
Connections[A].IsRamp = false;
}
PathfinderNode tmpNodeA = default(PathfinderNode);
PathfinderNode tmpNodeB = default(PathfinderNode);
PathfinderNode[,] PassageNodePathNodes = null;
PathfinderConnection NewConnection;
clsPassageNodeNework PassageNodeNetwork = MakePassageNodeNetwork();
PassageNodePathNodes = PassageNodeNetwork.PassageNodePathNodes;
clsConnection[] PossibleRamps = new clsConnection[ConnectionCount];
int PossibleRampCount = 0;
PathfinderNode[] GetPathStartNodes = new PathfinderNode[1];
PathfinderNetwork.PathList[] ResultPaths = null;
//ramp connections whose points are too far apart
bool[] ConnectionsCanRamp = new bool[ConnectionCount];
for ( B = 0; B <= ConnectionCount - 1; B++ )
{
C = Math.Abs(Connections[B].PassageNodeA.Level - Connections[B].PassageNodeB.Level);
if ( C == 1 )
{
if ( !(Connections[B].PassageNodeA.IsOnBorder || Connections[B].PassageNodeB.IsOnBorder)
&& Connections[B].PassageNodeA.MirrorNum == 0
&& Connections[B].PassageNodeA.Num != Connections[B].PassageNodeB.Num )
{
ConnectionsCanRamp[B] = true;
}
else
{
ConnectionsCanRamp[B] = false;
}
}
else
{
ConnectionsCanRamp[B] = false;
}
}
clsNodeConnectedness Connectedness = new clsNodeConnectedness();
Connectedness.NodeConnectedness = new float[PassageNodeCount];
Connectedness.PassageNodeVisited = new bool[SymmetryBlockCount, PassageNodeCount];
Connectedness.PassageNodePathNodes = PassageNodePathNodes;
Connectedness.PassageNodePathMap = PassageNodeNetwork.Network;
PathfinderConnection[] tmpPathConnection = new PathfinderConnection[4];
double Value = 0;
double BestDistB = 0;
double BaseDist = 0;
double RampDist = 0;
clsUpdateNodeConnectednessArgs UpdateNodeConnectednessArgs = new clsUpdateNodeConnectednessArgs();
clsUpdateNetworkConnectednessArgs UpdateNetworkConnectednessArgs = new clsUpdateNetworkConnectednessArgs();
UpdateNodeConnectednessArgs.Args = Connectedness;
UpdateNetworkConnectednessArgs.Args = Connectedness;
UpdateNetworkConnectednessArgs.PassageNodeUpdated = new bool[PassageNodeCount];
UpdateNetworkConnectednessArgs.SymmetryBlockCount = SymmetryBlockCount;
for ( A = 0; A <= PassageNodeCount - 1; A++ )
{
Connectedness.NodeConnectedness[A] = 0.0F;
for ( B = 0; B <= PassageNodeCount - 1; B++ )
{
for ( C = 0; C <= SymmetryBlockCount - 1; C++ )
{
Connectedness.PassageNodeVisited[C, B] = false;
}
}
UpdateNodeConnectednessArgs.OriginalNode = PassageNodes[0, A];
UpdateNodeConnectedness(UpdateNodeConnectednessArgs, PassageNodes[0, A]);
}
do
{
BestNum = -1;
BestDist = 1.0F; //for connections that can already reach the other side
BestDistB = 0.0F; //for connections that cant
PossibleRampCount = 0;
for ( B = 0; B <= ConnectionCount - 1; B++ )
{
if ( ConnectionsCanRamp[B] && !Connections[B].IsRamp )
{
if ( CheckRampAngles(Connections[B], Convert.ToDouble(80.0D * MathUtil.RadOf1Deg), Convert.ToDouble(120.0D * MathUtil.RadOf1Deg),
0.0D * MathUtil.RadOf1Deg) )
{
GetPathStartNodes[0] = PassageNodePathNodes[Connections[B].PassageNodeA.MirrorNum, Connections[B].PassageNodeA.Num];
ResultPaths = PassageNodeNetwork.Network.GetPath(GetPathStartNodes,
PassageNodePathNodes[Connections[B].PassageNodeB.MirrorNum, Connections[B].PassageNodeB.Num], -1, 0);
BaseDist = double.MaxValue;
XY_int.X = (int)((Connections[B].PassageNodeA.Pos.X + Connections[B].PassageNodeB.Pos.X) / 2.0D);
XY_int.Y = (int)((Connections[B].PassageNodeA.Pos.Y + Connections[B].PassageNodeB.Pos.Y) / 2.0D);
for ( E = 0; E <= TotalPlayerCount - 1; E++ )
{
Dist = Convert.ToDouble((PlayerBases[E].Pos - XY_int).ToDoubles().GetMagnitude());
if ( Dist < BaseDist )
{
BaseDist = Dist;
}
}
RampDist = Math.Max(MaxDisconnectionDist * Math.Pow(RampBase, (BaseDist / 1024.0D)), 1.0F);
if ( ResultPaths == null )
{
Value = Connectedness.NodeConnectedness[Connections[B].PassageNodeA.Num] +
Connectedness.NodeConnectedness[Connections[B].PassageNodeB.Num];
if ( double.MaxValue > BestDist )
{
BestDist = double.MaxValue;
BestDistB = Value;
PossibleRamps[0] = Connections[B];
PossibleRampCount = 1;
}
else
{
if ( Value < BestDistB )
{
BestDistB = Value;
PossibleRamps[0] = Connections[B];
PossibleRampCount = 1;
}
else if ( Value == BestDistB )
{
PossibleRamps[PossibleRampCount] = Connections[B];
PossibleRampCount++;
}
}
}
else if ( ResultPaths[0].PathCount != 1 )
{
ReturnResult.ProblemAdd("Error: Invalid number of routes returned.");
goto Finish;
}
else if ( ResultPaths[0].Paths[0].Value / RampDist > BestDist )
{
BestDist = ResultPaths[0].Paths[0].Value / RampDist;
PossibleRamps[0] = Connections[B];
PossibleRampCount = 1;
}
else if ( ResultPaths[0].Paths[0].Value / RampDist == BestDist )
{
PossibleRamps[PossibleRampCount] = Connections[B];
PossibleRampCount++;
}
else if ( ResultPaths[0].Paths[0].Value <= RampDist )
{
ConnectionsCanRamp[B] = false;
}
}
else
{
ConnectionsCanRamp[B] = false;
}
}
else
{
ConnectionsCanRamp[B] = false;
}
}
if ( PossibleRampCount > 0 )
{
BestNum = (int)(Conversion.Int(VBMath.Rnd() * PossibleRampCount));
PossibleRamps[BestNum].IsRamp = true;
tmpPassageNodeA = PossibleRamps[BestNum].PassageNodeA;
tmpPassageNodeB = PossibleRamps[BestNum].PassageNodeB;
tmpNodeA = PassageNodePathNodes[tmpPassageNodeA.MirrorNum, tmpPassageNodeA.Num];
tmpNodeB = PassageNodePathNodes[tmpPassageNodeB.MirrorNum, tmpPassageNodeB.Num];
NewConnection = tmpNodeA.CreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
for ( C = 0; C <= PossibleRamps[BestNum].ReflectionCount - 1; C++ )
{
PossibleRamps[BestNum].Reflections[C].IsRamp = true;
tmpPassageNodeA = PossibleRamps[BestNum].Reflections[C].PassageNodeA;
tmpPassageNodeB = PossibleRamps[BestNum].Reflections[C].PassageNodeB;
tmpNodeA = PassageNodePathNodes[tmpPassageNodeA.MirrorNum, tmpPassageNodeA.Num];
tmpNodeB = PassageNodePathNodes[tmpPassageNodeB.MirrorNum, tmpPassageNodeB.Num];
NewConnection = tmpNodeA.CreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
PassageNodeNetwork.Network.FindCalc();
for ( E = 0; E <= PassageNodeCount - 1; E++ )
{
UpdateNetworkConnectednessArgs.PassageNodeUpdated[E] = false;
}
if ( PossibleRamps[BestNum].PassageNodeA.MirrorNum == 0 )
{
UpdateNetworkConnectedness(UpdateNetworkConnectednessArgs, PossibleRamps[BestNum].PassageNodeA);
}
else if ( PossibleRamps[BestNum].PassageNodeB.MirrorNum == 0 )
{
UpdateNetworkConnectedness(UpdateNetworkConnectednessArgs, PossibleRamps[BestNum].PassageNodeB);
}
else
{
ReturnResult.ProblemAdd("Error: Initial ramp not in area 0.");
goto Finish;
}
}
else
{
break;
}
} while ( true );
PathfinderNetwork.sFloodProximityArgs FloodArgs = new PathfinderNetwork.sFloodProximityArgs();
FloodArgs.StartNode = PassageNodeNetwork.PassageNodePathNodes[0, 0];
FloodArgs.NodeValues = PassageNodeNetwork.Network.NetworkLargeArrays.Nodes_ValuesA;
for ( A = 0; A <= PassageNodeCount - 1; A++ )
{
for ( B = 0; B <= SymmetryBlockCount - 1; B++ )
{
FloodArgs.NodeValues[PassageNodeNetwork.PassageNodePathNodes[B, A].Layer_NodeNum] = float.MaxValue;
}
}
PassageNodeNetwork.Network.FloodProximity(FloodArgs);
for ( A = 0; A <= PassageNodeCount - 1; A++ )
{
for ( B = 0; B <= SymmetryBlockCount - 1; B++ )
{
if ( !PassageNodes[B, A].IsWater )
{
if ( FloodArgs.NodeValues[PassageNodeNetwork.PassageNodePathNodes[B, A].Layer_NodeNum] == float.MaxValue )
{
ReturnResult.ProblemAdd("Land is unreachable. Reduce variation or retry.");
goto Finish;
}
}
}
}
Finish:
PassageNodeNetwork.Network.Deallocate();
return ReturnResult;
}
