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;
}
}
} // 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)");
}
}
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);
}
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);
}
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);
}
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 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 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)");
}
}
}
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)");
}
}
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;
}
}
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 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)");
}
}
}
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);
}
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);
}
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 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 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 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 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.");
}
}
}
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();
}),
});
}
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);
}
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));
}
}
}
),
});
}
}
private void Add(STFReader stf, TrackShape trackShape)
{
if (ContainsKey(trackShape.ShapeIndex))
{
STFException.TraceWarning(stf, "Replaced duplicate TrackShape " + trackShape.ShapeIndex);
}
this[trackShape.ShapeIndex] = trackShape;
}
private void AddSection(STFReader stf, TrackSection section)
{
if (ContainsKey(section.SectionIndex))
{
STFException.TraceWarning(stf, "Replaced existing TrackSection " + section.SectionIndex);
}
this[section.SectionIndex] = section;
}
private void AddPath(STFReader stf, TrackPath path)
{
try
{
Add(path.DynamicSectionIndex, path);
}
catch (Exception e)
{
STFException.TraceWarning(stf, "Warning: in route tsection.dat " + e.Message);
}
}
public ActivityFile(string fileName)
{
using (STFReader stf = new STFReader(fileName, false)) {
stf.ParseFile(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tr_activity", () => { Activity = new Activity(stf); }),
});
if (Activity == null)
{
STFException.TraceWarning(stf, "Missing Tr_Activity statement");
}
}
}
protected void ParsePosition(STFReader stf)
{
stf.MustMatchBlockStart();
bounds = new Rectangle(stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null));
// skipping additional values in between
while (!stf.EndOfBlock())
{
STFException.TraceWarning(stf, "Ignored additional positional parameters");
bounds.Width = bounds.Height;
bounds.Height = stf.ReadInt(null);
}
}
