public ORTrackData(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsmaxviewingdistance", () => { MaxViewingDistance = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
});
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalDrawState(STFReader stf)
{
stf.MustMatchBlockStart();
Index = stf.ReadInt(null);
Name = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("drawlights", () => { DrawLights = ReadDrawLights(stf); }),
new STFReader.TokenProcessor("semaphorepos", () => { SemaphorePosition = stf.ReadFloatBlock(STFReader.Units.None, 0); }),
});
}
public ApproachControlLimits(STFReader stf)
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("positionmiles", () => { ApproachControlPositionM = (float)Size.Length.FromMi(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("positionkm", () => { ApproachControlPositionM = (stf.ReadFloatBlock(STFReader.Units.None, 0) * 1000); }),
new STFReader.TokenProcessor("positionm", () => { ApproachControlPositionM = stf.ReadFloatBlock(STFReader.Units.None, 0); }),
new STFReader.TokenProcessor("positionyd", () => { ApproachControlPositionM = (float)Size.Length.FromYd(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("speedmph", () => { ApproachControlSpeedMpS = (float)Speed.MeterPerSecond.FromMpH(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { ApproachControlSpeedMpS = (float)Speed.MeterPerSecond.FromKpH(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
});
}
internal Route(STFReader stf)
{
stf.MustMatchBlockStart();
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", () => { RouteStart = new RouteStart(stf); }),
new STFReader.TokenProcessor("environment", () => { Environment = new Environment(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); }),
// if true removes forest trees also from roads
new STFReader.TokenProcessor("ortsuserpreferenceremoveforesttreesfromroads", () => { RemoveForestTreesFromRoads = stf.ReadBoolBlock(false); }),
// values for superelevation
new STFReader.TokenProcessor("ortstracksuperelevation", () => { SuperElevationHgtpRadiusM = stf.CreateInterpolator(); }),
// images
new STFReader.TokenProcessor("graphic", () => { Thumbnail = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("loadingscreen", () => { LoadingScreen = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("ortsloadingscreenwide", () => { LoadingScreenWide = stf.ReadStringBlock(null); }),
// values for OHLE
new STFReader.TokenProcessor("ortsdoublewireenabled", () => { DoubleWireEnabled = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("ortsdoublewireheight", () => { DoubleWireHeight = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
new STFReader.TokenProcessor("ortstriphaseenabled", () => { TriphaseEnabled = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("ortstriphasewidth", () => { TriphaseWidth = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
// default sms file for turntables and transfertables
new STFReader.TokenProcessor("ortsdefaultturntablesms", () => { DefaultTurntableSMS = stf.ReadStringBlock(null); }),
// sms file number in Ttype.dat when train over switch
new STFReader.TokenProcessor("ortsswitchsmsnumber", () => { SwitchSMSNumber = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("ortscurvesmsnumber", () => { CurveSMSNumber = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("ortscurveswitchsmsnumber", () => { CurveSwitchSMSNumber = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("ortsopendoorsinaitrains", () => { OpenDoorsInAITrains = stf.ReadBoolBlock(false); }),
});
//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");
}
if (ForestClearDistance == 0 && RemoveForestTreesFromRoads)
{
Trace.TraceWarning("You must define also ORTSUserPreferenceForestClearDistance to avoid trees on roads");
}
}
public void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "engine(trainbrakescontrollermaxsystempressure":
case "engine(enginebrakescontrollermaxsystempressure":
MaxPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null);
break;
case "engine(trainbrakescontrollermaxreleaserate":
case "engine(enginebrakescontrollermaxreleaserate":
ReleaseRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrollermaxquickreleaserate":
case "engine(enginebrakescontrollermaxquickreleaserate":
QuickReleaseRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrollermaxapplicationrate":
case "engine(enginebrakescontrollermaxapplicationrate":
ApplyRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrolleremergencyapplicationrate":
case "engine(enginebrakescontrolleremergencyapplicationrate":
EmergencyRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null);
break;
case "engine(trainbrakescontrollerfullservicepressuredrop":
case "engine(enginebrakescontrollerfullservicepressuredrop":
FullServReductionPSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null);
break;
case "engine(trainbrakescontrollerminpressurereduction":
case "engine(enginebrakescontrollerminpressurereduction":
MinReductionPSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null);
break;
case "engine(enginecontrollers(brake_train":
case "engine(enginecontrollers(brake_engine":
stf.MustMatch("(");
MinimumValue = stf.ReadFloat(STFReader.UNITS.None, null);
MaximumValue = stf.ReadFloat(STFReader.UNITS.None, null);
StepSize = stf.ReadFloat(STFReader.UNITS.None, null);
CurrentValue = stf.ReadFloat(STFReader.UNITS.None, null);
string token = stf.ReadItem(); // s/b numnotches
if (string.Compare(token, "NumNotches", true) != 0) // handle error in gp38.eng where extra parameter provided before NumNotches statement
{
stf.ReadItem();
}
stf.MustMatch("(");
stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("notch", () => {
stf.MustMatch("(");
float value = stf.ReadFloat(STFReader.UNITS.None, null);
int smooth = stf.ReadInt(null);
string type = stf.ReadString();
Notches.Add(new MSTSNotch(value, smooth, type, stf));
if (type != ")")
{
stf.SkipRestOfBlock();
}
}),
});
break;
case "engine(ortstrainbrakecontroller":
case "engine(ortsenginebrakecontroller":
if (Locomotive.Train as AITrain == null)
{
ScriptName = stf.ReadStringBlock(null);
}
break;
}
}
public ENVFileWaterLayer(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_water_layer_height", () => { Height = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
new STFReader.TokenProcessor("world_anim_shader", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_shader", () => { stf.MustMatch("("); stf.ReadString() /*TextureMode*/; stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("terrain_texslots", () => { stf.MustMatch("("); stf.ReadInt(null) /*Count*/; stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("terrain_texslot", () => { stf.MustMatch("("); TextureName = stf.ReadString(); stf.SkipRestOfBlock(); }),
}); }),
}); }),
}); }),
});
}
public ShapeDescriptor(STFReader stf)
{
Name = stf.ReadString(); // Ignore the filename string. TODO: Check if it agrees with the SD file name? Is this important?
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("esd_detail_level", () => { EsdDetailLevel = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("esd_alternative_texture", () => { EsdAlternativeTexture = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("esd_no_visual_obstruction", () => { EsdNoVisualObstruction = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("esd_snapable", () => { EsdSnapable = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("esd_subobj", () => { EsdSubObject = true; stf.SkipBlock(); }),
new STFReader.TokenProcessor("esd_bounding_box", () => {
EsdBoundingBox = new EsdBoundingBox(stf);
if (EsdBoundingBox.Min == null || EsdBoundingBox.Max == null) // ie quietly handle ESD_Bounding_Box()
{
EsdBoundingBox = null;
}
}),
new STFReader.TokenProcessor("esd_ortssoundfilename", () => { EsdSoundFileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("esd_ortsbellanimationfps", () => { EsdBellAnimationFps = stf.ReadFloatBlock(STFReader.Units.Frequency, null); }),
});
// TODO - some objects have no bounding box - ie JP2BillboardTree1.sd
//if (ESD_Bounding_Box == null) throw new STFException(stf, "Missing ESD_Bound_Box statement");
}
public bool ResetOnResetButton; // OverspeedMonitor only
public MonitoringDevice(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("monitoringdevicemonitortimelimit", () => { MonitorTimeS = stf.ReadFloatBlock(STFReader.UNITS.Time, MonitorTimeS); }),
new STFReader.TokenProcessor("monitoringdevicealarmtimelimit", () => { AlarmTimeS = stf.ReadFloatBlock(STFReader.UNITS.Time, AlarmTimeS); }),
new STFReader.TokenProcessor("monitoringdevicepenaltytimelimit", () => { PenaltyTimeS = stf.ReadFloatBlock(STFReader.UNITS.Time, PenaltyTimeS); }),
new STFReader.TokenProcessor("monitoringdevicecriticallevel", () => { CriticalLevelMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, CriticalLevelMpS); }),
new STFReader.TokenProcessor("monitoringdeviceresetlevel", () => { ResetLevelMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, ResetLevelMpS); }),
new STFReader.TokenProcessor("monitoringdeviceappliesfullbrake", () => { AppliesFullBrake = stf.ReadBoolBlock(AppliesFullBrake); }),
new STFReader.TokenProcessor("monitoringdeviceappliesemergencybrake", () => { AppliesEmergencyBrake = stf.ReadBoolBlock(AppliesEmergencyBrake); }),
new STFReader.TokenProcessor("monitoringdeviceappliescutspower", () => { EmergencyCutsPower = stf.ReadBoolBlock(EmergencyCutsPower); }),
new STFReader.TokenProcessor("monitoringdeviceappliesshutsdownengine", () => { EmergencyShutsDownEngine = stf.ReadBoolBlock(EmergencyShutsDownEngine); }),
new STFReader.TokenProcessor("monitoringdevicealarmtimebeforeoverspeed", () => { AlarmTimeBeforeOverspeedS = stf.ReadFloatBlock(STFReader.UNITS.Time, AlarmTimeBeforeOverspeedS); }),
new STFReader.TokenProcessor("monitoringdevicetriggeronoverspeed", () => { TriggerOnOverspeedMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, TriggerOnOverspeedMpS); }),
new STFReader.TokenProcessor("monitoringdevicetriggerontrackoverspeed", () => { TriggerOnTrackOverspeed = stf.ReadBoolBlock(TriggerOnTrackOverspeed); }),
new STFReader.TokenProcessor("monitoringdevicetriggerontrackoverspeedmargin", () => { TriggerOnTrackOverspeedMarginMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, TriggerOnTrackOverspeedMarginMpS); }),
new STFReader.TokenProcessor("monitoringdeviceresetondirectionneutral", () => { ResetOnDirectionNeutral = stf.ReadBoolBlock(ResetOnDirectionNeutral); }),
new STFReader.TokenProcessor("monitoringdeviceresetonresetbutton", () => { ResetOnResetButton = stf.ReadBoolBlock(ResetOnResetButton); }),
new STFReader.TokenProcessor("monitoringdeviceresetonzerospeed", () => { ResetOnZeroSpeed = stf.ReadBoolBlock(ResetOnZeroSpeed); }),
});
}
public override void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
// OpenRails specific parameters
case "wagon(brakepipevolume": BrakePipeVolumeM3 = (float)Size.Volume.FromFt3(stf.ReadFloatBlock(STFReader.Units.VolumeDefaultFT3, null)); break;
}
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
/// <param name="ORTSMode">Process SignalType for ORTS mode (always set NumClearAhead_ORTS only)</param>
public SignalType(STFReader stf, bool ORTSMode)
: this()
{
stf.MustMatch("(");
Name = stf.ReadString().ToLowerInvariant();
int numClearAhead = -2;
int numdefs = 0;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("signalfntype", () => { FnType = ReadFnType(stf); }), //[Rob Roeterdink] value was not passed
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("sigflashduration", () => {
stf.MustMatch("(");
FlashTimeOn = stf.ReadFloat(STFReader.UNITS.None, null);
FlashTimeOff = stf.ReadFloat(STFReader.UNITS.None, null);
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
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 (ORTSMode)
{
// In ORTS mode : always set value for NumClearAhead_ORTS
NumClearAhead_MSTS = -2;
NumClearAhead_ORTS = numClearAhead;
}
else
{
// In MSTS mode : if one line for SignalNumClearAhead defined, set value for NumClearAhead_MSTS, otherwise set value for NumClearAhead_ORTS
NumClearAhead_MSTS = numdefs == 1 ? numClearAhead : -2;
NumClearAhead_ORTS = numdefs == 2 ? numClearAhead : -2;
}
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalAspect(STFReader stf)
{
SpeedMpS = -1;
stf.MustMatch("(");
string aspectName = stf.ReadString();
try
{
Aspect = (MstsSignalAspect)Enum.Parse(typeof(MstsSignalAspect), aspectName, true);
}
catch (ArgumentException)
{
STFException.TraceInformation(stf, "Skipped unknown signal aspect " + aspectName);
Aspect = MstsSignalAspect.UNKNOWN;
}
DrawStateName = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("speedmph", () => { SpeedMpS = MpS.FromMpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { SpeedMpS = MpS.FromKpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "asap": Asap = true; break;
case "or_speedreset": Reset = true; break;
case "or_nospeedreduction": NoSpeedReduction = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown DrawLight flag " + stf.ReadString()); break;
}
}
}),
});
}
public ApproachControlLimits(STFReader stf)
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("positionmiles", () => { ApproachControlPositionM = Me.FromMi(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("positionkm", () => { ApproachControlPositionM = (stf.ReadFloatBlock(STFReader.UNITS.None, 0) * 1000); }),
new STFReader.TokenProcessor("positionm", () => { ApproachControlPositionM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("positionyd", () => { ApproachControlPositionM = Me.FromYd(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedmph", () => { ApproachControlSpeedMpS = MpS.FromMpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { ApproachControlSpeedMpS = MpS.FromKpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
});
}
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); }),
}); }),
});
}
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 AttributeProcessor(object setWhom, FieldInfo fi, STFReader stf, object defaultValue)
{
_fi = fi;
P = () =>
{
switch (_fi.FieldType.Name.ToLower())
{
case "int":
case "int32":
{
int?i = defaultValue as int?;
_fi.SetValue(setWhom,
stf.ReadIntBlock(i));
break;
}
case "bool":
case "boolean":
{
bool?b = defaultValue as bool?;
_fi.SetValue(setWhom,
stf.ReadBoolBlock(b.Value));
break;
}
case "string":
{
string s = defaultValue as string;
_fi.SetValue(setWhom,
stf.ReadStringBlock(s));
break;
}
case "float":
case "single":
{
float?f = defaultValue as float?;
_fi.SetValue(setWhom,
stf.ReadFloatBlock(STFReader.Units.Any, f));
break;
}
case "double":
{
double?d = defaultValue as double?;
_fi.SetValue(setWhom,
stf.ReadDoubleBlock(d));
break;
}
case "vector3":
{
Vector3 v3 = (defaultValue as string).ParseVector3();
{
_fi.SetValue(setWhom,
stf.ReadVector3Block(STFReader.Units.Any, v3));
}
break;
}
case "vector4":
{
Vector4 v4 = (defaultValue as string).ParseVector4();
{
stf.ReadVector4Block(STFReader.Units.Any, ref v4);
_fi.SetValue(setWhom, v4);
}
break;
}
case "color":
{
Color c = (defaultValue as string).ParseColor();
{
Vector4 v4 = new Vector4(-1);
stf.ReadVector4Block(STFReader.Units.Any, ref v4);
if (v4.W == -1)
{
c.A = 255;
c.R = v4.X == -1 ? c.R : (byte)v4.X;
c.G = v4.Y == -1 ? c.G : (byte)v4.Y;
c.B = v4.Z == -1 ? c.B : (byte)v4.Z;
}
else
{
c.A = v4.X == -1 ? c.A : (byte)v4.X;
c.R = v4.Y == -1 ? c.R : (byte)v4.Y;
c.G = v4.Z == -1 ? c.G : (byte)v4.Z;
c.B = v4.W == -1 ? c.B : (byte)v4.W;
}
_fi.SetValue(setWhom, c);
}
break;
}
}
};
}
public TrackShape(STFReader stf)
{
stf.MustMatchBlockStart();
ShapeIndex = stf.ReadUInt(null);
int nextPath = 0;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("filename", () => { FileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("numpaths", () => { SectionIndices = new SectionIndex[PathsNumber = stf.ReadUIntBlock(null)]; }),
new STFReader.TokenProcessor("mainroute", () => { MainRoute = stf.ReadUIntBlock(null); }),
new STFReader.TokenProcessor("clearancedist", () => { ClearanceDistance = stf.ReadFloatBlock(STFReader.Units.Distance, null); }),
new STFReader.TokenProcessor("sectionidx", () => { SectionIndices[nextPath++] = new SectionIndex(stf); }),
new STFReader.TokenProcessor("tunnelshape", () => { TunnelShape = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("roadshape", () => { RoadShape = stf.ReadBoolBlock(true); }),
});
// TODO - this was removed since TrackShape( 183 ) is blank
//if( FileName == null ) throw( new STFError( stf, "Missing FileName" ) );
//if( SectionIdxs == null ) throw( new STFError( stf, "Missing SectionIdxs" ) );
//if( NumPaths == 0 ) throw( new STFError( stf, "No Paths in TrackShape" ) );
}
public void Parse(string lowercasetoken, STFReader stf)
{
string temp = "";
switch (lowercasetoken)
{
case "engine(gearboxnumberofgears": GearBoxNumberOfGears = stf.ReadIntBlock(1); initLevel++; break;
case "engine(gearboxdirectdrivegear": GearBoxDirectDriveGear = stf.ReadIntBlock(1); break; // initLevel++; break;
case "engine(gearboxoperation":
temp = stf.ReadStringBlock("manual");
switch (temp)
{
case "manual": GearBoxOperation = GearBoxOperation.Manual; break;
case "automatic": GearBoxOperation = GearBoxOperation.Automatic; break;
case "semiautomatic": GearBoxOperation = GearBoxOperation.Semiautomatic; break;
}
initLevel++;
break;
case "engine(gearboxenginebraking":
temp = stf.ReadStringBlock("none");
switch (temp)
{
case "none": GearBoxEngineBraking = GearBoxEngineBraking.None; break;
case "all_gears": GearBoxEngineBraking = GearBoxEngineBraking.AllGears; break;
case "direct_drive": GearBoxEngineBraking = GearBoxEngineBraking.DirectDrive; break;
}
initLevel++;
break;
case "engine(gearboxmaxspeedforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxSpeedForGearsMpS.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxSpeedForGearsMpS.Add(stf.ReadFloat(STFReader.UNITS.SpeedDefaultMPH, 10.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(gearboxmaxtractiveforceforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxTractiveForceForGearsN.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxTractiveForceForGearsN.Add(stf.ReadFloat(STFReader.UNITS.Force, 10000.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(gearboxoverspeedpercentageforfailure": GearBoxOverspeedPercentageForFailure = stf.ReadFloatBlock(STFReader.UNITS.None, 150f); break; // initLevel++; break;
case "engine(gearboxbackloadforce": GearBoxBackLoadForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxcoastingforce": GearBoxCoastingForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxupgearproportion": GearBoxUpGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.85f); break; // initLevel++; break;
case "engine(gearboxdowngearproportion": GearBoxDownGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.25f); break; // initLevel++; break;
default: break;
}
}
/// <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;
}
}
}
public EnvironmentFile(string filePath)
{
using (STFReader stf = new STFReader(filePath, false))
stf.ParseFile(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_water", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_water_wave_height", () => { WaterWaveHeight = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
new STFReader.TokenProcessor("world_water_wave_speed", () => { WaterWaveSpeed = stf.ReadFloatBlock(STFReader.UNITS.Speed, null); }),
new STFReader.TokenProcessor("world_water_layers", () => { ParseWaterLayers(stf); }),
}); }),
}); }),
});
using (STFReader stf = new STFReader(filePath, false))
stf.ParseFile(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("world_sky", () => { stf.MustMatch("("); stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("worldskynlayers_behind_satellites", () => { WorldSkynLayers = stf.ReadFloatBlock(STFReader.UNITS.Any, null); }),
new STFReader.TokenProcessor("world_sky_layers", () => { ParseSkyLayers(stf); }),
new STFReader.TokenProcessor("world_sky_satellites", () => { ParseWorldSkySatellites(stf); }),
}); }),
}); }),
});
}
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); }),
});
}
public void Parse(string lowercasetoken, STFReader stf)
{
string temp = "";
switch (lowercasetoken)
{
case "engine(gearboxnumberofgears": GearBoxNumberOfGears = stf.ReadIntBlock(1); initLevel++; break;
case "engine(gearboxdirectdrivegear": GearBoxDirectDriveGear = stf.ReadIntBlock(1); break;
case "engine(ortsgearboxfreewheel":
var freeWheel = stf.ReadIntBlock(null);
if (freeWheel == 1)
{
FreeWheelFitted = true;
}
break;
case "engine(ortsgearboxtype":
stf.MustMatch("(");
var gearType = stf.ReadString();
try
{
GearBoxType = (TypesGearBox)Enum.Parse(typeof(TypesGearBox), gearType.First().ToString().ToUpper() + gearType.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown gear box type " + gearType);
}
break;
case "engine(ortsmainclutchtype":
stf.MustMatch("(");
var clutchType = stf.ReadString();
try
{
ClutchType = (TypesClutch)Enum.Parse(typeof(TypesClutch), clutchType.First().ToString().ToUpper() + clutchType.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown main clutch type " + clutchType);
}
break;
case "engine(gearboxoperation":
stf.MustMatch("(");
var gearOperation = stf.ReadString();
try
{
GearBoxOperation = (GearBoxOperation)Enum.Parse(typeof(GearBoxOperation), gearOperation.First().ToString().ToUpper() + gearOperation.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown gear box operation type " + gearOperation);
}
initLevel++;
break;
case "engine(gearboxenginebraking":
stf.MustMatch("(");
var engineBraking = stf.ReadString();
try
{
GearBoxEngineBraking = (GearBoxEngineBraking)Enum.Parse(typeof(GearBoxEngineBraking), engineBraking.First().ToString().ToUpper() + engineBraking.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Assumed unknown gear box engine braking type " + engineBraking);
}
break;
case "engine(gearboxmaxspeedforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxSpeedForGearsMpS.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxSpeedForGearsMpS.Add(stf.ReadFloat(STFReader.UNITS.SpeedDefaultMPH, 10.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
// gearboxmaxtractiveforceforgears purely retained for legacy reasons
case "engine(gearboxmaxtractiveforceforgears":
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxMaxTractiveForceForGearsN.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxMaxTractiveForceForGearsN.Add(stf.ReadFloat(STFReader.UNITS.Force, 10000.0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(ortsgearboxtractiveforceatspeed":
MaxTEFound = true;
temp = stf.ReadItem();
if (temp == ")")
{
stf.StepBackOneItem();
}
if (temp == "(")
{
GearBoxTractiveForceAtSpeedN.Clear();
for (int i = 0; i < GearBoxNumberOfGears; i++)
{
GearBoxTractiveForceAtSpeedN.Add(stf.ReadFloat(STFReader.UNITS.Force, 0f));
}
stf.SkipRestOfBlock();
initLevel++;
}
break;
case "engine(gearboxoverspeedpercentageforfailure": GearBoxOverspeedPercentageForFailure = stf.ReadFloatBlock(STFReader.UNITS.None, 150f); break; // initLevel++; break;
case "engine(gearboxbackloadforce": GearBoxBackLoadForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxcoastingforce": GearBoxCoastingForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, 0f); break;
case "engine(gearboxupgearproportion": GearBoxUpGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.85f); break; // initLevel++; break;
case "engine(gearboxdowngearproportion": GearBoxDownGearProportion = stf.ReadFloatBlock(STFReader.UNITS.None, 0.25f); break; // initLevel++; break;
default: break;
}
}
public FreightAnimations(STFReader stf, MSTSWagon wagon)
{
stf.MustMatch("(");
bool empty = true;
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("mstsfreightanimenabled", () => { MSTSFreightAnimEnabled = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("wagonemptyweight", () => { WagonEmptyWeight = stf.ReadFloatBlock(STFReader.UNITS.Mass, -1); }),
new STFReader.TokenProcessor("loadingstartdelay", () => { UnloadingStartDelay = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("unloadingstartdelay", () => { UnloadingStartDelay = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("isgondola", () => { IsGondola = stf.ReadBoolBlock(false); }),
new STFReader.TokenProcessor("freightanimcontinuous", () =>
{
Animations.Add(new FreightAnimationContinuous(stf, wagon));
if (wagon.WeightLoadController == null)
{
wagon.WeightLoadController = new MSTSNotchController(0, 1, 0.01f);
}
if ((Animations.Last() as FreightAnimationContinuous).FullAtStart)
{
if (empty)
{
empty = false;
FreightType = wagon.IntakePointList.Last().Type;
LoadedOne = Animations.Last() as FreightAnimationContinuous;
FreightWeight += LoadedOne.FreightWeightWhenFull;
LoadedOne.LoadPerCent = 100;
}
else
{
(Animations.Last() as FreightAnimationContinuous).FullAtStart = false;
Trace.TraceWarning("The wagon can't be full with two different materials, only first is retained");
}
}
}),
new STFReader.TokenProcessor("freightanimstatic", () =>
{
Animations.Add(new FreightAnimationStatic(stf));
StaticFreightWeight += (Animations.Last() as FreightAnimationStatic).FreightWeight;
}),
/* new STFReader.TokenProcessor("freightanimdiscrete", ()=>
* {
* ORTSFreightAnims.Add(new FreightAnimDiscrete(stf));
* if ((ORTSFreightAnims.Last() as FreightAnimDiscrete).LoadedAtStart)
* {
* if (empty)
* {
* empty = false;
* DiscreteLoadedOne = ORTSFreightAnims.Last() as FreightAnimDiscrete;
* FreightWeight += DiscreteLoadedOne.LoadWeight;
* }
* else
* {
* (ORTSFreightAnims.Last() as FreightAnimContinuous).FullAtStart = false;
* Trace.TraceWarning("The wagon can't be full with two different materials, only first is retained");
* }
* }
* }),*/
});
}
/// <summary>
/// Parse the wag file parameters required for the simulator and viewer classes
/// </summary>
public override void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "engine(dieselengineidlerpm": IdleRPM = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(dieselenginemaxrpm": MaxRPM = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(dieselenginemaxrpmchangerate": MaxRPMChangeRate = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(ortsdieselenginemaxpower": MaximumDieselEnginePowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, null); break;
case "engine(effects(dieselspecialeffects": ParseEffects(lowercasetoken, stf); break;
case "engine(dieselsmokeeffectinitialsmokerate": InitialExhaust = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(dieselsmokeeffectinitialmagnitude": InitialMagnitude = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(dieselsmokeeffectmaxsmokerate": MaxExhaust = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(dieselsmokeeffectmaxmagnitude": MaxMagnitude = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
case "engine(ortsdieselengines": DieselEngines = new DieselEngines(this, stf); break;
case "engine(maxdiesellevel": MaxDieselLevelL = stf.ReadFloatBlock(STFReader.UNITS.Volume, null); break;
case "engine(dieselusedperhouratmaxpower": DieselUsedPerHourAtMaxPowerL = stf.ReadFloatBlock(STFReader.UNITS.Volume, null); break;
case "engine(dieselusedperhouratidle": DieselUsedPerHourAtIdleL = stf.ReadFloatBlock(STFReader.UNITS.Volume, null); break;
case "engine(maxoilpressure": DieselMaxOilPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, 120f); break;
case "engine(ortsminoilpressure": DieselMinOilPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, 40f); break;
case "engine(maxtemperature": DieselMaxTemperatureDeg = stf.ReadFloatBlock(STFReader.UNITS.TemperatureDifference, 100f); break;
case "engine(ortsdieselcooling": DieselEngineCooling = (DieselEngine.Cooling)stf.ReadInt((int)DieselEngine.Cooling.Proportional); break;
default:
GearBox.Parse(lowercasetoken, stf);
base.Parse(lowercasetoken, stf); break;
}
if (IdleRPM != 0 && MaxRPM != 0 && MaxRPMChangeRate != 0)
{
PercentChangePerSec = MaxRPMChangeRate / (MaxRPM - IdleRPM);
EngineRPM = IdleRPM;
}
}
public CVCMultiStateDisplay(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("units", () => { ParseUnits(stf); }),
new STFReader.TokenProcessor("states", () => {
stf.MustMatch("(");
FramesCount = stf.ReadInt(null);
FramesX = stf.ReadInt(null);
FramesY = stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("state", () => {
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("style", () => { MSStyles.Add(ParseNumStyle(stf)); }),
new STFReader.TokenProcessor("switchval", () => { Values.Add(stf.ReadFloatBlock(STFReader.UNITS.None, null))
; }),
});
}),
});
if (Values.Count > 0)
{
MaxValue = Values.Last();
}
for (int i = Values.Count; i < FramesCount; i++)
{
Values.Add(-10000);
}
}),
});
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
/// <param name="orMode">Process SignalType for ORTS mode (always set NumClearAhead_ORTS only)</param>
public SignalType(STFReader stf, bool orMode)
: this()
{
stf.MustMatchBlockStart();
Name = stf.ReadString().ToLowerInvariant();
int numClearAhead = -2;
int numdefs = 0;
string ortsFunctionType = string.Empty;
string ortsNormalSubType = string.Empty;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsscript", () => { Script = stf.ReadStringBlock("").ToLowerInvariant(); }),
new STFReader.TokenProcessor("signalfntype", () => {
if (orMode)
{
ortsFunctionType = ReadOrtsFunctionType(stf);
}
else
{
FunctionType = ReadFunctionType(stf);
}
}),
new STFReader.TokenProcessor("signallighttex", () => { LightTextureName = stf.ReadStringBlock("").ToLowerInvariant(); }),
new STFReader.TokenProcessor("signallights", () => { Lights = ReadLights(stf); }),
new STFReader.TokenProcessor("signaldrawstates", () => { DrawStates = ReadDrawStates(stf); }),
new STFReader.TokenProcessor("signalaspects", () => { Aspects = ReadAspects(stf); }),
new STFReader.TokenProcessor("approachcontrolsettings", () => { ApproachControlDetails = ReadApproachControlDetails(stf); }),
new STFReader.TokenProcessor("signalnumclearahead", () => { numClearAhead = numClearAhead >= -1 ? numClearAhead : stf.ReadIntBlock(null); numdefs++; }),
new STFReader.TokenProcessor("semaphoreinfo", () => { SemaphoreInfo = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("ortsdayglow", () => { DayGlow = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("ortsnightglow", () => { NightGlow = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("ortsdaylight", () => { DayLight = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("ortsnormalsubtype", () => { ortsNormalSubType = ReadOrtsNormalSubType(stf); }),
new STFReader.TokenProcessor("ortsonofftime", () => { TransitionTime = stf.ReadFloatBlock(STFReader.Units.None, null); }),
new STFReader.TokenProcessor("sigflashduration", () => {
stf.MustMatchBlockStart();
FlashTimeOn = stf.ReadFloat(STFReader.Units.None, null);
FlashTimeOff = stf.ReadFloat(STFReader.Units.None, null);
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "abs": Abs = true; break;
case "no_gantry": NoGantry = true; break;
case "semaphore": Semaphore = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown SignalType flag " + stf.ReadString()); break;
}
}
}),
});
if (orMode)
{
// set related MSTS function type
OrtsFunctionTypeIndex = OrSignalTypes.Instance.FunctionTypes.FindIndex(i => StringComparer.OrdinalIgnoreCase.Equals(i, ortsFunctionType));
if (!EnumExtension.GetValue(ortsFunctionType, out SignalFunction functionType))
{
FunctionType = SignalFunction.Info;
}
else
{
FunctionType = functionType;
}
// set index for Normal Subtype
OrtsNormalSubTypeIndex = OrSignalTypes.Instance.NormalSubTypes.FindIndex(i => StringComparer.OrdinalIgnoreCase.Equals(i, ortsNormalSubType));
// set SNCA
NumClearAhead_MSTS = -2;
NumClearAhead_ORTS = numClearAhead;
}
else
{
// set defaulted OR function type
OrtsFunctionTypeIndex = (int)FunctionType;
// set SNCA
NumClearAhead_MSTS = numdefs == 1 ? numClearAhead : -2;
NumClearAhead_ORTS = numdefs == 2 ? numClearAhead : -2;
}
}
public float FullStaticCentreOfGravityM_Y = -9999; // get centre of gravity after adjusted for freight animation
public FreightAnimationStatic(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("subtype", () =>
{
var typeString = stf.ReadStringBlock(null);
switch (typeString)
{
default:
SubType = FreightAnimationStatic.Type.DEFAULT;
break;
}
}),
new STFReader.TokenProcessor("shape", () => { ShapeFileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("freightweight", () => { FreightWeight = stf.ReadFloatBlock(STFReader.UNITS.Mass, 0); }),
new STFReader.TokenProcessor("offset", () => {
stf.MustMatch("(");
XOffset = stf.ReadFloat(STFReader.UNITS.Distance, 0);
YOffset = stf.ReadFloat(STFReader.UNITS.Distance, 0);
ZOffset = stf.ReadFloat(STFReader.UNITS.Distance, 0);
stf.MustMatch(")");
}),
new STFReader.TokenProcessor("flip", () => { Flipped = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("visibility", () => {
for (int index = 0; index < 3; index++)
{
Visibility[index] = false;
}
foreach (var visibilityPlace in stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(','))
{
switch (visibilityPlace)
{
case "outside":
Visibility[(int)VisibleFrom.Outside] = true;
break;
case "cab2d":
Visibility[(int)VisibleFrom.Cab2D] = true;
break;
case "cab3d":
Visibility[(int)VisibleFrom.Cab3D] = true;
break;
default:
break;
}
}
}),
// additions to manage consequences of variable weight on friction and brake forces
new STFReader.TokenProcessor("fullortsdavis_a", () => { FullStaticORTSDavis_A = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullortsdavis_b", () => { FullStaticORTSDavis_B = stf.ReadFloatBlock(STFReader.UNITS.Resistance, -1); }),
new STFReader.TokenProcessor("fullortsdavis_c", () => { FullStaticORTSDavis_C = stf.ReadFloatBlock(STFReader.UNITS.ResistanceDavisC, -1); }),
new STFReader.TokenProcessor("fullortswagonfrontalarea", () => { FullStaticORTSWagonFrontalAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, -1); }),
new STFReader.TokenProcessor("fullortsdavisdragconstant", () => { FullStaticORTSDavisDragConstant = stf.ReadFloatBlock(STFReader.UNITS.Any, -1); }),
new STFReader.TokenProcessor("fullmaxbrakeforce", () => { FullStaticMaxBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullmaxhandbrakeforce", () => { FullStaticMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("fullcentreofgravity_y", () => { FullStaticCentreOfGravityM_Y = stf.ReadFloatBlock(STFReader.UNITS.Distance, -1); })
});
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalAspect(STFReader stf)
{
SpeedLimit = -1;
stf.MustMatchBlockStart();
string aspectName = stf.ReadString();
if (!EnumExtension.GetValue(aspectName, out SignalAspectState aspect))
{
STFException.TraceInformation(stf, "Skipped unknown signal aspect " + aspectName);
Aspect = SignalAspectState.Unknown;
}
else
{
Aspect = aspect;
}
DrawStateName = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("speedmph", () => { SpeedLimit = (float)Speed.MeterPerSecond.FromMpH(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { SpeedLimit = (float)Speed.MeterPerSecond.FromKpH(stf.ReadFloatBlock(STFReader.Units.None, 0)); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "asap":
Asap = true;
break;
case "or_speedreset":
Reset = true;
break;
case "or_nospeedreduction":
NoSpeedReduction = true;
break;
default:
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown DrawLight flag " + stf.ReadString());
break;
}
}
}),
});
}
public bool StaticFreightAnimationsPresent = false; // Flag to indicate that a continuous freight animation is present
public FreightAnimations(STFReader stf, MSTSWagon wagon)
{
stf.MustMatch("(");
bool empty = true;
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("mstsfreightanimenabled", () => { MSTSFreightAnimEnabled = stf.ReadBoolBlock(true); }),
new STFReader.TokenProcessor("wagonemptyweight", () => { WagonEmptyWeight = stf.ReadFloatBlock(STFReader.UNITS.Mass, -1); }),
new STFReader.TokenProcessor("loadingstartdelay", () => { UnloadingStartDelay = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("unloadingstartdelay", () => { UnloadingStartDelay = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("isgondola", () => { IsGondola = stf.ReadBoolBlock(false); }),
// additions to manage consequences of variable weight on friction and brake forces
new STFReader.TokenProcessor("emptyortsdavis_a", () => { EmptyORTSDavis_A = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("emptyortsdavis_b", () => { EmptyORTSDavis_B = stf.ReadFloatBlock(STFReader.UNITS.Resistance, -1); }),
new STFReader.TokenProcessor("emptyortsdavis_c", () => { EmptyORTSDavis_C = stf.ReadFloatBlock(STFReader.UNITS.ResistanceDavisC, -1); }),
new STFReader.TokenProcessor("emptyortswagonfrontalarea", () => { EmptyORTSWagonFrontalAreaM2 = stf.ReadFloatBlock(STFReader.UNITS.AreaDefaultFT2, -1); }),
new STFReader.TokenProcessor("emptyortsdavisdragconstant", () => { EmptyORTSDavisDragConstant = stf.ReadFloatBlock(STFReader.UNITS.Any, -1); }),
new STFReader.TokenProcessor("emptymaxbrakeforce", () => { EmptyMaxBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("emptymaxhandbrakeforce", () => { EmptyMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, -1); }),
new STFReader.TokenProcessor("emptycentreofgravity_y", () => { EmptyCentreOfGravityM_Y = stf.ReadFloatBlock(STFReader.UNITS.Distance, -1); }),
new STFReader.TokenProcessor("freightanimcontinuous", () =>
{
Animations.Add(new FreightAnimationContinuous(stf, wagon));
FullPhysicsContinuousOne = Animations.Last() as FreightAnimationContinuous;
if (wagon.WeightLoadController == null)
{
wagon.WeightLoadController = new MSTSNotchController(0, 1, 0.01f);
}
if ((Animations.Last() as FreightAnimationContinuous).FullAtStart)
{
if (empty)
{
empty = false;
FreightType = wagon.IntakePointList.Last().Type;
LoadedOne = Animations.Last() as FreightAnimationContinuous;
FreightWeight += LoadedOne.FreightWeightWhenFull;
LoadedOne.LoadPerCent = 100;
}
else
{
(Animations.Last() as FreightAnimationContinuous).FullAtStart = false;
Trace.TraceWarning("The wagon can't be full with two different materials, only first is retained");
}
}
ContinuousFreightAnimationsPresent = true;
}),
new STFReader.TokenProcessor("freightanimstatic", () =>
{
Animations.Add(new FreightAnimationStatic(stf));
StaticFreightWeight += (Animations.Last() as FreightAnimationStatic).FreightWeight;
StaticFreightAnimationsPresent = true;
FullPhysicsStaticOne = Animations.Last() as FreightAnimationStatic;
}),
/* new STFReader.TokenProcessor("freightanimdiscrete", ()=>
* {
* ORTSFreightAnims.Add(new FreightAnimDiscrete(stf));
* if ((ORTSFreightAnims.Last() as FreightAnimDiscrete).LoadedAtStart)
* {
* if (empty)
* {
* empty = false;
* DiscreteLoadedOne = ORTSFreightAnims.Last() as FreightAnimDiscrete;
* FreightWeight += DiscreteLoadedOne.LoadWeight;
* }
* else
* {
* (ORTSFreightAnims.Last() as FreightAnimContinuous).FullAtStart = false;
* Trace.TraceWarning("The wagon can't be full with two different materials, only first is retained");
* }
* }
* }),*/
});
}
public ORTRKData(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsmaxviewingdistance", () => { MaxViewingDistance = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
});
}
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); })
});
}
