// SigSubJnLinkIf is not supported
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalSubObj(STFReader stf)
{
SignalSubType = -1; // not (yet) specified
stf.MustMatch("(");
Index = stf.ReadInt(null);
MatrixName = stf.ReadString().ToUpper();
Description = stf.ReadString();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("sigsubtype", () => { SignalSubType = SignalSubTypes.IndexOf(stf.ReadStringBlock(null).ToUpper()); }),
new STFReader.TokenProcessor("sigsubstype", () => { SignalSubSignalType = stf.ReadStringBlock(null).ToLowerInvariant(); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "optional": Optional = true; break;
case "default": Default = true; break;
case "back_facing": BackFacing = true; break;
case "jn_link": JunctionLink = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown SignalSubObj flag " + stf.ReadString()); break;
}
}
}),
});
}
internal ActivitySound(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsactsoundfile", () =>
{
stf.MustMatchBlockStart();
string soundFile = stf.ReadString();
SoundFile = Path.Combine(FolderStructure.RouteFromActivity(stf.FileName).SoundFile(soundFile));
if (!EnumExtension.GetValue(stf.ReadString(), out OrtsActivitySoundFileType soundFileType))
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown activity sound file type " + stf.ReadString());
SoundFileType = OrtsActivitySoundFileType.None;
}
else
{
SoundFileType = soundFileType;
}
stf.MustMatchBlockEnd();
}),
new STFReader.TokenProcessor("ortssoundlocation", () => {
stf.MustMatchBlockStart();
location = new WorldLocation(stf.ReadInt(null), stf.ReadInt(null),
stf.ReadFloat(STFReader.Units.None, null), stf.ReadFloat(STFReader.Units.None, null), stf.ReadFloat(STFReader.Units.None, null));
stf.MustMatchBlockEnd();
}),
});
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalLight(STFReader stf)
{
stf.MustMatchBlockStart();
Index = stf.ReadInt(null);
Name = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("radius", () => { Radius = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("position", () => {
stf.MustMatchBlockStart();
position = new Vector3(stf.ReadFloat(null), stf.ReadFloat(null), stf.ReadFloat(null));
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "semaphore_change":
SemaphoreChange = true;
break;
default:
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown SignalLight flag " + stf.ReadString());
break;
}
}
}),
});
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
/// <param name="ORTSMode">Process SignalType for ORTS mode (always set NumClearAhead_ORTS only)</param>
public SignalType(STFReader stf, bool ORTSMode)
: this()
{
stf.MustMatch("(");
Name = stf.ReadString().ToLowerInvariant();
int numClearAhead = -2;
int numdefs = 0;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("signalfntype", () => { FnType = ReadFnType(stf); }), //[Rob Roeterdink] value was not passed
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("sigflashduration", () => {
stf.MustMatch("(");
FlashTimeOn = stf.ReadFloat(STFReader.UNITS.None, null);
FlashTimeOff = stf.ReadFloat(STFReader.UNITS.None, null);
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
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 (ORTSMode)
{
// In ORTS mode : always set value for NumClearAhead_ORTS
NumClearAhead_MSTS = -2;
NumClearAhead_ORTS = numClearAhead;
}
else
{
// In MSTS mode : if one line for SignalNumClearAhead defined, set value for NumClearAhead_MSTS, otherwise set value for NumClearAhead_ORTS
NumClearAhead_MSTS = numdefs == 1 ? numClearAhead : -2;
NumClearAhead_ORTS = numdefs == 2 ? numClearAhead : -2;
}
}
protected void ParseUnits(STFReader stf)
{
stf.MustMatchBlockStart();
string units = stf.ReadItem().Replace('/', '_');
if (!EnumExtension.GetValue(units, out CabViewControlUnit unit))
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlUnit " + stf.ReadItem());
ControlUnit = CabViewControlUnit.None;
}
ControlUnit = unit;
stf.SkipRestOfBlock();
}
public EsdBoundingBox(STFReader stf)
{
stf.MustMatchBlockStart();
string item = stf.ReadString();
if (item == ")")
{
return; // quietly return on ESD_Bounding_Box()
}
stf.StepBackOneItem();
min = new Vector3(stf.ReadFloat(null), stf.ReadFloat(null), stf.ReadFloat(null));
max = new Vector3(stf.ReadFloat(null), stf.ReadFloat(null), stf.ReadFloat(null));
// JP2indirt.sd has extra parameters
stf.SkipRestOfBlock();
}
protected void ParseType(STFReader stf)
{
stf.MustMatch("(");
try
{
ControlType = (CABViewControlTypes)Enum.Parse(typeof(CABViewControlTypes), stf.ReadString());
}
catch (ArgumentException)
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlType " + stf.ReadString());
ControlType = CABViewControlTypes.NONE;
}
//stf.ReadItem(); // Skip repeated Class Type
stf.SkipRestOfBlock();
}
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();
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalAspect(STFReader stf)
{
SpeedLimit = -1;
stf.MustMatchBlockStart();
string aspectName = stf.ReadString();
if (!EnumExtension.GetValue(aspectName, out SignalAspectState aspect))
{
STFException.TraceInformation(stf, "Skipped unknown signal aspect " + aspectName);
Aspect = SignalAspectState.Unknown;
}
else
{
Aspect = aspect;
}
DrawStateName = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("speedmph", () => { SpeedLimit = (float)Speed.MeterPerSecond.FromMpH(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { SpeedLimit = (float)Speed.MeterPerSecond.FromKpH(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
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;
}
}
}),
});
}
protected void ParseStyle(STFReader stf)
{
stf.MustMatchBlockStart();
string styleTemp = stf.ReadString();
if (char.IsDigit(styleTemp[0]))
{
styleTemp = (styleTemp + styleTemp.Substring(0, 2)).Remove(0, 2);
}
if (!EnumExtension.GetValue(styleTemp, out CabViewControlStyle style))
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlStyle " + stf.ReadString());
ControlStyle = CabViewControlStyle.None;
}
ControlStyle = style;
stf.SkipRestOfBlock();
}
protected void ParseUnits(STFReader stf)
{
stf.MustMatch("(");
try
{
string sUnits = stf.ReadItem();
// sUnits = sUnits.Replace('/', '?');
sUnits = sUnits.Replace('/', '_');
Units = (CABViewControlUnits)Enum.Parse(typeof(CABViewControlUnits), sUnits);
}
catch (ArgumentException)
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlStyle " + stf.ReadItem());
Units = CABViewControlUnits.NONE;
}
stf.SkipRestOfBlock();
}
// SigSubJnLinkIf is not supported
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
internal SignalSubObject(STFReader stf)
{
SignalSubType = SignalSubType.None;
stf.MustMatchBlockStart();
Index = stf.ReadInt(null);
MatrixName = stf.ReadString().ToUpperInvariant();
Description = stf.ReadString();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("sigsubtype", () => {
if (EnumExtension.GetValue(stf.ReadStringBlock(null), out SignalSubType subType))
{
SignalSubType = subType;
}
}),
new STFReader.TokenProcessor("sigsubstype", () => { SignalSubSignalType = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToUpperInvariant())
{
case "OPTIONAL":
Optional = true;
break;
case "DEFAULT":
Default = true; break;
case "BACK_FACING":
BackFacing = true;
break;
case "JN_LINK":
JunctionLink = true;
break;
default:
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown SignalSubObj flag " + stf.ReadString());
break;
}
}
}),
});
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalDrawLight(STFReader stf)
{
stf.MustMatch("(");
LightIndex = stf.ReadUInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "flashing": Flashing = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown DrawLight flag " + stf.ReadString()); break;
}
}
}),
});
}
protected void ParseStyle(STFReader stf)
{
stf.MustMatch("(");
try
{
string sStyle = stf.ReadString();
int checkNumeric = 0;
if (int.TryParse(sStyle.Substring(0, 1), out checkNumeric) == true)
{
sStyle = sStyle.Insert(0, "_");
}
ControlStyle = (CABViewControlStyles)Enum.Parse(typeof(CABViewControlStyles), sStyle);
}
catch (ArgumentException)
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlStyle " + stf.ReadString());
ControlStyle = CABViewControlStyles.NONE;
}
stf.SkipRestOfBlock();
}
/// <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;
}
}
}),
});
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
internal SignalDrawLight(STFReader stf)
{
stf.MustMatchBlockStart();
Index = stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToUpperInvariant())
{
case "FLASHING":
Flashing = true;
break;
default:
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown DrawLight flag " + stf.ReadString());
break;
}
}
}),
});
}
/// <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;
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 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;
}
}
