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); }),
});
}
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 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();
}),
});
}
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();
}),
});
}
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();
}),
});
}
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); }),
});
}
private void ParseTrainConfig(STFReader stf)
{
stf.MustMatchBlockStart();
Name = stf.ReadString();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("name", () => { Name = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("serial", () => { Serial = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("maxvelocity", () => { MaxVelocity = new MaxVelocity(stf); }),
new STFReader.TokenProcessor("nextwagonuid", () => { nextWagonUiD = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("durability", () => { Durability = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("wagon", () => { Wagons.Add(new Wagon(stf)); }),
new STFReader.TokenProcessor("engine", () => { Wagons.Add(new Wagon(stf)); }),
});
}
{ // e.g. ActivityFailedSignals ( ActivityFailedSignal ( 50 ) )
internal FailedSignals(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("activityfailedsignal", () => { Add(stf.ReadIntBlock(null)); }),
});
}
internal ActivityObject(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("objecttype", () => { stf.MustMatchBlockStart(); stf.MustMatch("WagonsList"); stf.MustMatchBlockEnd(); }),
new STFReader.TokenProcessor("train_config", () => { TrainSet = new TrainSet(stf); }),
new STFReader.TokenProcessor("direction", () => { Direction = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("id", () => { ID = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("tile", () => {
stf.MustMatchBlockStart();
location = new WorldLocation(stf.ReadInt(null), stf.ReadInt(null),
stf.ReadFloat(STFReader.Units.None, null), 0f, stf.ReadFloat(STFReader.Units.None, null));
stf.MustMatchBlockEnd();
}),
});
}
internal Services(STFReader stf)
{
stf.MustMatchBlockStart();
Name = stf.ReadString();
Time = (int)stf.ReadFloat(STFReader.Units.Time, null);
stf.MustMatch("uid");
UiD = stf.ReadIntBlock(null);
// Clumsy parsing. You only get a new Service_Item in the list after a PlatformStartId is met.
// Blame lies with Microsoft for poor design of syntax.
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("efficiency", () => { efficiency = stf.ReadFloatBlock(STFReader.Units.Any, null); }),
new STFReader.TokenProcessor("skipcount", () => { skipCount = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("distancedownpath", () => { distanceDownPath = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
new STFReader.TokenProcessor("platformstartid", () => { platformStartID = stf.ReadIntBlock(null);
Add(new TrafficItem(efficiency, skipCount, distanceDownPath, platformStartID)); }),
});
}
internal Activity(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tr_activity_file", () => { ParseActivityDetails(stf); }),
new STFReader.TokenProcessor("serial", () => { Serial = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("tr_activity_header", () => { ParseActivityHeader(stf); }),
});
}
public Traffic_Traffic_Definition(STFReader stf)
{
stf.MustMatch("(");
Name = stf.ReadString();
stf.MustMatch("serial");
Serial = stf.ReadIntBlock(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("service_definition", () => { TrafficItems.Add(new Traffic_Service_Definition(stf)); }),
});
}
internal ServiceTraffic(STFReader stf)
{
stf.MustMatchBlockStart();
Name = stf.ReadString();
stf.MustMatch("serial");
Serial = stf.ReadIntBlock(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("service_definition", () => { ServiceTraffics.Add(new ServiceTraffics(stf)); }),
});
}
public Wagon(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("uid", () => { UiD = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("flip", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Flip = true; }),
new STFReader.TokenProcessor("enginedata", () => { stf.MustMatchBlockStart(); Name = stf.ReadString(); Folder = stf.ReadString(); stf.MustMatchBlockEnd(); IsEngine = true; }),
new STFReader.TokenProcessor("wagondata", () => { stf.MustMatchBlockStart(); Name = stf.ReadString(); Folder = stf.ReadString(); stf.MustMatchBlockEnd(); }),
});
}
public Light(int index, STFReader stf)
{
Index = index;
stf.MustMatch("(");
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("type", () => { Type = (LightType)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("conditions", () => { stf.MustMatch("("); stf.ParseBlock(new[] {
new STFReader.TokenProcessor("headlight", () => { Headlight = (LightHeadlightCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("unit", () => { Unit = (LightUnitCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("penalty", () => { Penalty = (LightPenaltyCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("control", () => { Control = (LightControlCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("service", () => { Service = (LightServiceCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("timeofday", () => { TimeOfDay = (LightTimeOfDayCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("weather", () => { Weather = (LightWeatherCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("coupling", () => { Coupling = (LightCouplingCondition)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("ortsbattery", () => { Battery = (LightBatteryCondition)stf.ReadIntBlock(null); }),
}); }),
new STFReader.TokenProcessor("cycle", () => { Cycle = 0 != stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("fadein", () => { FadeIn = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("fadeout", () => { FadeOut = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("states", () => {
stf.MustMatch("(");
var count = stf.ReadInt(null);
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("state", () => {
if (States.Count >= count)
{
STFException.TraceWarning(stf, "Skipped extra State");
}
else
{
States.Add(new LightState(stf));
}
}),
});
if (States.Count < count)
{
STFException.TraceWarning(stf, (count - States.Count).ToString() + " missing State(s)");
}
}),
});
}
public Activation(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("externalcam", () => { ExternalCam = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("cabcam", () => { CabCam = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("passengercam", () => { PassengerCam = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("distance", () => { Distance = stf.ReadFloatBlock(STFReader.UNITS.Distance, Distance); }),
new STFReader.TokenProcessor("tracktype", () => { TrackType = stf.ReadIntBlock(null); }),
});
}
public SMSStream(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("priority", () => { Priority = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("triggers", () => { Triggers = new Triggers(stf); }),
new STFReader.TokenProcessor("volumecurve", () => { VolumeCurves.Add(new VolumeCurve(stf)); }),
new STFReader.TokenProcessor("frequencycurve", () => { FrequencyCurve = new FrequencyCurve(stf); }),
new STFReader.TokenProcessor("volume", () => { Volume = stf.ReadFloatBlock(STFReader.UNITS.None, Volume); }),
});
//if (Volume > 1) Volume /= 100f;
}
public CabViewGaugeControl(STFReader stf, string basePath)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("type", () => { ParseType(stf); }),
new STFReader.TokenProcessor("position", () => { ParsePosition(stf); }),
new STFReader.TokenProcessor("scalerange", () => { ParseScaleRange(stf); }),
new STFReader.TokenProcessor("graphic", () => { ParseGraphic(stf, basePath); }),
new STFReader.TokenProcessor("style", () => { ParseStyle(stf); }),
new STFReader.TokenProcessor("units", () => { ParseUnits(stf); }),
new STFReader.TokenProcessor("zeropos", () => { ZeroPos = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("orientation", () => { Orientation = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("dirincrease", () => { Direction = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("area", () => {
stf.MustMatchBlockStart();
area = new Rectangle(stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null));
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("positivecolour", () => {
stf.MustMatchBlockStart();
(PositiveColors, PositiveTrigger) = ParseControlColors(stf);
}),
new STFReader.TokenProcessor("negativecolour", () => {
stf.MustMatchBlockStart();
(NegativeColors, NegativeTrigger) = ParseControlColors(stf);
}),
new STFReader.TokenProcessor("decreasecolour", () => {
stf.MustMatchBlockStart();
stf.ReadInt(0);
if (!stf.EndOfBlock())
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("controlcolour", () => { DecreaseColor = ParseControlColor(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 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.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); }),
});
}
internal override void Update(STFReader stf)
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("eventtypeallstops", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.AllStops; }),
new STFReader.TokenProcessor("eventtypeassembletrain", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.AssembleTrain; }),
new STFReader.TokenProcessor("eventtypeassembletrainatlocation", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.AssembleTrainAtLocation; }),
new STFReader.TokenProcessor("eventtypedropoffwagonsatlocation", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.DropOffWagonsAtLocation; }),
new STFReader.TokenProcessor("eventtypepickuppassengers", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.PickUpPassengers; }),
new STFReader.TokenProcessor("eventtypepickupwagons", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.PickUpWagons; }),
new STFReader.TokenProcessor("eventtypereachspeed", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Type = EventType.ReachSpeed; }),
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("wagon_list", () => { WorkOrderWagons = new WorkOrderWagons(stf); }),
new STFReader.TokenProcessor("sidingitem", () => { SidingId = (uint)stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("speed", () => { SpeedMpS = stf.ReadFloatBlock(STFReader.Units.Speed, null); }),
new STFReader.TokenProcessor("reversable_event", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Reversible = true; }),
// Also support the correct spelling !
new STFReader.TokenProcessor("reversible_event", () => { stf.MustMatchBlockStart(); stf.MustMatchBlockEnd(); Reversible = true; }),
new STFReader.TokenProcessor("ortscontinue", () => { OrtsContinue = stf.ReadIntBlock(0); }),
new STFReader.TokenProcessor("ortsactsoundfile", () => OrtsActivitySoundProcessor(stf)),
});
}
public Traffic_Service_Definition(STFReader stf)
{
var arrivalTime = 0;
var departTime = 0;
var skipCount = 0;
var distanceDownPath = 0F;
var platformStartID = 0;
stf.MustMatch("(");
Service_Definition = stf.ReadString();
Time = stf.ReadInt(null); // Cannot use stt.ReadFloat(STFReader.UNITS.Time, null) as number will be followed by "arrivaltime"
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("arrivaltime", () => { arrivalTime = (int)stf.ReadFloatBlock(STFReader.UNITS.Time, null); }),
new STFReader.TokenProcessor("departtime", () => { departTime = (int)stf.ReadFloatBlock(STFReader.UNITS.Time, null); }),
new STFReader.TokenProcessor("skipcount", () => { skipCount = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("distancedownpath", () => { distanceDownPath = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
new STFReader.TokenProcessor("platformstartid", () => { platformStartID = stf.ReadIntBlock(null);
TrafficDetails.Add(new Traffic_Traffic_Item(arrivalTime, departTime, skipCount, distanceDownPath, platformStartID)); }),
});
}
internal ServiceTraffics(STFReader stf)
{
int arrivalTime = 0;
int departTime = 0;
int skipCount = 0;
float distanceDownPath = 0f;
int platformStartID = 0;
stf.MustMatchBlockStart();
Name = stf.ReadString();
Time = stf.ReadInt(null); // Cannot use stt.ReadFloat(STFReader.Units.Time, null) as number will be followed by "arrivaltime"
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("arrivaltime", () => { arrivalTime = (int)stf.ReadFloatBlock(STFReader.Units.Time, null); }),
new STFReader.TokenProcessor("departtime", () => { departTime = (int)stf.ReadFloatBlock(STFReader.Units.Time, null); }),
new STFReader.TokenProcessor("skipcount", () => { skipCount = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("distancedownpath", () => { distanceDownPath = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
new STFReader.TokenProcessor("platformstartid", () => { platformStartID = stf.ReadIntBlock(null);
Add(new ServiceTrafficItem(arrivalTime, departTime, skipCount, distanceDownPath, platformStartID, this)); }),
});
}
public CVCDial(STFReader stf, string basepath)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("type", () => { ParseType(stf); }),
new STFReader.TokenProcessor("position", () => { ParsePosition(stf); }),
new STFReader.TokenProcessor("scalerange", () => { ParseScaleRange(stf); }),
new STFReader.TokenProcessor("graphic", () => { ParseGraphic(stf, basepath); }),
new STFReader.TokenProcessor("style", () => { ParseStyle(stf); }),
new STFReader.TokenProcessor("units", () => { ParseUnits(stf); }),
new STFReader.TokenProcessor("pivot", () => { Center = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("dirincrease", () => { Direction = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("scalepos", () => {
stf.MustMatch("(");
FromDegree = stf.ReadFloat(STFReader.UNITS.None, null);
ToDegree = stf.ReadFloat(STFReader.UNITS.None, null);
stf.SkipRestOfBlock();
}),
});
}
internal PlayerTraffics(STFReader stf)
{
int arrivalTime = 0;
int departTime = 0;
int skipCount = 0;
float distanceDownPath = 0f;
int platformStartID;
stf.MustMatchBlockStart();
Time = (int)stf.ReadFloat(STFReader.Units.Time, null);
// Clumsy parsing. You only get a new Player_Traffic_Item in the list after a PlatformStartId is met.
// Blame lies with Microsoft for poor design of syntax.
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("arrivaltime", () => { arrivalTime = (int)stf.ReadFloatBlock(STFReader.Units.Time, null); }),
new STFReader.TokenProcessor("departtime", () => { departTime = (int)stf.ReadFloatBlock(STFReader.Units.Time, null); }),
new STFReader.TokenProcessor("skipcount", () => { skipCount = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("distancedownpath", () => { distanceDownPath = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
new STFReader.TokenProcessor("platformstartid", () => { platformStartID = stf.ReadIntBlock(null);
Add(new ServiceTrafficItem(arrivalTime, departTime, skipCount, distanceDownPath, platformStartID)); }),
});
}
// constructor for standard dials
public CabViewDialControl(STFReader stf, string basePath)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("type", () => { ParseType(stf); }),
new STFReader.TokenProcessor("position", () => { ParsePosition(stf); }),
new STFReader.TokenProcessor("scalerange", () => { ParseScaleRange(stf); }),
new STFReader.TokenProcessor("graphic", () => { ParseGraphic(stf, basePath); }),
new STFReader.TokenProcessor("style", () => { ParseStyle(stf); }),
new STFReader.TokenProcessor("units", () => { ParseUnits(stf); }),
new STFReader.TokenProcessor("pivot", () => { Center = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("dirincrease", () => { Direction = stf.ReadIntBlock(null) == 0 ? Rotation.Clockwise : Rotation.CounterClockwise; }),
new STFReader.TokenProcessor("scalepos", () => {
stf.MustMatchBlockStart();
StartAngle = stf.ReadFloat(STFReader.Units.None, null);
EndAngle = stf.ReadFloat(STFReader.Units.None, null);
stf.SkipRestOfBlock();
}),
});
}
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); }),
});
}
/// <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;
}
}
/// <summary>
/// Parses parameters from the stf reader
/// </summary>
/// <param name="stf">Reference to the stf reader</param>
/// <param name="loco">Reference to the locomotive</param>
public virtual void Parse(STFReader stf, MSTSDieselLocomotive loco)
{
locomotive = loco;
stf.MustMatch("(");
bool end = false;
while (!end)
{
string lowercasetoken = stf.ReadItem().ToLower();
switch (lowercasetoken)
{
case "idlerpm": IdleRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.IdleRPM; break;
case "maxrpm": MaxRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.MaxRPM; break;
case "startingrpm": StartingRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.StartingRPM; break;
case "startingconfirmrpm": StartingConfirmationRPM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.StartingConfirmRPM; break;
case "changeuprpmps": ChangeUpRPMpS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.ChangeUpRPMpS; break;
case "changedownrpmps": ChangeDownRPMpS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.ChangeDownRPMpS; break;
case "rateofchangeuprpmpss": RateOfChangeUpRPMpSS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.RateOfChangeUpRPMpSS; break;
case "rateofchangedownrpmpss": RateOfChangeDownRPMpSS = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.RateOfChangeDownRPMpSS; break;
case "maximalpower": MaximalPowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, 0); initLevel |= SettingsFlags.MaximalPowerW; break;
case "idleexhaust": InitialExhaust = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.IdleExhaust; break;
case "maxexhaust": MaxExhaust = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.MaxExhaust; break;
case "exhaustdynamics": ExhaustAccelIncrease = stf.ReadFloatBlock(STFReader.UNITS.None, 0); initLevel |= SettingsFlags.ExhaustDynamics; break;
case "exhaustdynamicsdown": ExhaustDecelReduction = stf.ReadFloatBlock(STFReader.UNITS.None, null); initLevel |= SettingsFlags.ExhaustDynamics; break;
case "exhaustcolor": ExhaustSteadyColor.PackedValue = stf.ReadHexBlock(Color.Gray.PackedValue); initLevel |= SettingsFlags.ExhaustColor; break;
case "exhausttransientcolor": ExhaustTransientColor.PackedValue = stf.ReadHexBlock(Color.Black.PackedValue); initLevel |= SettingsFlags.ExhaustTransientColor; break;
case "dieselpowertab": DieselPowerTab = new Interpolator(stf); initLevel |= SettingsFlags.DieselPowerTab; break;
case "dieselconsumptiontab": DieselConsumptionTab = new Interpolator(stf); initLevel |= SettingsFlags.DieselConsumptionTab; break;
case "throttlerpmtab": ThrottleRPMTab = new Interpolator(stf); initLevel |= SettingsFlags.ThrottleRPMTab; break;
case "dieseltorquetab": DieselTorqueTab = new Interpolator(stf); initLevel |= SettingsFlags.DieselTorqueTab; break;
case "minoilpressure": DieselMinOilPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, 40f); initLevel |= SettingsFlags.MinOilPressure; break;
case "maxoilpressure": DieselMaxOilPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, 120f); initLevel |= SettingsFlags.MaxOilPressure; break;
case "maxtemperature": DieselMaxTemperatureDeg = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 100f); initLevel |= SettingsFlags.MaxTemperature; break;
case "cooling": EngineCooling = (Cooling)stf.ReadIntBlock((int)Cooling.Proportional); initLevel |= SettingsFlags.Cooling; break; //ReadInt changed to ReadIntBlock
case "temptimeconstant": DieselTempTimeConstantSec = stf.ReadFloatBlock(STFReader.UNITS.Time, 720f); initLevel |= SettingsFlags.TempTimeConstant; break;
case "opttemperature": DieselOptimalTemperatureDegC = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 95f); initLevel |= SettingsFlags.OptTemperature; break;
case "idletemperature": DieselIdleTemperatureDegC = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 75f); initLevel |= SettingsFlags.IdleTemperature; break;
default:
end = true;
break;
}
}
}
