public static void BuildRoad(Vector3 startVector, Vector3 endVector, uint prefabNumber)
{
int maxSegments = 100;
bool test = false;
bool visualize = false;
bool autoFix = true;
bool needMoney = false;
bool invert = false;
bool switchDir = false;
ushort relocateBuildingID = 0;
ushort firstNode;
ushort lastNode;
ushort startNode;
ushort endNode;
ushort segment;
int cost;
int productionRate;
NetTool tool = new NetTool();
NetInfo netInfo = PrefabCollection<NetInfo>.GetPrefab(prefabNumber);
float startHeight = NetSegment.SampleTerrainHeight(netInfo, startVector, false);
float endHeight = NetSegment.SampleTerrainHeight(netInfo, endVector, false);
NetTool.ControlPoint startControlPt = new NetTool.ControlPoint();
NetTool.ControlPoint endControlPt = new NetTool.ControlPoint();
startVector.y = startHeight;
startControlPt.m_position = startVector;
endVector.y = endHeight;
endControlPt.m_position = endVector;
NetTool.CreateNode(netInfo, startControlPt, startControlPt, startControlPt, NetTool.m_nodePositionsSimulation,
0, false, false, false, false, false, false, (ushort)0, out startNode, out segment, out cost, out productionRate);
NetTool.CreateNode(netInfo, endControlPt, endControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
0, false, false, false, false, false, false, (ushort)0, out endNode, out segment, out cost, out productionRate);
startControlPt.m_node = startNode;
endControlPt.m_node = endNode;
NetTool.ControlPoint midControlPt = endControlPt;
midControlPt.m_position = (startControlPt.m_position + endControlPt.m_position) * 0.5f;
midControlPt.m_direction = VectorUtils.NormalizeXZ(midControlPt.m_position - startControlPt.m_position);
endControlPt.m_direction = VectorUtils.NormalizeXZ(endControlPt.m_position - midControlPt.m_position);
NetTool.CreateNode(netInfo, startControlPt, midControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
maxSegments, test, visualize, autoFix, needMoney, invert, switchDir, relocateBuildingID, out firstNode,
out lastNode, out segment, out cost, out productionRate);
}
private void GetSegmentControlPoints(int segmentIndex, out NetTool.ControlPoint startPoint, out NetTool.ControlPoint middlePoint, out NetTool.ControlPoint endPoint)
{
//WriteLog("Entering GetSegmentControlPoints");
NetManager net = Singleton<NetManager>.instance;
startPoint = new NetTool.ControlPoint();
middlePoint = new NetTool.ControlPoint();
endPoint = new NetTool.ControlPoint();
if (segmentIndex >= net.m_segments.m_buffer.Length)
{
ARUT.WriteLog("GetSegmentControlPoints:: segmentIndex >= net.m_segments.m_buffer.Length: segmentIndex: " + segmentIndex + " net.m_segments.m_buffer.Length: " + net.m_segments.m_buffer.Length);
return;
}
NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;
startPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_startNode;
startPoint.m_segment = 0;
startPoint.m_position = net.m_nodes.m_buffer[startPoint.m_node].m_position;
startPoint.m_direction = net.m_segments.m_buffer[segmentIndex].m_startDirection;
startPoint.m_elevation = net.m_nodes.m_buffer[startPoint.m_node].m_elevation;
startPoint.m_outside = (net.m_nodes.m_buffer[startPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;
endPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_endNode;
endPoint.m_segment = 0;
endPoint.m_position = net.m_nodes.m_buffer[endPoint.m_node].m_position;
endPoint.m_direction = -net.m_segments.m_buffer[segmentIndex].m_endDirection;
endPoint.m_elevation = net.m_nodes.m_buffer[endPoint.m_node].m_elevation;
endPoint.m_outside = (net.m_nodes.m_buffer[endPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;
middlePoint.m_node = 0;
middlePoint.m_segment = (ushort)segmentIndex;
middlePoint.m_position = startPoint.m_position + startPoint.m_direction * (prefab.GetMinNodeDistance() + 1f);
middlePoint.m_direction = startPoint.m_direction;
middlePoint.m_elevation = Mathf.Lerp(startPoint.m_elevation, endPoint.m_elevation, 0.5f);
middlePoint.m_outside = false;
//WriteLog("Leaving GetSegmentControlPoints");
}
//Test
public static void CloneNode(NetNode node)
{
Log.Message("BuildRoad enter");
int maxSegments = 100;
bool test = false;
bool visualize = false;
bool autoFix = true;
bool needMoney = false;
bool invert = false;
bool switchDir = false;
ushort relocateBuildingID = 0;
ushort firstNode;
ushort lastNode;
ushort startNode;
ushort endNode;
ushort segment;
int cost;
int productionRate;
Log.Message("BuildRoad fields inied");
NetTool tool = new NetTool();
NetInfo netInfo = node.Info;
float startHeight = NetSegment.SampleTerrainHeight(netInfo, node.m_position, false);
float endHeight = NetSegment.SampleTerrainHeight(netInfo, node.m_position, false);
Log.Message("BuildRoad netinfo");
NetTool.ControlPoint startControlPt = new NetTool.ControlPoint();
NetTool.ControlPoint endControlPt = new NetTool.ControlPoint();
Log.Message("BuildRoad netcontrol set");
node.m_position.y = startHeight;
startControlPt.m_position = node.m_position;
node.m_position.y = endHeight;
endControlPt.m_position = node.m_position;
Log.Message("BuildRoad creating node 1");
NetTool.CreateNode(netInfo, startControlPt, startControlPt, startControlPt, NetTool.m_nodePositionsSimulation,
0, false, false, false, false, false, false, (ushort)0, out startNode, out segment, out cost, out productionRate);
// CreateNode(out startNode, ref rand, netInfo, new Vector2(startVector.x, startVector.z) , NetSegment.SampleTerrainHeight(netInfo, startVector, false));
Log.Message("BuildRoad creating node 2");
NetTool.CreateNode(netInfo, endControlPt, endControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
0, false, false, false, false, false, false, (ushort)0, out endNode, out segment, out cost, out productionRate);
// CreateNode(out endNode, ref rand, netInfo, new Vector2(endVector.x, endVector.z), NetSegment.SampleTerrainHeight(netInfo, startVector, false));
// Array16<NetNode> abc = NetManager.instance.m_nodes; Test
startControlPt.m_node = startNode;
endControlPt.m_node = endNode;
Log.Message("BuildRoad midcontrpt setting");
NetTool.ControlPoint midControlPt = endControlPt;
midControlPt.m_position = (startControlPt.m_position + endControlPt.m_position) * 0.5f;
midControlPt.m_direction = VectorUtils.NormalizeXZ(midControlPt.m_position - startControlPt.m_position);
endControlPt.m_direction = VectorUtils.NormalizeXZ(endControlPt.m_position - midControlPt.m_position);
NetTool.CreateNode(netInfo, startControlPt, midControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
maxSegments, test, visualize, autoFix, needMoney, invert, switchDir, relocateBuildingID, out firstNode,
out lastNode, out segment, out cost, out productionRate);
Log.Message("BuildRoad road set");
}
public override ToolBase.ToolErrors CheckBuildPosition(bool test, bool visualize, bool overlay, bool autofix, ref NetTool.ControlPoint startPoint, ref NetTool.ControlPoint middlePoint, ref NetTool.ControlPoint endPoint, out BuildingInfo ownerBuilding, out Vector3 ownerPosition, out Vector3 ownerDirection, out int productionRate)
{
ToolBase.ToolErrors toolErrors = base.CheckBuildPosition(test, visualize, overlay, autofix, ref startPoint, ref middlePoint, ref endPoint, out ownerBuilding, out ownerPosition, out ownerDirection, out productionRate);
NetManager instance1 = Singleton <NetManager> .instance;
TerrainManager instance2 = Singleton <TerrainManager> .instance;
if ((int)startPoint.m_node != 0)
{
NetInfo info = instance1.m_nodes.m_buffer[(int)startPoint.m_node].Info;
if (info.m_class.m_subService != this.m_info.m_class.m_subService || info.m_class.m_level != this.m_info.m_class.m_level)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
else
{
float y = instance1.m_nodes.m_buffer[(int)startPoint.m_node].m_position.y;
startPoint.m_elevation = y - startPoint.m_position.y;
startPoint.m_position.y = y;
if (instance1.m_nodes.m_buffer[(int)startPoint.m_node].CountSegments() > 1)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
}
}
else if ((int)startPoint.m_segment != 0)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
else
{
float y = startPoint.m_position.y;
Vector3 vector3 = new Vector3(middlePoint.m_direction.z, 0.0f, -middlePoint.m_direction.x);
float num = Mathf.Max(Mathf.Max(y, Singleton <TerrainManager> .instance.SampleRawHeightSmooth(startPoint.m_position + vector3 * (this.m_info.m_halfWidth + 8f))), Singleton <TerrainManager> .instance.SampleRawHeightSmooth(startPoint.m_position - vector3 * (this.m_info.m_halfWidth + 8f)));
startPoint.m_elevation = num - startPoint.m_position.y;
startPoint.m_position.y = num;
}
if ((int)endPoint.m_node != 0)
{
NetInfo info = instance1.m_nodes.m_buffer[(int)endPoint.m_node].Info;
if (info.m_class.m_subService != this.m_info.m_class.m_subService || info.m_class.m_level != this.m_info.m_class.m_level)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
else
{
float y = instance1.m_nodes.m_buffer[(int)endPoint.m_node].m_position.y;
endPoint.m_elevation = y - endPoint.m_position.y;
endPoint.m_position.y = y;
if (instance1.m_nodes.m_buffer[(int)endPoint.m_node].CountSegments() > 1)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
}
}
else if ((int)endPoint.m_segment != 0)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
else
{
float y = endPoint.m_position.y;
Vector3 vector3 = new Vector3(endPoint.m_direction.z, 0.0f, -endPoint.m_direction.x);
float num = Mathf.Max(Mathf.Max(y, Singleton <TerrainManager> .instance.SampleRawHeightSmooth(endPoint.m_position + vector3 * (this.m_info.m_halfWidth + 8f))), Singleton <TerrainManager> .instance.SampleRawHeightSmooth(endPoint.m_position - vector3 * (this.m_info.m_halfWidth + 8f)));
endPoint.m_elevation = num - endPoint.m_position.y;
endPoint.m_position.y = num;
}
middlePoint.m_elevation = (float)(((double)startPoint.m_elevation + (double)endPoint.m_elevation) * 0.5);
middlePoint.m_position.y = (float)(((double)startPoint.m_position.y + (double)endPoint.m_position.y) * 0.5);
Vector3 middlePos1;
Vector3 middlePos2;
NetSegment.CalculateMiddlePoints(startPoint.m_position, middlePoint.m_direction, endPoint.m_position, -endPoint.m_direction, true, true, out middlePos1, out middlePos2);
Bezier2 bezier2;
bezier2.a = VectorUtils.XZ(startPoint.m_position);
bezier2.b = VectorUtils.XZ(middlePos1);
bezier2.c = VectorUtils.XZ(middlePos2);
bezier2.d = VectorUtils.XZ(endPoint.m_position);
int num1 = Mathf.CeilToInt(Vector2.Distance(bezier2.a, bezier2.d) * 0.005f) + 3;
Vector2 vector2_1 = new Vector2(middlePoint.m_direction.z, -middlePoint.m_direction.x);
Segment2 segment1;
segment1.a = bezier2.a + vector2_1 * this.m_info.m_halfWidth;
Segment2 segment2;
segment2.a = bezier2.a - vector2_1 * this.m_info.m_halfWidth;
//begin mod
//end mod
for (int index = 1; index <= num1; ++index)
{
Vector2 vector2_2 = bezier2.Position((float)index / (float)num1);
Vector2 vector2_3 = bezier2.Tangent((float)index / (float)num1);
vector2_3 = new Vector2(vector2_3.y, -vector2_3.x).normalized;
segment1.b = vector2_2 + vector2_3 * this.m_info.m_halfWidth;
segment2.b = vector2_2 - vector2_3 * this.m_info.m_halfWidth;
//begin mod
//end mod
segment1.a = segment1.b;
segment2.a = segment2.b;
}
//begin mod
//end mod
return(toolErrors);
}
#pragma warning disable 108,114
public virtual ToolBase.ToolErrors CheckBuildPosition(bool test, bool visualize, bool overlay, bool autofix,
#pragma warning restore 108,114
ref NetTool.ControlPoint startPoint, ref NetTool.ControlPoint middlePoint, ref NetTool.ControlPoint endPoint,
out BuildingInfo ownerBuilding, out Vector3 ownerPosition, out Vector3 ownerDirection,
out int productionRate)
{
ownerBuilding = null;
ownerPosition = Vector3.zero;
ownerDirection = Vector3.forward;
productionRate = 0;
ToolBase.ToolErrors toolErrors = ToolBase.ToolErrors.None;
if (test)
{
ushort num = middlePoint.m_segment;
if (startPoint.m_segment == num || endPoint.m_segment == num)
{
num = 0;
}
if (num != 0 && Singleton <NetManager> .instance.m_segments.m_buffer[(int)num].Info == this.m_info && (Singleton <NetManager> .instance.m_segments.m_buffer[(int)num].m_flags & NetSegment.Flags.Collapsed) == NetSegment.Flags.None)
{
if (ZoneBlocksOffset.Mode == ZoneBlocksOffsetMode.Default)
{
toolErrors |= ToolBase.ToolErrors.CannotUpgrade;
}
else
{
// Do nothing
}
}
}
if (autofix && this.m_info.m_enableBendingSegments)
{
Vector3 vector = middlePoint.m_direction;
Vector3 vector2 = -endPoint.m_direction;
Vector3 vector3 = middlePoint.m_position;
float minNodeDistance = this.m_info.GetMinNodeDistance();
for (int i = 0; i < 3; i++)
{
bool flag = false;
bool flag2 = false;
if (startPoint.m_node != 0)
{
if (ForceValidDirection(this.m_info, ref vector, startPoint.m_node,
ref Singleton <NetManager> .instance.m_nodes.m_buffer[(int)startPoint.m_node]))
{
flag = true;
}
}
else if (startPoint.m_segment != 0 &&
ForceValidDirection(this.m_info, startPoint.m_position, ref vector,
startPoint.m_segment,
ref Singleton <NetManager> .instance.m_segments.m_buffer[(int)startPoint.m_segment]))
{
flag = true;
}
if (flag)
{
Line2 line = Line2.XZ(startPoint.m_position, startPoint.m_position + vector);
Line2 line2 = Line2.XZ(endPoint.m_position, endPoint.m_position + vector2);
bool flag3 = true;
float num2;
float num3;
if (line.Intersect(line2, out num2, out num3) && num2 >= minNodeDistance &&
num3 >= minNodeDistance)
{
vector3 = startPoint.m_position + vector * num2;
flag3 = false;
}
if (flag3)
{
Vector3 vector4 = endPoint.m_position - startPoint.m_position;
Vector3 vector5 = vector;
vector4.y = 0f;
vector5.y = 0f;
float num4 = Vector3.SqrMagnitude(vector4);
vector4 = Vector3.Normalize(vector4);
float num5 = Mathf.Min(1.17809725f, Mathf.Acos(Vector3.Dot(vector4, vector5)));
float d = Mathf.Sqrt(0.5f * num4 / Mathf.Max(0.001f, 1f - Mathf.Cos(3.14159274f - 2f * num5)));
vector3 = startPoint.m_position + vector5 * d;
vector2 = vector3 - endPoint.m_position;
vector2.y = 0f;
vector2.Normalize();
}
}
if (endPoint.m_node != 0)
{
if (ForceValidDirection(this.m_info, ref vector2, endPoint.m_node,
ref Singleton <NetManager> .instance.m_nodes.m_buffer[(int)endPoint.m_node]))
{
flag2 = true;
}
}
else if (endPoint.m_segment != 0 &&
ForceValidDirection(this.m_info, endPoint.m_position, ref vector2, endPoint.m_segment,
ref Singleton <NetManager> .instance.m_segments.m_buffer[(int)endPoint.m_segment]))
{
flag2 = true;
}
if (flag2)
{
Line2 line3 = Line2.XZ(startPoint.m_position, startPoint.m_position + vector);
Line2 line4 = Line2.XZ(endPoint.m_position, endPoint.m_position + vector2);
bool flag4 = true;
float num6;
float num7;
if (line3.Intersect(line4, out num6, out num7) && num6 >= minNodeDistance &&
num7 >= minNodeDistance)
{
vector3 = endPoint.m_position + vector2 * num7;
flag4 = false;
}
if (flag4)
{
Vector3 vector6 = startPoint.m_position - endPoint.m_position;
Vector3 vector7 = vector2;
vector6.y = 0f;
vector7.y = 0f;
float num8 = Vector3.SqrMagnitude(vector6);
vector6 = Vector3.Normalize(vector6);
float num9 = Mathf.Min(1.17809725f, Mathf.Acos(Vector3.Dot(vector6, vector7)));
float d2 = Mathf.Sqrt(0.5f * num8 / Mathf.Max(0.001f, 1f - Mathf.Cos(3.14159274f - 2f * num9)));
vector3 = endPoint.m_position + vector7 * d2;
vector = vector3 - startPoint.m_position;
vector.y = 0f;
vector.Normalize();
}
}
if (!flag && !flag2)
{
middlePoint.m_direction = vector;
endPoint.m_direction = -vector2;
middlePoint.m_position = vector3;
break;
}
}
}
return(toolErrors);
}
public static void Prefix(out CallState __state, bool test, bool visualize,
NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint)
{
__state = new CallState();
if (IgnoreHelper.IsIgnored())
{
__state.valid = false;
return;
}
if (test || visualize)
{
__state.valid = false;
return;
}
__state.valid = true;
__state.SetControlPoints(startPoint, middlePoint, endPoint);
IgnoreHelper.StartIgnore();
ArrayHandler.StartCollecting();
}
