/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
/// <param name="index">The index of this TrItem in the list of TrItems</param>
internal SignalItem(STFReader stf, int index)
{
SignalObject = -1;
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tritemid", () => { ParseTrackItemId(stf, index); }),
new STFReader.TokenProcessor("tritemrdata", () => { ParseTrackItemRData(stf); }),
new STFReader.TokenProcessor("tritemsdata", () => { ParseTrackItemSData(stf); }),
new STFReader.TokenProcessor("trsignaltype", () => {
stf.MustMatchBlockStart();
Flags1 = stf.ReadUInt(null);
Direction = (TrackDirection)stf.ReadUInt(null);
SignalData = stf.ReadFloat(STFReader.Units.None, null);
SignalType = stf.ReadString();
// To do get index to Sigtypes table corresponding to this signal
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("trsignaldirs", () => {
stf.MustMatchBlockStart();
uint signalDirs = stf.ReadUInt(null);
SignalDirections = new List <TrackItemSignalDirection>((int)signalDirs);
int i = 0;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("trsignaldir", () => {
if (SignalDirections.Count >= signalDirs)
{
STFException.TraceWarning(stf, $"Adding extra TrSignalDirs in SignalItem {TrackItemId}");
}
SignalDirections.Add(new TrackItemSignalDirection(stf));
}),
});
if (i < signalDirs)
{
STFException.TraceWarning(stf, $"{(signalDirs - i)} missing TrSignalDirs(s)");
}
}),
});
}
public ESD_Bounding_Box(STFReader stf)
{
stf.MustMatch("(");
string item = stf.ReadString();
if (item == ")") return; // quietly return on ESD_Bounding_Box()
stf.StepBackOneItem();
float X = stf.ReadFloat(STFReader.UNITS.None, null);
float Y = stf.ReadFloat(STFReader.UNITS.None, null);
float Z = stf.ReadFloat(STFReader.UNITS.None, null);
Min = new TWorldPosition(X, Y, Z);
X = stf.ReadFloat(STFReader.UNITS.None, null);
Y = stf.ReadFloat(STFReader.UNITS.None, null);
Z = stf.ReadFloat(STFReader.UNITS.None, null);
Max = new TWorldPosition(X, Y, Z);
// JP2indirt.sd has extra parameters
stf.SkipRestOfBlock();
}
public static Interpolator CreateInterpolator(this STFReader stf)
{
if (null == stf)
{
throw new ArgumentNullException(nameof(stf));
}
List <double> list = new List <double>();
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
list.Add(stf.ReadFloat(STFReader.Units.Any, null));
}
if (list.Count % 2 == 1)
{
STFException.TraceWarning(stf, "Ignoring extra odd value in Interpolator list.");
}
int n = list.Count / 2;
if (n < 2)
{
STFException.TraceWarning(stf, "Interpolator must have at least two value pairs.");
}
double[] xArray = new double[n];
double[] yArray = new double[n];
for (int i = 0; i < n; i++)
{
xArray[i] = list[2 * i];
yArray[i] = list[2 * i + 1];
if (i > 0 && xArray[i - 1] >= xArray[i])
{
STFException.TraceWarning(stf, "Interpolator x values must be increasing.");
}
}
return(new Interpolator(xArray, yArray));
}
public static Interpolator2D CreateInterpolator2D(this STFReader stf)
{
if (null == stf)
{
throw new ArgumentNullException(nameof(stf));
}
List <double> xlist = new List <double>();
List <Interpolator> ilist = new List <Interpolator>();
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
xlist.Add(stf.ReadFloat(STFReader.Units.Any, null));
ilist.Add(stf.CreateInterpolator());
}
stf.SkipRestOfBlock();
int n = xlist.Count;
if (n < 2)
{
STFException.TraceWarning(stf, "Interpolator must have at least two x values.");
}
double[] xArray = new double[n];
Interpolator[] yArray = new Interpolator[n];
for (int i = 0; i < n; i++)
{
xArray[i] = xlist[i];
yArray[i] = ilist[i];
if (i > 0 && xArray[i - 1] >= xArray[i])
{
STFException.TraceWarning(stf, " Interpolator x values must be increasing.");
}
}
return(new Interpolator2D(xArray, yArray));
}
internal RouteStart(STFReader stf)
{
stf.MustMatchBlockStart();
location = new WorldLocation(stf.ReadInt(null), stf.ReadInt(null), stf.ReadFloat(null), 0f, stf.ReadFloat(null));
stf.SkipRestOfBlock();
}
public void Parse(string lowercasetoken, STFReader stf)
{
string temp = "";
switch (lowercasetoken)
{
case "engine(gearboxnumberofgears": GearBoxNumberOfGears = stf.ReadIntBlock(1); initLevel++; break;
case "engine(gearboxdirectdrivegear": GearBoxDirectDriveGear = stf.ReadIntBlock(1); break;
case "engine(ortsgearboxfreewheel":
var freeWheel = stf.ReadIntBlock(null);
if (freeWheel == 1)
{
FreeWheelFitted = true;
}
break;
case "engine(ortsgearboxtype":
stf.MustMatch("(");
var gearType = stf.ReadString();
try
{
GearBoxType = (TypesGearBox)Enum.Parse(typeof(TypesGearBox), gearType.First().ToString().ToUpper() + gearType.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown gear box type " + gearType);
}
break;
case "engine(ortsmainclutchtype":
stf.MustMatch("(");
var clutchType = stf.ReadString();
try
{
ClutchType = (TypesClutch)Enum.Parse(typeof(TypesClutch), clutchType.First().ToString().ToUpper() + clutchType.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown main clutch type " + clutchType);
}
break;
case "engine(gearboxoperation":
stf.MustMatch("(");
var gearOperation = stf.ReadString();
try
{
GearBoxOperation = (GearBoxOperation)Enum.Parse(typeof(GearBoxOperation), gearOperation.First().ToString().ToUpper() + gearOperation.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown gear box operation type " + gearOperation);
}
initLevel++;
break;
case "engine(gearboxenginebraking":
stf.MustMatch("(");
var engineBraking = stf.ReadString();
try
{
GearBoxEngineBraking = (GearBoxEngineBraking)Enum.Parse(typeof(GearBoxEngineBraking), engineBraking.First().ToString().ToUpper() + engineBraking.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown gear box engine braking type " + engineBraking);
}
break;
case "engine(gearboxmaxspeedforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxSpeedForGearsMpS.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxSpeedForGearsMpS.Add(stf.ReadFloat(STFReader.UNITS.SpeedDefaultMPH, 10.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
// gearboxmaxtractiveforceforgears purely retained for legacy reasons
case "engine(gearboxmaxtractiveforceforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxTractiveForceForGearsN.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxTractiveForceForGearsN.Add(stf.ReadFloat(STFReader.UNITS.Force, 10000.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(ortsgearboxtractiveforceatspeed":
MaxTEFound = true;
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxTractiveForceAtSpeedN.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxTractiveForceAtSpeedN.Add(stf.ReadFloat(STFReader.UNITS.Force, 0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(gearboxoverspeedpercentageforfailure": GearBoxOverspeedPercentageForFailure = stf.ReadFloatBlock(STFReader.UNITS.None, 150f); break; // initLevel++; break;
case "engine(gearboxbackloadforce": GearBoxBackLoadForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxcoastingforce": GearBoxCoastingForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxupgearproportion": GearBoxUpGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.85f); break; // initLevel++; break;
case "engine(gearboxdowngearproportion": GearBoxDownGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.25f); break; // initLevel++; break;
default: break;
}
}
public override float ReadFloat()
{
return(stf.ReadFloat(STFReader.Units.None, null));
}
public ENVFileSkyLayer(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_sky_layer_fadein", () => { stf.MustMatch("("); Fadein_Begin_Time = stf.ReadString(); Fadein_End_Time = stf.ReadString(); stf.SkipRestOfBlock(); }),
new STFReader.TokenProcessor("world_anim_shader", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_anim_shader_frames", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_anim_shader_frame", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_anim_shader_frame_uvtiles", () => { stf.MustMatch("("); TileX = stf.ReadFloat(STFReader.UNITS.Any, 1.0f); TileY = stf.ReadFloat(STFReader.UNITS.Any, 1.0f); stf.ParseBlock(new STFReader.TokenProcessor[] {
}); }),
}); }),
}); }),
new STFReader.TokenProcessor("world_shader", () => { stf.MustMatch("("); TextureMode = stf.ReadString(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("terrain_texslots", () => { stf.MustMatch("("); stf.ReadInt(null) /*Count*/; stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("terrain_texslot", () => { stf.MustMatch("("); TextureName = stf.ReadString(); stf.SkipRestOfBlock(); }),
}); }),
}); }),
}); }),
});
}
public static Interpolator2D CreateInterpolator2D(this STFReader stf, bool tab)
{
List <double> xlist = new List <double>();
List <Interpolator> ilist = new List <Interpolator>();
bool errorFound = false;
if (tab)
{
stf.MustMatchBlockStart();
int numOfRows = stf.ReadInt(0);
if (numOfRows < 2)
{
STFException.TraceWarning(stf, "Interpolator must have at least two rows.");
errorFound = true;
}
int numOfColumns = stf.ReadInt(0);
string header = stf.ReadString().ToLower();
if (header == "throttle")
{
stf.MustMatchBlockStart();
int numOfThrottleValues = 0;
while (!stf.EndOfBlock())
{
xlist.Add(stf.ReadFloat(STFReader.Units.None, 0f));
ilist.Add(new Interpolator(numOfRows));
numOfThrottleValues++;
}
if (numOfThrottleValues != (numOfColumns - 1))
{
STFException.TraceWarning(stf, "Interpolator throttle vs. num of columns mismatch.");
errorFound = true;
}
if (numOfColumns < 3)
{
STFException.TraceWarning(stf, "Interpolator must have at least three columns.");
errorFound = true;
}
int numofData = 0;
string tableLabel = stf.ReadString().ToLower();
if (tableLabel == "table")
{
stf.MustMatchBlockStart();
for (int i = 0; i < numOfRows; i++)
{
float x = stf.ReadFloat(STFReader.Units.SpeedDefaultMPH, 0);
numofData++;
for (int j = 0; j < numOfColumns - 1; j++)
{
if (j >= ilist.Count)
{
STFException.TraceWarning(stf, "Interpolator throttle vs. num of columns mismatch. (missing some throttle values)");
errorFound = true;
}
ilist[j][x] = stf.ReadFloat(STFReader.Units.Force, 0);
numofData++;
}
}
stf.SkipRestOfBlock();
}
else
{
STFException.TraceWarning(stf, "Interpolator didn't find a table to load.");
errorFound = true;
}
//check the table for inconsistencies
foreach (Interpolator checkMe in ilist)
{
if (checkMe.Size != numOfRows)
{
STFException.TraceWarning(stf, "Interpolator has found a mismatch between num of rows declared and num of rows given.");
errorFound = true;
}
double dx = (checkMe.MaxX() - checkMe.MinX()) * 0.1f;
if (dx <= 0f)
{
STFException.TraceWarning(stf, "Interpolator has found X data error - x values must be increasing. (Possible row number mismatch)");
errorFound = true;
}
else
{
for (double x = checkMe.MinX(); x <= checkMe.MaxX(); x += dx)
{
if (double.IsNaN(checkMe[x]))
{
STFException.TraceWarning(stf, "Interpolator has found X data error - x values must be increasing. (Possible row number mismatch)");
errorFound = true;
break;
}
}
}
}
if (numofData != (numOfRows * numOfColumns))
{
STFException.TraceWarning(stf, "Interpolator has found a mismatch: num of data doesn't fit the header information.");
errorFound = true;
}
}
else
{
STFException.TraceWarning(stf, "Interpolator must have a 'throttle' header row.");
errorFound = true;
}
stf.SkipRestOfBlock();
}
else
{
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
xlist.Add(stf.ReadFloat(STFReader.Units.Any, null));
ilist.Add(stf.CreateInterpolator());
}
}
int n = xlist.Count;
if (n < 2)
{
STFException.TraceWarning(stf, "Interpolator must have at least two x values.");
errorFound = true;
}
double[] xArray = new double[n];
Interpolator[] yArray = new Interpolator[n];
for (int i = 0; i < n; i++)
{
xArray[i] = xlist[i];
yArray[i] = ilist[i];
if (i > 0 && xArray[i - 1] >= xArray[i])
{
STFException.TraceWarning(stf, "Interpolator x values must be increasing.");
}
}
if (errorFound)
{
STFException.TraceWarning(stf, "Errors found in the Interpolator definition!!! The Interpolator will not work correctly!");
}
Interpolator2D result = new Interpolator2D(xArray, yArray);
return(result);
}
public override float ReadFloat()
{
return(f.ReadFloat(STFReader.UNITS.None, null));
}
public SetStreamVolume(STFReader f)
{
f.MustMatch("(");
Volume = f.ReadFloat(STFReader.UNITS.None, null);
f.SkipRestOfBlock();
}
public float FullStaticCentreOfGravityM_Y = -9999; // get centre of gravity after adjusted for freight animation
public FreightAnimationStatic(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("subtype", () =>
{
var typeString = stf.ReadStringBlock(null);
switch (typeString)
{
default:
SubType = FreightAnimationStatic.Type.DEFAULT;
break;
}
}),
new STFReader.TokenProcessor("shape", () => { ShapeFileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("freightweight", () => { FreightWeight = stf.ReadFloatBlock(STFReader.UNITS.Mass, 0); }),
new STFReader.TokenProcessor("offset", () => {
stf.MustMatch("(");
XOffset = stf.ReadFloat(STFReader.UNITS.Distance, 0);
YOffset = stf.ReadFloat(STFReader.UNITS.Distance, 0);
ZOffset = stf.ReadFloat(STFReader.UNITS.Distance, 0);
stf.MustMatch(")");
}),
new STFReader.TokenProcessor("flip", () => { Flipped = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("visibility", () => {
for (int index = 0; index < 3; index++)
{
Visibility[index] = false;
}
foreach (var visibilityPlace in stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(','))
{
switch (visibilityPlace)
{
case "outside":
Visibility[(int)VisibleFrom.Outside] = true;
break;
case "cab2d":
Visibility[(int)VisibleFrom.Cab2D] = true;
break;
case "cab3d":
Visibility[(int)VisibleFrom.Cab3D] = true;
break;
default:
break;
}
}
}),
// additions to manage consequences of variable weight on friction and brake forces
new STFReader.TokenProcessor("fullortsdavis_a", () => { FullStaticORTSDavis_A = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullortsdavis_b", () => { FullStaticORTSDavis_B = stf.ReadFloatBlock(STFReader.UNITS.Resistance, -1); }),
new STFReader.TokenProcessor("fullortsdavis_c", () => { FullStaticORTSDavis_C = stf.ReadFloatBlock(STFReader.UNITS.ResistanceDavisC, -1); }),
new STFReader.TokenProcessor("fullortswagonfrontalarea", () => { FullStaticORTSWagonFrontalAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, -1); }),
new STFReader.TokenProcessor("fullortsdavisdragconstant", () => { FullStaticORTSDavisDragConstant = stf.ReadFloatBlock(STFReader.UNITS.Any, -1); }),
new STFReader.TokenProcessor("fullmaxbrakeforce", () => { FullStaticMaxBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullmaxhandbrakeforce", () => { FullStaticMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullcentreofgravity_y", () => { FullStaticCentreOfGravityM_Y = stf.ReadFloatBlock(STFReader.UNITS.Distance, -1); })
});
}
public InterpolatorDiesel2D(STFReader stf, bool tab)
{
// <CSComment> TODO: probably there is some other stf.SkipRestOfBlock() that should be removed </CSComment>
List <float> xlist = new List <float>();
List <Interpolator> ilist = new List <Interpolator>();
bool errorFound = false;
if (tab)
{
stf.MustMatch("(");
int numOfRows = stf.ReadInt(0);
if (numOfRows < 2)
{
STFException.TraceWarning(stf, "Interpolator must have at least two rows.");
errorFound = true;
}
int numOfColumns = stf.ReadInt(0);
string header = stf.ReadString().ToLower();
if (header == "throttle")
{
stf.MustMatch("(");
int numOfThrottleValues = 0;
while (!stf.EndOfBlock())
{
xlist.Add(stf.ReadFloat(STFReader.UNITS.None, 0f));
ilist.Add(new Interpolator(numOfRows));
numOfThrottleValues++;
}
if (numOfThrottleValues != (numOfColumns - 1))
{
STFException.TraceWarning(stf, "Interpolator throttle vs. num of columns mismatch.");
errorFound = true;
}
if (numOfColumns < 3)
{
STFException.TraceWarning(stf, "Interpolator must have at least three columns.");
errorFound = true;
}
int numofData = 0;
string tableLabel = stf.ReadString().ToLower();
if (tableLabel == "table")
{
stf.MustMatch("(");
for (int i = 0; i < numOfRows; i++)
{
float x = stf.ReadFloat(STFReader.UNITS.SpeedDefaultMPH, 0);
numofData++;
for (int j = 0; j < numOfColumns - 1; j++)
{
if (j >= ilist.Count)
{
STFException.TraceWarning(stf, "Interpolator throttle vs. num of columns mismatch. (missing some throttle values)");
errorFound = true;
}
ilist[j][x] = stf.ReadFloat(STFReader.UNITS.Force, 0);
numofData++;
}
}
stf.SkipRestOfBlock();
}
else
{
STFException.TraceWarning(stf, "Interpolator didn't find a table to load.");
errorFound = true;
}
//check the table for inconsistencies
foreach (Interpolator checkMe in ilist)
{
if (checkMe.GetSize() != numOfRows)
{
STFException.TraceWarning(stf, "Interpolator has found a mismatch between num of rows declared and num of rows given.");
errorFound = true;
}
float dx = (checkMe.MaxX() - checkMe.MinX()) * 0.1f;
if (dx <= 0f)
{
STFException.TraceWarning(stf, "Interpolator has found X data error - x values must be increasing. (Possible row number mismatch)");
errorFound = true;
}
else
{
for (float x = checkMe.MinX(); x <= checkMe.MaxX(); x += dx)
{
if ((checkMe[x] == float.NaN))
{
STFException.TraceWarning(stf, "Interpolator has found X data error - x values must be increasing. (Possible row number mismatch)");
errorFound = true;
break;
}
}
}
}
if (numofData != (numOfRows * numOfColumns))
{
STFException.TraceWarning(stf, "Interpolator has found a mismatch: num of data doesn't fit the header information.");
errorFound = true;
}
}
else
{
STFException.TraceWarning(stf, "Interpolator must have a 'throttle' header row.");
errorFound = true;
}
stf.SkipRestOfBlock();
}
else
{
stf.MustMatch("(");
while (!stf.EndOfBlock())
{
xlist.Add(stf.ReadFloat(STFReader.UNITS.Any, null));
ilist.Add(new Interpolator(stf));
}
}
int n = xlist.Count;
if (n < 2)
{
STFException.TraceWarning(stf, "Interpolator must have at least two x values.");
errorFound = true;
}
X = new float[n];
Y = new Interpolator[n];
Size = n;
for (int i = 0; i < n; i++)
{
X[i] = xlist[i];
Y[i] = ilist[i];
if (i > 0 && X[i - 1] >= X[i])
{
STFException.TraceWarning(stf, "Interpolator x values must be increasing.");
}
}
//stf.SkipRestOfBlock();
if (errorFound)
{
STFException.TraceWarning(stf, "Errors found in the Interpolator definition!!! The Interpolator will not work correctly!");
}
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
/// <param name="orMode">Process SignalType for ORTS mode (always set NumClearAhead_ORTS only)</param>
public SignalType(STFReader stf, bool orMode)
: this()
{
stf.MustMatchBlockStart();
Name = stf.ReadString().ToLowerInvariant();
int numClearAhead = -2;
int numdefs = 0;
string ortsFunctionType = string.Empty;
string ortsNormalSubType = string.Empty;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsscript", () => { Script = stf.ReadStringBlock("").ToLowerInvariant(); }),
new STFReader.TokenProcessor("signalfntype", () => {
if (orMode)
{
ortsFunctionType = ReadOrtsFunctionType(stf);
}
else
{
FunctionType = ReadFunctionType(stf);
}
}),
new STFReader.TokenProcessor("signallighttex", () => { LightTextureName = stf.ReadStringBlock("").ToLowerInvariant(); }),
new STFReader.TokenProcessor("signallights", () => { Lights = ReadLights(stf); }),
new STFReader.TokenProcessor("signaldrawstates", () => { DrawStates = ReadDrawStates(stf); }),
new STFReader.TokenProcessor("signalaspects", () => { Aspects = ReadAspects(stf); }),
new STFReader.TokenProcessor("approachcontrolsettings", () => { ApproachControlDetails = ReadApproachControlDetails(stf); }),
new STFReader.TokenProcessor("signalnumclearahead", () => { numClearAhead = numClearAhead >= -1 ? numClearAhead : stf.ReadIntBlock(null); numdefs++; }),
new STFReader.TokenProcessor("semaphoreinfo", () => { SemaphoreInfo = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("ortsdayglow", () => { DayGlow = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("ortsnightglow", () => { NightGlow = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("ortsdaylight", () => { DayLight = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("ortsnormalsubtype", () => { ortsNormalSubType = ReadOrtsNormalSubType(stf); }),
new STFReader.TokenProcessor("ortsonofftime", () => { TransitionTime = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("sigflashduration", () => {
stf.MustMatchBlockStart();
FlashTimeOn = stf.ReadFloat(STFReader.Units.None, null);
FlashTimeOff = stf.ReadFloat(STFReader.Units.None, null);
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "abs": Abs = true; break;
case "no_gantry": NoGantry = true; break;
case "semaphore": Semaphore = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown SignalType flag " + stf.ReadString()); break;
}
}
}),
});
if (orMode)
{
// set related MSTS function type
OrtsFunctionTypeIndex = OrSignalTypes.Instance.FunctionTypes.FindIndex(i => StringComparer.OrdinalIgnoreCase.Equals(i, ortsFunctionType));
if (!EnumExtension.GetValue(ortsFunctionType, out SignalFunction functionType))
{
FunctionType = SignalFunction.Info;
}
else
{
FunctionType = functionType;
}
// set index for Normal Subtype
OrtsNormalSubTypeIndex = OrSignalTypes.Instance.NormalSubTypes.FindIndex(i => StringComparer.OrdinalIgnoreCase.Equals(i, ortsNormalSubType));
// set SNCA
NumClearAhead_MSTS = -2;
NumClearAhead_ORTS = numClearAhead;
}
else
{
// set defaulted OR function type
OrtsFunctionTypeIndex = (int)FunctionType;
// set SNCA
NumClearAhead_MSTS = numdefs == 1 ? numClearAhead : -2;
NumClearAhead_ORTS = numdefs == 2 ? numClearAhead : -2;
}
}
public void Parse(string lowercasetoken, STFReader stf)
{
string temp = "";
switch (lowercasetoken)
{
case "engine(gearboxnumberofgears": GearBoxNumberOfGears = stf.ReadIntBlock(1); initLevel++; break;
case "engine(gearboxdirectdrivegear": GearBoxDirectDriveGear = stf.ReadIntBlock(1); break; // initLevel++; break;
case "engine(gearboxoperation":
temp = stf.ReadStringBlock("manual");
switch (temp)
{
case "manual": GearBoxOperation = GearBoxOperation.Manual; break;
case "automatic": GearBoxOperation = GearBoxOperation.Automatic; break;
case "semiautomatic": GearBoxOperation = GearBoxOperation.Semiautomatic; break;
}
initLevel++;
break;
case "engine(gearboxenginebraking":
temp = stf.ReadStringBlock("none");
switch (temp)
{
case "none": GearBoxEngineBraking = GearBoxEngineBraking.None; break;
case "all_gears": GearBoxEngineBraking = GearBoxEngineBraking.AllGears; break;
case "direct_drive": GearBoxEngineBraking = GearBoxEngineBraking.DirectDrive; break;
}
initLevel++;
break;
case "engine(gearboxmaxspeedforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxSpeedForGearsMpS.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxSpeedForGearsMpS.Add(stf.ReadFloat(STFReader.UNITS.SpeedDefaultMPH, 10.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(gearboxmaxtractiveforceforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxTractiveForceForGearsN.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxTractiveForceForGearsN.Add(stf.ReadFloat(STFReader.UNITS.Force, 10000.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(gearboxoverspeedpercentageforfailure": GearBoxOverspeedPercentageForFailure = stf.ReadFloatBlock(STFReader.UNITS.None, 150f); break; // initLevel++; break;
case "engine(gearboxbackloadforce": GearBoxBackLoadForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxcoastingforce": GearBoxCoastingForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxupgearproportion": GearBoxUpGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.85f); break; // initLevel++; break;
case "engine(gearboxdowngearproportion": GearBoxDownGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.25f); break; // initLevel++; break;
default: break;
}
}
public void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "engine(trainbrakescontrollermaxsystempressure":
case "engine(enginebrakescontrollermaxsystempressure":
MaxPressurePSI = stf.ReadFloatBlock(STFReader.Units.PressureDefaultPSI, null);
break;
case "engine(trainbrakescontrollermaxreleaserate":
case "engine(enginebrakescontrollermaxreleaserate":
ReleaseRatePSIpS = stf.ReadFloatBlock(STFReader.Units.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrollermaxquickreleaserate":
case "engine(enginebrakescontrollermaxquickreleaserate":
QuickReleaseRatePSIpS = stf.ReadFloatBlock(STFReader.Units.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrollermaxapplicationrate":
case "engine(enginebrakescontrollermaxapplicationrate":
ApplyRatePSIpS = stf.ReadFloatBlock(STFReader.Units.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrolleremergencyapplicationrate":
case "engine(enginebrakescontrolleremergencyapplicationrate":
EmergencyRatePSIpS = stf.ReadFloatBlock(STFReader.Units.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrollerfullservicepressuredrop":
case "engine(enginebrakescontrollerfullservicepressuredrop":
FullServReductionPSI = stf.ReadFloatBlock(STFReader.Units.PressureDefaultPSI, null);
break;
case "engine(trainbrakescontrollerminpressurereduction":
case "engine(enginebrakescontrollerminpressurereduction":
MinReductionPSI = stf.ReadFloatBlock(STFReader.Units.PressureDefaultPSI, null);
break;
case "engine(enginecontrollers(brake_train":
case "engine(enginecontrollers(brake_engine":
stf.MustMatch("(");
MinimumValue = stf.ReadFloat(STFReader.Units.None, null);
MaximumValue = stf.ReadFloat(STFReader.Units.None, null);
StepSize = stf.ReadFloat(STFReader.Units.None, null);
CurrentValue = stf.ReadFloat(STFReader.Units.None, null);
string token = stf.ReadItem(); // s/b numnotches
if (string.Compare(token, "NumNotches", true) != 0) // handle error in gp38.eng where extra parameter provided before NumNotches statement
{
stf.ReadItem();
}
stf.MustMatch("(");
stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("notch", () => {
stf.MustMatch("(");
float value = stf.ReadFloat(STFReader.Units.None, null);
int smooth = stf.ReadInt(null);
string type = stf.ReadString();
Notches.Add(new MSTSNotch(value, smooth, type, stf));
if (type != ")")
{
stf.SkipRestOfBlock();
}
}),
});
break;
case "engine(ortstrainbrakecontroller":
case "engine(ortsenginebrakecontroller":
if (Locomotive.Train as AITrain == null)
{
ScriptName = stf.ReadStringBlock(null);
}
break;
}
}
internal SkyLayer(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_sky_layer_fadein", () => { stf.MustMatchBlockStart(); FadeinStartTime = stf.ReadString(); FadeinEndTime = stf.ReadString(); stf.SkipRestOfBlock(); }),
new STFReader.TokenProcessor("world_anim_shader", () => { stf.MustMatchBlockStart(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_anim_shader_frames", () => { stf.MustMatchBlockStart(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_anim_shader_frame", () => { stf.MustMatchBlockStart(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_anim_shader_frame_uvtiles", () => { stf.MustMatchBlockStart(); TileX = stf.ReadFloat(STFReader.Units.Any, 1.0f); TileY = stf.ReadFloat(STFReader.Units.Any, 1.0f); stf.ParseBlock(Array.Empty <STFReader.TokenProcessor>()
); }),
}); }),
}); }),
new STFReader.TokenProcessor("world_shader", () => { stf.MustMatchBlockStart(); TextureMode = stf.ReadString(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("terrain_texslots", () => { stf.MustMatchBlockStart(); stf.ReadInt(null) /*Count*/; stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("terrain_texslot", () => { stf.MustMatchBlockStart(); TextureName = stf.ReadString(); stf.SkipRestOfBlock(); }),
}); }),
}); }),
}); }),
});
}
