private void CreateSignalObject()
{
__cSignalObject = ScriptManager.Manager.CreateScript(__cProfile.ScriptName, this) as SignalObject;
if (__cSignalObject != null)
{
string sTitle = string.Format("{0}", __cSignalObject.About.Comment);
if (this.InvokeRequired)
{
this.BeginInvoke((MethodInvoker) delegate {
this.Text = sTitle;
this.Invalidate(false);
});
}
else
{
this.Text = sTitle;
this.Invalidate(false);
}
__cSignalObject.onReady += SignalObject_onReady;
__cSignalObject.onScriptParameters += SignalObject_onScriptParameters;
__cSignalObject.onTradeResponse += SignalObject_onTradeResponse;
OutputWriter cOutputWriter = __cSignalObject.Output as OutputWriter;
cOutputWriter.onOutputData += OutputWriter_onOutputData;
SignalSetting cSignalSetting = __cProfile.Script as SignalSetting;
__cSignalObject.ApplyProperty(cSignalSetting.Property);
__cSignalObject.AddDataStreams(RequestSetting.Convert(cSignalSetting.DataRequests));
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
SignalObject signal = (SignalObject)target;
if (GUILayout.Button("Call Signal"))
{
signal.CallSignal();
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <param name="signal"></param>
public AESignalItem(SignalItem item, SignalObject signal, TDBFile TDB)
{
typeWidget = (int)TypeWidget.SIGNAL_WIDGET;
Item = item;
Signal = signal;
sigFonction = new List <SignalHead.MstsSignalFunction>();
foreach (var sig in Signal.SignalHeads)
{
sigFonction.Add(sig.sigFunction);
if (sig.sigFunction == SignalHead.MstsSignalFunction.SPEED)
{
File.AppendAllText(@"C:\temp\AE.txt", "SPEED\n");
}
}
foreach (var fn in sigFonction)
{
File.AppendAllText(@"C:\temp\AE.txt", "FN " + fn + "\n");
}
hasDir = false;
Location.X = item.TileX * 2048 + item.X;
Location.Y = item.TileZ * 2048 + item.Z;
try
{
var node = TDB.TrackDB.TrackNodes[signal.trackNode];
Vector2 v2;
if (node.TrVectorNode != null)
{
var ts = node.TrVectorNode.TrVectorSections[0];
v2 = new Vector2(ts.TileX * 2048 + ts.X, ts.TileZ * 2048 + ts.Z);
}
else if (node.TrJunctionNode != null)
{
var ts = node.UiD;
v2 = new Vector2(ts.TileX * 2048 + ts.X, ts.TileZ * 2048 + ts.Z);
}
else
{
throw new Exception();
}
var v1 = new Vector2(Location.X, Location.Y);
var v3 = v1 - v2;
v3.Normalize();
//v2 = v1 - Vector2.Multiply(v3, signal.direction == 0 ? 12f : -12f);
v2 = v1 - Vector2.Multiply(v3, 12f);
Dir.X = (float)v2.X;
Dir.Y = (float)v2.Y;
//v2 = v1 - Vector2.Multiply(v3, signal.direction == 0 ? 1.5f : -1.5f);//shift signal along the dir for 2m, so signals will not be overlapped
v2 = v1 - Vector2.Multiply(v3, 1.5f);
Location.X = (float)v2.X;
Location.Y = (float)v2.Y;
hasDir = true;
}
catch { }
}
private void FSSSignalDiscoveryCallback(FSSSignalDiscoveredEvent obj)
{
var signal = new SignalObject()
{
Name = string.IsNullOrEmpty(obj.SignalNameLocalised) ? obj.SignalName : obj.SignalNameLocalised,
IsStation = obj.IsStation
};
_singals.Add(signal);
OnAction("AddSignal");
}
internal Signal(double trackPosition, int sectionIndex, SignalObject signalObject, Vector2 position, double yaw, double pitch, double roll, bool showObject, bool showPost)
{
TrackPosition = trackPosition;
SectionIndex = sectionIndex;
SignalObject = signalObject;
Position = position;
Yaw = yaw;
Pitch = pitch;
Roll = roll;
ShowObject = showObject;
ShowPost = showPost;
}
private static void NewAlert(Packet p)
{
int x = (short)p.ReadUShort();
int y = (short)p.ReadUShort();
string username = p.ReadASCII(p.ReadByte());
UserObject user = RenderObjectsManager.GetUser(username);
SignalObject signal = new SignalObject(x, y);
RenderObjectsManager.AddSignal(signal);
UOClientManager.SysMessage(string.Format("[Alert][{0}] sends an alert!", user.Name), 83);
}
static DebugWindowSignalAspect GetAspect(SignalObject signal)
{
var aspect = signal.this_sig_lr(MstsSignalFunction.NORMAL);
if (aspect >= MstsSignalAspect.CLEAR_1)
{
return(DebugWindowSignalAspect.Clear);
}
if (aspect >= MstsSignalAspect.STOP_AND_PROCEED)
{
return(DebugWindowSignalAspect.Warning);
}
return(DebugWindowSignalAspect.Stop);
}
private void SignalObject_onReady(object sender, EventArgs e)
{
SignalObject cObject = sender as SignalObject;
int iCount = cObject.MaxDataStream;
for (int i = 1; i <= iCount; i++)
{
__cChart.AddSeries(cObject.BarsOfData(i), i);
}
__cChart.AddDrwText(cObject.DrwText);
__cChart.AddTradeContainer(new TradeContainer());
cObject.onUpdate += __cChart.onUpdate;
cObject.onTradeResponse += __cChart.onTradeResponse;
}
internal void Create(Vector3 wpos, Transformation RailTransformation, double StartingDistance, double EndingDistance, double Brightness)
{
double dz = TrackPosition - StartingDistance;
if (ShowPost)
{
// post
double dx = Position.X;
wpos += dx * RailTransformation.X + dz * RailTransformation.Z;
CompatibilityObjects.SignalPost.CreateObject(wpos, RailTransformation, Transformation.NullTransformation, -1, StartingDistance, EndingDistance, TrackPosition, Brightness);
}
if (ShowObject)
{
// signal object
double dx = Position.X;
double dy = Position.Y;
wpos += dx * RailTransformation.X + dy * RailTransformation.Y + dz * RailTransformation.Z;
SignalObject.Create(wpos, RailTransformation, new Transformation(Yaw, Pitch, Roll), SectionIndex, StartingDistance, EndingDistance, TrackPosition, Brightness);
}
}
internal void Create(Vector3 wpos, Transformation RailTransformation, double StartingDistance, double EndingDistance, double Brightness)
{
double dz = TrackPosition - StartingDistance;
if (ShowPost)
{
/*
* Post-
* Need to clone a copy of the vector for transform
* Do it in the post as this is the lesser used option
*/
Vector3 wpos2 = new Vector3(wpos);
wpos2 += Position.X * RailTransformation.X + dz * RailTransformation.Z;
CompatibilityObjects.SignalPost.CreateObject(wpos2, RailTransformation, Transformation.NullTransformation, -1, StartingDistance, EndingDistance, TrackPosition, Brightness);
}
if (ShowObject)
{
// signal object
wpos += Position.X * RailTransformation.X + Position.Y * RailTransformation.Y + dz * RailTransformation.Z;
SignalObject.Create(wpos, RailTransformation, new Transformation(Yaw, Pitch, Roll), SectionIndex, StartingDistance, EndingDistance, TrackPosition, Brightness);
}
}
public float SignalLocation; // relative signal position //
//================================================================================================//
//
// Constructor
//
public TrackCircuitSignalItem(SignalObject thisRef, float thisLocation)
{
SignalState = ObjectItemInfo.ObjectItemFindState.Object;
SignalRef = thisRef;
SignalLocation = thisLocation;
}
//================================================================================================//
//
// return function value
// Possible functions :
// BLOCK_STATE
// ROUTE_SET
// NEXT_SIG_LR
// NEXT_SIG_MR
// THIS_SIG_LR
// THIS_SIG_MR
// OPP_SIG_LR
// OPP_SIG_MR
// DIST_MULTI_SIG_MR
// SIG_FEATURE
// DEF_DRAW_STATE
// HASHEAD
// DEBUG_HEADER (does not return a value)
// DEBUG_OUT (does not return a value)
//
//================================================================================================//
public int SH_function_value(SignalHead thisHead, SignalScripts.SCRScripts.SCRStatTerm thisTerm,
int[] localFloats, SIGSCRfile sigscr)
{
int return_value = 0;
int parameter1_value = 0;
int parameter2_value = 0;
// extract parameters (max. 2)
if (thisTerm.PartParameter != null)
{
if (thisTerm.PartParameter.Length >= 1)
{
SignalScripts.SCRScripts.SCRParameterType thisParameter = thisTerm.PartParameter[0];
parameter1_value = SH_termvalue(thisHead, thisParameter,
localFloats, sigscr);
}
if (thisTerm.PartParameter.Length >= 2)
{
SignalScripts.SCRScripts.SCRParameterType thisParameter = thisTerm.PartParameter[1];
parameter2_value = SH_termvalue(thisHead, thisParameter,
localFloats, sigscr);
}
}
// switch on function
SignalScripts.SCRExternalFunctions thisFunction = thisTerm.Function;
String dumpfile = String.Empty;
switch (thisFunction)
{
// BlockState
case (SignalScripts.SCRExternalFunctions.BLOCK_STATE):
return_value = (int)thisHead.mainSignal.block_state();
break;
// Route set
case (SignalScripts.SCRExternalFunctions.ROUTE_SET):
return_value = (int)thisHead.route_set();
break;
// next_sig_lr
case (SignalScripts.SCRExternalFunctions.NEXT_SIG_LR):
return_value = (int)thisHead.next_sig_lr((MstsSignalFunction)parameter1_value);
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
File.AppendAllText(dpe_fileLoc + @"printproc.txt",
" NEXT_SIG_LR : Located signal : " +
thisHead.mainSignal.sigfound[parameter1_value].ToString() + "\n");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
var sob = new StringBuilder();
sob.AppendFormat(" NEXT_SIG_LR : Located signal : {0}", thisHead.mainSignal.sigfound[parameter1_value].ToString());
if (thisHead.mainSignal.sigfound[parameter1_value] > 0)
{
SignalObject otherSignal = thisHead.mainSignal.signalRef.SignalObjects[thisHead.mainSignal.sigfound[parameter1_value]];
sob.AppendFormat(" (");
foreach (SignalHead otherHead in otherSignal.SignalHeads)
{
sob.AppendFormat(" {0} ", otherHead.TDBIndex);
}
sob.AppendFormat(") ");
}
sob.AppendFormat("\n");
File.AppendAllText(dpr_fileLoc + @"printproc.txt", sob.ToString());
}
#endif
break;
// next_sig_mr
case (SignalScripts.SCRExternalFunctions.NEXT_SIG_MR):
return_value = (int)thisHead.next_sig_mr((MstsSignalFunction)parameter1_value);
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
File.AppendAllText(dpe_fileLoc + @"printproc.txt",
" NEXT_SIG_LR : Located signal : " +
thisHead.mainSignal.sigfound[parameter1_value].ToString() + "\n");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
File.AppendAllText(dpr_fileLoc + @"printproc.txt",
" NEXT_SIG_LR : Located signal : " +
thisHead.mainSignal.sigfound[parameter1_value].ToString() + "\n");
}
#endif
break;
// this_sig_lr
case (SignalScripts.SCRExternalFunctions.THIS_SIG_LR):
bool sigfound_lr = false;
MstsSignalAspect returnState_lr = thisHead.this_sig_lr((MstsSignalFunction)parameter1_value, ref sigfound_lr);
return_value = sigfound_lr ? (int)returnState_lr : -1;
break;
// this_sig_mr
case (SignalScripts.SCRExternalFunctions.THIS_SIG_MR):
bool sigfound_mr = false;
MstsSignalAspect returnState_mr = thisHead.this_sig_mr((MstsSignalFunction)parameter1_value, ref sigfound_mr);
return_value = sigfound_mr ? (int)returnState_mr : -1;
break;
// opp_sig_lr
case (SignalScripts.SCRExternalFunctions.OPP_SIG_LR):
return_value = (int)thisHead.opp_sig_lr((MstsSignalFunction)parameter1_value);
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
SignalObject foundSignal = null;
int dummy = (int)thisHead.opp_sig_lr((MstsSignalFunction)parameter1_value, ref foundSignal);
int foundRef = foundSignal != null ? foundSignal.thisRef : -1;
File.AppendAllText(dpe_fileLoc + @"printproc.txt",
" OPP_SIG_LR : Located signal : " + foundRef.ToString() + "\n");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
SignalObject foundSignal = null;
int dummy = (int)thisHead.opp_sig_lr((MstsSignalFunction)parameter1_value, ref foundSignal);
int foundRef = foundSignal != null ? foundSignal.thisRef : -1;
File.AppendAllText(dpr_fileLoc + @"printproc.txt",
" OPP_SIG_LR : Located signal : " + foundRef.ToString() + "\n");
}
#endif
break;
// opp_sig_mr
case (SignalScripts.SCRExternalFunctions.OPP_SIG_MR):
return_value = (int)thisHead.opp_sig_mr((MstsSignalFunction)parameter1_value);
break;
// next_nsig_lr
case (SignalScripts.SCRExternalFunctions.NEXT_NSIG_LR):
dumpfile = String.Empty;
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
dumpfile = String.Concat(dpe_fileLoc, "printproc.txt");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
}
#endif
return_value = (int)thisHead.next_nsig_lr((MstsSignalFunction)parameter1_value, parameter2_value, dumpfile);
break;
// dist_multi_sig_mr
case (SignalScripts.SCRExternalFunctions.DIST_MULTI_SIG_MR):
dumpfile = String.Empty;
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
dumpfile = String.Concat(dpe_fileLoc, "printproc.txt");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
}
#endif
return_value = (int)thisHead.dist_multi_sig_mr(
(MstsSignalFunction)parameter1_value,
(MstsSignalFunction)parameter2_value,
dumpfile);
break;
// sig_feature
case (SignalScripts.SCRExternalFunctions.SIG_FEATURE):
bool temp_value;
temp_value = thisHead.sig_feature(parameter1_value);
return_value = Convert.ToInt32(temp_value);
break;
// approach control position
case (SignalScripts.SCRExternalFunctions.APPROACH_CONTROL_POSITION):
dumpfile = String.Empty;
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
dumpfile = String.Concat(dpe_fileLoc, "printproc.txt");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
}
#endif
temp_value = thisHead.mainSignal.ApproachControlPosition(parameter1_value, dumpfile);
return_value = Convert.ToInt32(temp_value);
break;
// approach control speed
case (SignalScripts.SCRExternalFunctions.APPROACH_CONTROL_SPEED):
dumpfile = String.Empty;
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
dumpfile = String.Concat(dpe_fileLoc, "printproc.txt");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
}
#endif
temp_value = thisHead.mainSignal.ApproachControlSpeed(parameter1_value, parameter2_value, dumpfile);
return_value = Convert.ToInt32(temp_value);
break;
// Check for CallOn
case (SignalScripts.SCRExternalFunctions.TRAINHASCALLON):
dumpfile = String.Empty;
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
dumpfile = String.Concat(dpe_fileLoc, "printproc.txt");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
}
#endif
temp_value = thisHead.mainSignal.TrainHasCallOn(true, dumpfile);
return_value = Convert.ToInt32(temp_value);
break;
// Check for CallOn
case (SignalScripts.SCRExternalFunctions.TRAINHASCALLON_RESTRICTED):
dumpfile = String.Empty;
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
dumpfile = String.Concat(dpe_fileLoc, "printproc.txt");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
}
#endif
temp_value = thisHead.mainSignal.TrainHasCallOn(false, dumpfile);
return_value = Convert.ToInt32(temp_value);
break;
case (SignalScripts.SCRExternalFunctions.HASHEAD):
return_value = thisHead.mainSignal.HasHead(parameter1_value);
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
File.AppendAllText(dpe_fileLoc + @"printproc.txt",
" HASHEAD : required head : " + parameter1_value + " ; state : " + return_value + "\n");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
File.AppendAllText(dpr_fileLoc + @"printproc.txt",
" HASHEAD : required head : " + parameter1_value + " ; state : " + return_value + "\n");
}
#endif
break;
// def_draw_state
case (SignalScripts.SCRExternalFunctions.DEF_DRAW_STATE):
return_value = thisHead.def_draw_state((MstsSignalAspect)parameter1_value);
break;
// DEBUG routine : to be implemented later
default:
break;
}
#if DEBUG_PRINT_ENABLED
if (thisHead.mainSignal.enabledTrain != null)
{
File.AppendAllText(dpe_fileLoc + @"printproc.txt",
"Function Result : " + thisFunction.ToString() + "(" + parameter1_value.ToString() + ") = " +
return_value.ToString() + "\n");
}
#endif
#if DEBUG_PRINT_PROCESS
if (TDB_debug_ref.Contains(thisHead.TDBIndex))
{
File.AppendAllText(dpr_fileLoc + @"printproc.txt",
"Function Result : " + thisFunction.ToString() + "(" + parameter1_value.ToString() + ") = " +
return_value.ToString() + "\n");
}
#endif
// check sign
if (thisTerm.TermOperator == SignalScripts.SCRTermOperator.MINUS)
{
return_value = -(return_value);
}
return(return_value);
}
public SignalShape(SignalObject mstsSignal, string path, IWorldPosition positionSource, ShapeFlags flags)
: base(path, positionSource, flags)
{
#if DEBUG_SIGNAL_SHAPES
Console.WriteLine("{0} signal {1}:", Location.ToString(), mstsSignal.UID);
UID = mstsSignal.UID;
#endif
var signalShape = Path.GetFileName(path).ToUpper();
if (!viewer.SIGCFG.SignalShapes.ContainsKey(signalShape))
{
Trace.TraceWarning("{0} signal {1} has invalid shape {2}.", WorldPosition.ToString(), mstsSignal.UiD, signalShape);
return;
}
var mstsSignalShape = viewer.SIGCFG.SignalShapes[signalShape];
#if DEBUG_SIGNAL_SHAPES
Console.WriteLine(" Shape={0} SubObjs={1,-2} {2}", Path.GetFileNameWithoutExtension(path).ToUpper(), mstsSignalShape.SignalSubObjs.Count, mstsSignalShape.Description);
#endif
// The matrix names are used as the sub-object names. The sub-object visibility comes from
// mstsSignal.SignalSubObj, which is mapped to names through mstsSignalShape.SignalSubObjs.
var visibleMatrixNames = new bool[SharedShape.MatrixNames.Count];
for (var i = 0; i < mstsSignalShape.SignalSubObjs.Count; i++)
{
if ((((mstsSignal.SignalSubObject >> i) & 0x1) == 1) && (SharedShape.MatrixNames.Contains(mstsSignalShape.SignalSubObjs[i].MatrixName)))
{
visibleMatrixNames[SharedShape.MatrixNames.IndexOf(mstsSignalShape.SignalSubObjs[i].MatrixName)] = true;
}
}
// All sub-objects except the one pointing to the first matrix (99.00% times it is the first one, but not always, see Protrain) are hidden by default.
//For each other sub-object, look up its name in the hierarchy and use the visibility of that matrix.
visibleMatrixNames[0] = true;
SubObjVisible = new bool[SharedShape.LodControls[0].DistanceLevels[0].SubObjects.Length];
SubObjVisible[0] = true;
for (var i = 1; i < SharedShape.LodControls[0].DistanceLevels[0].SubObjects.Length; i++)
{
if (i == SharedShape.RootSubObjectIndex)
{
SubObjVisible[i] = true;
}
else
{
var subObj = SharedShape.LodControls[0].DistanceLevels[0].SubObjects[i];
int minHiLevIndex = 0;
if (subObj.ShapePrimitives[0].Hierarchy[subObj.ShapePrimitives[0].HierarchyIndex] > 0)
// Search for ShapePrimitive with lowest Hierarchy Value and check visibility with it
{
var minHiLev = 999;
for (var j = 0; j < subObj.ShapePrimitives.Length; j++)
{
if (subObj.ShapePrimitives[0].Hierarchy[subObj.ShapePrimitives[j].HierarchyIndex] < minHiLev)
{
minHiLevIndex = j;
minHiLev = subObj.ShapePrimitives[0].Hierarchy[subObj.ShapePrimitives[j].HierarchyIndex];
}
}
}
SubObjVisible[i] = visibleMatrixNames[SharedShape.LodControls[0].DistanceLevels[0].SubObjects[i].ShapePrimitives[minHiLevIndex].HierarchyIndex];
}
}
#if DEBUG_SIGNAL_SHAPES
for (var i = 0; i < mstsSignalShape.SignalSubObjs.Count; i++)
{
Console.WriteLine(" SUBOBJ {1,-12} {0,-7} {2,3} {3,3} {4,2} {5,2} {6,-14} {8} ({7})", ((mstsSignal.SignalSubObj >> i) & 0x1) != 0 ? "VISIBLE" : "hidden", mstsSignalShape.SignalSubObjs[i].MatrixName, mstsSignalShape.SignalSubObjs[i].Optional ? "Opt" : "", mstsSignalShape.SignalSubObjs[i].Default ? "Def" : "", mstsSignalShape.SignalSubObjs[i].JunctionLink ? "JL" : "", mstsSignalShape.SignalSubObjs[i].BackFacing ? "BF" : "", mstsSignalShape.SignalSubObjs[i].SignalSubType == -1 ? "<none>" : MSTS.SignalShape.SignalSubObj.SignalSubTypes[mstsSignalShape.SignalSubObjs[i].SignalSubType], mstsSignalShape.SignalSubObjs[i].SignalSubSignalType, mstsSignalShape.SignalSubObjs[i].Description);
}
for (var i = 0; i < SubObjVisible.Length; i++)
{
Console.WriteLine(" SUBOBJ {0,-2} {1,-7}", i, SubObjVisible[i] ? "VISIBLE" : "hidden");
}
#endif
if (mstsSignal.SignalUnits == null)
{
Trace.TraceWarning("{0} signal {1} has no SignalUnits.", WorldPosition.ToString(), mstsSignal.UiD);
return;
}
for (var i = 0; i < mstsSignal.SignalUnits.Count; i++)
{
#if DEBUG_SIGNAL_SHAPES
Console.Write(" UNIT {0}: TrItem={1,-5} SubObj={2,-2}", i, mstsSignal.SignalUnits.Units[i].TrItem, mstsSignal.SignalUnits.Units[i].SubObj);
#endif
// Find the simulation SignalObject for this shape.
var signalAndHead = viewer.Simulator.Signals.FindByTrItem(mstsSignal.SignalUnits[i].TrackItem);
if (!signalAndHead.HasValue)
{
Trace.TraceWarning("Skipped {0} signal {1} unit {2} with invalid TrItem {3}", WorldPosition.ToString(), mstsSignal.UiD, i, mstsSignal.SignalUnits[i].TrackItem);
continue;
}
// Get the signal sub-object for this unit (head).
var mstsSignalSubObj = mstsSignalShape.SignalSubObjs[mstsSignal.SignalUnits[i].SubObject];
if (mstsSignalSubObj.SignalSubType != SignalSubType.Signal_Head) // SIGNAL_HEAD
{
Trace.TraceWarning("Skipped {0} signal {1} unit {2} with invalid SubObj {3}", WorldPosition.ToString(), mstsSignal.UiD, i, mstsSignal.SignalUnits[i].SubObject);
continue;
}
var mstsSignalItem = (SignalItem)(viewer.Simulator.TDB.TrackDB.TrackItems[mstsSignal.SignalUnits[i].TrackItem]);
try
{
// Go create the shape head.
Heads.Add(new SignalShapeHead(viewer, this, i, signalAndHead.Value.Value, mstsSignalItem, mstsSignalSubObj));
}
catch (InvalidDataException error)
{
Trace.TraceWarning(error.Message);
}
#if DEBUG_SIGNAL_SHAPES
Console.WriteLine();
#endif
}
}
} = new List <int>(); // Flags heads which are backfacing
public SignalWorldInfo(SignalObject signalWorldItem, SignalConfigurationFile signalConfig)
{
if (null == signalConfig)
{
throw new ArgumentNullException(nameof(signalConfig));
}
if (null == signalWorldItem)
{
throw new ArgumentNullException(nameof(signalWorldItem));
}
HeadReference = new Dictionary <uint, uint>();
// set flags with length to number of possible SubObjects type
FlagsSet = new BitArray(EnumExtension.GetLength <SignalSubType>());
FlagsSetBackfacing = new BitArray(EnumExtension.GetLength <SignalSubType>());
string fileName = Path.GetFileName(signalWorldItem.FileName);
// search defined shapes in SIGCFG to find signal definition
if (signalConfig.SignalShapes.TryGetValue(fileName, out SignalShape thisCFGShape))
{
HeadsSet = new BitArray(thisCFGShape.SignalSubObjs.Count);
// loop through all heads and check SubObj flag per bit to check if head is set
uint mask = 1;
for (int i = 0; i < thisCFGShape.SignalSubObjs.Count; i++)
{
uint headSet = signalWorldItem.SignalSubObject & mask;
SignalShape.SignalSubObject signalSubObjects = thisCFGShape.SignalSubObjs[i];
if (headSet != 0)
{
// set head, and if head is flag, also set flag
HeadsSet[i] = true;
if (signalSubObjects.BackFacing)
{
Backfacing.Add(i);
if ((int)signalSubObjects.SignalSubType >= 1)
{
FlagsSetBackfacing[(int)signalSubObjects.SignalSubType] = true;
}
}
else if ((int)signalSubObjects.SignalSubType >= 1)
{
FlagsSet[(int)signalSubObjects.SignalSubType] = true;
}
}
mask <<= 1;
}
// get TDB and head reference from World file
foreach (SignalUnit signalUnitInfo in signalWorldItem.SignalUnits)
{
HeadReference.Add(signalUnitInfo.TrackItem, (uint)signalUnitInfo.SubObject);
}
}
else
{
Trace.TraceWarning("Signal not found : {0} n", fileName);
}
}
public static void RemoveSignal(SignalObject obj)
{
_objects[(int)LAYER_ORDER.SIGNALS].Remove(obj);
}
public static void AddSignal(SignalObject obj)
{
_objects[(int)LAYER_ORDER.SIGNALS].Add(obj);
}
