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