protected void ParsePosition(STFReader stf) { stf.MustMatch("("); PositionX = stf.ReadDouble(null); PositionY = stf.ReadDouble(null); Width = stf.ReadDouble(null); Height = stf.ReadDouble(null); // Handling middle values while (!stf.EndOfBlock()) { STFException.TraceWarning(stf, "Ignored additional positional parameters"); Width = Height; Height = stf.ReadInt(null); } }
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 FreightAnimationContinuous(STFReader stf, MSTSWagon wagon) { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("intakepoint", () => { wagon.IntakePointList.Add(new IntakePoint(stf)); wagon.IntakePointList.Last().LinkedFreightAnim = this; LinkedIntakePoint = wagon.IntakePointList.Last(); }), new STFReader.TokenProcessor("shape", () => { ShapeFileName = stf.ReadStringBlock(null); }), new STFReader.TokenProcessor("maxheight", () => { MaxHeight = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0); }), new STFReader.TokenProcessor("minheight", () => { MinHeight = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0); }), new STFReader.TokenProcessor("freightweightwhenfull", () => { FreightWeightWhenFull = stf.ReadFloatBlock(STFReader.UNITS.Mass, 0); }), new STFReader.TokenProcessor("fullatstart", () => { FullAtStart = stf.ReadBoolBlock(true); }), }); }
internal Services(STFReader stf) { stf.MustMatchBlockStart(); Name = stf.ReadString(); Time = (int)stf.ReadFloat(STFReader.Units.Time, null); stf.MustMatch("uid"); UiD = stf.ReadIntBlock(null); // Clumsy parsing. You only get a new Service_Item in the list after a PlatformStartId is met. // Blame lies with Microsoft for poor design of syntax. stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("efficiency", () => { efficiency = stf.ReadFloatBlock(STFReader.Units.Any, null); }), new STFReader.TokenProcessor("skipcount", () => { skipCount = stf.ReadIntBlock(null); }), new STFReader.TokenProcessor("distancedownpath", () => { distanceDownPath = stf.ReadFloatBlock(STFReader.Units.Distance, null); }), new STFReader.TokenProcessor("platformstartid", () => { platformStartID = stf.ReadIntBlock(null); Add(new TrafficItem(efficiency, skipCount, distanceDownPath, platformStartID)); }), }); }
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(); }
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(); }
public CVCFirebox(STFReader stf, string basepath) { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("type", () => { ParseType(stf); }), new STFReader.TokenProcessor("position", () => { ParsePosition(stf); }), new STFReader.TokenProcessor("graphic", () => { ParseFireACEFile(stf, basepath); }), new STFReader.TokenProcessor("fuelcoal", () => { ParseGraphic(stf, basepath); }), }); Direction = 1; Orientation = 1; MaxValue = 1; MinValue = 0; ControlStyle = CABViewControlStyles.POINTER; Area = new Rectangle(0, 0, (int)Width, (int)Height); PositionY += Height / 2; }
static IList <SignalDrawLight> ReadDrawLights(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); List <SignalDrawLight> drawLights = new List <SignalDrawLight>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("drawlight", () => { if (drawLights.Count >= drawLights.Capacity) { STFException.TraceWarning(stf, "Skipped extra DrawLight"); } else { drawLights.Add(new SignalDrawLight(stf)); } }), }); return(drawLights); }
public Traffic_Service_Definition(STFReader stf) { var arrivalTime = 0; var departTime = 0; var skipCount = 0; var distanceDownPath = 0F; var platformStartID = 0; stf.MustMatch("("); Service_Definition = stf.ReadString(); Time = stf.ReadInt(null); // Cannot use stt.ReadFloat(STFReader.UNITS.Time, null) as number will be followed by "arrivaltime" stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("arrivaltime", () => { arrivalTime = (int)stf.ReadFloatBlock(STFReader.UNITS.Time, null); }), new STFReader.TokenProcessor("departtime", () => { departTime = (int)stf.ReadFloatBlock(STFReader.UNITS.Time, null); }), new STFReader.TokenProcessor("skipcount", () => { skipCount = stf.ReadIntBlock(null); }), new STFReader.TokenProcessor("distancedownpath", () => { distanceDownPath = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }), new STFReader.TokenProcessor("platformstartid", () => { platformStartID = stf.ReadIntBlock(null); TrafficDetails.Add(new Traffic_Traffic_Item(arrivalTime, departTime, skipCount, distanceDownPath, platformStartID)); }), }); }
public Tr_HazardFile(STFReader stf) { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("filename", () => { FileName = stf.ReadStringBlock(null); }), new STFReader.TokenProcessor("workers", () => { Workers = stf.ReadStringBlock(null); }), new STFReader.TokenProcessor("distance", () => { Distance = stf.ReadFloatBlock(STFReader.UNITS.None, 10); }), new STFReader.TokenProcessor("speed", () => { Speed = stf.ReadFloatBlock(STFReader.UNITS.None, 3); }), new STFReader.TokenProcessor("idle_key", () => { Idle_Key = stf.ReadVector2Block(STFReader.UNITS.None, Idle_Key); }), new STFReader.TokenProcessor("idle_key2", () => { Idle_Key2 = stf.ReadVector2Block(STFReader.UNITS.None, Idle_Key2); }), new STFReader.TokenProcessor("surprise_key_left", () => { Surprise_Key_Left = stf.ReadVector2Block(STFReader.UNITS.None, Surprise_Key_Left); }), new STFReader.TokenProcessor("surprise_key_right", () => { Surprise_Key_Right = stf.ReadVector2Block(STFReader.UNITS.None, Surprise_Key_Right); }), new STFReader.TokenProcessor("success_scarper_key", () => { Success_Scarper_Key = stf.ReadVector2Block(STFReader.UNITS.None, Success_Scarper_Key); }), }); //TODO This should be changed to STFException.TraceError() with defaults values created if (FileName == null) { throw new STFException(stf, "Missing FileName"); } }
public TrackShape(STFReader stf) { stf.MustMatch("("); ShapeIndex = stf.ReadUInt(null); int nextPath = 0; stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("filename", () => { FileName = stf.ReadStringBlock(null); }), new STFReader.TokenProcessor("numpaths", () => { SectionIdxs = new SectionIdx[NumPaths = stf.ReadUIntBlock(null)]; }), new STFReader.TokenProcessor("mainroute", () => { MainRoute = stf.ReadUIntBlock(null); }), new STFReader.TokenProcessor("clearancedist", () => { ClearanceDistance = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }), new STFReader.TokenProcessor("sectionidx", () => { SectionIdxs[nextPath++] = new SectionIdx(stf); }), new STFReader.TokenProcessor("tunnelshape", () => { TunnelShape = stf.ReadBoolBlock(true); }), new STFReader.TokenProcessor("roadshape", () => { RoadShape = stf.ReadBoolBlock(true); }), }); // TODO - this was removed since TrackShape( 183 ) is blank //if( FileName == null ) throw( new STFError( stf, "Missing FileName" ) ); //if( SectionIdxs == null ) throw( new STFError( stf, "Missing SectionIdxs" ) ); //if( NumPaths == 0 ) throw( new STFError( stf, "No Paths in TrackShape" ) ); }
public Triggers(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("dist_travelled_trigger", () => { Add(new Dist_Travelled_Trigger(stf)); }), new STFReader.TokenProcessor("discrete_trigger", () => { Add(new Discrete_Trigger(stf)); }), new STFReader.TokenProcessor("random_trigger", () => { Add(new Random_Trigger(stf)); }), new STFReader.TokenProcessor("variable_trigger", () => { Add(new Variable_Trigger(stf)); }), new STFReader.TokenProcessor("initial_trigger", () => { Add(new Initial_Trigger(stf)); }), }); foreach (Trigger trigger in this) { if (trigger.SoundCommand == null) { STFException.TraceWarning(stf, "Trigger lacks a sound command"); } } }
public LightCollection(STFReader stf) { stf.MustMatch("("); stf.ReadInt(null); // count; ignore this because its not always correct stf.ParseBlock(new[] { new STFReader.TokenProcessor("light", () => { Lights.Add(new Light(Lights.Count, stf)); }), }); if (Lights.Count == 0) { throw new InvalidDataException("lights with no lights"); } // MSTSBin created reverse headlight cones automatically, so we shall do so too. foreach (var light in Lights.ToArray()) { if (light.Type == LightType.Cone) { Lights.Add(new Light(light, true)); } } }
public MonitoringDevice(STFReader stf) { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("monitoringdevicemonitortimelimit", () => { MonitorTimeS = stf.ReadFloatBlock(STFReader.UNITS.Time, MonitorTimeS); }), new STFReader.TokenProcessor("monitoringdevicealarmtimelimit", () => { AlarmTimeS = stf.ReadFloatBlock(STFReader.UNITS.Time, AlarmTimeS); }), new STFReader.TokenProcessor("monitoringdevicepenaltytimelimit", () => { PenaltyTimeS = stf.ReadFloatBlock(STFReader.UNITS.Time, PenaltyTimeS); }), new STFReader.TokenProcessor("monitoringdeviceappliescutspower", () => { EmergencyCutsPower = stf.ReadBoolBlock(EmergencyCutsPower); }), new STFReader.TokenProcessor("monitoringdeviceappliesshutsdownengine", () => { EmergencyShutsDownEngine = stf.ReadBoolBlock(EmergencyShutsDownEngine); }), new STFReader.TokenProcessor("monitoringdeviceresetonzerospeed", () => { ResetOnZeroSpeed = stf.ReadBoolBlock(ResetOnZeroSpeed); }), new STFReader.TokenProcessor("monitoringdeviceresetonresetbutton", () => { ResetOnResetButton = stf.ReadBoolBlock(ResetOnResetButton); }), new STFReader.TokenProcessor("monitoringdevicetriggeronoverspeed", () => { TriggerOnOverspeedMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, TriggerOnOverspeedMpS); }), new STFReader.TokenProcessor("monitoringdevicetriggerontrackoverspeed", () => { TriggerOnTrackOverspeed = stf.ReadBoolBlock(TriggerOnTrackOverspeed); }), new STFReader.TokenProcessor("monitoringdevicetriggerontrackoverspeedmargin", () => { TriggerOnTrackOverspeedMarginMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, TriggerOnTrackOverspeedMarginMpS); }), new STFReader.TokenProcessor("monitoringdevicecriticallevel", () => { CriticalLevelMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, CriticalLevelMpS); }), new STFReader.TokenProcessor("monitoringdeviceresetlevel", () => { ResetLevelMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, ResetLevelMpS); }), new STFReader.TokenProcessor("monitoringdevicealarmtimebeforeoverspeed", () => { AlarmTimeBeforeOverspeedS = stf.ReadFloatBlock(STFReader.UNITS.Time, AlarmTimeBeforeOverspeedS); }), new STFReader.TokenProcessor("monitoringdeviceappliesfullbrake", () => { AppliesFullBrake = stf.ReadBoolBlock(AppliesFullBrake); }), new STFReader.TokenProcessor("monitoringdeviceappliesemergencybrake", () => { AppliesEmergencyBrake = stf.ReadBoolBlock(AppliesEmergencyBrake); }), }); }
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(); }
public TrackPath(STFReader stf) { stf.MustMatch("("); DynamicSectionIndex = stf.ReadUInt(null); NoSections = stf.ReadUInt(null); TrackSections = new uint[NoSections]; for (int i = 0; i < NoSections; ++i) { string token = stf.ReadString(); if (token == ")") { STFException.TraceWarning(stf, "Missing track section"); return; // there are many TSECTION.DAT's with missing sections so we will accept this error } if (!uint.TryParse(token, out TrackSections[i])) { STFException.TraceWarning(stf, "Invalid track section " + token); } } stf.SkipRestOfBlock(); }
public SMSStreams(STFReader stf) { stf.MustMatch("("); var count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("stream", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra Stream"); } else { Add(new SMSStream(stf)); } }), }); if (count > 0) { STFException.TraceWarning(stf, count + " missing Stream(s)"); } }
private void TryModify(int category, STFReader stf) { ActivityEvent origEvent; bool wrongEventID = false; int modifiedID = -1; try { stf.MustMatchBlockStart(); stf.MustMatch("id"); stf.MustMatchBlockStart(); modifiedID = stf.ReadInt(null); stf.MustMatchBlockEnd(); origEvent = Find(x => x.ID == modifiedID); if (origEvent == null) { wrongEventID = true; Trace.TraceWarning("Skipped event {0} not present in base activity file", modifiedID); stf.SkipRestOfBlock(); } else { wrongEventID = !TestMatch(category, origEvent); if (!wrongEventID) { origEvent.Update(stf); } else { Trace.TraceWarning("Skipped event {0} of event category not matching with base activity file", modifiedID); stf.SkipRestOfBlock(); } } } catch (Exception error) { Trace.WriteLine(new FileLoadException("Error in additional activity file", error)); } }
public LightState(STFReader stf) { stf.MustMatch("("); stf.ParseBlock(new[] { new STFReader.TokenProcessor("duration", () => { Duration = stf.ReadFloatBlock(STFReader.UNITS.None, null); }), new STFReader.TokenProcessor("lightcolour", () => { Color = stf.ReadHexBlock(null); }), new STFReader.TokenProcessor("position", () => { Position = stf.ReadVector3Block(STFReader.UNITS.None, Vector3.Zero); }), new STFReader.TokenProcessor("radius", () => { Radius = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }), new STFReader.TokenProcessor("azimuth", () => { Azimuth = stf.ReadVector3Block(STFReader.UNITS.None, Vector3.Zero); }), new STFReader.TokenProcessor("elevation", () => { Elevation = stf.ReadVector3Block(STFReader.UNITS.None, Vector3.Zero); }), new STFReader.TokenProcessor("transition", () => { Transition = 1 <= stf.ReadFloatBlock(STFReader.UNITS.None, 0); }), new STFReader.TokenProcessor("angle", () => { Angle = stf.ReadFloatBlock(STFReader.UNITS.None, null); }), }); // Color byte order changed in XNA 4 from BGRA to RGBA Color = new Color() { B = (byte)(Color), G = (byte)(Color >> 8), R = (byte)(Color >> 16), A = (byte)(Color >> 24) }.PackedValue; }
public override void Parse(string lowercasetoken, STFReader stf) { switch (lowercasetoken) { case "ortseot(level": stf.MustMatch("("); var eotLevel = stf.ReadString(); try { EOTLevel = (EOTLevel)Enum.Parse(typeof(EOTLevel), eotLevel.First().ToString().ToUpper() + eotLevel.Substring(1)); } catch { STFException.TraceWarning(stf, "Skipped unknown EOT Level " + eotLevel); } break; default: base.Parse(lowercasetoken, stf); break; } }
} // degrees public TrackSection(STFReader stf, bool routeTrackSection) { if (routeTrackSection) { stf.MustMatchBlockStart(); stf.MustMatch("SectionCurve"); stf.SkipBlock(); SectionIndex = stf.ReadUInt(null); float a = stf.ReadFloat(STFReader.Units.Distance, null); float b = stf.ReadFloat(STFReader.Units.None, null); if (b == 0) // Its straight { Length = a; } else // its curved { Radius = b; Angle = MathHelper.ToDegrees(a); Curved = true; } stf.SkipRestOfBlock(); } else { stf.MustMatchBlockStart(); SectionIndex = stf.ReadUInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("sectionsize", () => { ReadSectionSize(stf); }), new STFReader.TokenProcessor("sectioncurve", () => { ReadSectionCurve(stf); }), }); //if( SectionSize == null ) // throw( new STFError( stf, "Missing SectionSize" ) ); // note- default TSECTION.DAT does have some missing sections } }
/// <summary> /// Parses all the parameters within the ENG file /// </summary> /// <param name="stf">eference to the ENG file reader</param> public void Parse(STFReader stf, MSTSDieselLocomotive loco) { stf.MustMatch("("); int count = stf.ReadInt(0); for (int i = 0; i < count; i++) { string setting = stf.ReadString().ToLower(); if (setting == "diesel") { DEList.Add(new DieselEngine()); DEList[i].Parse(stf, loco); DEList[i].Initialize(true); } if ((!DEList[i].IsInitialized)) { STFException.TraceWarning(stf, "Diesel engine model has some errors - loading MSTS format"); DEList[i].InitFromMSTS((MSTSDieselLocomotive)Locomotive); DEList[i].Initialize(true); } } }
public CabViewControls(STFReader stf, string basepath) { stf.MustMatch("("); int count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("dial", () => { Add(new CVCDial(stf, basepath)); }), new STFReader.TokenProcessor("gauge", () => { Add(new CVCGauge(stf, basepath)); }), new STFReader.TokenProcessor("lever", () => { Add(new CVCDiscrete(stf, basepath)); }), new STFReader.TokenProcessor("twostate", () => { Add(new CVCDiscrete(stf, basepath)); }), new STFReader.TokenProcessor("tristate", () => { Add(new CVCDiscrete(stf, basepath)); }), new STFReader.TokenProcessor("multistatedisplay", () => { Add(new CVCMultiStateDisplay(stf, basepath)); }), new STFReader.TokenProcessor("cabsignaldisplay", () => { Add(new CVCSignal(stf, basepath)); }), new STFReader.TokenProcessor("digital", () => { Add(new CVCDigital(stf, basepath)); }), new STFReader.TokenProcessor("combinedcontrol", () => { Add(new CVCDiscrete(stf, basepath)); }), new STFReader.TokenProcessor("firebox", () => { Add(new CVCFirebox(stf, basepath)); }), new STFReader.TokenProcessor("digitalclock", () => { Add(new CVCDigitalClock(stf, basepath)); }) }); //TODO Uncomment when parsed all type /* * if (count != this.Count) STFException.ReportWarning(inf, "CabViewControl count mismatch"); */ }
/// <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; } }
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 ReleaseLoopReleaseWithJump(STFReader f) { f.MustMatch("("); f.SkipRestOfBlock(); }
public DisableTrigger(STFReader f) { f.MustMatch("("); TriggerID = f.ReadInt(null); f.SkipRestOfBlock(); }
public SetStreamVolume(STFReader f) { f.MustMatch("("); Volume = f.ReadFloat(STFReader.UNITS.None, null); f.SkipRestOfBlock(); }
public bool StaticFreightAnimationsPresent = false; // Flag to indicate that a continuous freight animation is present public FreightAnimations(STFReader stf, MSTSWagon wagon) { stf.MustMatch("("); bool empty = true; stf.ParseBlock(new[] { new STFReader.TokenProcessor("mstsfreightanimenabled", () => { MSTSFreightAnimEnabled = stf.ReadBoolBlock(true); }), new STFReader.TokenProcessor("wagonemptyweight", () => { WagonEmptyWeight = stf.ReadFloatBlock(STFReader.UNITS.Mass, -1); }), new STFReader.TokenProcessor("loadingstartdelay", () => { UnloadingStartDelay = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }), new STFReader.TokenProcessor("unloadingstartdelay", () => { UnloadingStartDelay = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }), new STFReader.TokenProcessor("isgondola", () => { IsGondola = stf.ReadBoolBlock(false); }), // additions to manage consequences of variable weight on friction and brake forces new STFReader.TokenProcessor("emptyortsdavis_a", () => { EmptyORTSDavis_A = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }), new STFReader.TokenProcessor("emptyortsdavis_b", () => { EmptyORTSDavis_B = stf.ReadFloatBlock(STFReader.UNITS.Resistance, -1); }), new STFReader.TokenProcessor("emptyortsdavis_c", () => { EmptyORTSDavis_C = stf.ReadFloatBlock(STFReader.UNITS.ResistanceDavisC, -1); }), new STFReader.TokenProcessor("emptyortswagonfrontalarea", () => { EmptyORTSWagonFrontalAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, -1); }), new STFReader.TokenProcessor("emptyortsdavisdragconstant", () => { EmptyORTSDavisDragConstant = stf.ReadFloatBlock(STFReader.UNITS.Any, -1); }), new STFReader.TokenProcessor("emptymaxbrakeforce", () => { EmptyMaxBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }), new STFReader.TokenProcessor("emptymaxhandbrakeforce", () => { EmptyMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }), new STFReader.TokenProcessor("emptycentreofgravity_y", () => { EmptyCentreOfGravityM_Y = stf.ReadFloatBlock(STFReader.UNITS.Distance, -1); }), new STFReader.TokenProcessor("freightanimcontinuous", () => { Animations.Add(new FreightAnimationContinuous(stf, wagon)); FullPhysicsContinuousOne = Animations.Last() as FreightAnimationContinuous; if (wagon.WeightLoadController == null) { wagon.WeightLoadController = new MSTSNotchController(0, 1, 0.01f); } if ((Animations.Last() as FreightAnimationContinuous).FullAtStart) { if (empty) { empty = false; FreightType = wagon.IntakePointList.Last().Type; LoadedOne = Animations.Last() as FreightAnimationContinuous; FreightWeight += LoadedOne.FreightWeightWhenFull; LoadedOne.LoadPerCent = 100; } else { (Animations.Last() as FreightAnimationContinuous).FullAtStart = false; Trace.TraceWarning("The wagon can't be full with two different materials, only first is retained"); } } ContinuousFreightAnimationsPresent = true; }), new STFReader.TokenProcessor("freightanimstatic", () => { Animations.Add(new FreightAnimationStatic(stf)); StaticFreightWeight += (Animations.Last() as FreightAnimationStatic).FreightWeight; StaticFreightAnimationsPresent = true; FullPhysicsStaticOne = Animations.Last() as FreightAnimationStatic; }), /* new STFReader.TokenProcessor("freightanimdiscrete", ()=> * { * ORTSFreightAnims.Add(new FreightAnimDiscrete(stf)); * if ((ORTSFreightAnims.Last() as FreightAnimDiscrete).LoadedAtStart) * { * if (empty) * { * empty = false; * DiscreteLoadedOne = ORTSFreightAnims.Last() as FreightAnimDiscrete; * FreightWeight += DiscreteLoadedOne.LoadWeight; * } * else * { * (ORTSFreightAnims.Last() as FreightAnimContinuous).FullAtStart = false; * Trace.TraceWarning("The wagon can't be full with two different materials, only first is retained"); * } * } * }),*/ }); }