public FreightAnimationDiscrete(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[]
{
new STFReader.TokenProcessor("subtype", () =>
{
var typeString = stf.ReadStringBlock(null);
switch (typeString)
{
default:
SubType = FreightAnimationDiscrete.Type.DEFAULT;
break;
}
}),
new STFReader.TokenProcessor("shape", () => { ShapeFileName = stf.ReadStringBlock(null); }),
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("loadweight", () => { LoadWeight = stf.ReadFloatBlock(STFReader.UNITS.Mass, 0); }),
new STFReader.TokenProcessor("loadedatstart", () => { LoadedAtStart = stf.ReadBoolBlock(true); }),
});
}
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); }),
// 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 Turntable(STFReader stf, Simulator simulator)
: base(stf, simulator)
{
signalRef = Simulator.SignalEnvironment;
string animation;
Matrix position = Matrix.Identity;
position.M44 = 100000000; //WorlPosition not yet defined, will be loaded when loading related tile;
stf.MustMatch("(");
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("wfile", () => {
WFile = stf.ReadStringBlock(null);
WorldPosition = new WorldPosition(int.Parse(WFile.Substring(1, 7)), int.Parse(WFile.Substring(8, 7)), position);
}),
new STFReader.TokenProcessor("uid", () => { UID = stf.ReadIntBlock(-1); }),
new STFReader.TokenProcessor("animation", () => { animation = stf.ReadStringBlock(null);
Animations.Add(animation.ToLower()); }),
new STFReader.TokenProcessor("diameter", () => { Length = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("xoffset", () => { CenterOffset.X = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("zoffset", () => { CenterOffset.Z = -stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("trackshapeindex", () =>
{
TrackShapeIndex = stf.ReadIntBlock(-1);
InitializeAnglesAndTrackNodes();
}),
});
}
private bool saveConnected = true; // Transfertable is connected to a track
internal TransferTable(STFReader stf)
{
string animation;
Matrix location = Matrix.Identity;
location.M44 = 100_000_000; //WorlPosition not yet defined, will be loaded when loading related tile;
stf.MustMatch("(");
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("wfile", () => {
WFile = stf.ReadStringBlock(null);
position = new WorldPosition(int.Parse(WFile.Substring(1, 7), CultureInfo.InvariantCulture), int.Parse(WFile.Substring(8, 7), CultureInfo.InvariantCulture), location);
}),
new STFReader.TokenProcessor("uid", () => { UID = stf.ReadIntBlock(-1); }),
new STFReader.TokenProcessor("animation", () => { animation = stf.ReadStringBlock(null);
Animations.Add(animation); }),
new STFReader.TokenProcessor("verticaltransfer", () => { verticalTransfer = stf.ReadBoolBlock(false); }),
new STFReader.TokenProcessor("length", () => { Length = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("xoffset", () => { offset.X = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("zoffset", () => { offset.Z = -stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("yoffset", () => { offset.Y = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("trackshapeindex", () =>
{
TrackShapeIndex = stf.ReadIntBlock(-1);
InitializeOffsetsAndTrackNodes();
}),
});
}
private void ParseActivityHeader(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("routeid", () => { Header.RouteID = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("name", () => { Header.Name = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("description", () => { Header.Description = stf.ReadStringBlock(string.Empty); }),
new STFReader.TokenProcessor("briefing", () => { Header.Briefing = stf.ReadStringBlock(string.Empty); }),
new STFReader.TokenProcessor("completeactivity", () => { Header.CompleteActivity = (stf.ReadIntBlock(1) == 1); }),
new STFReader.TokenProcessor("type", () => { Header.Type = stf.ReadIntBlock(0); }),
new STFReader.TokenProcessor("mode", () => { Header.Mode = (ActivityMode)stf.ReadIntBlock((int)Header.Mode); }),
new STFReader.TokenProcessor("starttime", () => {
stf.MustMatchBlockStart();
Header.StartTime = new TimeSpan(stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null));
stf.MustMatchBlockEnd();
}),
new STFReader.TokenProcessor("season", () => { Header.Season = (SeasonType)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("weather", () => { Header.Weather = (WeatherType)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("pathid", () => { Header.PathID = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("startingspeed", () => { Header.StartingSpeed = stf.ReadFloatBlock(STFReader.Units.Speed, Header.StartingSpeed); }),
new STFReader.TokenProcessor("duration", () => {
stf.MustMatchBlockStart();
Header.Duration = new TimeSpan(stf.ReadInt(null), stf.ReadInt(null), 0);
stf.MustMatchBlockEnd();
}),
new STFReader.TokenProcessor("difficulty", () => { Header.Difficulty = (Difficulty)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("animals", () => { Header.Animals = stf.ReadIntBlock(Header.Animals); }),
new STFReader.TokenProcessor("workers", () => { Header.Workers = stf.ReadIntBlock(Header.Workers); }),
new STFReader.TokenProcessor("fuelwater", () => { Header.FuelWater = stf.ReadIntBlock(Header.FuelWater); }),
new STFReader.TokenProcessor("fuelcoal", () => { Header.FuelCoal = stf.ReadIntBlock(Header.FuelCoal); }),
new STFReader.TokenProcessor("fueldiesel", () => { Header.FuelDiesel = stf.ReadIntBlock(Header.FuelDiesel); }),
});
}
public Transfertable(STFReader stf, Simulator simulator) : base(stf, simulator)
{
signalRef = Simulator.Signals;
string animation;
WorldPosition.XNAMatrix.M44 = 100000000; //WorlPosition not yet defined, will be loaded when loading related tile
stf.MustMatch("(");
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("wfile", () => {
WFile = stf.ReadStringBlock(null);
WorldPosition.TileX = int.Parse(WFile.Substring(1, 7));
WorldPosition.TileZ = int.Parse(WFile.Substring(8, 7));
}),
new STFReader.TokenProcessor("uid", () => { UID = stf.ReadIntBlock(-1); }),
new STFReader.TokenProcessor("animation", () => { animation = stf.ReadStringBlock(null);
Animations.Add(animation.ToLower()); }),
new STFReader.TokenProcessor("length", () => { Length = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("xoffset", () => { CenterOffset.X = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("zoffset", () => { CenterOffset.Z = -stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("trackshapeindex", () =>
{
TrackShapeIndex = stf.ReadIntBlock(-1);
InitializeOffsetsAndTrackNodes();
}),
});
}
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));
}
}
}
),
});
}
}
public Tr_RouteFile(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("routeid", () => { RouteID = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("name", () => { Name = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("filename", () => { FileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("description", () => { Description = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("maxlinevoltage", () => { MaxLineVoltage = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("routestart", () => { if (RouteStart == null)
{
RouteStart = new RouteStart(stf);
}
}),
new STFReader.TokenProcessor("environment", () => { Environment = new TRKEnvironment(stf); }),
new STFReader.TokenProcessor("milepostunitskilometers", () => { MilepostUnitsMetric = true; }),
new STFReader.TokenProcessor("electrified", () => { Electrified = stf.ReadBoolBlock(false); }),
new STFReader.TokenProcessor("overheadwireheight", () => { OverheadWireHeight = stf.ReadFloatBlock(STFReader.UNITS.Distance, 6.0f); }),
new STFReader.TokenProcessor("speedlimit", () => { SpeedLimit = stf.ReadFloatBlock(STFReader.UNITS.Speed, 500.0f); }),
new STFReader.TokenProcessor("defaultcrossingsms", () => { DefaultCrossingSMS = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("defaultcoaltowersms", () => { DefaultCoalTowerSMS = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("defaultdieseltowersms", () => { DefaultDieselTowerSMS = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("defaultwatertowersms", () => { DefaultWaterTowerSMS = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("defaultsignalsms", () => { DefaultSignalSMS = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("temprestrictedspeed", () => { TempRestrictedSpeed = stf.ReadFloatBlock(STFReader.UNITS.Speed, -1f); }),
// values for tunnel operation
new STFReader.TokenProcessor("ortssingletunnelarea", () => { SingleTunnelAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, null); }),
new STFReader.TokenProcessor("ortssingletunnelperimeter", () => { SingleTunnelPerimeterM = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
new STFReader.TokenProcessor("ortsdoubletunnelarea", () => { DoubleTunnelAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, null); }),
new STFReader.TokenProcessor("ortsdoubletunnelperimeter", () => { DoubleTunnelPerimeterM = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
// if > 0 indicates distance from track without forest trees
new STFReader.TokenProcessor("ortsuserpreferenceforestcleardistance", () => { ForestClearDistance = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0); }),
// values for superelevation
new STFReader.TokenProcessor("ortstracksuperelevation", () => { SuperElevationHgtpRadiusM = new Interpolator(stf); }),
});
//TODO This should be changed to STFException.TraceError() with defaults values created
if (RouteID == null)
{
throw new STFException(stf, "Missing RouteID");
}
if (Name == null)
{
throw new STFException(stf, "Missing Name");
}
if (Description == null)
{
throw new STFException(stf, "Missing Description");
}
if (RouteStart == null)
{
throw new STFException(stf, "Missing RouteStart");
}
}
public Camera(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("camtype", () => { CameraType = stf.ReadStringBlock(null); CameraControl = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("cameraoffset", () => { stf.ReadVector3Block(STFReader.Units.None, ref cameraOffset); }),
new STFReader.TokenProcessor("direction", () => { stf.ReadVector3Block(STFReader.Units.None, ref direction); }),
new STFReader.TokenProcessor("objectoffset", () => { stf.ReadVector3Block(STFReader.Units.None, ref objectOffset); }),
new STFReader.TokenProcessor("rotationlimit", () => { stf.ReadVector3Block(STFReader.Units.None, ref rotationLimit); }),
new STFReader.TokenProcessor("description", () => { Description = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("fov", () => { Fov = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("zclip", () => { ZClip = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("wagonnum", () => { WagonNumber = stf.ReadIntBlock(null); }),
});
}
public ServiceFile(string fileName)
{
using (STFReader stf = new STFReader(fileName, false))
stf.ParseFile(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("service_definition", () => { stf.MustMatchBlockStart(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("serial", () => { Serial = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("name", () => { Name = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("train_config", () => { TrainConfig = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("pathid", () => { PathId = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("maxwheelacceleration", () => { MaxWheelAcceleration = stf.ReadFloatBlock(STFReader.Units.Any, null); }),
new STFReader.TokenProcessor("efficiency", () => { Efficiency = stf.ReadFloatBlock(STFReader.Units.Any, null); }),
new STFReader.TokenProcessor("timetable", () => { TimeTable = new TimeTable(stf); }),
}); }),
});
}
public Camera(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("camtype", () => { CamType = stf.ReadStringBlock(null); CamControl = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("cameraoffset", () => { CameraOffset = stf.ReadVector3Block(STFReader.UNITS.None, CameraOffset); }),
new STFReader.TokenProcessor("direction", () => { Direction = stf.ReadVector3Block(STFReader.UNITS.None, Direction); }),
new STFReader.TokenProcessor("objectoffset", () => { ObjectOffset = stf.ReadVector3Block(STFReader.UNITS.None, ObjectOffset); }),
new STFReader.TokenProcessor("rotationlimit", () => { RotationLimit = stf.ReadVector3Block(STFReader.UNITS.None, RotationLimit); }),
new STFReader.TokenProcessor("description", () => { Description = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("fov", () => { Fov = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("zclip", () => { ZClip = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("wagonnum", () => { WagonNum = stf.ReadIntBlock(null); }),
});
}
public virtual void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "engine(ortspowersupply":
ScriptName = stf.ReadStringBlock(null);
break;
case "engine(ortspowerondelay":
PowerOnDelayS = stf.ReadFloatBlock(STFReader.Units.Time, null);
break;
case "engine(ortsauxpowerondelay":
AuxPowerOnDelayS = stf.ReadFloatBlock(STFReader.Units.Time, null);
break;
case "engine(ortsbattery(mode":
case "engine(ortsbattery(delay":
BatterySwitch.Parse(lowercasetoken, stf);
break;
case "engine(ortsmasterkey(mode":
case "engine(ortsmasterkey(delayoff":
case "engine(ortsmasterkey(headlightcontrol":
MasterKey.Parse(lowercasetoken, stf);
break;
case "engine(ortselectrictrainsupply(mode":
ElectricTrainSupplySwitch.Parse(lowercasetoken, stf);
break;
}
}
public float FullCentreOfGravityM_Y = -9999; // get centre of gravity after adjusted for freight animation
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); }),
// additions to manage consequences of variable weight on friction and brake forces
new STFReader.TokenProcessor("fullortsdavis_a", () => { FullORTSDavis_A = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullortsdavis_b", () => { FullORTSDavis_B = stf.ReadFloatBlock(STFReader.UNITS.Resistance, -1); }),
new STFReader.TokenProcessor("fullortsdavis_c", () => { FullORTSDavis_C = stf.ReadFloatBlock(STFReader.UNITS.ResistanceDavisC, -1); }),
new STFReader.TokenProcessor("fullortswagonfrontalarea", () => { FullORTSWagonFrontalAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, -1); }),
new STFReader.TokenProcessor("fullortsdavisdragconstant", () => { FullORTSDavisDragConstant = stf.ReadFloatBlock(STFReader.UNITS.Any, -1); }),
new STFReader.TokenProcessor("fullmaxbrakeforce", () => { FullMaxBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullmaxhandbrakeforce", () => { FullMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullcentreofgravity_y", () => { FullCentreOfGravityM_Y = stf.ReadFloatBlock(STFReader.UNITS.Distance, -1); })
});
}
public CabViewControls CabViewControls; // Controls in CAB - by GeorgeS
public CabViewFile(string filePath, string basePath)
{
using (STFReader stf = new STFReader(filePath, false))
stf.ParseFile(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tr_cabviewfile", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("position", () => { Locations.Add(stf.ReadVector3Block(STFReader.UNITS.None, new Vector3())); }),
new STFReader.TokenProcessor("direction", () => { Directions.Add(stf.ReadVector3Block(STFReader.UNITS.None, new Vector3())); }),
new STFReader.TokenProcessor("cabviewfile", () => {
var fileName = stf.ReadStringBlock(null);
var path = Path.Combine(basePath, Path.GetDirectoryName(fileName));
var name = Path.GetFileName(fileName);
// Use *Frnt1024.ace if available
string s = name;
string[] nameParts = s.Split('.');
string name1024 = nameParts[0] + "1024." + nameParts[1];
var tstFileName1024 = Path.Combine(path, name1024);
if (File.Exists(tstFileName1024))
{
name = name1024;
}
TwoDViews.Add(Path.Combine(path, name));
NightViews.Add(Path.Combine(path, Path.Combine("NIGHT", name)));
LightViews.Add(Path.Combine(path, Path.Combine("CABLIGHT", name)));
}),
new STFReader.TokenProcessor("cabviewcontrols", () => { CabViewControls = new CabViewControls(stf, basePath); }),
}); }),
});
}
public virtual void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "wagon(ortspowersupply":
ScriptName = stf.ReadStringBlock(null);
break;
case "wagon(ortspowerondelay":
PowerOnDelayS = stf.ReadFloatBlock(STFReader.UNITS.Time, null);
break;
case "wagon(ortsbattery(mode":
case "wagon(ortsbattery(delay":
BatterySwitch.Parse(lowercasetoken, stf);
break;
case "wagon(ortspowersupplycontinuouspower":
ContinuousPowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, 0f);
break;
case "wagon(ortspowersupplyheatingpower":
HeatingPowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, 0f);
break;
case "wagon(ortspowersupplyairconditioningpower":
AirConditioningPowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, 0f);
break;
case "wagon(ortspowersupplyairconditioningyield":
AirConditioningYield = stf.ReadFloatBlock(STFReader.UNITS.Power, 0.9f);
break;
}
}
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 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 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 CabViewFile(string basePath, string fileName)
{
using (STFReader stf = new STFReader(Path.GetFullPath(Path.Combine(basePath, fileName)), false))
stf.ParseFile(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tr_cabviewfile", () => { stf.MustMatchBlockStart(); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("position", () => { Locations.Add(stf.ReadVector3Block(STFReader.Units.None, new Vector3())); }),
new STFReader.TokenProcessor("direction", () => { Directions.Add(stf.ReadVector3Block(STFReader.Units.None, new Vector3())); }),
new STFReader.TokenProcessor("cabviewfile", () => {
string cvfileName = stf.ReadStringBlock(null);
string path = Path.Combine(basePath, Path.GetDirectoryName(cvfileName));
string name = Path.GetFileName(cvfileName);
// Use *Frnt1024.ace if available
if (!Path.GetFileNameWithoutExtension(cvfileName).EndsWith("1024", StringComparison.OrdinalIgnoreCase))
{
string name1024 = Path.GetFileNameWithoutExtension(cvfileName) + "1024" + Path.GetExtension(cvfileName);
if (File.Exists(Path.Combine(path, name1024)))
{
name = name1024;
}
}
Views2D.Add(Path.Combine(path, name));
ViewsNight.Add(Path.Combine(path, "NIGHT", name));
ViewsLight.Add(Path.Combine(path, "CABLIGHT", name));
}),
new STFReader.TokenProcessor("cabviewcontrols", () => { CabViewControls = new CabViewControls(stf, basePath); }),
}); }),
});
}
internal override void Update(STFReader stf)
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("id", () => { ID = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("activation_level", () => { ActivationLevel = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("outcomes", () =>
{
if (Outcomes == null)
{
Outcomes = new Outcomes(stf);
}
else
{
Outcomes.Update(stf);
}
}),
new STFReader.TokenProcessor("texttodisplayoncompletioniftriggered", () => { TextToDisplayOnCompletionIfTriggered = stf.ReadStringBlock(""); }),
new STFReader.TokenProcessor("texttodisplayoncompletionifnotriggered", () => { TextToDisplayOnCompletionIfNotTriggered = stf.ReadStringBlock(""); }),
new STFReader.TokenProcessor("name", () => { Name = stf.ReadStringBlock(""); }),
new STFReader.TokenProcessor("time", () => { Time = (int)stf.ReadFloatBlock(STFReader.Units.Time, null); }),
new STFReader.TokenProcessor("ortscontinue", () => { OrtsContinue = stf.ReadIntBlock(0); }),
new STFReader.TokenProcessor("ortsactsoundfile", () => OrtsActivitySoundProcessor(stf)),
new STFReader.TokenProcessor("ortsweatherchange", () => { WeatherChange = new OrtsWeatherChange(stf); }),
});
}
public OpenRailsData(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsdll", () => { DLL = stf.ReadStringBlock(null); }),
});
}
internal override void Update(STFReader stf)
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("eventtypelocation", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); }),
new STFReader.TokenProcessor("id", () => { ID = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("ortstriggeringtrain", () => { ParseTrain(stf); }),
new STFReader.TokenProcessor("activation_level", () => { ActivationLevel = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("outcomes", () =>
{
if (Outcomes == null)
{
Outcomes = new Outcomes(stf);
}
else
{
Outcomes.Update(stf);
}
}),
new STFReader.TokenProcessor("name", () => { Name = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("texttodisplayoncompletioniftriggered", () => { TextToDisplayOnCompletionIfTriggered = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("texttodisplayoncompletionifnottriggered", () => { TextToDisplayOnCompletionIfNotTriggered = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("triggeronstop", () => { TriggerOnStop = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("location", () => {
stf.MustMatchBlockStart();
location = new WorldLocation(stf.ReadInt(null), stf.ReadInt(null),
stf.ReadFloat(STFReader.Units.None, null), 0f, stf.ReadFloat(STFReader.Units.None, null));
RadiusM = stf.ReadFloat(STFReader.Units.Distance, null);
stf.MustMatchBlockEnd();
}),
new STFReader.TokenProcessor("ortscontinue", () => { OrtsContinue = stf.ReadIntBlock(0); }),
new STFReader.TokenProcessor("ortsactsoundfile", () => OrtsActivitySoundProcessor(stf)),
new STFReader.TokenProcessor("ortsweatherchange", () => { WeatherChange = new OrtsWeatherChange(stf); }),
});
}
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 EngineClass(STFReader stf)
{
stf.MustMatch("(");
stf.ReadString();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("type", () => { Type = stf.ReadStringBlock(null); }),
});
}
internal void Update(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("activitysuccess", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); ActivitySuccess = true; }),
new STFReader.TokenProcessor("activityfail", () => { ActivityFail = stf.ReadStringBlock(""); }),
new STFReader.TokenProcessor("activateevent", () => { ActivateList.Add(stf.ReadIntBlock(null)); }),
new STFReader.TokenProcessor("restoreactlevel", () => { RestoreActivityLevels.Add(stf.ReadIntBlock(null)); }),
new STFReader.TokenProcessor("decactlevel", () => { DecrementActivityLevels.Add(stf.ReadIntBlock(null)); }),
new STFReader.TokenProcessor("incactlevel", () => { IncrementActivityLevels.Add(stf.ReadIntBlock(null)); }),
new STFReader.TokenProcessor("displaymessage", () => {
DisplayMessage = stf.ReadStringBlock("");
}),
new STFReader.TokenProcessor("ortsrestartwaitingtrain", () => { RestartWaitingTrain = new RestartWaitingTrain(stf); }),
new STFReader.TokenProcessor("ortsweatherchange", () => { WeatherChange = new OrtsWeatherChange(stf); }),
new STFReader.TokenProcessor("ortsactivitysound", () => { ActivitySound = new ActivitySound(stf); }),
});
}
private static IList <string> ReadScriptFiles(STFReader stf)
{
stf.MustMatch("(");
List <string> scriptFiles = new List <string>();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("scriptfile", () => { scriptFiles.Add(stf.ReadStringBlock(null)); }),
});
return(scriptFiles);
}
public void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "engine(vigilancemonitor": VigilanceMonitor = new MonitoringDevice(stf); break;
case "engine(overspeedmonitor": OverspeedMonitor = new MonitoringDevice(stf); break;
case "engine(emergencystopmonitor": EmergencyStopMonitor = new MonitoringDevice(stf); break;
case "engine(awsmonitor": AWSMonitor = new MonitoringDevice(stf); break;
case "engine(ortstraincontrolsystem": ScriptName = stf.ReadStringBlock(null); break;
case "engine(ortstraincontrolsystemsound": SoundFileName = stf.ReadStringBlock(null); break;
case "engine(ortstraincontrolsystemparameters": ParametersFileName = stf.ReadStringBlock(null); break;
}
}
public TRKEnvironment(STFReader stf)
{
stf.MustMatch("(");
for (int i = 0; i < 12; ++i)
{
string s = stf.ReadString();
ENVFileNames[i] = stf.ReadStringBlock(null);
}
stf.SkipRestOfBlock();
}
private SignalFunction ReadFunctionType(STFReader stf)
{
string signalType = stf.ReadStringBlock(null);
if (!EnumExtension.GetValue(signalType, out SignalFunction result))
{
STFException.TraceInformation(stf, $"Skipped unknown SignalFnType {signalType}");
return(SignalFunction.Info);
}
return(result);
}
internal Environment(STFReader stf)
{
stf.MustMatchBlockStart();
for (int i = 0; i < 12; ++i)
{
string envfilekey = stf.ReadString();
string envfile = stf.ReadStringBlock(null);
fileNames.Add(envfilekey, envfile);
}
stf.SkipRestOfBlock();
}
