protected override void HandleSegmentEndReplacement(SegmentEndReplacement replacement, SegmentEndGeometry endGeo)
{
ISegmentEndId oldSegmentEndId = replacement.oldSegmentEndId;
ISegmentEndId newSegmentEndId = replacement.newSegmentEndId;
SegmentEndFlags flags;
if (oldSegmentEndId.StartNode)
{
flags = invalidSegmentFlags[oldSegmentEndId.SegmentId].startNodeFlags;
invalidSegmentFlags[oldSegmentEndId.SegmentId].startNodeFlags.Reset();
}
else
{
flags = invalidSegmentFlags[oldSegmentEndId.SegmentId].endNodeFlags;
invalidSegmentFlags[oldSegmentEndId.SegmentId].endNodeFlags.Reset();
}
Services.NetService.ProcessNode(endGeo.NodeId(), delegate(ushort nId, ref NetNode node) {
flags.UpdateDefaults(newSegmentEndId.SegmentId, newSegmentEndId.StartNode, ref node);
return(true);
});
Log._Debug($"JunctionRestrictionsManager.HandleSegmentEndReplacement({replacement}): Segment replacement detected: {oldSegmentEndId.SegmentId} -> {newSegmentEndId.SegmentId} @ {newSegmentEndId.StartNode}");
SetSegmentEndFlags(newSegmentEndId.SegmentId, newSegmentEndId.StartNode, flags);
}
protected void Invalidate()
{
for (int i = 0; i < MAX_NUM_SEGMENTS; ++i)
{
SegmentEndGeometries[i] = null;
}
lastRemovedSegmentEndId = null;
CurrentSegmentReplacement = default(SegmentEndReplacement);
NotifyGeomentryManager();
}
public void OnSegmentEndReplacement(SegmentEndReplacement replacement)
{
#if DEBUG
if (DebugSwitch.GeometryDebug.Get())
{
Log._Debug(
"GeometryManager.OnSegmentEndReplacement(): Detected segment replacement: " +
$"{replacement.oldSegmentEndId.SegmentId} -> {replacement.newSegmentEndId.SegmentId}");
}
#endif
lock (updateLock) {
segmentReplacements.Enqueue(replacement);
stateUpdated = true;
}
}
public void AddSegment(ushort nodeId, ushort segmentId)
{
if (ExtNodes[nodeId].segmentIds.Add(segmentId) &&
ExtNodes[nodeId].removedSegmentEndId != null)
{
var replacement = new SegmentEndReplacement {
oldSegmentEndId = ExtNodes[nodeId].removedSegmentEndId,
newSegmentEndId = new SegmentEndId(
segmentId,
(bool)Services.NetService.IsStartNode(segmentId, nodeId))
};
ExtNodes[nodeId].removedSegmentEndId = null;
Constants.ManagerFactory.GeometryManager.OnSegmentEndReplacement(replacement);
}
}
public GeometryUpdate(SegmentEndReplacement replacement)
{
this.replacement = replacement;
segment = null;
nodeId = null;
}
public GeometryUpdate(ushort nodeId)
{
this.nodeId = nodeId;
segment = null;
replacement = default(SegmentEndReplacement);
}
public GeometryUpdate(ref ExtSegment segment)
{
this.segment = segment;
nodeId = null;
replacement = default(SegmentEndReplacement);
}
public void SimulationStep(bool onlyFirstPass = false)
{
#if DEBUG
bool logGeometry = DebugSwitch.GeometryDebug.Get();
#else
const bool logGeometry = false;
#endif
if (!stateUpdated)
{
return;
}
NetManager netManager = Singleton <NetManager> .instance;
if (!onlyFirstPass && (netManager.m_segmentsUpdated || netManager.m_nodesUpdated))
{
// TODO maybe refactor NetManager use (however this could influence performance)
if (logGeometry)
{
Log._Debug(
$"GeometryManager.SimulationStep(): Skipping! stateUpdated={stateUpdated}, " +
$"m_segmentsUpdated={netManager.m_segmentsUpdated}, " +
$"m_nodesUpdated={netManager.m_nodesUpdated}");
}
return;
}
lock (updateLock) {
bool updatesMissing = onlyFirstPass;
for (var pass = 0; pass < (onlyFirstPass ? 1 : 2); ++pass)
{
bool firstPass = pass == 0;
int len = updatedSegmentBuckets.Length;
for (var i = 0; i < len; i++)
{
ulong segMask = updatedSegmentBuckets[i];
if (segMask == 0uL)
{
continue;
}
for (var m = 0; m < 64; m++)
{
if ((segMask & 1uL << m) == 0uL)
{
continue;
}
ushort segmentId = (ushort)(i << 6 | m);
ExtSegment seg = Constants.ManagerFactory.ExtSegmentManager.ExtSegments[segmentId];
if (firstPass ^ !seg.valid)
{
if (!firstPass)
{
updatesMissing = true;
if (logGeometry)
{
Log.Warning(
"GeometryManager.SimulationStep(): Detected invalid " +
$"segment {segmentId} in second pass");
}
}
continue;
}
if (logGeometry)
{
Log._Debug(
$"GeometryManager.SimulationStep(): Notifying observers about " +
$"segment {segmentId}. Valid? {seg.valid} First pass? {firstPass}");
}
NotifyObservers(new GeometryUpdate(ref seg));
updatedSegmentBuckets[i] &= ~(1uL << m);
}
}
len = updatedNodeBuckets.Length;
for (var i = 0; i < len; i++)
{
ulong nodeMask = updatedNodeBuckets[i];
if (nodeMask == 0uL)
{
continue;
}
for (var m = 0; m < 64; m++)
{
if ((nodeMask & 1uL << m) == 0uL)
{
continue;
}
ushort nodeId = (ushort)(i << 6 | m);
bool valid = Services.NetService.IsNodeValid(nodeId);
if (firstPass ^ !valid)
{
if (!firstPass)
{
updatesMissing = true;
if (logGeometry)
{
Log.Warning(
"GeometryManager.SimulationStep(): Detected invalid " +
$"node {nodeId} in second pass");
}
}
continue;
}
if (logGeometry)
{
Log._Debug(
"GeometryManager.SimulationStep(): Notifying observers about " +
$"node {nodeId}. Valid? {valid} First pass? {firstPass}");
}
NotifyObservers(new GeometryUpdate(nodeId));
updatedNodeBuckets[i] &= ~(1uL << m);
}
}
}
if (updatesMissing)
{
return;
}
while (segmentReplacements.Count > 0)
{
SegmentEndReplacement replacement = segmentReplacements.Dequeue();
if (logGeometry)
{
Log._Debug(
"GeometryManager.SimulationStep(): Notifying observers about " +
$"segment end replacement {replacement}");
}
NotifyObservers(new GeometryUpdate(replacement));
}
stateUpdated = false;
}
}
/// <summary>
/// Handles a segment replacement
/// </summary>
/// <param name="replacement">segment replacement</param>
/// <param name="newEndGeo">new segment end geometry</param>
protected virtual void HandleSegmentEndReplacement(SegmentEndReplacement replacement, ref ExtSegmentEnd segEnd)
{
}
public void SimulationStep(bool onlyFirstPass = false)
{
#if DEBUGGEO
bool debug = GlobalConfig.Instance.Debug.Switches[5];
#endif
if (!stateUpdated)
{
return;
}
NetManager netManager = Singleton <NetManager> .instance;
if (!onlyFirstPass && (netManager.m_segmentsUpdated || netManager.m_nodesUpdated)) // TODO maybe refactor NetManager use (however this could influence performance)
{
#if DEBUGGEO
if (debug)
{
Log._Debug($"GeometryManager.SimulationStep(): Skipping! stateUpdated={stateUpdated}, m_segmentsUpdated={netManager.m_segmentsUpdated}, m_nodesUpdated={netManager.m_nodesUpdated}");
}
#endif
return;
}
try {
Monitor.Enter(updateLock);
bool updatesMissing = onlyFirstPass;
for (int pass = 0; pass < (onlyFirstPass ? 1 : 2); ++pass)
{
bool firstPass = pass == 0;
int len = updatedSegmentBuckets.Length;
for (int i = 0; i < len; i++)
{
ulong segMask = updatedSegmentBuckets[i];
if (segMask != 0uL)
{
for (int m = 0; m < 64; m++)
{
if ((segMask & 1uL << m) != 0uL)
{
ushort segmentId = (ushort)(i << 6 | m);
SegmentGeometry segmentGeometry = SegmentGeometry.Get(segmentId, true);
if (firstPass ^ !segmentGeometry.IsValid())
{
if (!firstPass)
{
updatesMissing = true;
#if DEBUGGEO
if (debug)
{
Log.Warning($"GeometryManager.SimulationStep(): Detected invalid segment {segmentGeometry.SegmentId} in second pass");
}
#endif
}
continue;
}
#if DEBUGGEO
if (debug)
{
Log._Debug($"GeometryManager.SimulationStep(): Notifying observers about segment {segmentGeometry.SegmentId}. Valid? {segmentGeometry.IsValid()} First pass? {firstPass}");
}
#endif
NotifyObservers(new GeometryUpdate(segmentGeometry));
updatedSegmentBuckets[i] &= ~(1uL << m);
}
}
}
}
len = updatedNodeBuckets.Length;
for (int i = 0; i < len; i++)
{
ulong nodeMask = updatedNodeBuckets[i];
if (nodeMask != 0uL)
{
for (int m = 0; m < 64; m++)
{
if ((nodeMask & 1uL << m) != 0uL)
{
ushort nodeId = (ushort)(i << 6 | m);
NodeGeometry nodeGeometry = NodeGeometry.Get(nodeId);
if (firstPass ^ !nodeGeometry.IsValid())
{
if (!firstPass)
{
updatesMissing = true;
#if DEBUGGEO
if (debug)
{
Log.Warning($"GeometryManager.SimulationStep(): Detected invalid node {nodeGeometry.NodeId} in second pass");
}
#endif
}
continue;
}
#if DEBUGGEO
if (debug)
{
Log._Debug($"GeometryManager.SimulationStep(): Notifying observers about node {nodeGeometry.NodeId}. Valid? {nodeGeometry.IsValid()} First pass? {firstPass}");
}
#endif
NotifyObservers(new GeometryUpdate(nodeGeometry));
updatedNodeBuckets[i] &= ~(1uL << m);
}
}
}
}
}
if (!updatesMissing)
{
while (segmentReplacements.Count > 0)
{
SegmentEndReplacement replacement = segmentReplacements.Dequeue();
#if DEBUGGEO
if (debug)
{
Log._Debug($"GeometryManager.SimulationStep(): Notifying observers about segment end replacement {replacement}");
}
#endif
NotifyObservers(new GeometryUpdate(replacement));
}
stateUpdated = false;
}
} finally {
Monitor.Exit(updateLock);
}
}
public GeometryUpdate(NodeGeometry nodeGeometry)
{
this.nodeGeometry = nodeGeometry;
segmentGeometry = null;
replacement = default(SegmentEndReplacement);
}
public GeometryUpdate(SegmentGeometry segmentGeometry)
{
this.segmentGeometry = segmentGeometry;
nodeGeometry = null;
replacement = default(SegmentEndReplacement);
}
/// <summary>
/// Handles a segment replacement
/// </summary>
/// <param name="replacement">segment replacement</param>
/// <param name="newEndGeo">new segment end geometry</param>
protected virtual void HandleSegmentEndReplacement(SegmentEndReplacement replacement, SegmentEndGeometry newEndGeo)
{
}
