/// <param name="consistencyLevel">0=consistent 1=inconsistent</param>
public NodeInfoClass(NetInfo.Node nodeInfo, int usedIndex, int inconsistencyLevel)
{
InconsistencyLevel = inconsistencyLevel;
UsedIndex = usedIndex;
Track = nodeInfo.m_connectGroup.GetTrackType();
RequireWindSpeed = nodeInfo.m_requireWindSpeed;
RequiredFlags = default;
ForbiddenFlags = default;
Layer = -1;
EmptyTransparent = default;
RequireSurfaceMaps = default;
if (inconsistencyLevel <= 1)
{
RequiredFlags = nodeInfo.m_flagsRequired;
}
if (inconsistencyLevel == 0)
{
ForbiddenFlags = nodeInfo.m_flagsForbidden;
Layer = nodeInfo.m_layer;
EmptyTransparent = nodeInfo.m_emptyTransparent;
RequireSurfaceMaps = nodeInfo.m_requireSurfaceMaps;
}
}
public static NetInfo.Node SetFlags(this NetInfo.Node node, NetNode.Flags required, NetNode.Flags forbidden)
{
node.m_flagsRequired = required;
node.m_flagsForbidden = forbidden;
return(node);
}
public override void OnPrimaryClickOverlay()
{
if (HoveredNodeId == 0 || HoveredSegmentId == 0)
{
return;
}
NetNode.Flags netFlags = Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags;
if ((netFlags & NetNode.Flags.Junction) == NetNode.Flags.None)
{
return;
}
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
if (segmentsBuffer[HoveredSegmentId].m_startNode != HoveredNodeId &&
segmentsBuffer[HoveredSegmentId].m_endNode != HoveredNodeId)
{
return;
}
SelectedSegmentId = HoveredSegmentId;
SelectedNodeId = HoveredNodeId;
}
public bool CheckFlags(NetSegmentExt.Flags flags,
NetSegmentEnd.Flags tailFlags,
NetSegmentEnd.Flags headFlags,
NetNode.Flags tailNodeFlags,
NetNode.Flags headNodeFlags,
NetNodeExt.Flags tailNodeExtFlags,
NetNodeExt.Flags headNodeExtFlags,
bool turnAround)
{
if (!turnAround)
{
return(Forward.CheckFlags(flags) && CheckEndFlags(
tailFlags: tailFlags,
headFlags: headFlags,
tailNodeFlags: tailNodeFlags,
headNodeFlags: headNodeFlags,
tailNodeExtFlags: tailNodeExtFlags,
headNodeExtFlags: headNodeExtFlags));
}
else
{
Helpers.Swap(ref tailFlags, ref headFlags);
Helpers.Swap(ref tailNodeFlags, ref headNodeFlags);
var ret = Backward.CheckFlags(flags) && CheckEndFlags(
tailFlags: tailFlags,
headFlags: headFlags,
tailNodeFlags: tailNodeFlags,
headNodeFlags: headNodeFlags,
tailNodeExtFlags: tailNodeExtFlags,
headNodeExtFlags: headNodeExtFlags);
return(ret);
}
}
public bool SetTrafficLight(ushort nodeId, bool flag, ref NetNode node, out UnableReason reason)
{
#if DEBUGTTL
if (GlobalConfig.Instance.Debug.Switches[7] && GlobalConfig.Instance.Debug.NodeId == nodeId)
{
Log._Debug($"TrafficLightManager.SetTrafficLight: called for node {nodeId}, flag={flag}");
}
#endif
if (!IsTrafficLightToggleable(nodeId, flag, ref node, out reason))
{
#if DEBUGTTL
if (GlobalConfig.Instance.Debug.Switches[7] && GlobalConfig.Instance.Debug.NodeId == nodeId)
{
Log._Debug($"TrafficLightManager.SetTrafficLight: Traffic light @ {nodeId} is not toggleable");
}
#endif
if (reason != UnableReason.HasTimedLight || !flag)
{
#if DEBUGTTL
if (GlobalConfig.Instance.Debug.Switches[7] && GlobalConfig.Instance.Debug.NodeId == nodeId)
{
Log._Debug($"TrafficLightManager.SetTrafficLight: ... but has timed light and we want to enable it");
}
#endif
return(false);
}
}
NetNode.Flags flags = node.m_flags | NetNode.Flags.CustomTrafficLights;
if ((bool)flag)
{
#if DEBUGTTL
if (GlobalConfig.Instance.Debug.Switches[7] && GlobalConfig.Instance.Debug.NodeId == nodeId)
{
Log._Debug($"Adding traffic light @ node {nodeId}");
}
#endif
flags |= NetNode.Flags.TrafficLights;
TrafficPriorityManager.Instance.RemovePrioritySignsFromNode(nodeId);
}
else
{
#if DEBUGTTL
if (GlobalConfig.Instance.Debug.Switches[7] && GlobalConfig.Instance.Debug.NodeId == nodeId)
{
Log._Debug($"Removing traffic light @ node {nodeId}");
}
#endif
flags &= ~NetNode.Flags.TrafficLights;
}
#if DEBUGTTL
if (GlobalConfig.Instance.Debug.Switches[7] && GlobalConfig.Instance.Debug.NodeId == nodeId)
{
Log._Debug($"TrafficLightManager.SetTrafficLight: Setting traffic light at node {nodeId} -- flags={flags}");
}
#endif
node.m_flags = flags;
Constants.ManagerFactory.GeometryManager.MarkAsUpdated(NodeGeometry.Get(nodeId), true);
return(true);
}
public override void UpdateNodeFlags(ushort nodeID, ref NetNode data)
{
base.UpdateNodeFlags(nodeID, ref data);
NetNode.Flags flags = data.m_flags & ~(NetNode.Flags.Transition | NetNode.Flags.LevelCrossing | NetNode.Flags.TrafficLights);
int num = 0;
int num2 = 0;
uint num3 = 0u;
int num4 = 0;
int num5 = 0;
NetManager instance = Singleton <NetManager> .instance;
for (int i = 0; i < 8; i++)
{
ushort segment = data.GetSegment(i);
if (segment != 0)
{
NetInfo info = instance.m_segments.m_buffer[(int)segment].Info;
if (info != null)
{
uint num8 = 1u << (int)info.m_class.m_level;
if ((num3 & num8) == 0u)
{
num3 |= num8;
num4++;
}
if (info.m_createPavement)
{
flags |= NetNode.Flags.Transition;
}
if (info.m_class.m_service == ItemClass.Service.Road)
{
if (info.name.ToLower().Contains("tram"))
{
num5++;
}
num++;
}
else if (info.m_class.m_service == ItemClass.Service.PublicTransport)
{
num2++;
}
}
}
}
if (num2 >= 2 && num >= 1 && num5 == 0)
{
flags |= (NetNode.Flags.LevelCrossing | NetNode.Flags.TrafficLights);
}
if (num2 >= 2 && num4 >= 2)
{
flags |= NetNode.Flags.Transition;
}
else
{
flags &= ~NetNode.Flags.Transition;
}
data.m_flags = flags;
}
Nodes(NetNode.Flags flags = NetNode.Flags.Created)
{
var mgr = Singleton <Cities::NetManager> .instance;
return(mgr.m_nodes.m_buffer.Where(e =>
(e.m_flags & flags) != Cities::NetNode.Flags.None
));
}
/// <summary>
/// Check node flags contain at least one of the flags in <paramref name="flagMask"/>.
/// </summary>
///
/// <param name="nodeId">The id of the node to inspect.</param>
/// <param name="flagMask">The flags to test.</param>
/// <param name="expectedResult">If specified, ensure only the expected flags are found.</param>
///
/// <returns>Returns <c>true</c> if the test passes, otherwise <c>false</c>.</returns>
public bool CheckNodeFlags(ushort nodeId,
NetNode.Flags flagMask,
NetNode.Flags?expectedResult = null)
{
NetNode.Flags result = Singleton <NetManager> .instance.m_nodes.m_buffer[nodeId].m_flags & flagMask;
return(expectedResult == null ? result != 0 : result == expectedResult);
}
private void OnToolLeftClick_Select()
{
if (HoveredNodeId == 0 || HoveredSegmentId == 0)
{
return;
}
// Clicked on something which was hovered
NetNode.Flags netFlags =
Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags;
// Not interested in clicking anything other than a junction
if ((netFlags & NetNode.Flags.Junction) == NetNode.Flags.None)
{
return;
}
// Not interested in segments which don't start at the hovered node
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
if (segmentsBuffer[HoveredSegmentId].m_startNode != HoveredNodeId &&
segmentsBuffer[HoveredSegmentId].m_endNode != HoveredNodeId)
{
return;
}
if (Time.frameCount - framesSeparateTurningLanesModeActivated > 80)
{
// the mode resets after 2 seconds.
alternativeMode_ = DEFAULT_ALT_MODE;
}
if (SeparateSegmentLanesModifierIsPressed)
{
SeparateTurningLanesUtil.SeparateSegmentLanes(
HoveredSegmentId, HoveredNodeId, out var res, alternativeMode: alternativeMode_);
InformUserAboutPossibleFailure(res);
}
else if (SeparateNodeLanesModifierIsPressed)
{
SeparateTurningLanesUtil.SeparateNode(HoveredNodeId, out var res, alternativeMode: alternativeMode_);
InformUserAboutPossibleFailure(res);
}
else if (HasHoverLaneArrows())
{
SelectedSegmentId = HoveredSegmentId;
SelectedNodeId = HoveredNodeId;
alternativeMode_ = DEFAULT_ALT_MODE;
fsm_.SendTrigger(Trigger.SegmentClick);
}
if (SeparateSegmentLanesModifierIsPressed || SeparateNodeLanesModifierIsPressed)
{
framesSeparateTurningLanesModeActivated = Time.frameCount;
alternativeMode_ = !alternativeMode_;
}
}
public bool CheckNodeFlags(ushort nodeId, NetNode.Flags flagMask, NetNode.Flags?expectedResult = null)
{
bool ret = false;
ProcessNode(nodeId, delegate(ushort nId, ref NetNode node) {
ret = LogicUtil.CheckFlags((uint)node.m_flags, (uint)flagMask, (uint?)expectedResult);
return(true);
});
return(ret);
}
public override void OnPrimaryClickOverlay()
{
if ((HoveredNodeId == 0) || (HoveredSegmentId == 0))
{
return;
}
NetNode.Flags netFlags = Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags;
if ((netFlags & NetNode.Flags.Junction) == NetNode.Flags.None)
{
return;
}
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
if ((segmentsBuffer[HoveredSegmentId].m_startNode != HoveredNodeId) &&
(segmentsBuffer[HoveredSegmentId].m_endNode != HoveredNodeId))
{
return;
}
bool ctrlDown = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
bool altDown = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
SetLaneArrowError res = SetLaneArrowError.Success;
if (altDown)
{
LaneArrowManager.SeparateTurningLanes.SeparateSegmentLanes(HoveredSegmentId, HoveredNodeId, out res);
}
else if (ctrlDown)
{
LaneArrowManager.SeparateTurningLanes.SeparateNode(HoveredNodeId, out res);
}
else if (HasHoverLaneArrows())
{
SelectedSegmentId = HoveredSegmentId;
SelectedNodeId = HoveredNodeId;
}
switch (res)
{
case SetLaneArrowError.HighwayArrows: {
MainTool.ShowError(
Translation.LaneRouting.Get("Dialog.Text:Disabled due to highway rules"));
break;
}
case SetLaneArrowError.LaneConnection: {
MainTool.ShowError(
Translation.LaneRouting.Get("Dialog.Text:Disabled due to manual connection"));
break;
}
}
}
public bool CheckEndFlags(
NetSegmentEnd.Flags tailFlags,
NetSegmentEnd.Flags headFlags,
NetNode.Flags tailNodeFlags,
NetNode.Flags headNodeFlags)
{
return
(Tail.CheckFlags(tailFlags) &
Head.CheckFlags(headFlags) &
VanillaTailtNode.CheckFlags(tailNodeFlags) &
VanillaHeadNode.CheckFlags(headNodeFlags));
}
/* Everything below is pure stock code with no changes whatsoever */
// Token: 0x060009AB RID: 2475 RVA: 0x00076754 File Offset: 0x00074B54
private static BuildingInfo.TrafficLights FlagsToTrafficLights(NetNode.Flags flags)
{
if ((flags & NetNode.Flags.CustomTrafficLights) == NetNode.Flags.None)
{
return(BuildingInfo.TrafficLights.Default);
}
if ((flags & NetNode.Flags.TrafficLights) == NetNode.Flags.None)
{
return(BuildingInfo.TrafficLights.ForceOff);
}
return(BuildingInfo.TrafficLights.ForceOn);
}
public bool MayHaveJunctionRestrictions(ushort nodeId)
{
NetNode.Flags flags = NetNode.Flags.None;
Services.NetService.ProcessNode(nodeId, delegate(ushort nId, ref NetNode node) {
flags = node.m_flags;
return(true);
});
if (LogicUtil.CheckFlags((uint)flags, (uint)(NetNode.Flags.Created | NetNode.Flags.Deleted), (uint)NetNode.Flags.Created))
{
return(false);
}
return(LogicUtil.CheckFlags((uint)flags, (uint)(NetNode.Flags.Junction | NetNode.Flags.Bend)));
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
base.RenderOverlay(cameraInfo);
if (HoveredSegmentId == 0 || HoveredNodeId == 0)
{
return;
}
NetNode.Flags nodeFlags = HoveredNodeId.ToNode().m_flags;
Color color = GetToolColor(Input.GetMouseButton(0), false);
NetTool.RenderOverlay(
cameraInfo,
ref HoveredSegmentId.ToSegment(),
color,
color);
}
private static IEnumerator <bool> SetNodeName(ushort nodeId, string name)
{
bool result = false;
NetNode.Flags flags = NetManager.instance.m_nodes.m_buffer[nodeId].m_flags;
LogUtils.DoLog($"SetNodeName({nodeId},{name}) {flags}");
if (nodeId != 0 && flags != NetNode.Flags.None)
{
var id = default(InstanceID);
id.NetNode = nodeId;
Singleton <InstanceManager> .instance.SetName(id, name.IsNullOrWhiteSpace()?null : name);
result = true;
}
yield return(result);
TransportLinesManagerMod.Controller.SharedInstance.OnAutoNameParameterChanged();
}
//private bool defaultPedestrianCrossingAllowed;
public void UpdateDefaults(SegmentEndGeometry segmentEndGeometry)
{
NodeGeometry nodeGeo = NodeGeometry.Get(segmentEndGeometry.NodeId());
bool newDefaultEnterWhenBlockedAllowed = false;
NetNode.Flags _nodeFlags = NetNode.Flags.None;
Constants.ServiceFactory.NetService.ProcessNode(segmentEndGeometry.NodeId(), delegate(ushort nodeId, ref NetNode node) {
_nodeFlags = node.m_flags;
int numOutgoing = 0;
int numIncoming = 0;
node.CountLanes(nodeId, 0, NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle, VehicleInfo.VehicleType.Car, true, ref numOutgoing, ref numIncoming);
newDefaultEnterWhenBlockedAllowed = numOutgoing == 1 || numIncoming == 1;
return(true);
});
defaultEnterWhenBlockedAllowed = newDefaultEnterWhenBlockedAllowed;
//Log._Debug($"SegmentEndFlags.UpdateDefaults: this={this} _nodeFlags={_nodeFlags} defaultEnterWhenBlockedAllowed={defaultEnterWhenBlockedAllowed}");
}
public static bool setNodeTrafficLight(ushort nodeId, bool flag)
{
if (nodeId <= 0)
{
return(false);
}
#if DEBUGFLAGS
Log._Debug($"Flags: Set node traffic light: {nodeId}={flag}");
#endif
if (!mayHaveTrafficLight(nodeId))
{
//Log.Warning($"Flags: Refusing to add/delete traffic light to/from node: {nodeId} {flag}");
return(false);
}
Constants.ServiceFactory.NetService.ProcessNode(
nodeId,
(ushort nId, ref NetNode node) => {
NetNode.Flags flags =
node.m_flags | NetNode.Flags.CustomTrafficLights;
if (flag)
{
#if DEBUGFLAGS
Log._Debug($"Adding traffic light @ node {nId}");
#endif
flags |= NetNode.Flags.TrafficLights;
}
else
{
#if DEBUGFLAGS
Log._Debug($"Removing traffic light @ node {nId}");
#endif
flags &= ~NetNode.Flags.TrafficLights;
}
node.m_flags = flags;
return(true);
});
return(true);
}
public override void OnPrimaryClickOverlay()
{
if ((HoveredNodeId == 0) || (HoveredSegmentId == 0))
{
return;
}
NetNode.Flags netFlags = Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags;
if ((netFlags & NetNode.Flags.Junction) == NetNode.Flags.None)
{
return;
}
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
if ((segmentsBuffer[HoveredSegmentId].m_startNode != HoveredNodeId) &&
(segmentsBuffer[HoveredSegmentId].m_endNode != HoveredNodeId))
{
return;
}
bool ctrlDown = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
bool altDown = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
SetLaneArrowError res = SetLaneArrowError.Success;
if (altDown)
{
LaneArrowManager.SeparateTurningLanes.SeparateSegmentLanes(HoveredSegmentId, HoveredNodeId, out res);
HandleResult(res);
}
else if (ctrlDown)
{
LaneArrowManager.SeparateTurningLanes.SeparateNode(HoveredNodeId, out res);
HandleResult(res);
}
else if (HasHoverLaneArrows())
{
SelectedSegmentId = HoveredSegmentId;
SelectedNodeId = HoveredNodeId;
}
}
public void RenderInstance(RenderManager.CameraInfo cameraInfo, ushort segmentID, uint laneID, NetInfo.Lane laneInfo, NetNode.Flags startFlags, NetNode.Flags endFlags, Color startColor, Color endColor, float startAngle, float endAngle, bool segmentInverted, int layerMask, Vector4 objectIndex1, Vector4 objectIndex2, ref RenderManager.Instance data, ref int propIndex)
{
NetLaneProps laneProps = laneInfo.m_laneProps;
bool backward = (byte)(laneInfo.m_finalDirection & NetInfo.Direction.Both) == 2 || (byte)(laneInfo.m_finalDirection & NetInfo.Direction.AvoidBoth) == 11;
bool inverted = backward != segmentInverted;
if (backward)
{
NetNode.Flags flags = startFlags;
startFlags = endFlags;
endFlags = flags;
NetLaneProps.Prop prop = laneProps.m_props[0];
float num4 = prop.m_segmentOffset * 0.5f;
num4 = Mathf.Clamp(num4 + prop.m_position.z / this.m_length, -0.5f, 0.5f);
if (inverted)
{
num4 = -num4;
}
}
}
private static bool MustStopAtMovableBridge(ushort prevSegmentID, ushort nextSegmentID, byte prevOffset, byte nextOffset)
{
var netManager = NetManager.instance;
ushort prevTargetNodeId = (prevOffset >= 128) ? netManager.m_segments.m_buffer[prevSegmentID].m_endNode : netManager.m_segments.m_buffer[prevSegmentID].m_startNode;
ushort nextSourceNodeId = (nextOffset >= 128) ? netManager.m_segments.m_buffer[nextSegmentID].m_endNode : netManager.m_segments.m_buffer[nextSegmentID].m_startNode;
if (prevTargetNodeId == nextSourceNodeId)
{
NetNode.Flags flags = netManager.m_nodes.m_buffer[prevTargetNodeId].m_flags;
if (flags.IsFlagSet(NetNode.Flags.CustomTrafficLights))
{
var previousSegmentAI = netManager.m_segments.m_buffer[prevSegmentID].Info.m_netAI;
if (!(previousSegmentAI is MovableBridgeRoadAI))
{
return(false);
}
var nextSegmentAI = netManager.m_segments.m_buffer[nextSegmentID].Info.m_netAI;
if (!(nextSegmentAI is MovableBridgeRoadAI))
{
return(false);
}
uint currentFrameIndex = Singleton <SimulationManager> .instance.m_currentFrameIndex;
uint num6n = (uint)(prevTargetNodeId << 8) / 32768u;
RoadBaseAI.GetTrafficLightState(prevTargetNodeId, ref netManager.m_segments.m_buffer[prevSegmentID], currentFrameIndex - num6n, out RoadBaseAI.TrafficLightState vehicleLightState, out RoadBaseAI.TrafficLightState pedestrianLightState, out bool vehicles, out bool pedestrians);
//Debug.Log($"CheckSegmentChange on bridge! state: ${vehicleLightState}");
if (vehicleLightState == RoadBaseAI.TrafficLightState.Red)
{
return(true);
}
}
}
return(false);
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
NetManager netManager = Singleton <NetManager> .instance;
// Log._Debug($"LaneArrow Overlay: {HoveredNodeId} {HoveredSegmentId} {SelectedNodeId} {SelectedSegmentId}");
if (!cursorInSecondaryPanel &&
HoveredSegmentId != 0 &&
HoveredNodeId != 0 &&
(HoveredSegmentId != SelectedSegmentId ||
HoveredNodeId != SelectedNodeId))
{
NetNode.Flags nodeFlags = netManager.m_nodes.m_buffer[HoveredNodeId].m_flags;
if ((netManager.m_segments.m_buffer[HoveredSegmentId].m_startNode == HoveredNodeId ||
netManager.m_segments.m_buffer[HoveredSegmentId].m_endNode == HoveredNodeId) &&
(nodeFlags & NetNode.Flags.Junction) != NetNode.Flags.None)
{
NetTool.RenderOverlay(
cameraInfo,
ref Singleton <NetManager> .instance.m_segments.m_buffer[HoveredSegmentId],
MainTool.GetToolColor(false, false),
MainTool.GetToolColor(false, false));
}
}
if (SelectedSegmentId == 0)
{
return;
}
NetTool.RenderOverlay(
cameraInfo,
ref Singleton <NetManager> .instance.m_segments.m_buffer[SelectedSegmentId],
MainTool.GetToolColor(true, false),
MainTool.GetToolColor(true, false));
}
private void ExportNodes()
{
NetManager netManager = Singleton <NetManager> .instance;
NetNode[] netNodes = netManager.m_nodes.m_buffer;
int nodeId = 0;
foreach (NetNode netNode in netNodes)
{
NetNode.Flags nodeFlags = netNode.m_flags;
if (nodeFlags.IsFlagSet(NetNode.Flags.Created))
{
OSMNode generatedNode = CreateNode(nodeId, netNode.m_position);
if (generatedNode != null)
{
osmNodes.Add(generatedNode);
}
}
++nodeId;
}
}
private bool RayCastSegmentAndNode(NetInfo connectedType, Segment3 ray, float snapElevation, bool nameOnly, ItemClass.Service service, ItemClass.Service service2, ItemClass.SubService subService, ItemClass.SubService subService2, ItemClass.Layer itemLayers, ItemClass.Layer itemLayers2, NetNode.Flags ignoreNodeFlags, NetSegment.Flags ignoreSegmentFlags, out Vector3 hit, out ushort nodeIndex, out ushort segmentIndex)
{
var bounds = new Bounds(new Vector3(0f, 512f, 0f), new Vector3(17280f, 1152f, 17280f));
if (ray.Clip(bounds))
{
Vector3 vector = ray.b - ray.a;
var num = (int)((ray.a.x / 64f) + 135f);
var num2 = (int)((ray.a.z / 64f) + 135f);
var num3 = (int)((ray.b.x / 64f) + 135f);
var num4 = (int)((ray.b.z / 64f) + 135f);
var num5 = Mathf.Abs(vector.x);
var num6 = Mathf.Abs(vector.z);
int num7;
int num8;
if (num5 >= num6)
{
num7 = ((vector.x <= 0f) ? -1 : 1);
num8 = 0;
if (num5 > 0.001f)
{
vector *= 64f / num5;
}
}
else
{
num7 = 0;
num8 = ((vector.z <= 0f) ? -1 : 1);
if (num6 > 0.001f)
{
vector *= 64f / num6;
}
}
var num9 = 2f;
var num10 = 16f;
var num11 = 2f;
var num12 = 16f;
ushort num13 = 0;
ushort num14 = 0;
ushort num15 = 0;
Vector3 vector2 = ray.a;
Vector3 vector3 = ray.a;
var num16 = num;
var num17 = num2;
do
{
Vector3 vector4 = vector3 + vector;
int num18;
int num19;
int num20;
int num21;
if (num7 != 0)
{
if ((num16 == num && num7 > 0) || (num16 == num3 && num7 < 0))
{
num18 = Mathf.Max((int)(((vector4.x - 64f) / 64f) + 135f), 0);
}
else
{
num18 = Mathf.Max(num16, 0);
}
if ((num16 == num && num7 < 0) || (num16 == num3 && num7 > 0))
{
num19 = Mathf.Min((int)(((vector4.x + 64f) / 64f) + 135f), 269);
}
else
{
num19 = Mathf.Min(num16, 269);
}
num20 = Mathf.Max((int)(((Mathf.Min(vector2.z, vector4.z) - 64f) / 64f) + 135f), 0);
num21 = Mathf.Min((int)(((Mathf.Max(vector2.z, vector4.z) + 64f) / 64f) + 135f), 269);
}
else
{
if ((num17 == num2 && num8 > 0) || (num17 == num4 && num8 < 0))
{
num20 = Mathf.Max((int)(((vector4.z - 64f) / 64f) + 135f), 0);
}
else
{
num20 = Mathf.Max(num17, 0);
}
if ((num17 == num2 && num8 < 0) || (num17 == num4 && num8 > 0))
{
num21 = Mathf.Min((int)(((vector4.z + 64f) / 64f) + 135f), 269);
}
else
{
num21 = Mathf.Min(num17, 269);
}
num18 = Mathf.Max((int)(((Mathf.Min(vector2.x, vector4.x) - 64f) / 64f) + 135f), 0);
num19 = Mathf.Min((int)(((Mathf.Max(vector2.x, vector4.x) + 64f) / 64f) + 135f), 269);
}
for (var i = num20; i <= num21; i++)
{
for (var j = num18; j <= num19; j++)
{
var num22 = Singleton <NetManager> .instance.m_nodeGrid[(i * 270) + j];
var num23 = 0;
while (num22 != 0)
{
NetNode.Flags flags = NodeBuffer[num22].m_flags;
NetInfo info = NodeBuffer[num22].Info;
ItemClass connectionClass = info.GetConnectionClass();
if ((((service == ItemClass.Service.None || connectionClass.m_service == service) && (subService == ItemClass.SubService.None || connectionClass.m_subService == subService) && (itemLayers == ItemClass.Layer.None || (connectionClass.m_layer & itemLayers) != ItemClass.Layer.None)) || (info.m_intersectClass != null && (service == ItemClass.Service.None || info.m_intersectClass.m_service == service) && (subService == ItemClass.SubService.None || info.m_intersectClass.m_subService == subService) && (itemLayers == ItemClass.Layer.None || (info.m_intersectClass.m_layer & itemLayers) != ItemClass.Layer.None)) || (info.m_netAI.CanIntersect(connectedType) && connectionClass.m_service == service2 && (subService2 == ItemClass.SubService.None || connectionClass.m_subService == subService2) && (itemLayers2 == ItemClass.Layer.None || (connectionClass.m_layer & itemLayers2) != ItemClass.Layer.None))) && (flags & ignoreNodeFlags) == NetNode.Flags.None && (connectedType == null || (info.m_netAI.CanConnect(connectedType) && connectedType.m_netAI.CanConnect(info))))
{
var flag = false;
if ((flags & (NetNode.Flags.Middle | NetNode.Flags.Untouchable)) == (NetNode.Flags.Middle | NetNode.Flags.Untouchable) && NodeBuffer[num22].CountSegments(NetSegment.Flags.Untouchable, 0) >= 2)
{
flag = true;
}
if (!flag && NodeBuffer[num22].RayCast(ray, snapElevation, out var num24, out var num25) && (num25 < num12 || (num25 == num12 && num24 < num11)))
{
num11 = num24;
num12 = num25;
num14 = num22;
}
}
num22 = NodeBuffer[num22].m_nextGridNode;
if (++num23 > 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
for (var k = num20; k <= num21; k++)
{
for (var l = num18; l <= num19; l++)
{
var num26 = Singleton <NetManager> .instance.m_segmentGrid[(k * 270) + l];
var num27 = 0;
while (num26 != 0)
{
NetSegment.Flags flags2 = SegmentBuffer[num26].m_flags;
NetInfo info2 = SegmentBuffer[num26].Info;
ItemClass connectionClass2 = info2.GetConnectionClass();
if (((service == ItemClass.Service.None || connectionClass2.m_service == service) && (subService == ItemClass.SubService.None || connectionClass2.m_subService == subService) && (itemLayers == ItemClass.Layer.None || (connectionClass2.m_layer & itemLayers) != ItemClass.Layer.None || nameOnly)) || (info2.m_intersectClass != null && (service == ItemClass.Service.None || info2.m_intersectClass.m_service == service) && (subService == ItemClass.SubService.None || info2.m_intersectClass.m_subService == subService) && (itemLayers == ItemClass.Layer.None || (info2.m_intersectClass.m_layer & itemLayers) != ItemClass.Layer.None || nameOnly)) || (info2.m_netAI.CanIntersect(connectedType) && connectionClass2.m_service == service2 && (subService2 == ItemClass.SubService.None || connectionClass2.m_subService == subService2) && (itemLayers2 == ItemClass.Layer.None || (connectionClass2.m_layer & itemLayers2) != ItemClass.Layer.None || nameOnly)))
{
var flag2 = (flags2 & ignoreSegmentFlags) != NetSegment.Flags.None && !nameOnly;
if ((flags2 & ignoreSegmentFlags) == NetSegment.Flags.None && (connectedType == null || (info2.m_netAI.CanConnect(connectedType) && connectedType.m_netAI.CanConnect(info2))) && SegmentBuffer[num26].RayCast(num26, ray, snapElevation, nameOnly, out var num28, out var num29) && (num29 < num10 || (num29 == num10 && num28 < num9)))
{
var startNode = SegmentBuffer[num26].m_startNode;
var endNode = SegmentBuffer[num26].m_endNode;
Vector3 position = NodeBuffer[startNode].m_position;
Vector3 position2 = NodeBuffer[endNode].m_position;
var num30 = NodeBuffer[startNode].Info.GetMinNodeDistance();
var num31 = NodeBuffer[endNode].Info.GetMinNodeDistance();
num10 = num29;
num9 = num28;
Vector3 a = ray.a + ((ray.b - ray.a) * num28);
NetNode.Flags flags3 = NodeBuffer[startNode].m_flags;
if ((flags3 & NetNode.Flags.End) != NetNode.Flags.None)
{
flags3 &= ~NetNode.Flags.Moveable;
}
NetNode.Flags flags4 = NodeBuffer[endNode].m_flags;
if ((flags4 & NetNode.Flags.End) != NetNode.Flags.None)
{
flags4 &= ~NetNode.Flags.Moveable;
}
if (flag2)
{
num30 = 1000f;
num31 = 1000f;
}
var flag3 = (flags3 & (NetNode.Flags.Moveable | ignoreNodeFlags)) == NetNode.Flags.None;
var flag4 = (flags4 & (NetNode.Flags.Moveable | ignoreNodeFlags)) == NetNode.Flags.None;
var num32 = VectorUtils.LengthSqrXZ(a - position) / (num30 * num30);
var num33 = VectorUtils.LengthSqrXZ(a - position2) / (num31 * num31);
if (flag3 && num32 < 1f && (!flag4 || num32 < num33) && !nameOnly)
{
num13 = startNode;
if (!flag2)
{
num15 = num26;
}
}
else if (flag4 && num33 < 1f && !nameOnly)
{
num13 = endNode;
if (!flag2)
{
num15 = num26;
}
}
else if (!flag2)
{
num13 = 0;
num15 = num26;
}
}
}
num26 = SegmentBuffer[num26].m_nextGridSegment;
if (++num27 > 36864)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
vector2 = vector3;
vector3 = vector4;
num16 += num7;
num17 += num8;
}while ((num16 <= num3 || num7 <= 0) && (num16 >= num3 || num7 >= 0) && (num17 <= num4 || num8 <= 0) && (num17 >= num4 || num8 >= 0));
if (num12 < num10 || (num12 == num10 && num11 < num9))
{
num9 = num11;
num13 = num14;
}
if (num9 != 2f)
{
hit = ray.Position(num9);
nodeIndex = num13;
segmentIndex = num15;
return(true);
}
}
hit = Vector3.zero;
nodeIndex = 0;
segmentIndex = 0;
return(false);
}
public static bool CheckFlags(this NetNode.Flags value, NetNode.Flags required, NetNode.Flags forbidden = 0) => (value & (required | forbidden)) == required;
public bool SetTrafficLight(ushort nodeId,
bool flag,
ref NetNode node,
out ToggleTrafficLightError reason)
{
#if DEBUG
bool logTrafficLights = DebugSwitch.TimedTrafficLights.Get() &&
DebugSettings.NodeId == nodeId;
#else
const bool logTrafficLights = false;
#endif
if (logTrafficLights)
{
Log._Debug($"TrafficLightManager.SetTrafficLight: called for node {nodeId}, flag={flag}");
}
if (!CanToggleTrafficLight(nodeId, flag, ref node, out reason))
{
if (logTrafficLights)
{
Log._Debug($"TrafficLightManager.SetTrafficLight: Traffic light @ {nodeId} is not toggleable");
}
if (reason != ToggleTrafficLightError.HasTimedLight || !flag)
{
if (logTrafficLights)
{
Log._Debug("TrafficLightManager.SetTrafficLight: ... but has timed light " +
"and we want to enable it");
}
return(false);
}
}
NetNode.Flags flags = node.m_flags | NetNode.Flags.CustomTrafficLights;
if (flag)
{
if (logTrafficLights)
{
Log._Debug($"Adding traffic light @ node {nodeId}");
}
flags |= NetNode.Flags.TrafficLights;
TrafficPriorityManager.Instance.RemovePrioritySignsFromNode(nodeId);
}
else
{
if (logTrafficLights)
{
Log._Debug($"Removing traffic light @ node {nodeId}");
}
flags &= ~NetNode.Flags.TrafficLights;
}
if (logTrafficLights)
{
Log._Debug("TrafficLightManager.SetTrafficLight: Setting traffic light at " +
$"node {nodeId} -- flags={flags}");
}
node.m_flags = flags;
Constants.ManagerFactory.GeometryManager.MarkAsUpdated(nodeId, true);
return(true);
}
public static bool CheckFlags(this NetNode.Flags value, NetNode.Flags required, NetNode.Flags forbidden)
{
return((value & (required | forbidden)) == required);
}
private static void RenderInstanceBendIfExtracted(ref NetNode instance, CameraInfo cameraInfo, ushort nodeID, NetInfo info, int iter, NetNode.Flags flags, ref uint instanceIndex, ref Instance data)
{
IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions)
{
var newInstructions = new List <CodeInstruction>();
var mainIfBlock = instructions.GetIfBlock(MainIfBlockFind);
//Logger.Debug(nameof(NetNodePatch), nameof(mainIfBlock), mainIfBlock);
var bendIfBlock = mainIfBlock.GetIfBlock(BendIfBlockFind);
//Logger.Debug(nameof(NetNodePatch), nameof(junctionIfBlock), junctionIfBlock);
newInstructions.AddRange(bendIfBlock);
#if Debug
Patcher.AddStopWatch(newInstructions);
#endif
newInstructions.Add(new CodeInstruction(OpCodes.Ret));
#if Debug && Trace
Logger.AddDebugInstructions(newInstructions, nameof(NetNodePatch), nameof(NetNodePatch.RenderInstanceBendIfExtracted));
#endif
#if Debug && IL
Logger.Debug(nameof(NetNodePatch), nameof(NetNodePatch.RenderInstanceBendIfExtracted), newInstructions);
#endif
return(newInstructions);
}
_ = Transpiler(null);
}
public static void AddToDispatcherBendIf(NetNode instance, CameraInfo cameraInfo, ushort nodeID, NetInfo info, int iter, NetNode.Flags flags, uint instanceIndex, Instance data)
{
#if Debug && Trace
Logger.Start(nameof(NetNodePatch), nameof(AddToDispatcherBendIf));
#endif
#if UseTask
Patcher.Dispatcher.Add(() => RenderInstanceBendIfExtracted(ref instance, cameraInfo, nodeID, info, iter, flags, ref instanceIndex, ref data));
#else
RenderInstanceBendIfExtracted(ref instance, cameraInfo, nodeID, info, iter, flags, ref instanceIndex, ref data);
#endif
}
private static void TrafficLightsToFlags(BuildingInfo.TrafficLights trafficLights, ref NetNode.Flags flags)
{
if (trafficLights != BuildingInfo.TrafficLights.Default)
{
if (trafficLights != BuildingInfo.TrafficLights.ForceOn)
{
if (trafficLights == BuildingInfo.TrafficLights.ForceOff)
{
flags = ((flags & ~NetNode.Flags.TrafficLights) | NetNode.Flags.CustomTrafficLights);
}
}
else
{
flags |= (NetNode.Flags.TrafficLights | NetNode.Flags.CustomTrafficLights);
}
}
else
{
flags &= (NetNode.Flags.Created | NetNode.Flags.Deleted | NetNode.Flags.Original | NetNode.Flags.Disabled | NetNode.Flags.End | NetNode.Flags.Middle | NetNode.Flags.Bend | NetNode.Flags.Junction | NetNode.Flags.Moveable | NetNode.Flags.Untouchable | NetNode.Flags.Outside | NetNode.Flags.Temporary | NetNode.Flags.Double | NetNode.Flags.Fixed | NetNode.Flags.OnGround | NetNode.Flags.Ambiguous | NetNode.Flags.Water | NetNode.Flags.Sewage | NetNode.Flags.ForbidLaneConnection | NetNode.Flags.Underground | NetNode.Flags.Transition | NetNode.Flags.LevelCrossing | NetNode.Flags.OneWayOut | NetNode.Flags.TrafficLights | NetNode.Flags.OneWayIn | NetNode.Flags.Heating | NetNode.Flags.Electricity | NetNode.Flags.Collapsed | NetNode.Flags.DisableOnlyMiddle | NetNode.Flags.AsymForward | NetNode.Flags.AsymBackward);
}
}
