// 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; } }