public void Parse(STFReader stf) { stf.MustMatch("("); MinimumValue = stf.ReadFloat(STFReader.UNITS.None, null); MaximumValue = stf.ReadFloat(STFReader.UNITS.None, null); StepSize = stf.ReadFloat(STFReader.UNITS.None, null); IntermediateValue = 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(); } }), }); SetValue(CurrentValue); }
public override SBR ReadSubBlock() { UnicodeBlockReader block = new UnicodeBlockReader(); block.f = f; string token = f.ReadItem(); if (token == "(") { // ie 310.eng Line 349 (#_fire temp, fire mass, water mass, boil ... block.ID = TokenID.comment; return(block); } // parse token block.ID = GetTokenID(token); if (token == ")") { TraceWarning("Ignored extra close bracket"); return(block); } // now look for optional label, ie matrix MAIN ( .... token = f.ReadItem(); if (token != "(") { block.Label = token; f.VerifyStartOfBlock(); } return(block); }
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(); }
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(); }
/// <summary> /// Parses parameters from the stf reader /// </summary> /// <param name="stf">Reference to the stf reader</param> /// <param name="loco">Reference to the locomotive</param> public virtual void Parse(STFReader stf, MSTSDieselLocomotive loco) { locomotive = loco; stf.MustMatch("("); bool end = false; while (!end) { string lowercasetoken = stf.ReadItem().ToLower(); switch (lowercasetoken) { case "idlerpm": IdleRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.IdleRPM; break; case "maxrpm": MaxRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.MaxRPM; break; case "startingrpm": StartingRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.StartingRPM; break; case "startingconfirmrpm": StartingConfirmationRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.StartingConfirmRPM; break; case "changeuprpmps": ChangeUpRPMpS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.ChangeUpRPMpS; break; case "changedownrpmps": ChangeDownRPMpS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.ChangeDownRPMpS; break; case "rateofchangeuprpmpss": RateOfChangeUpRPMpSS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.RateOfChangeUpRPMpSS; break; case "rateofchangedownrpmpss": RateOfChangeDownRPMpSS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.RateOfChangeDownRPMpSS; break; case "maximalpower": MaximalPowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, 0); initLevel |= SettingsFlags.MaximalPowerW; break; case "idleexhaust": InitialExhaust = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.IdleExhaust; break; case "maxexhaust": MaxExhaust = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.MaxExhaust; break; case "exhaustdynamics": ExhaustAccelIncrease = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.ExhaustDynamics; break; case "exhaustdynamicsdown": ExhaustDecelReduction = stf.ReadFloatBlock(STFReader.UNITS.None, null); initLevel |= SettingsFlags.ExhaustDynamics; break; case "exhaustcolor": ExhaustSteadyColor.PackedValue = stf.ReadHexBlock(Color.Gray.PackedValue); initLevel |= SettingsFlags.ExhaustColor; break; case "exhausttransientcolor": ExhaustTransientColor.PackedValue = stf.ReadHexBlock(Color.Black.PackedValue); initLevel |= SettingsFlags.ExhaustTransientColor; break; case "dieselpowertab": DieselPowerTab = new Interpolator(stf); initLevel |= SettingsFlags.DieselPowerTab; break; case "dieselconsumptiontab": DieselConsumptionTab = new Interpolator(stf); initLevel |= SettingsFlags.DieselConsumptionTab; break; case "throttlerpmtab": ThrottleRPMTab = new Interpolator(stf); initLevel |= SettingsFlags.ThrottleRPMTab; break; case "dieseltorquetab": DieselTorqueTab = new Interpolator(stf); initLevel |= SettingsFlags.DieselTorqueTab; break; case "minoilpressure": DieselMinOilPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, 40f); initLevel |= SettingsFlags.MinOilPressure; break; case "maxoilpressure": DieselMaxOilPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, 120f); initLevel |= SettingsFlags.MaxOilPressure; break; case "maxtemperature": DieselMaxTemperatureDeg = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 100f); initLevel |= SettingsFlags.MaxTemperature; break; case "cooling": EngineCooling = (Cooling)stf.ReadIntBlock((int)Cooling.Proportional); initLevel |= SettingsFlags.Cooling; break; //ReadInt changed to ReadIntBlock case "temptimeconstant": DieselTempTimeConstantSec = stf.ReadFloatBlock(STFReader.UNITS.Time, 720f); initLevel |= SettingsFlags.TempTimeConstant; break; case "opttemperature": DieselOptimalTemperatureDegC = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 95f); initLevel |= SettingsFlags.OptTemperature; break; case "idletemperature": DieselIdleTemperatureDegC = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 75f); initLevel |= SettingsFlags.IdleTemperature; break; default: end = true; 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; } }
/// <summary> /// Reads RailDriver calibration data from a ModernCalibration.rdm file /// This file is not in the usual STF format, but the STFReader can handle it okay. /// </summary> /// <param name="basePath"></param> void ReadCalibrationData(string basePath) { string file = basePath + "\\ModernCalibration.rdm"; if (!File.Exists(file)) { RegistryKey RK = Registry.LocalMachine.OpenSubKey("SOFTWARE\\PI Engineering\\PIBUS"); if (RK != null) { string dir = (string)RK.GetValue("RailDriver", null, RegistryValueOptions.None); if (dir != null) { file = dir + "\\..\\controller\\ModernCalibration.rdm"; } } if (!File.Exists(file)) { SetLEDs(0, 0, 0); Trace.TraceWarning("Cannot find RailDriver calibration file {0}", file); return; } } // TODO: This is... kinda weird and cool at the same time. STF parsing being used on RailDriver's calebration file. Probably should be a dedicated parser, though. STFReader reader = new STFReader(file, false); while (!reader.Eof) { string token = reader.ReadItem(); if (token == "Position") { string name = reader.ReadItem(); int min = -1; int max = -1; while (token != "}") { token = reader.ReadItem(); if (token == "Min") { min = reader.ReadInt(-1); } else if (token == "Max") { max = reader.ReadInt(-1); } } if (min >= 0 && max >= 0) { float v = .5f * (min + max); switch (name) { case "Full Reversed": FullReversed = v; break; case "Neutral": Neutral = v; break; case "Full Forward": FullForward = v; break; case "Full Throttle": FullThrottle = v; break; case "Throttle Idle": ThrottleIdle = v; break; case "Dynamic Brake": DynamicBrake = v; break; case "Dynamic Brake Setup": DynamicBrakeSetup = v; break; case "Auto Brake Released": AutoBrakeRelease = v; break; case "Full Auto Brake (CS)": FullAutoBrake = v; break; case "Emergency Brake (EMG)": EmergencyBrake = v; break; case "Independent Brake Released": IndependentBrakeRelease = v; break; case "Bail Off Engaged (in Released position)": BailOffEngagedRelease = v; break; case "Independent Brake Full": IndependentBrakeFull = v; break; case "Bail Off Engaged (in Full position)": BailOffEngagedFull = v; break; case "Bail Off Disengaged (in Released position)": BailOffDisengagedRelease = v; break; case "Bail Off Disengaged (in Full position)": BailOffDisengagedFull = v; break; case "Rotary Switch 1-Position 1(OFF)": Rotary1Position1 = v; break; case "Rotary Switch 1-Position 2(SLOW)": Rotary1Position2 = v; break; case "Rotary Switch 1-Position 3(FULL)": Rotary1Position3 = v; break; case "Rotary Switch 2-Position 1(OFF)": Rotary2Position1 = v; break; case "Rotary Switch 2-Position 2(DIM)": Rotary2Position2 = v; break; case "Rotary Switch 2-Position 3(FULL)": Rotary2Position3 = v; break; default: STFException.TraceInformation(reader, "Skipped unknown calibration value " + name); 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; 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; } }