/// <summary>
/// This method returns the next least restrictive aspect from the one specified.
/// </summary>
public MstsSignalAspect GetNextLeastRestrictiveState(MstsSignalAspect state)
{
MstsSignalAspect targetState = MstsSignalAspect.UNKNOWN;
MstsSignalAspect leastState = MstsSignalAspect.STOP;
for (int i = 0; i < Aspects.Count; i++)
{
if (Aspects[i].Aspect > leastState)
{
leastState = Aspects[i].Aspect;
}
if (Aspects[i].Aspect > state && Aspects[i].Aspect < targetState)
{
targetState = Aspects[i].Aspect;
}
}
if (targetState == MstsSignalAspect.UNKNOWN)
{
return(leastState);
}
else
{
return(targetState);
}
}
/// <summary>
/// constructor for dummy entries
/// </summary>
/// <param name="reqAspect">Requested aspect</param>
/// <param name="reqName">Requested drawstate name</param>
public SignalAspect(MstsSignalAspect reqAspect, string reqName)
{
Aspect = reqAspect;
DrawStateName = String.Copy(reqName);
SpeedMpS = -1;
Asap = false;
NoSpeedReduction = false;
}
/// <summary>
/// This method returns the lowest speed limit linked to the aspect
/// </summary>
public float GetSpeedLimitMpS(MstsSignalAspect aspect)
{
for (int i = 0; i < Aspects.Count; i++)
{
if (Aspects[i].Aspect == aspect)
{
return(Aspects[i].SpeedMpS);
}
}
return(-1);
}
/// <summary>
/// This method returns the default draw state for the specified aspect or -1 if none.
/// </summary>
public int def_draw_state(MstsSignalAspect state)
{
for (int i = 0; i < Aspects.Count; i++)
{
if (state == Aspects[i].Aspect)
{
return(DrawStates[Aspects[i].DrawStateName].Index);
}
}
return(-1);
}
/// <summary>
/// Constructor for dummy entries
/// </summary>
public SignalType(FnTypes reqType, MstsSignalAspect reqAspect)
: this()
{
FnType = reqType;
Name = "UNDEFINED";
Semaphore = false;
DrawStates = new Dictionary <string, SignalDrawState>();
DrawStates.Add("CLEAR", new SignalDrawState("CLEAR", 1));
Aspects = new List <SignalAspect>();
Aspects.Add(new SignalAspect(reqAspect, "CLEAR"));
}
/// <summary>
/// This method returns the least restrictive aspect for this signal type.
/// [Rob Roeterdink] added for basic signals without script
/// </summary>
public MstsSignalAspect GetLeastRestrictiveAspect()
{
MstsSignalAspect targetAspect = MstsSignalAspect.STOP;
for (int i = 0; i < Aspects.Count; i++)
{
if (Aspects[i].Aspect > targetAspect)
{
targetAspect = Aspects[i].Aspect;
}
}
if (targetAspect > MstsSignalAspect.CLEAR_2)
{
return(MstsSignalAspect.CLEAR_2);
}
else
{
return(targetAspect);
}
}
/// <summary>
/// This method returns the most restrictive aspect for this signal type.
/// </summary>
public MstsSignalAspect GetMostRestrictiveAspect()
{
MstsSignalAspect targetAspect = MstsSignalAspect.UNKNOWN;
for (int i = 0; i < Aspects.Count; i++)
{
if (Aspects[i].Aspect < targetAspect)
{
targetAspect = Aspects[i].Aspect;
}
}
if (targetAspect == MstsSignalAspect.UNKNOWN)
{
return(MstsSignalAspect.STOP);
}
else
{
return(targetAspect);
}
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalAspect(STFReader stf)
{
SpeedMpS = -1;
stf.MustMatch("(");
string aspectName = stf.ReadString();
try
{
Aspect = (MstsSignalAspect)Enum.Parse(typeof(MstsSignalAspect), aspectName, true);
}
catch (ArgumentException)
{
STFException.TraceInformation(stf, "Skipped unknown signal aspect " + aspectName);
Aspect = MstsSignalAspect.UNKNOWN;
}
DrawStateName = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("speedmph", () => { SpeedMpS = MpS.FromMpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { SpeedMpS = MpS.FromKpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "asap": Asap = true; break;
case "or_speedreset": Reset = true; break;
case "or_nospeedreduction": NoSpeedReduction = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown DrawLight flag " + stf.ReadString()); break;
}
}
}),
});
}
//================================================================================================//
//
// 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);
}
