protected void ParsePosition(STFReader stf)
{
stf.MustMatch("(");
PositionX = stf.ReadDouble(null);
PositionY = stf.ReadDouble(null);
Width = stf.ReadDouble(null);
Height = stf.ReadDouble(null);
// Handling middle values
while (!stf.EndOfBlock())
{
STFException.TraceWarning(stf, "Ignored additional positional parameters");
Width = Height;
Height = stf.ReadInt(null);
}
}
protected void ParseType(STFReader stf)
{
stf.MustMatch("(");
try
{
ControlType = (CABViewControlTypes)Enum.Parse(typeof(CABViewControlTypes), stf.ReadString());
}
catch (ArgumentException)
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlType " + stf.ReadString());
ControlType = CABViewControlTypes.NONE;
}
//stf.ReadItem(); // Skip repeated Class Type
stf.SkipRestOfBlock();
}
public FreightAnimationContinuous(STFReader stf, MSTSWagon wagon)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("intakepoint", () =>
{
wagon.IntakePointList.Add(new IntakePoint(stf));
wagon.IntakePointList.Last().LinkedFreightAnim = this;
LinkedIntakePoint = wagon.IntakePointList.Last();
}),
new STFReader.TokenProcessor("shape", () => { ShapeFileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("maxheight", () => { MaxHeight = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0); }),
new STFReader.TokenProcessor("minheight", () => { MinHeight = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0); }),
new STFReader.TokenProcessor("freightweightwhenfull", () => { FreightWeightWhenFull = stf.ReadFloatBlock(STFReader.UNITS.Mass, 0); }),
new STFReader.TokenProcessor("fullatstart", () => { FullAtStart = stf.ReadBoolBlock(true); }),
});
}
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)); }),
});
}
public ESD_Bounding_Box(STFReader stf)
{
stf.MustMatch("(");
string item = stf.ReadString();
if (item == ")") return; // quietly return on ESD_Bounding_Box()
stf.StepBackOneItem();
float X = stf.ReadFloat(STFReader.UNITS.None, null);
float Y = stf.ReadFloat(STFReader.UNITS.None, null);
float Z = stf.ReadFloat(STFReader.UNITS.None, null);
Min = new TWorldPosition(X, Y, Z);
X = stf.ReadFloat(STFReader.UNITS.None, null);
Y = stf.ReadFloat(STFReader.UNITS.None, null);
Z = stf.ReadFloat(STFReader.UNITS.None, null);
Max = new TWorldPosition(X, Y, Z);
// JP2indirt.sd has extra parameters
stf.SkipRestOfBlock();
}
protected void ParseUnits(STFReader stf)
{
stf.MustMatch("(");
try
{
string sUnits = stf.ReadItem();
// sUnits = sUnits.Replace('/', '?');
sUnits = sUnits.Replace('/', '_');
Units = (CABViewControlUnits)Enum.Parse(typeof(CABViewControlUnits), sUnits);
}
catch (ArgumentException)
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlStyle " + stf.ReadItem());
Units = CABViewControlUnits.NONE;
}
stf.SkipRestOfBlock();
}
public CVCFirebox(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("graphic", () => { ParseFireACEFile(stf, basepath); }),
new STFReader.TokenProcessor("fuelcoal", () => { ParseGraphic(stf, basepath); }),
});
Direction = 1;
Orientation = 1;
MaxValue = 1;
MinValue = 0;
ControlStyle = CABViewControlStyles.POINTER;
Area = new Rectangle(0, 0, (int)Width, (int)Height);
PositionY += Height / 2;
}
static IList <SignalDrawLight> ReadDrawLights(STFReader stf)
{
stf.MustMatch("(");
int count = stf.ReadInt(null);
List <SignalDrawLight> drawLights = new List <SignalDrawLight>(count);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("drawlight", () => {
if (drawLights.Count >= drawLights.Capacity)
{
STFException.TraceWarning(stf, "Skipped extra DrawLight");
}
else
{
drawLights.Add(new SignalDrawLight(stf));
}
}),
});
return(drawLights);
}
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)); }),
});
}
public Tr_HazardFile(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("filename", () => { FileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("workers", () => { Workers = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("distance", () => { Distance = stf.ReadFloatBlock(STFReader.UNITS.None, 10); }),
new STFReader.TokenProcessor("speed", () => { Speed = stf.ReadFloatBlock(STFReader.UNITS.None, 3); }),
new STFReader.TokenProcessor("idle_key", () => { Idle_Key = stf.ReadVector2Block(STFReader.UNITS.None, Idle_Key); }),
new STFReader.TokenProcessor("idle_key2", () => { Idle_Key2 = stf.ReadVector2Block(STFReader.UNITS.None, Idle_Key2); }),
new STFReader.TokenProcessor("surprise_key_left", () => { Surprise_Key_Left = stf.ReadVector2Block(STFReader.UNITS.None, Surprise_Key_Left); }),
new STFReader.TokenProcessor("surprise_key_right", () => { Surprise_Key_Right = stf.ReadVector2Block(STFReader.UNITS.None, Surprise_Key_Right); }),
new STFReader.TokenProcessor("success_scarper_key", () => { Success_Scarper_Key = stf.ReadVector2Block(STFReader.UNITS.None, Success_Scarper_Key); }),
});
//TODO This should be changed to STFException.TraceError() with defaults values created
if (FileName == null)
{
throw new STFException(stf, "Missing FileName");
}
}
public TrackShape(STFReader stf)
{
stf.MustMatch("(");
ShapeIndex = stf.ReadUInt(null);
int nextPath = 0;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("filename", () => { FileName = stf.ReadStringBlock(null); }),
new STFReader.TokenProcessor("numpaths", () => { SectionIdxs = new SectionIdx[NumPaths = 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", () => { SectionIdxs[nextPath++] = new SectionIdx(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 Triggers(STFReader stf)
{
stf.MustMatch("(");
int count = stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("dist_travelled_trigger", () => { Add(new Dist_Travelled_Trigger(stf)); }),
new STFReader.TokenProcessor("discrete_trigger", () => { Add(new Discrete_Trigger(stf)); }),
new STFReader.TokenProcessor("random_trigger", () => { Add(new Random_Trigger(stf)); }),
new STFReader.TokenProcessor("variable_trigger", () => { Add(new Variable_Trigger(stf)); }),
new STFReader.TokenProcessor("initial_trigger", () => { Add(new Initial_Trigger(stf)); }),
});
foreach (Trigger trigger in this)
{
if (trigger.SoundCommand == null)
{
STFException.TraceWarning(stf, "Trigger lacks a sound command");
}
}
}
public LightCollection(STFReader stf)
{
stf.MustMatch("(");
stf.ReadInt(null); // count; ignore this because its not always correct
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("light", () => { Lights.Add(new Light(Lights.Count, stf)); }),
});
if (Lights.Count == 0)
{
throw new InvalidDataException("lights with no lights");
}
// MSTSBin created reverse headlight cones automatically, so we shall do so too.
foreach (var light in Lights.ToArray())
{
if (light.Type == LightType.Cone)
{
Lights.Add(new Light(light, true));
}
}
}
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("monitoringdeviceappliescutspower", () => { EmergencyCutsPower = stf.ReadBoolBlock(EmergencyCutsPower); }),
new STFReader.TokenProcessor("monitoringdeviceappliesshutsdownengine", () => { EmergencyShutsDownEngine = stf.ReadBoolBlock(EmergencyShutsDownEngine); }),
new STFReader.TokenProcessor("monitoringdeviceresetonzerospeed", () => { ResetOnZeroSpeed = stf.ReadBoolBlock(ResetOnZeroSpeed); }),
new STFReader.TokenProcessor("monitoringdeviceresetonresetbutton", () => { ResetOnResetButton = stf.ReadBoolBlock(ResetOnResetButton); }),
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("monitoringdevicecriticallevel", () => { CriticalLevelMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, CriticalLevelMpS); }),
new STFReader.TokenProcessor("monitoringdeviceresetlevel", () => { ResetLevelMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, ResetLevelMpS); }),
new STFReader.TokenProcessor("monitoringdevicealarmtimebeforeoverspeed", () => { AlarmTimeBeforeOverspeedS = stf.ReadFloatBlock(STFReader.UNITS.Time, AlarmTimeBeforeOverspeedS); }),
new STFReader.TokenProcessor("monitoringdeviceappliesfullbrake", () => { AppliesFullBrake = stf.ReadBoolBlock(AppliesFullBrake); }),
new STFReader.TokenProcessor("monitoringdeviceappliesemergencybrake", () => { AppliesEmergencyBrake = stf.ReadBoolBlock(AppliesEmergencyBrake); }),
});
}
protected void ParseStyle(STFReader stf)
{
stf.MustMatch("(");
try
{
string sStyle = stf.ReadString();
int checkNumeric = 0;
if (int.TryParse(sStyle.Substring(0, 1), out checkNumeric) == true)
{
sStyle = sStyle.Insert(0, "_");
}
ControlStyle = (CABViewControlStyles)Enum.Parse(typeof(CABViewControlStyles), sStyle);
}
catch (ArgumentException)
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlStyle " + stf.ReadString());
ControlStyle = CABViewControlStyles.NONE;
}
stf.SkipRestOfBlock();
}
public TrackPath(STFReader stf)
{
stf.MustMatch("(");
DynamicSectionIndex = stf.ReadUInt(null);
NoSections = stf.ReadUInt(null);
TrackSections = new uint[NoSections];
for (int i = 0; i < NoSections; ++i)
{
string token = stf.ReadString();
if (token == ")")
{
STFException.TraceWarning(stf, "Missing track section");
return; // there are many TSECTION.DAT's with missing sections so we will accept this error
}
if (!uint.TryParse(token, out TrackSections[i]))
{
STFException.TraceWarning(stf, "Invalid track section " + token);
}
}
stf.SkipRestOfBlock();
}
public SMSStreams(STFReader stf)
{
stf.MustMatch("(");
var count = stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("stream", () => {
if (--count < 0)
{
STFException.TraceWarning(stf, "Skipped extra Stream");
}
else
{
Add(new SMSStream(stf));
}
}),
});
if (count > 0)
{
STFException.TraceWarning(stf, count + " missing Stream(s)");
}
}
private void TryModify(int category, STFReader stf)
{
ActivityEvent origEvent;
bool wrongEventID = false;
int modifiedID = -1;
try
{
stf.MustMatchBlockStart();
stf.MustMatch("id");
stf.MustMatchBlockStart();
modifiedID = stf.ReadInt(null);
stf.MustMatchBlockEnd();
origEvent = Find(x => x.ID == modifiedID);
if (origEvent == null)
{
wrongEventID = true;
Trace.TraceWarning("Skipped event {0} not present in base activity file", modifiedID);
stf.SkipRestOfBlock();
}
else
{
wrongEventID = !TestMatch(category, origEvent);
if (!wrongEventID)
{
origEvent.Update(stf);
}
else
{
Trace.TraceWarning("Skipped event {0} of event category not matching with base activity file", modifiedID);
stf.SkipRestOfBlock();
}
}
}
catch (Exception error)
{
Trace.WriteLine(new FileLoadException("Error in additional activity file", error));
}
}
public LightState(STFReader stf)
{
stf.MustMatch("(");
stf.ParseBlock(new[] {
new STFReader.TokenProcessor("duration", () => { Duration = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
new STFReader.TokenProcessor("lightcolour", () => { Color = stf.ReadHexBlock(null); }),
new STFReader.TokenProcessor("position", () => { Position = stf.ReadVector3Block(STFReader.UNITS.None, Vector3.Zero); }),
new STFReader.TokenProcessor("radius", () => { Radius = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); }),
new STFReader.TokenProcessor("azimuth", () => { Azimuth = stf.ReadVector3Block(STFReader.UNITS.None, Vector3.Zero); }),
new STFReader.TokenProcessor("elevation", () => { Elevation = stf.ReadVector3Block(STFReader.UNITS.None, Vector3.Zero); }),
new STFReader.TokenProcessor("transition", () => { Transition = 1 <= stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("angle", () => { Angle = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
});
// Color byte order changed in XNA 4 from BGRA to RGBA
Color = new Color()
{
B = (byte)(Color),
G = (byte)(Color >> 8),
R = (byte)(Color >> 16),
A = (byte)(Color >> 24)
}.PackedValue;
}
public override void Parse(string lowercasetoken, STFReader stf)
{
switch (lowercasetoken)
{
case "ortseot(level":
stf.MustMatch("(");
var eotLevel = stf.ReadString();
try
{
EOTLevel = (EOTLevel)Enum.Parse(typeof(EOTLevel), eotLevel.First().ToString().ToUpper() + eotLevel.Substring(1));
}
catch
{
STFException.TraceWarning(stf, "Skipped unknown EOT Level " + eotLevel);
}
break;
default:
base.Parse(lowercasetoken, stf);
break;
}
}
} // degrees
public TrackSection(STFReader stf, bool routeTrackSection)
{
if (routeTrackSection)
{
stf.MustMatchBlockStart();
stf.MustMatch("SectionCurve");
stf.SkipBlock();
SectionIndex = stf.ReadUInt(null);
float a = stf.ReadFloat(STFReader.Units.Distance, null);
float b = stf.ReadFloat(STFReader.Units.None, null);
if (b == 0) // Its straight
{
Length = a;
}
else // its curved
{
Radius = b;
Angle = MathHelper.ToDegrees(a);
Curved = true;
}
stf.SkipRestOfBlock();
}
else
{
stf.MustMatchBlockStart();
SectionIndex = stf.ReadUInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("sectionsize", () => { ReadSectionSize(stf); }),
new STFReader.TokenProcessor("sectioncurve", () => { ReadSectionCurve(stf); }),
});
//if( SectionSize == null )
// throw( new STFError( stf, "Missing SectionSize" ) );
// note- default TSECTION.DAT does have some missing sections
}
}
/// <summary>
/// Parses all the parameters within the ENG file
/// </summary>
/// <param name="stf">eference to the ENG file reader</param>
public void Parse(STFReader stf, MSTSDieselLocomotive loco)
{
stf.MustMatch("(");
int count = stf.ReadInt(0);
for (int i = 0; i < count; i++)
{
string setting = stf.ReadString().ToLower();
if (setting == "diesel")
{
DEList.Add(new DieselEngine());
DEList[i].Parse(stf, loco);
DEList[i].Initialize(true);
}
if ((!DEList[i].IsInitialized))
{
STFException.TraceWarning(stf, "Diesel engine model has some errors - loading MSTS format");
DEList[i].InitFromMSTS((MSTSDieselLocomotive)Locomotive);
DEList[i].Initialize(true);
}
}
}
public CabViewControls(STFReader stf, string basepath)
{
stf.MustMatch("(");
int count = stf.ReadInt(null);
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("dial", () => { Add(new CVCDial(stf, basepath)); }),
new STFReader.TokenProcessor("gauge", () => { Add(new CVCGauge(stf, basepath)); }),
new STFReader.TokenProcessor("lever", () => { Add(new CVCDiscrete(stf, basepath)); }),
new STFReader.TokenProcessor("twostate", () => { Add(new CVCDiscrete(stf, basepath)); }),
new STFReader.TokenProcessor("tristate", () => { Add(new CVCDiscrete(stf, basepath)); }),
new STFReader.TokenProcessor("multistatedisplay", () => { Add(new CVCMultiStateDisplay(stf, basepath)); }),
new STFReader.TokenProcessor("cabsignaldisplay", () => { Add(new CVCSignal(stf, basepath)); }),
new STFReader.TokenProcessor("digital", () => { Add(new CVCDigital(stf, basepath)); }),
new STFReader.TokenProcessor("combinedcontrol", () => { Add(new CVCDiscrete(stf, basepath)); }),
new STFReader.TokenProcessor("firebox", () => { Add(new CVCFirebox(stf, basepath)); }),
new STFReader.TokenProcessor("digitalclock", () => { Add(new CVCDigitalClock(stf, basepath)); })
});
//TODO Uncomment when parsed all type
/*
* if (count != this.Count) STFException.ReportWarning(inf, "CabViewControl count mismatch");
*/
}
/// <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 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 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 ReleaseLoopReleaseWithJump(STFReader f)
{
f.MustMatch("(");
f.SkipRestOfBlock();
}
public DisableTrigger(STFReader f)
{
f.MustMatch("(");
TriggerID = f.ReadInt(null);
f.SkipRestOfBlock();
}
public SetStreamVolume(STFReader f)
{
f.MustMatch("(");
Volume = f.ReadFloat(STFReader.UNITS.None, null);
f.SkipRestOfBlock();
}
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");
* }
* }
* }),*/
});
}
