public void Parse(STFReader stf)
{
stf.MustMatch("(");
MinimumValue = stf.ReadFloat(STFReader.UNITS.None, null);
MaximumValue = stf.ReadFloat(STFReader.UNITS.None, null);
StepSize = stf.ReadFloat(STFReader.UNITS.None, null);
IntermediateValue = 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();
}
}),
});
SetValue(CurrentValue);
}
public override SBR ReadSubBlock()
{
UnicodeBlockReader block = new UnicodeBlockReader();
block.f = f;
string token = f.ReadItem();
if (token == "(")
{
// ie 310.eng Line 349 (#_fire temp, fire mass, water mass, boil ...
block.ID = TokenID.comment;
return(block);
}
// parse token
block.ID = GetTokenID(token);
if (token == ")")
{
TraceWarning("Ignored extra close bracket");
return(block);
}
// now look for optional label, ie matrix MAIN ( ....
token = f.ReadItem();
if (token != "(")
{
block.Label = token;
f.VerifyStartOfBlock();
}
return(block);
}
protected void ParseUnits(STFReader stf)
{
stf.MustMatchBlockStart();
string units = stf.ReadItem().Replace('/', '_');
if (!EnumExtension.GetValue(units, out CabViewControlUnit unit))
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown ControlUnit " + stf.ReadItem());
ControlUnit = CabViewControlUnit.None;
}
ControlUnit = unit;
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();
}
/// <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;
}
}
/// <summary>
/// Reads RailDriver calibration data from a ModernCalibration.rdm file
/// This file is not in the usual STF format, but the STFReader can handle it okay.
/// </summary>
/// <param name="basePath"></param>
void ReadCalibrationData(string basePath)
{
string file = basePath + "\\ModernCalibration.rdm";
if (!File.Exists(file))
{
RegistryKey RK = Registry.LocalMachine.OpenSubKey("SOFTWARE\\PI Engineering\\PIBUS");
if (RK != null)
{
string dir = (string)RK.GetValue("RailDriver", null, RegistryValueOptions.None);
if (dir != null)
{
file = dir + "\\..\\controller\\ModernCalibration.rdm";
}
}
if (!File.Exists(file))
{
SetLEDs(0, 0, 0);
Trace.TraceWarning("Cannot find RailDriver calibration file {0}", file);
return;
}
}
// TODO: This is... kinda weird and cool at the same time. STF parsing being used on RailDriver's calebration file. Probably should be a dedicated parser, though.
STFReader reader = new STFReader(file, false);
while (!reader.Eof)
{
string token = reader.ReadItem();
if (token == "Position")
{
string name = reader.ReadItem();
int min = -1;
int max = -1;
while (token != "}")
{
token = reader.ReadItem();
if (token == "Min")
{
min = reader.ReadInt(-1);
}
else if (token == "Max")
{
max = reader.ReadInt(-1);
}
}
if (min >= 0 && max >= 0)
{
float v = .5f * (min + max);
switch (name)
{
case "Full Reversed": FullReversed = v; break;
case "Neutral": Neutral = v; break;
case "Full Forward": FullForward = v; break;
case "Full Throttle": FullThrottle = v; break;
case "Throttle Idle": ThrottleIdle = v; break;
case "Dynamic Brake": DynamicBrake = v; break;
case "Dynamic Brake Setup": DynamicBrakeSetup = v; break;
case "Auto Brake Released": AutoBrakeRelease = v; break;
case "Full Auto Brake (CS)": FullAutoBrake = v; break;
case "Emergency Brake (EMG)": EmergencyBrake = v; break;
case "Independent Brake Released": IndependentBrakeRelease = v; break;
case "Bail Off Engaged (in Released position)": BailOffEngagedRelease = v; break;
case "Independent Brake Full": IndependentBrakeFull = v; break;
case "Bail Off Engaged (in Full position)": BailOffEngagedFull = v; break;
case "Bail Off Disengaged (in Released position)": BailOffDisengagedRelease = v; break;
case "Bail Off Disengaged (in Full position)": BailOffDisengagedFull = v; break;
case "Rotary Switch 1-Position 1(OFF)": Rotary1Position1 = v; break;
case "Rotary Switch 1-Position 2(SLOW)": Rotary1Position2 = v; break;
case "Rotary Switch 1-Position 3(FULL)": Rotary1Position3 = v; break;
case "Rotary Switch 2-Position 1(OFF)": Rotary2Position1 = v; break;
case "Rotary Switch 2-Position 2(DIM)": Rotary2Position2 = v; break;
case "Rotary Switch 2-Position 3(FULL)": Rotary2Position3 = v; break;
default: STFException.TraceInformation(reader, "Skipped unknown calibration value " + name); 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 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;
}
}
