//================================================================================================//
/// <summary>
/// check if linked route is set
/// </summary>
public int VerifyRouteSet()
{
// call route_set routine from main signal
if (TrackJunctionNode > 0)
{
return(MainSignal.CheckRouteSet(JunctionMainNode, TrackJunctionNode) ? 1 : 0);
}
//added by JTang
else if (MultiPlayerManager.IsMultiPlayer())
{
TrackNode node = Simulator.Instance.TrackDatabase.TrackDB.TrackNodes[MainSignal.TrackNode];
if (!(node is TrackJunctionNode) && node.TrackPins != null && (int)MainSignal.TrackCircuitDirection < node.TrackPins.Length)
{
node = Simulator.Instance.TrackDatabase.TrackDB.TrackNodes[node.TrackPins[(int)MainSignal.TrackCircuitDirection].Link];
if (!(node is TrackJunctionNode junctionNode))
{
return(0);
}
for (int pin = junctionNode.InPins; pin < junctionNode.InPins + junctionNode.OutPins; pin++)
{
if (junctionNode.TrackPins[pin].Link == MainSignal.TrackNode && pin - junctionNode.InPins != junctionNode.SelectedRoute)
{
return(0);
}
}
}
}
return(1);
}
internal int Switchstand(int aspect1, int aspect2)
{
return(MainSignal.Switchstand(aspect1, aspect2));
}
//================================================================================================//
/// <summary>
/// Returns most restrictive state of signal type A, for all type A upto type B
/// Uses Least Restrictive state per signal
/// </summary>
public SignalAspectState LRSignalMultiOnRoute(int signalType, int signalTypeOther)
{
SignalAspectState foundState = SignalAspectState.Clear_2;
bool foundValid = false;
// get signal of type 2 (end signal)
int sig2Index = MainSignal.Signalfound[signalTypeOther];
if (sig2Index < 0) // try renewed search with full route
{
sig2Index = MainSignal.SONextSignal(signalTypeOther);
MainSignal.Signalfound[signalTypeOther] = sig2Index;
}
Signal thisSignal = MainSignal;
// ensure next signal of type 1 is located correctly (cannot be done for normal signals searching next normal signal)
if (!thisSignal.SignalNormal() || signalType != (int)SignalFunction.Normal)
{
thisSignal.Signalfound[signalType] = thisSignal.SONextSignal(signalType);
}
// loop through all available signals of type 1
while (thisSignal.Signalfound[signalType] >= 0)
{
thisSignal = Simulator.Instance.SignalEnvironment.Signals[thisSignal.Signalfound[signalType]];
SignalAspectState thisState = thisSignal.SignalLRLimited(signalType);
// ensure correct next signals are located
if (signalType != (int)SignalFunction.Normal || !thisSignal.SignalNormal())
{
int sigFound = thisSignal.SONextSignal(signalType);
if (sigFound >= 0)
{
thisSignal.Signalfound[signalType] = thisSignal.SONextSignal(signalType);
}
}
if (signalTypeOther != (int)SignalFunction.Normal || !thisSignal.SignalNormal())
{
int sigFound = thisSignal.SONextSignal(signalTypeOther);
if (sigFound >= 0)
{
thisSignal.Signalfound[signalTypeOther] = thisSignal.SONextSignal(signalTypeOther);
}
}
if (sig2Index == thisSignal.Index) // this signal also contains type 2 signal and is therefor valid
{
return(foundState < thisState ? foundState : thisState);
}
else if (sig2Index >= 0 && thisSignal.Signalfound[signalTypeOther] != sig2Index) // we are beyond type 2 signal
{
return(foundValid ? foundState : SignalAspectState.Stop);
}
foundValid = true;
foundState = foundState < thisState ? foundState : thisState;
}
return(foundValid ? foundState : SignalAspectState.Stop); // no type 2 or running out of signals before finding type 2
}
public int NextSignalLocalVariable(int signalType, int index)
{
return(MainSignal.NextSignalLocalVariable(signalType, index));
}
public int SignalHasNormalSubtype(int requestedSubtype)
{
return(MainSignal.SignalHasNormalSubtype(requestedSubtype));
}
public void StoreLocalVariable(int index, int value)
{
MainSignal.StoreLocalVariable(index, value);
}
public int ThisSignalLocalVariable(int index)
{
return(MainSignal.SignalLocalVariable(index));
}
public int NextNthSignalId(int signalType, int nsignal)
{
return(MainSignal.NextNthSignalId(signalType, nsignal));
}
public int OppositeSignalId(int signalType)
{
return(MainSignal.OppositeSignalId(signalType));
}
public int NextSignalId(int signalType)
{
return(MainSignal.NextSignalId(signalType));
}
public SignalAspectState NextNthSignalLR(int signalType, int nsignals)
{
return(MainSignal.NextNthSignalLR(signalType, nsignals));
}
public SignalAspectState OppositeSignalLR(int signalType)
{
return(MainSignal.OppositeSignalLR(signalType));
}
public SignalAspectState ThisSignalMR(int signalType)
{
return(MainSignal.SignalMR(signalType));
}
public SignalAspectState NextSignalLR(int signalType)
{
return(MainSignal.NextSignalLR(signalType));
}
