private static IDictionary <string, LightTexture> ReadLightTextures(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); Dictionary <string, LightTexture> lightTextures = new Dictionary <string, LightTexture>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("lighttex", () => { if (lightTextures.Count >= count) { STFException.TraceWarning(stf, "Skipped extra LightTex"); } else { LightTexture lightTexture = new LightTexture(stf); if (lightTextures.ContainsKey(lightTexture.Name)) { STFException.TraceWarning(stf, "Skipped duplicate LightTex " + lightTexture.Name); } else { lightTextures.Add(lightTexture.Name, lightTexture); } } }), }); if (lightTextures.Count < count) { STFException.TraceWarning(stf, (count - lightTextures.Count).ToString() + " missing LightTex(s)"); } return(lightTextures); }
public virtual void Parse(string lowercasetoken, STFReader stf) { switch (lowercasetoken) { case "engine(ortsbattery(mode": case "wagon(ortsbattery(mode": string text = stf.ReadStringBlock("").ToLower(); if (text == "alwayson") { Mode = ModeType.AlwaysOn; } else if (text == "switch") { Mode = ModeType.Switch; } else if (text == "pushbuttons") { Mode = ModeType.PushButtons; } else { STFException.TraceWarning(stf, "Skipped invalid battery switch mode"); } break; case "engine(ortsbattery(delay": case "wagon(ortsbattery(delay": DelayS = stf.ReadFloatBlock(STFReader.UNITS.Time, 0f); break; } }
private static IDictionary <string, SignalShape> ReadSignalShapes(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); Dictionary <string, SignalShape> signalShapes = new Dictionary <string, SignalShape>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signalshape", () => { if (signalShapes.Count >= count) { STFException.TraceWarning(stf, "Skipped extra SignalShape"); } else { SignalShape signalShape = new SignalShape(stf); if (signalShapes.ContainsKey(signalShape.ShapeFileName)) { STFException.TraceWarning(stf, "Skipped duplicate SignalShape " + signalShape.ShapeFileName); } else { signalShapes.Add(signalShape.ShapeFileName, signalShape); } } }), }); if (signalShapes.Count < count) { STFException.TraceWarning(stf, (count - signalShapes.Count).ToString() + " missing SignalShape(s)"); } return(signalShapes); }
static IDictionary <string, SignalDrawState> ReadDrawStates(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); Dictionary <string, SignalDrawState> drawStates = new Dictionary <string, SignalDrawState>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signaldrawstate", () => { if (drawStates.Count >= count) { STFException.TraceWarning(stf, "Skipped extra SignalDrawState"); } else { SignalDrawState drawState = new SignalDrawState(stf); if (drawStates.ContainsKey(drawState.Name)) { string TempNew = String.Copy("DST"); TempNew = String.Concat(TempNew, drawStates.Count.ToString()); drawStates.Add(TempNew, drawState); STFException.TraceInformation(stf, "Duplicate SignalDrawState name \'" + drawState.Name + "\', using name \'" + TempNew + "\' instead"); } else { drawStates.Add(drawState.Name, drawState); } } }), }); if (drawStates.Count < count) { STFException.TraceWarning(stf, (count - drawStates.Count).ToString() + " missing SignalDrawState(s)"); } return(drawStates); }
// 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; } } }), }); }
private static IDictionary <string, LightTableEntry> ReadLightsTable(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); Dictionary <string, LightTableEntry> lightsTable = new Dictionary <string, LightTableEntry>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("lightstabentry", () => { if (lightsTable.Count >= count) { STFException.TraceWarning(stf, "Skipped extra LightsTabEntry"); } else { LightTableEntry lightsTableEntry = new LightTableEntry(stf); if (lightsTable.ContainsKey(lightsTableEntry.Name)) { STFException.TraceWarning(stf, "Skipped duplicate LightsTabEntry " + lightsTableEntry.Name); } else { lightsTable.Add(lightsTableEntry.Name, lightsTableEntry); } } }), }); if (lightsTable.Count < count) { STFException.TraceWarning(stf, (count - lightsTable.Count).ToString() + " missing LightsTabEntry(s)"); } return(lightsTable); }
public TurntableFile(string filePath, string shapePath, List <MovingTable> movingTables, Simulator simulator) { using (STFReader stf = new STFReader(filePath, false)) { var count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("turntable", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra Turntable"); } else { movingTables.Add(new Turntable(stf, simulator)); } }), new STFReader.TokenProcessor("transfertable", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra Transfertable"); } else { movingTables.Add(new Transfertable(stf, simulator)); } }), }); if (count > 0) { STFException.TraceWarning(stf, count + " missing Turntable(s)"); } } }
static IList <SignalSubObj> ReadSignalSubObjects(STFReader stf) { stf.MustMatch("("); int count = stf.ReadInt(null); List <SignalSubObj> signalSubObjects = new List <SignalSubObj>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signalsubobj", () => { if (signalSubObjects.Count >= count) { STFException.TraceWarning(stf, "Skipped extra SignalSubObj"); } else { SignalSubObj signalSubObject = new SignalSubObj(stf); if (signalSubObject.Index != signalSubObjects.Count) { STFException.TraceWarning(stf, "Invalid SignalSubObj index; expected " + signalSubObjects.Count + ", got " + signalSubObject.Index); } signalSubObjects.Add(signalSubObject); } }), }); if (signalSubObjects.Count < count) { STFException.TraceWarning(stf, (count - signalSubObjects.Count).ToString() + " missing SignalSubObj(s)"); } return(signalSubObjects); }
public ClockList(STFReader stf, string shapePath) { var count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("clockitem", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra ClockItem"); } else { var dataItem = new Clock(stf, shapePath); if (File.Exists(dataItem.Name)) { Add(dataItem); } else { STFException.TraceWarning(stf, $"Non-existent shape file {dataItem.Name} referenced"); } } }), }); if (count > 0) { STFException.TraceWarning(stf, count + " missing ClockItem(s)"); } }
internal WorldSoundRegion(STFReader stf, TrackItem[] trItems) { TrackNodes = new List <int>(); stf.MustMatchBlockStart(); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("soundregiontracktype", () => { TrackType = stf.ReadIntBlock(-1); }), new STFReader.TokenProcessor("soundregionroty", () => { RotY = stf.ReadFloatBlock(STFReader.Units.None, float.MaxValue); }), new STFReader.TokenProcessor("tritemid", () => { stf.MustMatchBlockStart(); stf.ReadInt(0);//dummy read int trItemId = stf.ReadInt(-1); if (trItemId != -1) { if (trItemId >= trItems.Length) { STFException.TraceWarning(stf, $"Ignored invalid TrItemId {trItemId}"); } else { TrackNodes.Add(trItemId); } } stf.SkipRestOfBlock(); }), }); }
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(); }), });
public virtual void Parse(string lowercasetoken, STFReader stf) { switch (lowercasetoken) { case "engine(ortselectrictrainsupply(mode": string text = stf.ReadStringBlock("").ToLower(); if (text == "automatic") { Mode = ModeType.Automatic; } else if (text == "unfitted") { Mode = ModeType.Unfitted; } else if (text == "switch") { Mode = ModeType.Switch; } else { STFException.TraceWarning(stf, "Skipped invalid electric train supply switch mode"); } break; } }
public Interpolator(STFReader stf) { List <float> list = new List <float>(); stf.MustMatch("("); 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."); } X = new float[n]; Y = new float[n]; Size = n; for (int i = 0; i < n; i++) { X[i] = list[2 * i]; Y[i] = list[2 * i + 1]; if (i > 0 && X[i - 1] >= X[i]) { STFException.TraceWarning(stf, "Interpolator x values must be increasing."); } } }
public CabViewControls(STFReader stf, string basePath) { stf.MustMatchBlockStart(); int count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("dial", () => { Add(new CabViewDialControl(stf, basePath)); }), new STFReader.TokenProcessor("gauge", () => { Add(new CabViewGaugeControl(stf, basePath)); }), new STFReader.TokenProcessor("lever", () => { Add(new CabViewDiscreteControl(stf, basePath)); }), new STFReader.TokenProcessor("twostate", () => { Add(new CabViewDiscreteControl(stf, basePath)); }), new STFReader.TokenProcessor("tristate", () => { Add(new CabViewDiscreteControl(stf, basePath)); }), new STFReader.TokenProcessor("multistate", () => { Add(new CabViewDiscreteControl(stf, basePath)); }), new STFReader.TokenProcessor("multistatedisplay", () => { Add(new CabViewMultiStateDisplayControl(stf, basePath)); }), new STFReader.TokenProcessor("cabsignaldisplay", () => { Add(new CabViewSignalControl(stf, basePath)); }), new STFReader.TokenProcessor("digital", () => { Add(new CabViewDigitalControl(stf, basePath)); }), new STFReader.TokenProcessor("combinedcontrol", () => { Add(new CabViewDiscreteControl(stf, basePath)); }), new STFReader.TokenProcessor("firebox", () => { Add(new CabViewFireboxControl(stf, basePath)); }), new STFReader.TokenProcessor("dialclock", () => { ProcessDialClock(stf, basePath); }), new STFReader.TokenProcessor("digitalclock", () => { Add(new CabViewDigitalClockControl(stf, basePath)); }) }); if (count != Count) { STFException.TraceInformation(stf, $"CabViewControl count mismatch - expected {count} but found {Count} controls."); } }
} // true for humans public CarSpawnerList(STFReader stf, string shapePath, string listName) { ListName = listName; var count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("ignorexrotation", () => { IgnoreXRotation = stf.ReadBoolBlock(true); }), new STFReader.TokenProcessor("carspawneritem", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra CarSpawnerItem"); } else { CarSpawner dataItem = new CarSpawner(stf, shapePath); if (File.Exists(dataItem.Name)) { Add(dataItem); } else { STFException.TraceWarning(stf, $"Non-existent shape file {dataItem.Name} referenced"); } } }), }); if (count > 0) { STFException.TraceWarning(stf, count + " missing CarSpawnerItem(s)"); } }
public ORCarSpawnerFile(string fileName, string shapePath) { using (STFReader stf = new STFReader(fileName, false)) { var listCount = stf.ReadInt(null); string listName = null; stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("carspawnerlist", () => { if (--listCount < 0) { STFException.TraceWarning(stf, "Skipped extra CarSpawner List"); } else { stf.MustMatchBlockStart(); stf.MustMatch("ListName"); listName = stf.ReadStringBlock(null); CarSpawners.Add(new CarSpawnerList(stf, shapePath, listName)); } }), }); if (listCount > 0) { STFException.TraceWarning(stf, listCount + " missing CarSpawner List(s)"); } } }
public CarSpawnerBlock(STFReader stf, string shapePath, List <CarSpawnerList> carSpawnerLists, string listName) { var spawnerDataItems = new List <CarSpawnerItemData>(); { var count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("carspawneritem", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra CarSpawnerItem"); } else { var dataItem = new CarSpawnerItemData(stf, shapePath); if (File.Exists(dataItem.name)) { spawnerDataItems.Add(dataItem); } else { STFException.TraceWarning(stf, String.Format("Non-existent shape file {0} referenced", dataItem.name)); } } }), }); if (count > 0) { STFException.TraceWarning(stf, count + " missing CarSpawnerItem(s)"); } } CarSpawnerList carSpawnerList = new CarSpawnerList(spawnerDataItems, listName); carSpawnerLists.Add(carSpawnerList); }
static List <SignalSubObject> ReadSignalSubObjects(STFReader stf) { stf.MustMatchBlockStart(); int count = stf.ReadInt(null); List <SignalSubObject> signalSubObjects = new List <SignalSubObject>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signalsubobj", () => { if (signalSubObjects.Count >= count) { STFException.TraceWarning(stf, "Skipped extra SignalSubObj"); } else { SignalSubObject signalSubObject = new SignalSubObject(stf); if (signalSubObject.Index != signalSubObjects.Count) { STFException.TraceWarning(stf, $"Invalid SignalSubObj index; expected {signalSubObjects.Count}, got {signalSubObject.Index}"); } signalSubObjects.Add(signalSubObject); } }), }); if (signalSubObjects.Count < count) { STFException.TraceWarning(stf, $"{(count - signalSubObjects.Count)} missing SignalSubObj(s)"); } return(signalSubObjects); }
public MSTSNotch(float v, int s, string type, STFReader stf) { Value = v; Smooth = s == 0 ? false : true; Type = ControllerState.Dummy; string lower = type.ToLower(); if (lower.StartsWith("trainbrakescontroller")) { lower = lower.Substring(21); } if (lower.StartsWith("enginebrakescontroller")) { lower = lower.Substring(22); } switch (lower) { case "dummy": break; case ")": break; case "releasestart": Type = ControllerState.Release; break; case "fullquickreleasestart": Type = ControllerState.FullQuickRelease; break; case "runningstart": Type = ControllerState.Running; break; case "selflapstart": Type = ControllerState.SelfLap; break; case "holdstart": Type = ControllerState.Lap; break; case "holdlappedstart": Type = ControllerState.Lap; break; case "neutralhandleoffstart": Type = ControllerState.Neutral; break; case "graduatedselflaplimitedstart": Type = ControllerState.GSelfLap; break; case "graduatedselflaplimitedholdingstart": Type = ControllerState.GSelfLapH; break; case "applystart": Type = ControllerState.Apply; break; case "continuousservicestart": Type = ControllerState.ContServ; break; case "suppressionstart": Type = ControllerState.Suppression; break; case "fullservicestart": Type = ControllerState.FullServ; break; case "emergencystart": Type = ControllerState.Emergency; break; case "epapplystart": Type = ControllerState.EPApply; break; case "epholdstart": Type = ControllerState.Lap; break; case "minimalreductionstart": Type = ControllerState.Lap; break; default: STFException.TraceInformation(stf, "Skipped unknown notch type " + type); break; } }
private List <SignalAspect> ReadAspects(STFReader stf) { stf.MustMatchBlockStart(); int count = stf.ReadInt(null); List <SignalAspect> aspects = new List <SignalAspect>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signalaspect", () => { if (aspects.Count >= aspects.Capacity) { STFException.TraceWarning(stf, "Skipped extra SignalAspect"); } else { SignalAspect aspect = new SignalAspect(stf); if (aspects.Any(sa => sa.Aspect == aspect.Aspect)) { STFException.TraceWarning(stf, "Skipped duplicate SignalAspect " + aspect.Aspect); } else { aspects.Add(aspect); } } }), }); return(aspects); }
/// <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; } } }), }); }
static List <SignalLight> ReadLights(STFReader stf) { stf.MustMatchBlockStart(); int count = stf.ReadInt(null); List <SignalLight> lights = new List <SignalLight>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signallight", () => { if (lights.Count >= lights.Capacity) { STFException.TraceWarning(stf, "Skipped extra SignalLight"); } else { lights.Add(new SignalLight(stf)); } }), }); lights.Sort(SignalLight.Comparer); for (int i = 0; i < lights.Count; i++) { if (lights[i].Index != i) { STFException.TraceWarning(stf, $"Invalid SignalLight index; expected {i}, got {lights[i].Index}"); } } return(lights); }
private Dictionary <string, SignalDrawState> ReadDrawStates(STFReader stf) { stf.MustMatchBlockStart(); int count = stf.ReadInt(null); Dictionary <string, SignalDrawState> drawStates = new Dictionary <string, SignalDrawState>(count); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("signaldrawstate", () => { if (drawStates.Count >= count) { STFException.TraceWarning(stf, "Skipped extra SignalDrawState"); } else { SignalDrawState drawState = new SignalDrawState(stf); if (drawStates.ContainsKey(drawState.Name)) { string newState = $"DST{drawStates.Count}"; drawStates.Add(newState, drawState); STFException.TraceInformation(stf, $"Duplicate SignalDrawState name \'{drawState.Name}\', using name \'{newState}\' instead"); } else { drawStates.Add(drawState.Name, drawState); } } }), }); if (drawStates.Count < count) { STFException.TraceWarning(stf, (count - drawStates.Count).ToString() + " missing SignalDrawState(s)"); } return(drawStates); }
public static Interpolator CreateInterpolator(this STFReader reader) { List <double> list = new List <double>(); reader.MustMatchBlockStart(); while (!reader.EndOfBlock()) { list.Add(reader.ReadFloat(STFReader.Units.Any, null)); } if (list.Count % 2 == 1) { STFException.TraceWarning(reader, "Ignoring extra odd value in Interpolator list."); } int n = list.Count / 2; if (n < 2) { STFException.TraceWarning(reader, "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(reader, "Interpolator x values must be increasing."); } } return(new Interpolator(xArray, yArray)); }
public WorldSoundRegion(STFReader stf, TrItem[] trItems) { TrackNodes = new List <int>(); stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("soundregiontracktype", () => { SoundRegionTrackType = stf.ReadIntBlock(-1); }), new STFReader.TokenProcessor("soundregionroty", () => { ROTy = stf.ReadFloatBlock(STFReader.UNITS.None, float.MaxValue); }), new STFReader.TokenProcessor("tritemid", () => { stf.MustMatch("("); var dummy = stf.ReadInt(0); var trItemId = stf.ReadInt(-1); if (trItemId != -1) { if (trItemId >= trItems.Length) { STFException.TraceWarning(stf, string.Format("Ignored invalid TrItemId {0}", trItemId)); } else { TrackNodes.Add(trItemId); } } stf.SkipRestOfBlock(); }), }); }
public static Interpolator2D CreateInterpolator2D(this STFReader 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)); }
public virtual void Parse(string lowercasetoken, STFReader stf) { switch (lowercasetoken) { case "engine(ortsmasterkey(mode": string text = stf.ReadStringBlock("").ToLower(); if (text == "alwayson") { Mode = ModeType.AlwaysOn; } else if (text == "manual") { Mode = ModeType.Manual; } else { STFException.TraceWarning(stf, "Skipped invalid master key mode"); } break; case "engine(ortsmasterkey(delayoff": DelayS = stf.ReadFloatBlock(STFReader.UNITS.Time, 0f); break; case "engine(ortsmasterkey(headlightcontrol": HeadlightControl = stf.ReadBoolBlock(false); break; } }
public Interpolator2D(STFReader stf) { List <float> xlist = new List <float>(); List <Interpolator> ilist = new List <Interpolator>(); stf.MustMatch("("); while (!stf.EndOfBlock()) { xlist.Add(stf.ReadFloat(STFReader.UNITS.Any, null)); ilist.Add(new Interpolator(stf)); } stf.SkipRestOfBlock(); int n = xlist.Count; if (n < 2) { STFException.TraceWarning(stf, "Interpolator must have at least two x values."); } 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."); } } }
public ClockBlock(STFReader stf, string shapePath, List <ClockList> clockLists, string listName) { var clockDataItems = new List <ClockShape>(); var count = stf.ReadInt(null); stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("clockitem", () => { if (--count < 0) { STFException.TraceWarning(stf, "Skipped extra ClockItem"); } else { var dataItem = new ClockShape(stf, shapePath); if (File.Exists(shapePath + dataItem.Name)) { clockDataItems.Add(dataItem); } else { STFException.TraceWarning(stf, String.Format("Non-existent shape file {0} referenced", dataItem.Name)); } } }), }); if (count > 0) { STFException.TraceWarning(stf, count + " missing ClockItem(s)"); } ClockList clockList = new ClockList(clockDataItems, listName); clockLists.Add(clockList); }
public SpeedpostDatFile(string filePath, string shapePath) { using (STFReader stf = new STFReader(filePath, false)) { stf.ParseBlock(new STFReader.TokenProcessor[] { new STFReader.TokenProcessor("speed_warning_sign_shape", () => { var dataItem = stf.ReadStringBlock(null); if (dataItem != null) { dataItem = shapePath + dataItem; if (File.Exists(dataItem)) { TempSpeedShapeNames[0] = dataItem; } else { STFException.TraceWarning(stf, String.Format("Non-existent shape file {0} referenced", dataItem)); } } } ), new STFReader.TokenProcessor("restricted_shape", () => { var dataItem = stf.ReadStringBlock(null); if (dataItem != null) { dataItem = shapePath + dataItem; if (File.Exists(dataItem)) { TempSpeedShapeNames[1] = dataItem; } else { STFException.TraceWarning(stf, String.Format("Non-existent shape file {0} referenced", dataItem)); } } } ), new STFReader.TokenProcessor("end_restricted_shape", () => { var dataItem = stf.ReadStringBlock(null); if (dataItem != null) { dataItem = shapePath + dataItem; if (File.Exists(dataItem)) { TempSpeedShapeNames[2] = dataItem; } else { STFException.TraceWarning(stf, String.Format("Non-existent shape file {0} referenced", dataItem)); } } } ), }); } }