int RebuildSegment(int segmentIndex, NetInfo newPrefab, Vector3 directionPoint, Vector3 direction, ref ToolError error)
{
// ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);
NetManager net = Singleton <NetManager> .instance;
NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;
NetTool.ControlPoint startPoint;
NetTool.ControlPoint middlePoint;
NetTool.ControlPoint endPoint;
MethodInfo dynMethod = netTool.GetType().GetMethod("ChangeElevation", BindingFlags.NonPublic | BindingFlags.Instance);
if (toolMode == ToolMode.RoadHeightUp)
{
Singleton <SimulationManager> .instance.AddAction <bool>((IEnumerator <bool>) dynMethod.Invoke(new NetTool(), new object[] { 1 }));
}
else if (toolMode == ToolMode.RoadHeightDown)
{
Singleton <SimulationManager> .instance.AddAction <bool>((IEnumerator <bool>) dynMethod.Invoke(new NetTool(), new object[] { -1 }));
}
GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint);
if (direction.magnitude > 0.0f)
{
float dot = Vector3.Dot(direction.normalized, (endPoint.m_position - startPoint.m_position).normalized);
float threshold = Mathf.Cos(Mathf.PI / 4);
if (dot > -threshold && dot < threshold)
{
return(0);
}
}
ushort node = 0;
ushort segment = 0;
int cost = 0;
int productionRate = 0;
// CreateNode(NetInfo info, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint, FastList<NetTool.NodePosition> nodeBuffer, int maxSegments, bool test, bool visualize, bool autoFix, bool needMoney, bool invert, bool switchDir, ushort relocateBuildingID, out ushort firstNode, out ushort lastNode, out ushort segment, out int cost, out int productionRate)
if (mouseDown && ((currentTime - prevRebuildTime) > 0.4f))
{
newPrefab.m_minHeight = 12.0f;
NetTool.CreateNode(newPrefab, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, false, false, true, false, false, false, (ushort)0, out node, out segment, out cost, out productionRate);
}
if (segment != 0)
{
if (newPrefab.m_class.m_service == ItemClass.Service.Road)
{
Singleton <CoverageManager> .instance.CoverageUpdated(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Level.None);
}
error = ToolError.None;
return(segment);
}
return(0);
}
//public static ToolBase.ToolErrors CreateNode(NetInfo info, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint, FastList<NetTool.NodePosition> nodeBuffer,
// int maxSegments, bool test, bool visualize, bool autoFix, bool needMoney, bool invert, bool switchDir, ushort relocateBuildingID,
// out ushort node, out ushort segment, out int cost, out int productionRate)
public override void SimulationStep()
{
base.SimulationStep();
if (isHoveringSegment)
{
ushort node;
ushort outSegment;
int cost;
int productionRate;
// Initializes colliding arrays
ToolErrors errors = NetTool.CreateNode(newPrefab != null ? newPrefab : segment.Info, startPoint, middlePoint, endPoint,
NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate);
}
}
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);
}
//public static ToolBase.ToolErrors CreateNode(NetInfo info, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint, FastList<NetTool.NodePosition> nodeBuffer,
// int maxSegments, bool test, bool visualize, bool autoFix, bool needMoney, bool invert, bool switchDir, ushort relocateBuildingID,
// out ushort node, out ushort segment, out int cost, out int productionRate)
public override void SimulationStep()
{
ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);
base.SimulationStep();
if (isHoveringSegment)
{
ushort node;
ushort outSegment;
int cost;
int productionRate;
// Initializes colliding arrays
ToolErrors errors = NetTool.CreateNode(newPrefab != null ? newPrefab : segment.Info, startPoint, middlePoint, endPoint,
NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate);
}
}
private int UpgradeWaterToHeat(bool test, out int totalCost, out ToolBase.ToolErrors errors)
{
int num = 0;
totalCost = 0;
errors = ToolBase.ToolErrors.None;
NetInfo info = PrefabCollection <NetInfo> .FindLoaded("Heating Pipe");
if (info == null)
{
//Debug.Log("Couldn't find Heating Pipe, aborting.");
Util.Log("Couldn't find Heating Pipe, aborting.");
return(num);
}
NetSegment[] buffer = Singleton <NetManager> .instance.m_segments.m_buffer;
for (int i = 0; i < buffer.Length; i++)
{
NetSegment segment = buffer[i];
if (((segment.Info != null) && (segment.Info.category == "WaterServices")) && (segment.m_flags != NetSegment.Flags.None))
{
NetTool.ControlPoint point;
NetTool.ControlPoint point2;
NetTool.ControlPoint point3;
this.GetSegmentControlPoints(i, out point, out point2, out point3);
bool visualize = false;
bool autoFix = true;
bool needMoney = true;
bool invert = false;
ushort node = 0;
ushort num4 = 0;
int cost = 0;
int productionRate = 0;
errors = NetTool.CreateNode(info, point, point2, point3, NetTool.m_nodePositionsSimulation, 0x3e8, test, visualize, autoFix, needMoney, invert, false, 0, out node, out num4, out cost, out productionRate);
if ((errors == ToolBase.ToolErrors.None) | test)
{
num++;
totalCost += cost;
}
else if ((errors & ToolBase.ToolErrors.NotEnoughMoney) != ToolBase.ToolErrors.None)
{
return(num);
}
}
}
return(num);
}
protected override void Handle(NodeCreateCommand command)
{
IgnoreHelper.StartIgnore();
ArrayHandler.StartApplying(command.Array16Ids, command.Array32Ids);
NetInfo prefab = PrefabCollection <NetInfo> .GetPrefab(command.Prefab);
FastList <NetTool.NodePosition> nodeBuffer = new FastList <NetTool.NodePosition>();
NetTool.CreateNode(prefab, command.StartPoint, command.MiddlePoint, command.EndPoint, nodeBuffer,
command.MaxSegments, false, command.TestEnds, false, command.AutoFix, false,
command.Invert, command.SwitchDir, command.RelocateBuildingId, out ushort _,
out ushort _, out ushort _, out int _, out int _);
ArrayHandler.StopApplying();
IgnoreHelper.EndIgnore();
}
public static ToolBase.ToolErrors InsertNode(NetTool.ControlPoint controlPoint, out ushort nodeId, bool test = false)
{
var ret = NetTool.CreateNode(
controlPoint.m_segment.ToSegment().Info,
controlPoint, controlPoint, controlPoint,
NetTool.m_nodePositionsSimulation,
maxSegments: 0,
test: test, visualize: false, autoFix: true, needMoney: false,
invert: false, switchDir: false,
relocateBuildingID: 0,
out nodeId, out var newSegment, out var cost, out var productionRate);
if (!test)
{
nodeId.ToNode().m_flags |= NetNode.Flags.Middle | NetNode.Flags.Moveable;
}
//Log.Debug($"[InsertNode] test={test} errors:{ret} nodeId:{nodeId} newSegment:{newSegment} cost:{cost} productionRate{productionRate}");
return(ret);
}
public bool CreateNodeImpl(NetInfo info, bool needMoney, bool switchDirection, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint)
{
bool flag = endPoint.m_node != 0 || endPoint.m_segment != 0;
ushort num;
ushort num2;
int num3;
int num4;
if (NetTool.CreateNode(info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, true, false, true, needMoney, false, switchDirection, 0, out num, out num2, out num3, out num4) == ToolBase.ToolErrors.None)
{
NetTool.CreateNode(info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, false, false, true, needMoney, false, switchDirection, 0, out num, out num2, out num3, out num4);
NetManager instance = Singleton <NetManager> .instance;
endPoint.m_segment = 0;
endPoint.m_node = num;
if (num2 != 0)
{
if (CustomNetTool.FieldUpgrading)
{
while (!Monitor.TryEnter(CustomNetTool.FieldUpgradedSegments, SimulationManager.SYNCHRONIZE_TIMEOUT))
{
}
try
{
CustomNetTool.FieldUpgradedSegments.Add(num2);
}
finally
{
Monitor.Exit(CustomNetTool.FieldUpgradedSegments);
}
}
if (instance.m_segments.m_buffer[(int)num2].m_startNode == num)
{
endPoint.m_direction = -instance.m_segments.m_buffer[(int)num2].m_startDirection;
}
else if (instance.m_segments.m_buffer[(int)num2].m_endNode == num)
{
endPoint.m_direction = -instance.m_segments.m_buffer[(int)num2].m_endDirection;
}
}
CustomNetTool.FieldControlPoints[0] = endPoint;
CustomNetTool.FieldElevation = Mathf.Max(0, Mathf.RoundToInt(endPoint.m_elevation / 12f));
if (num != 0 && (instance.m_nodes.m_buffer[(int)num].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None)
{
CustomNetTool.FieldControlPointCount = 0;
}
else if (this.m_mode == NetTool.Mode.Freeform && CustomNetTool.FieldControlPointCount == 2)
{
middlePoint.m_position = endPoint.m_position * 2f - middlePoint.m_position;
middlePoint.m_elevation = endPoint.m_elevation * 2f - middlePoint.m_elevation;
middlePoint.m_direction = endPoint.m_direction;
middlePoint.m_node = 0;
middlePoint.m_segment = 0;
CustomNetTool.FieldControlPoints[1] = middlePoint;
CustomNetTool.FieldControlPointCount = 2;
}
else
{
CustomNetTool.FieldControlPointCount = 1;
}
if (info.m_class.m_service > ItemClass.Service.Office)
{
int num5 = info.m_class.m_service - ItemClass.Service.Office - 1;
Singleton <GuideManager> .instance.m_serviceNotUsed[num5].Disable();
Singleton <GuideManager> .instance.m_serviceNeeded[num5].Deactivate();
}
if (info.m_class.m_service == ItemClass.Service.Road)
{
Singleton <CoverageManager> .instance.CoverageUpdated(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Level.None);
Singleton <NetManager> .instance.m_roadsNotUsed.Disable();
}
if ((info.m_class.m_service == ItemClass.Service.Road || info.m_class.m_service == ItemClass.Service.PublicTransport || info.m_class.m_service == ItemClass.Service.Beautification) && (info.m_hasForwardVehicleLanes || info.m_hasBackwardVehicleLanes) && (!info.m_hasForwardVehicleLanes || !info.m_hasBackwardVehicleLanes))
{
Singleton <NetManager> .instance.m_onewayRoadPlacement.Disable();
}
if (CustomNetTool.FieldUpgrading)
{
Debug.Log(startPoint);
//var priorityList = new Dictionary<ushort, int>();
//if (CustomRoadAI.GetNodeSimulation(startPoint.m_node) != null)
//{
// var nodeDict = CustomRoadAI.GetNodeSimulation(startPoint.m_node);
// if (nodeDict.FlagManualTrafficLights)
// {
// nodeDict.FlagManualTrafficLights = false;
// }
// if (nodeDict.FlagTimedTrafficLights)
// {
// nodeDict.FlagTimedTrafficLights = false;
// }
// CustomRoadAI.RemoveNodeFromSimulation(startPoint.m_node);
//}
//foreach (var prioritySegment in TrafficPriority.prioritySegments.Values)
//{
// if (prioritySegment.node_1 == startPoint.m_node && !priorityList.ContainsKey(startPoint.m_node))
// {
// priorityList.Add(startPoint.m_node, prioritySegment.segment);
// }
// if (prioritySegment.node_2 == startPoint.m_node && !priorityList.ContainsKey(startPoint.m_node))
// {
// priorityList.Add(startPoint.m_node, prioritySegment.segment);
// }
//}
//if (CustomRoadAI.GetNodeSimulation(endPoint.m_node) != null)
//{
// var nodeDict = CustomRoadAI.GetNodeSimulation(endPoint.m_node);
// if (nodeDict.FlagManualTrafficLights)
// {
// nodeDict.FlagManualTrafficLights = false;
// }
// if (nodeDict.FlagTimedTrafficLights)
// {
// nodeDict.FlagTimedTrafficLights = false;
// }
// CustomRoadAI.RemoveNodeFromSimulation(endPoint.m_node);
//}
//foreach (var prioritySegment in TrafficPriority.prioritySegments.Values)
//{
// if (prioritySegment.node_1 == endPoint.m_node && !priorityList.ContainsKey(endPoint.m_node))
// {
// priorityList.Add(endPoint.m_node, prioritySegment.segment);
// }
// if (prioritySegment.node_2 == endPoint.m_node && !priorityList.ContainsKey(endPoint.m_node))
// {
// priorityList.Add(endPoint.m_node, prioritySegment.segment);
// }
//}
//foreach (var pr in priorityList)
//{
// TrafficPriority.removePrioritySegment(pr.Key, pr.Value);
//}
info.m_netAI.UpgradeSucceeded();
}
else if (flag && num != 0)
{
info.m_netAI.ConnectionSucceeded(num, ref Singleton <NetManager> .instance.m_nodes.m_buffer[(int)num]);
}
Singleton <GuideManager> .instance.m_notEnoughMoney.Deactivate();
if (Singleton <GuideManager> .instance.m_properties != null && !CustomNetTool.FieldUpgrading && num2 != 0 && CustomNetTool.FieldBulldozerTool != null && CustomNetTool.FieldBulldozerTool.m_lastNetInfo != null && CustomNetTool.FieldBulldozerTool.m_lastNetInfo.m_netAI.CanUpgradeTo(info))
{
ushort startNode = instance.m_segments.m_buffer[(int)num2].m_startNode;
ushort endNode = instance.m_segments.m_buffer[(int)num2].m_endNode;
Vector3 position = instance.m_nodes.m_buffer[(int)startNode].m_position;
Vector3 position2 = instance.m_nodes.m_buffer[(int)endNode].m_position;
Vector3 startDirection = instance.m_segments.m_buffer[(int)num2].m_startDirection;
Vector3 endDirection = instance.m_segments.m_buffer[(int)num2].m_endDirection;
if (Vector3.SqrMagnitude(CustomNetTool.FieldBulldozerTool.m_lastStartPos - position) < 1f && Vector3.SqrMagnitude(CustomNetTool.FieldBulldozerTool.m_lastEndPos - position2) < 1f && Vector2.Dot(VectorUtils.XZ(CustomNetTool.FieldBulldozerTool.m_lastStartDir), VectorUtils.XZ(startDirection)) > 0.99f && Vector2.Dot(VectorUtils.XZ(CustomNetTool.FieldBulldozerTool.m_lastEndDir), VectorUtils.XZ(endDirection)) > 0.99f)
{
Singleton <NetManager> .instance.m_manualUpgrade.Activate(Singleton <GuideManager> .instance.m_properties.m_manualUpgrade, info.m_class.m_service);
}
}
return(true);
}
return(false);
}
public static bool LoadPaths(BuildingInfo info, ushort buildingID, ref Building data, float elevation)
{
if (info.m_paths != null)
{
// ns start
HashSet <ConnectionPoint> borderNodes = null;
if (info.m_paths.Length > 0)
{
//Debug.Log("LoadPaths detour");
borderNodes = ReleaseCollidingSegments();
}
// ns end
NetManager instance = Singleton <NetManager> .instance;
instance.m_tempNodeBuffer.Clear();
instance.m_tempSegmentBuffer.Clear();
for (int i = 0; i < info.m_paths.Length; i++)
{
BuildingInfo.PathInfo pathInfo = info.m_paths[i];
if (pathInfo.m_finalNetInfo != null && pathInfo.m_nodes != null && pathInfo.m_nodes.Length != 0)
{
Vector3 vector = data.CalculatePosition(pathInfo.m_nodes[0]);
bool flag = /*BuildingDecoration.*/ RequireFixedHeight(info, pathInfo.m_finalNetInfo, pathInfo.m_nodes[0]);
if (!flag)
{
vector.y = NetSegment.SampleTerrainHeight(pathInfo.m_finalNetInfo, vector, false, pathInfo.m_nodes[0].y + elevation);
}
Ray ray = new Ray(vector + new Vector3(0f, 8f, 0f), Vector3.down);
NetTool.ControlPoint controlPoint;
if (!FindConnectNode(instance.m_tempNodeBuffer, vector, pathInfo.m_finalNetInfo, out controlPoint))
{
if (NetTool.MakeControlPoint(ray, 16f, pathInfo.m_finalNetInfo, true, NetNode.Flags.Untouchable, NetSegment.Flags.Untouchable, Building.Flags.All, pathInfo.m_nodes[0].y + elevation - pathInfo.m_finalNetInfo.m_buildHeight, true, out controlPoint))
{
Vector3 vector2 = controlPoint.m_position - vector;
if (!flag)
{
vector2.y = 0f;
}
float sqrMagnitude = vector2.sqrMagnitude;
if (sqrMagnitude > pathInfo.m_maxSnapDistance * pathInfo.m_maxSnapDistance)
{
controlPoint.m_position = vector;
controlPoint.m_elevation = 0f;
controlPoint.m_node = 0;
controlPoint.m_segment = 0;
}
else
{
controlPoint.m_position.y = vector.y;
}
}
else
{
controlPoint.m_position = vector;
}
}
// ns start
/*if (!instance.m_tempNodeBuffer.Contains(controlPoint.m_node))
* {
* controlPoint.m_position = vector;
* controlPoint.m_elevation = 0f;
* controlPoint.m_node = 0;
* controlPoint.m_segment = 0;
* }*/
// ns end
//CheckSplitSegmentAngle(ref controlPoint, instance.m_tempSegmentBuffer, borderNodes); // ns
ushort node;
ushort num2;
int num3;
int num4;
if (controlPoint.m_node != 0)
{
instance.m_tempNodeBuffer.Add(controlPoint.m_node);
}
else if (NetTool.CreateNode(pathInfo.m_finalNetInfo, controlPoint, controlPoint, controlPoint, NetTool.m_nodePositionsSimulation, 0, false, false, false, false, pathInfo.m_invertSegments, false, 0, out node, out num2, out num3, out num4) == ToolBase.ToolErrors.None)
{
instance.m_tempNodeBuffer.Add(node);
controlPoint.m_node = node;
if (pathInfo.m_forbidLaneConnection != null && pathInfo.m_forbidLaneConnection.Length > 0 && pathInfo.m_forbidLaneConnection[0])
{
NetNode[] buffer = instance.m_nodes.m_buffer;
ushort num5 = node;
buffer[(int)num5].m_flags = (buffer[(int)num5].m_flags | NetNode.Flags.ForbidLaneConnection);
}
if (pathInfo.m_trafficLights != null && pathInfo.m_trafficLights.Length > 0)
{
/*BuildingDecoration.*/
TrafficLightsToFlags(pathInfo.m_trafficLights[0], ref instance.m_nodes.m_buffer[(int)node].m_flags);
}
}
for (int j = 1; j < pathInfo.m_nodes.Length; j++)
{
vector = data.CalculatePosition(pathInfo.m_nodes[j]);
bool flag2 = /*BuildingDecoration.*/ RequireFixedHeight(info, pathInfo.m_finalNetInfo, pathInfo.m_nodes[j]);
if (!flag2)
{
vector.y = NetSegment.SampleTerrainHeight(pathInfo.m_finalNetInfo, vector, false, pathInfo.m_nodes[j].y + elevation);
}
ray = new Ray(vector + new Vector3(0f, 8f, 0f), Vector3.down);
NetTool.ControlPoint controlPoint2;
if (!/*BuildingDecoration.*/ FindConnectNode(instance.m_tempNodeBuffer, vector, pathInfo.m_finalNetInfo, out controlPoint2))
{
if (NetTool.MakeControlPoint(ray, 16f, pathInfo.m_finalNetInfo, true, NetNode.Flags.Untouchable, NetSegment.Flags.Untouchable, Building.Flags.All, pathInfo.m_nodes[j].y + elevation - pathInfo.m_finalNetInfo.m_buildHeight, true, out controlPoint2))
{
Vector3 vector3 = controlPoint2.m_position - vector;
if (!flag2)
{
vector3.y = 0f;
}
float sqrMagnitude2 = vector3.sqrMagnitude;
if (sqrMagnitude2 > pathInfo.m_maxSnapDistance * pathInfo.m_maxSnapDistance)
{
controlPoint2.m_position = vector;
controlPoint2.m_elevation = 0f;
controlPoint2.m_node = 0;
controlPoint2.m_segment = 0;
}
else
{
controlPoint2.m_position.y = vector.y;
}
}
else
{
controlPoint2.m_position = vector;
}
}
NetTool.ControlPoint middlePoint = controlPoint2;
if (pathInfo.m_curveTargets != null && pathInfo.m_curveTargets.Length >= j)
{
middlePoint.m_position = data.CalculatePosition(pathInfo.m_curveTargets[j - 1]);
if (!flag || !flag2)
{
middlePoint.m_position.y = NetSegment.SampleTerrainHeight(pathInfo.m_finalNetInfo, middlePoint.m_position, false, pathInfo.m_curveTargets[j - 1].y + elevation);
}
}
else
{
middlePoint.m_position = (controlPoint.m_position + controlPoint2.m_position) * 0.5f;
}
middlePoint.m_direction = VectorUtils.NormalizeXZ(middlePoint.m_position - controlPoint.m_position);
controlPoint2.m_direction = VectorUtils.NormalizeXZ(controlPoint2.m_position - middlePoint.m_position);
ushort num6;
ushort num7;
ushort num8;
int num9;
int num10;
if (NetTool.CreateNode(pathInfo.m_finalNetInfo, controlPoint, middlePoint, controlPoint2, NetTool.m_nodePositionsSimulation, 1, false, false, false, false, false, pathInfo.m_invertSegments, false, 0, out num6, out num7, out num8, out num9, out num10) == ToolBase.ToolErrors.None)
{
instance.m_tempNodeBuffer.Add(num7);
instance.m_tempSegmentBuffer.Add(num8);
controlPoint2.m_node = num7;
if (pathInfo.m_forbidLaneConnection != null && pathInfo.m_forbidLaneConnection.Length > j && pathInfo.m_forbidLaneConnection[j])
{
NetNode[] buffer2 = instance.m_nodes.m_buffer;
ushort num11 = num7;
buffer2[(int)num11].m_flags = (buffer2[(int)num11].m_flags | NetNode.Flags.ForbidLaneConnection);
}
if (pathInfo.m_trafficLights != null && pathInfo.m_trafficLights.Length > j)
{
/*BuildingDecoration.*/
TrafficLightsToFlags(pathInfo.m_trafficLights[j], ref instance.m_nodes.m_buffer[(int)num7].m_flags);
}
if (pathInfo.m_yieldSigns != null && pathInfo.m_yieldSigns.Length >= j * 2)
{
if (pathInfo.m_yieldSigns[j * 2 - 2])
{
NetSegment[] buffer3 = instance.m_segments.m_buffer;
ushort num12 = num8;
buffer3[(int)num12].m_flags = (buffer3[(int)num12].m_flags | NetSegment.Flags.YieldStart);
}
if (pathInfo.m_yieldSigns[j * 2 - 1])
{
NetSegment[] buffer4 = instance.m_segments.m_buffer;
ushort num13 = num8;
buffer4[(int)num13].m_flags = (buffer4[(int)num13].m_flags | NetSegment.Flags.YieldEnd);
}
}
}
controlPoint = controlPoint2;
flag = flag2;
}
}
}
for (int k = 0; k < instance.m_tempNodeBuffer.m_size; k++)
{
ushort num14 = instance.m_tempNodeBuffer.m_buffer[k];
if ((instance.m_nodes.m_buffer[(int)num14].m_flags & NetNode.Flags.Untouchable) == NetNode.Flags.None)
{
if (buildingID != 0)
{
if ((data.m_flags & Building.Flags.Active) == Building.Flags.None && instance.m_nodes.m_buffer[(int)num14].Info.m_canDisable)
{
NetNode[] buffer5 = instance.m_nodes.m_buffer;
ushort num15 = num14;
buffer5[(int)num15].m_flags = (buffer5[(int)num15].m_flags | NetNode.Flags.Disabled);
}
NetNode[] buffer6 = instance.m_nodes.m_buffer;
ushort num16 = num14;
buffer6[(int)num16].m_flags = (buffer6[(int)num16].m_flags | NetNode.Flags.Untouchable);
instance.UpdateNode(num14);
instance.m_nodes.m_buffer[(int)num14].m_nextBuildingNode = data.m_netNode;
data.m_netNode = num14;
}
else
{
instance.UpdateNode(num14);
}
}
}
for (int l = 0; l < instance.m_tempSegmentBuffer.m_size; l++)
{
ushort num17 = instance.m_tempSegmentBuffer.m_buffer[l];
if ((instance.m_segments.m_buffer[(int)num17].m_flags & NetSegment.Flags.Untouchable) == NetSegment.Flags.None)
{
if (buildingID != 0)
{
NetSegment[] buffer7 = instance.m_segments.m_buffer;
ushort num18 = num17;
buffer7[(int)num18].m_flags = (buffer7[(int)num18].m_flags | NetSegment.Flags.Untouchable);
instance.UpdateSegment(num17);
}
else
{
if ((Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) != ItemClass.Availability.None)
{
NetInfo info2 = instance.m_segments.m_buffer[(int)num17].Info;
if ((info2.m_availableIn & ItemClass.Availability.AssetEditor) == ItemClass.Availability.None)
{
NetSegment[] buffer8 = instance.m_segments.m_buffer;
ushort num19 = num17;
buffer8[(int)num19].m_flags = (buffer8[(int)num19].m_flags | NetSegment.Flags.Untouchable);
}
}
instance.UpdateSegment(num17);
}
}
}
// ns start
if (info.m_paths.Length > 0)
{
ReleaseQuestionableSegments(instance.m_tempNodeBuffer, instance.m_tempSegmentBuffer);
new MakeConnections(borderNodes, instance.m_tempNodeBuffer);
}
// ns end
instance.m_tempNodeBuffer.Clear();
instance.m_tempSegmentBuffer.Clear();
}
return(false); // ns
}
int RebuildSegment(int segmentIndex, NetInfo newPrefab, bool roadDirectionMatters, Vector3 directionPoint, Vector3 direction, ref ToolError error)
{
NetManager net = Singleton <NetManager> .instance;
NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;
NetTool.ControlPoint startPoint;
NetTool.ControlPoint middlePoint;
NetTool.ControlPoint endPoint;
GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint);
if (direction.magnitude > 0.0f)
{
float dot = Vector3.Dot(direction.normalized, (endPoint.m_position - startPoint.m_position).normalized);
float threshold = Mathf.Cos(Mathf.PI / 4);
if (dot > -threshold && dot < threshold)
{
return(0);
}
if (roadDirectionMatters)
{
bool inverted = (net.m_segments.m_buffer[segmentIndex].m_flags & NetSegment.Flags.Invert) != 0;
if (Singleton <SimulationManager> .instance.m_metaData.m_invertTraffic == SimulationMetaData.MetaBool.True)
{
inverted = !inverted; // roads need to be placed in the opposite direction with left-hand traffic
}
bool reverseDirection = inverted ? (dot > 0.0f) : (dot < -0.0f);
if (reverseDirection)
{
var tmp = startPoint;
startPoint = endPoint;
endPoint = tmp;
startPoint.m_direction = -startPoint.m_direction;
endPoint.m_direction = -endPoint.m_direction;
middlePoint.m_direction = startPoint.m_direction;
}
else
{
if (prefab == newPrefab)
{
error = ToolError.SameDirection;
return(0);
}
}
}
}
bool test = false;
bool visualize = false;
bool autoFix = true;
bool needMoney = false;
bool invert = false;
ushort node = 0;
ushort segment = 0;
int cost = 0;
int productionRate = 0;
NetTool.CreateNode(newPrefab, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, test, visualize, autoFix, needMoney, invert, false, (ushort)0, out node, out segment, out cost, out productionRate);
if (segment != 0)
{
if (newPrefab.m_class.m_service == ItemClass.Service.Road)
{
Singleton <CoverageManager> .instance.CoverageUpdated(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Level.None);
}
error = ToolError.None;
return(segment);
}
return(0);
}
void _OnBeforeSimulationTick()
{
if (toolMode == ToolMode.None)
{
return;
}
if (!mouseDown)
{
dragging = false;
prevBuiltSegmentIndex = 0;
}
if (buildTool != null)
{
buildTool.isHoveringSegment = false;
buildTool.toolMode = toolMode;
buildTool.ToolCursor = netTool.m_upgradeCursor;
}
if (!mouseRayValid)
{
return;
}
ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength);
raycastInput.m_netService = raycastService;
raycastInput.m_ignoreTerrain = true;
raycastInput.m_ignoreNodeFlags = NetNode.Flags.All;
raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable;
ToolBase.RaycastOutput raycastOutput;
if (BuildTool118.RayCast(raycastInput, out raycastOutput))
{
int segmentIndex = raycastOutput.m_netSegment;
if (segmentIndex != 0)
{
NetManager net = Singleton <NetManager> .instance;
NetInfo newRoadPrefab = null;
NetTool.ControlPoint startPoint;
NetTool.ControlPoint middlePoint;
NetTool.ControlPoint endPoint;
GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint);
ushort node;
ushort outSegment;
int cost;
int productionRate;
// Check for out-of-area error and initialized collide arrays for visualization
ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info,
startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000,
true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate);
if ((errors & ToolBase.ToolErrors.OutOfArea) != 0)
{
toolError = ToolError.OutOfArea;
}
else
{
if (mouseDown)
{
HandleMouseDrag(ref raycastOutput, ref toolError, false, ref newRoadPrefab, ref segmentIndex);
if (segmentIndex == prevBuiltSegmentIndex)
{
toolError = ToolError.AlreadyBuilt;
}
}
else
{
HandleMouseDrag(ref raycastOutput, ref toolError, true, ref newRoadPrefab, ref segmentIndex);
}
}
if (buildTool != null)
{
buildTool.segment = net.m_segments.m_buffer[segmentIndex];
buildTool.segmentIndex = segmentIndex;
buildTool.isHoveringSegment = toolError != ToolError.Unknown;
if (newRoadPrefab != null)
{
buildTool.newPrefab = newRoadPrefab;
}
GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint);
}
}
}
if (buildTool != null)
{
buildTool.toolError = toolError;
}
}
/* STOCK CODE START */
/* Called when building (intersection) loads its segments. Detoured method. Added code is marked 'ns'
* We obrain a list with all the segments and pass them to the ProcessNewPaths method. We create our own list for that purpose instead of
* using instance.m_tempSegmentBuffer because it almost seems that the game can create multiple segments per one saved path in the file which
* makes absolutely no sense at all but would lead to our list being shifted compared to the (third) one in which we had saved the ids of the
* old segments. Whatever, you don't really have to understand this, I studied it a lot when creating my previous mods and it's the part I
* understand the most compared to the rest */
public static void LoadPaths(BuildingInfo info, ushort buildingID, ref Building data, float elevation)
{
#if DEBUG
Debug.Log("LoadPaths TMPE detour");
#endif
// ns
Dictionary <string, TmpeAssetData> dict = AssetDataManager.Instance.AssetsWithData;
bool isAssetWithTmpeSettings = dict.ContainsKey(IdentificationTool.GetNameWithoutPrefix(info.name));
List <ushort> CreatedSegments = null;
if (isAssetWithTmpeSettings)
{
CreatedSegments = new List <ushort>();
}
// ns end
if (info.m_paths != null)
{
NetManager instance = Singleton <NetManager> .instance;
instance.m_tempNodeBuffer.Clear();
instance.m_tempSegmentBuffer.Clear();
for (int i = 0; i < info.m_paths.Length; i++)
{
// ns
if (isAssetWithTmpeSettings)
{
CreatedSegments.Add(0);
}
// ns end
BuildingInfo.PathInfo pathInfo = info.m_paths[i];
if (pathInfo.m_finalNetInfo != null && pathInfo.m_nodes != null && pathInfo.m_nodes.Length != 0)
{
Vector3 vector = data.CalculatePosition(pathInfo.m_nodes[0]);
bool flag = /*BuildingDecoration.*/ RequireFixedHeight(info, pathInfo.m_finalNetInfo, pathInfo.m_nodes[0]);
if (!flag)
{
vector.y = NetSegment.SampleTerrainHeight(pathInfo.m_finalNetInfo, vector, false, pathInfo.m_nodes[0].y + elevation);
}
Ray ray = new Ray(vector + new Vector3(0f, 8f, 0f), Vector3.down);
NetTool.ControlPoint controlPoint;
if (!/*BuildingDecoration.*/ FindConnectNode(instance.m_tempNodeBuffer, vector, pathInfo.m_finalNetInfo, out controlPoint))
{
if (NetTool.MakeControlPoint(ray, 16f, pathInfo.m_finalNetInfo, true, NetNode.Flags.Untouchable, NetSegment.Flags.Untouchable, Building.Flags.All, pathInfo.m_nodes[0].y + elevation - pathInfo.m_finalNetInfo.m_buildHeight, true, out controlPoint))
{
Vector3 vector2 = controlPoint.m_position - vector;
if (!flag)
{
vector2.y = 0f;
}
float sqrMagnitude = vector2.sqrMagnitude;
if (sqrMagnitude > pathInfo.m_maxSnapDistance * pathInfo.m_maxSnapDistance)
{
controlPoint.m_position = vector;
controlPoint.m_elevation = 0f;
controlPoint.m_node = 0;
controlPoint.m_segment = 0;
}
else
{
controlPoint.m_position.y = vector.y;
}
}
else
{
controlPoint.m_position = vector;
}
}
ushort num;
ushort num2;
int num3;
int num4;
if (controlPoint.m_node != 0)
{
instance.m_tempNodeBuffer.Add(controlPoint.m_node);
}
else if (NetTool.CreateNode(pathInfo.m_finalNetInfo, controlPoint, controlPoint, controlPoint, NetTool.m_nodePositionsSimulation, 0, false, false, false, false, pathInfo.m_invertSegments, false, 0, out num, out num2, out num3, out num4) == ToolBase.ToolErrors.None)
{
instance.m_tempNodeBuffer.Add(num);
controlPoint.m_node = num;
if (pathInfo.m_forbidLaneConnection != null && pathInfo.m_forbidLaneConnection.Length > 0 && pathInfo.m_forbidLaneConnection[0])
{
NetNode[] buffer = instance.m_nodes.m_buffer;
ushort num5 = num;
buffer[(int)num5].m_flags = (buffer[(int)num5].m_flags | NetNode.Flags.ForbidLaneConnection);
}
if (pathInfo.m_trafficLights != null && pathInfo.m_trafficLights.Length > 0)
{
/*BuildingDecoration.*/
TrafficLightsToFlags(pathInfo.m_trafficLights[0], ref instance.m_nodes.m_buffer[(int)num].m_flags);
}
}
for (int j = 1; j < pathInfo.m_nodes.Length; j++)
{
vector = data.CalculatePosition(pathInfo.m_nodes[j]);
bool flag2 = /*BuildingDecoration.*/ RequireFixedHeight(info, pathInfo.m_finalNetInfo, pathInfo.m_nodes[j]);
if (!flag2)
{
vector.y = NetSegment.SampleTerrainHeight(pathInfo.m_finalNetInfo, vector, false, pathInfo.m_nodes[j].y + elevation);
}
ray = new Ray(vector + new Vector3(0f, 8f, 0f), Vector3.down);
NetTool.ControlPoint controlPoint2;
if (!/*BuildingDecoration.*/ FindConnectNode(instance.m_tempNodeBuffer, vector, pathInfo.m_finalNetInfo, out controlPoint2))
{
if (NetTool.MakeControlPoint(ray, 16f, pathInfo.m_finalNetInfo, true, NetNode.Flags.Untouchable, NetSegment.Flags.Untouchable, Building.Flags.All, pathInfo.m_nodes[j].y + elevation - pathInfo.m_finalNetInfo.m_buildHeight, true, out controlPoint2))
{
Vector3 vector3 = controlPoint2.m_position - vector;
if (!flag2)
{
vector3.y = 0f;
}
float sqrMagnitude2 = vector3.sqrMagnitude;
if (sqrMagnitude2 > pathInfo.m_maxSnapDistance * pathInfo.m_maxSnapDistance)
{
controlPoint2.m_position = vector;
controlPoint2.m_elevation = 0f;
controlPoint2.m_node = 0;
controlPoint2.m_segment = 0;
}
else
{
controlPoint2.m_position.y = vector.y;
}
}
else
{
controlPoint2.m_position = vector;
}
}
NetTool.ControlPoint middlePoint = controlPoint2;
if (pathInfo.m_curveTargets != null && pathInfo.m_curveTargets.Length >= j)
{
middlePoint.m_position = data.CalculatePosition(pathInfo.m_curveTargets[j - 1]);
if (!flag || !flag2)
{
middlePoint.m_position.y = NetSegment.SampleTerrainHeight(pathInfo.m_finalNetInfo, middlePoint.m_position, false, pathInfo.m_curveTargets[j - 1].y + elevation);
}
}
else
{
middlePoint.m_position = (controlPoint.m_position + controlPoint2.m_position) * 0.5f;
}
middlePoint.m_direction = VectorUtils.NormalizeXZ(middlePoint.m_position - controlPoint.m_position);
controlPoint2.m_direction = VectorUtils.NormalizeXZ(controlPoint2.m_position - middlePoint.m_position);
ushort num6;
ushort num7;
ushort num8;
int num9;
int num10;
if (NetTool.CreateNode(pathInfo.m_finalNetInfo, controlPoint, middlePoint, controlPoint2, NetTool.m_nodePositionsSimulation, 1, false, false, false, false, false, pathInfo.m_invertSegments, false, 0, out num6, out num7, out num8, out num9, out num10) == ToolBase.ToolErrors.None)
{
instance.m_tempNodeBuffer.Add(num7);
instance.m_tempSegmentBuffer.Add(num8);
// ns
if (isAssetWithTmpeSettings)
{
CreatedSegments[CreatedSegments.Count - 1] = num8;
}
// ns end
controlPoint2.m_node = num7;
if (pathInfo.m_forbidLaneConnection != null && pathInfo.m_forbidLaneConnection.Length > j && pathInfo.m_forbidLaneConnection[j])
{
NetNode[] buffer2 = instance.m_nodes.m_buffer;
ushort num11 = num7;
buffer2[(int)num11].m_flags = (buffer2[(int)num11].m_flags | NetNode.Flags.ForbidLaneConnection);
}
if (pathInfo.m_trafficLights != null && pathInfo.m_trafficLights.Length > j)
{
/*BuildingDecoration.*/
TrafficLightsToFlags(pathInfo.m_trafficLights[j], ref instance.m_nodes.m_buffer[(int)num7].m_flags);
}
if (pathInfo.m_yieldSigns != null && pathInfo.m_yieldSigns.Length >= j * 2)
{
if (pathInfo.m_yieldSigns[j * 2 - 2])
{
NetSegment[] buffer3 = instance.m_segments.m_buffer;
ushort num12 = num8;
buffer3[(int)num12].m_flags = (buffer3[(int)num12].m_flags | NetSegment.Flags.YieldStart);
}
if (pathInfo.m_yieldSigns[j * 2 - 1])
{
NetSegment[] buffer4 = instance.m_segments.m_buffer;
ushort num13 = num8;
buffer4[(int)num13].m_flags = (buffer4[(int)num13].m_flags | NetSegment.Flags.YieldEnd);
}
}
}
controlPoint = controlPoint2;
flag = flag2;
}
}
}
for (int k = 0; k < instance.m_tempNodeBuffer.m_size; k++)
{
ushort num14 = instance.m_tempNodeBuffer.m_buffer[k];
if ((instance.m_nodes.m_buffer[(int)num14].m_flags & NetNode.Flags.Untouchable) == NetNode.Flags.None)
{
if (buildingID != 0)
{
if ((data.m_flags & Building.Flags.Active) == Building.Flags.None && instance.m_nodes.m_buffer[(int)num14].Info.m_canDisable)
{
NetNode[] buffer5 = instance.m_nodes.m_buffer;
ushort num15 = num14;
buffer5[(int)num15].m_flags = (buffer5[(int)num15].m_flags | NetNode.Flags.Disabled);
}
NetNode[] buffer6 = instance.m_nodes.m_buffer;
ushort num16 = num14;
buffer6[(int)num16].m_flags = (buffer6[(int)num16].m_flags | NetNode.Flags.Untouchable);
instance.UpdateNode(num14);
instance.m_nodes.m_buffer[(int)num14].m_nextBuildingNode = data.m_netNode;
data.m_netNode = num14;
}
else
{
instance.UpdateNode(num14);
}
}
}
for (int l = 0; l < instance.m_tempSegmentBuffer.m_size; l++)
{
ushort num17 = instance.m_tempSegmentBuffer.m_buffer[l];
if ((instance.m_segments.m_buffer[(int)num17].m_flags & NetSegment.Flags.Untouchable) == NetSegment.Flags.None)
{
if (buildingID != 0)
{
NetSegment[] buffer7 = instance.m_segments.m_buffer;
ushort num18 = num17;
buffer7[(int)num18].m_flags = (buffer7[(int)num18].m_flags | NetSegment.Flags.Untouchable);
instance.UpdateSegment(num17);
}
else
{
if ((Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) != ItemClass.Availability.None)
{
NetInfo info2 = instance.m_segments.m_buffer[(int)num17].Info;
if ((info2.m_availableIn & ItemClass.Availability.AssetEditor) == ItemClass.Availability.None)
{
NetSegment[] buffer8 = instance.m_segments.m_buffer;
ushort num19 = num17;
buffer8[(int)num19].m_flags = (buffer8[(int)num19].m_flags | NetSegment.Flags.Untouchable);
}
}
instance.UpdateSegment(num17);
}
}
}
// ns
if (isAssetWithTmpeSettings && CreatedSegments.Count > 0)
{
if (CreatedSegments.Last() == 0)
{
CreatedSegments.RemoveAt(CreatedSegments.Count - 1);
}
ProcessNewPaths(CreatedSegments, info);
}
// ns end
instance.m_tempNodeBuffer.Clear();
instance.m_tempSegmentBuffer.Clear();
}
}
public NodeData InsertNode(NetTool.ControlPoint controlPoint, NodeStyleType nodeType = NodeStyleType.Crossing)
{
if (NetTool.CreateNode(controlPoint.m_segment.GetSegment().Info, controlPoint, controlPoint, controlPoint, NetTool.m_nodePositionsSimulation, 0, false, false, true, false, false, false, 0, out var nodeId, out _, out _, out _) != ToolBase.ToolErrors.None)
{
return(null);
}
public override void OnUpdate(float realTimeDelta, float simulationTimeDelta)
{
ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);
if (loadingLevel)
{
return;
}
if (Input.GetKeyDown(KeyCode.Return))
{
ModDebug.Log(netTool.m_prefab + " " + netTool.m_mode);
}
if (roadsPanel == null)
{
roadsPanel = UIView.Find <UIPanel>("RoadsPanel");
}
if (roadsPanel == null || !roadsPanel.isVisible)
{
if (toolMode != ToolMode.None)
{
ModDebug.Log("Roads panel no longer visible");
SetToolMode(ToolMode.None, true);
}
return;
}
if (netTool == null)
{
foreach (var tool in ToolsModifierControl.toolController.Tools)
{
NetTool nt = tool as NetTool;
if (nt != null && nt.m_prefab != null)
{
ModDebug.Log("NetTool found: " + nt.name);
netTool = nt;
break;
}
}
if (netTool == null)
{
return;
}
raycastService = new ToolBase.RaycastService(netTool.m_prefab.m_class.m_service, netTool.m_prefab.m_class.m_subService, netTool.m_prefab.m_class.m_layer);
ModDebug.Log("UI visible: " + ui.isVisible);
}
if (!ui.isVisible)
{
ui.Show();
}
if (toolMode != ToolMode.None)
{
mouseDown = Input.GetMouseButton(0);
mouseRayValid = !ToolsModifierControl.toolController.IsInsideUI && Cursor.visible;
mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
mouseRayLength = Camera.main.farClipPlane;
currentTime = Time.time;
if (ToolsModifierControl.toolController.CurrentTool != buildTool)
{
ModDebug.Log("Another tool selected");
SetToolMode(ToolMode.None);
}
}
else
{
ui.toolMode = ToolMode.None;
if (ToolsModifierControl.toolController.CurrentTool == buildTool)
{
ToolsModifierControl.toolController.CurrentTool = netTool;
}
}
//ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);
if (toolMode == ToolMode.None)
{
return;
}
if (!mouseDown)
{
prevBuiltSegmentIndex = 0;
}
if (buildTool != null)
{
buildTool.isHoveringSegment = false;
buildTool.toolMode = toolMode;
buildTool.ToolCursor = netTool.m_upgradeCursor;
}
if (!mouseRayValid)
{
return;
}
ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength);
raycastInput.m_netService = raycastService;
raycastInput.m_ignoreTerrain = true;
raycastInput.m_ignoreNodeFlags = NetNode.Flags.All;
raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable;
ToolBase.RaycastOutput raycastOutput;
if (BuildTool21.RayCast(raycastInput, out raycastOutput))
{
int segmentIndex = raycastOutput.m_netSegment;
if (segmentIndex != 0)
{
NetManager net = Singleton <NetManager> .instance;
NetInfo newRoadPrefab = null;
NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;
NetTool.ControlPoint startPoint;
NetTool.ControlPoint middlePoint;
NetTool.ControlPoint endPoint;
GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint);
ushort node;
ushort outSegment;
int cost;
int productionRate;
// Check for out-of-area error and initialized collide arrays for visualization
ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info,
startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000,
true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate);
if ((errors & ToolBase.ToolErrors.OutOfArea) != 0)
{
toolError = ToolError.OutOfArea;
}
string prefabName = null;
if (!roadPrefabNames.TryGetValue(prefab.GetInstanceID(), out prefabName) || prefabName == null)
{
ModDebug.Error("Prefab name not found");
toolError = ToolError.Unknown;
return;
}
NetInfo newPrefab;
if (!roadPrefabs.TryGetValue(prefabName, out newPrefab) || newPrefab == null)
{
ModDebug.Error("Prefab not found: " + prefabName);
toolError = ToolError.Unknown;
return;
}
newRoadPrefab = newPrefab;
// ModDebug.Log("Going to rebuild segment");
int newIndex = RebuildSegment(segmentIndex, newPrefab, raycastOutput.m_hitPos, hitPosDelta, ref toolError);
if (newIndex != 0)
{
// ModDebug.Log("newIndex: " + newIndex);
if (toolError != ToolError.None)
{
return;
}
prevBuiltSegmentIndex = segmentIndex;
prevRebuildTime = currentTime;
segmentIndex = newIndex;
}
if (buildTool != null)
{
// ModDebug.Log("Using segment from buffer");
buildTool.segment = net.m_segments.m_buffer[segmentIndex];
buildTool.segmentIndex = segmentIndex;
buildTool.isHoveringSegment = toolError != ToolError.Unknown;
if (newRoadPrefab != null)
{
buildTool.newPrefab = newRoadPrefab;
}
GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint);
}
}
}
if (buildTool != null)
{
buildTool.toolError = toolError;
}
}
//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");
}
