/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public TrackDB(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tracknodes", () => {
stf.MustMatchBlockStart();
int numberOfTrackNodes = stf.ReadInt(null);
TrackNodes = new TrackNode[numberOfTrackNodes + 1];
int idx = 1;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("tracknode", () => {
TrackNodes[idx] = TrackNode.ReadTrackNode(stf, idx, numberOfTrackNodes);
if (TrackNodes[idx] is TrackJunctionNode junctionNode)
{
string key = $"{junctionNode.UiD.WorldId}-{junctionNode.UiD.Location.TileX}-{junctionNode.UiD.Location.TileZ}";
if (!junctionNodes.ContainsKey(key))
{
junctionNodes.Add(key, junctionNode);
}
// only need any (first) junction node with that key here to relate back to ShapeIndex
}
++idx;
}),
});
}),
internal ActivitySound(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortsactsoundfile", () =>
{
stf.MustMatchBlockStart();
string soundFile = stf.ReadString();
SoundFile = Path.Combine(FolderStructure.RouteFromActivity(stf.FileName).SoundFile(soundFile));
if (!EnumExtension.GetValue(stf.ReadString(), out OrtsActivitySoundFileType soundFileType))
{
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown activity sound file type " + stf.ReadString());
SoundFileType = OrtsActivitySoundFileType.None;
}
else
{
SoundFileType = soundFileType;
}
stf.MustMatchBlockEnd();
}),
new STFReader.TokenProcessor("ortssoundlocation", () => {
stf.MustMatchBlockStart();
location = new WorldLocation(stf.ReadInt(null), stf.ReadInt(null),
stf.ReadFloat(STFReader.Units.None, null), stf.ReadFloat(STFReader.Units.None, null), stf.ReadFloat(STFReader.Units.None, null));
stf.MustMatchBlockEnd();
}),
});
public ORActivity(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
// General TAB
new STFReader.TokenProcessor("ortsgraduatedbrakerelease", () => { Options.GraduatedBrakeRelease = stf.ReadIntBlock(Options.GraduatedBrakeRelease); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsviewdispatchwindow", () => { Options.ViewDispatcherWindow = stf.ReadIntBlock(Options.ViewDispatcherWindow); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsretainersonallcars", () => { Options.RetainersOnAllCars = stf.ReadIntBlock(Options.RetainersOnAllCars); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortssoundspeedcontrol", () => { Options.SoundSpeedControl = stf.ReadIntBlock(Options.SoundSpeedControl); IsActivityOverride = true; }),
// Video TAB
new STFReader.TokenProcessor("ortsfastfullscreenalttab", () => { Options.FastFullScreenAltTab = stf.ReadIntBlock(Options.FastFullScreenAltTab); IsActivityOverride = true; }),
// Simulation TAB
new STFReader.TokenProcessor("ortsforcedredatstationstops", () => { Options.ForcedRedAtStationStops = stf.ReadIntBlock(Options.ForcedRedAtStationStops); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsuseadvancedadhesion", () => { Options.UseAdvancedAdhesion = stf.ReadIntBlock(Options.UseAdvancedAdhesion); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsbreakcouplers", () => { Options.BreakCouplers = stf.ReadIntBlock(Options.BreakCouplers); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortscurveresistancedependent", () => { Options.CurveResistanceDependent = stf.ReadIntBlock(Options.CurveResistanceDependent); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortscurvespeeddependent", () => { Options.CurveSpeedDependent = stf.ReadIntBlock(Options.CurveSpeedDependent); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortstunnelresistancedependent", () => { Options.TunnelResistanceDependent = stf.ReadIntBlock(Options.TunnelResistanceDependent); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortswindresistancedependent", () => { Options.WindResistanceDependent = stf.ReadIntBlock(Options.WindResistanceDependent); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortshotstart", () => { Options.HotStart = stf.ReadIntBlock(Options.HotStart); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortssimplecontrolphysics", () => { Options.SimpleControlPhysics = stf.ReadIntBlock(Options.SimpleControlPhysics); IsActivityOverride = true; }),
// Data Logger TAB
new STFReader.TokenProcessor("ortsverboseconfigurationmessages", () => { Options.VerboseConfigurationMessages = stf.ReadIntBlock(Options.VerboseConfigurationMessages); IsActivityOverride = true; }),
// Experimental TAB
new STFReader.TokenProcessor("ortslocationlinkedpassingpaths", () => { Options.UseLocationPassingPaths = stf.ReadIntBlock(Options.UseLocationPassingPaths); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsadhesionfactorcorrection", () => { Options.AdhesionFactor = stf.ReadIntBlock(Options.AdhesionFactor); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsadhesionfactorchange", () => { Options.AdhesionFactorChange = stf.ReadIntBlock(Options.AdhesionFactorChange); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsadhesionproportionaltoweather", () => { Options.AdhesionProportionalToWeather = stf.ReadIntBlock(Options.AdhesionProportionalToWeather); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsactivityrandomization", () => { Options.ActivityRandomization = stf.ReadIntBlock(Options.ActivityRandomization); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortsactivityweatherrandomization", () => { Options.ActivityWeatherRandomization = stf.ReadIntBlock(Options.ActivityWeatherRandomization); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortssuperelevationlevel", () => { Options.SuperElevationLevel = stf.ReadIntBlock(Options.SuperElevationLevel); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortssuperelevationminimumlength", () => { Options.SuperElevationMinimumLength = stf.ReadIntBlock(Options.SuperElevationMinimumLength); IsActivityOverride = true; }),
new STFReader.TokenProcessor("ortssuperelevationgauge", () => { Options.SuperElevationGauge = stf.ReadIntBlock(Options.SuperElevationGauge); IsActivityOverride = true; }),
new STFReader.TokenProcessor("events", () =>
{
Events.UpdateORActivtyData(stf);
}),
new STFReader.TokenProcessor("ortsaihornatcrossings", () => { AIBlowsHornAtLevelCrossings = stf.ReadIntBlock(Convert.ToInt32(AIBlowsHornAtLevelCrossings)) > 0; }),
new STFReader.TokenProcessor("ortsaicrossinghornpattern", () => { if (EnumExtension.GetValue(stf.ReadStringBlock(""), out LevelCrossingHornPattern value))
{
AILevelCrossingHornPattern = value;
}
})
});
// SigSubJnLinkIf is not supported
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalSubObject(STFReader stf)
{
SignalSubType = SignalSubType.None;
stf.MustMatchBlockStart();
Index = stf.ReadInt(null);
MatrixName = stf.ReadString().ToUpper();
Description = stf.ReadString();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("sigsubtype", () => {
if (EnumExtension.GetValue(stf.ReadStringBlock(null), out SignalSubType subType))
{
SignalSubType = subType;
}
}),
new STFReader.TokenProcessor("sigsubstype", () => { SignalSubSignalType = stf.ReadStringBlock(null).ToLowerInvariant(); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatchBlockStart();
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "optional":
Optional = true;
break;
case "default":
Default = true; break;
case "back_facing":
BackFacing = true;
break;
case "jn_link":
JunctionLink = true;
break;
default:
stf.StepBackOneItem();
STFException.TraceInformation(stf, "Skipped unknown SignalSubObj flag " + stf.ReadString());
break;
}
}
}),
});
private void ParseActivityDetails(STFReader stf)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("player_service_definition", () => { PlayerServices = new PlayerServices(stf); }),
new STFReader.TokenProcessor("nextserviceuid", () => { NextServiceUiD = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("nextactivityobjectuid", () => { NextActivityObjectUiD = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("events", () => { Events = new ActivityEvents(stf); }),
new STFReader.TokenProcessor("traffic_definition", () => { Traffic = new Traffic(stf); }),
new STFReader.TokenProcessor("activityobjects", () => { ActivityObjects = new ActivityObjects(stf); }),
new STFReader.TokenProcessor("platformnumpassengerswaiting", () => { PlatformWaitingPassengers = new PlatformPassengersWaiting(stf); }), // 35 files. To test, use EUROPE1\ACTIVITIES\aftstorm.act
new STFReader.TokenProcessor("activityfailedsignals", () => { FailedSignals = new FailedSignals(stf); }),
new STFReader.TokenProcessor("activityrestrictedspeedzones", () => { ActivityRestrictedSpeedZones = new RestrictedSpeedZones(stf); }), // 27 files. To test, use EUROPE1\ACTIVITIES\lclsrvce.act
new STFReader.TokenProcessor("ortsaihornatcrossings", () => { AIBlowsHornAtLevelCrossings = stf.ReadIntBlock(Convert.ToInt32(AIBlowsHornAtLevelCrossings)) > 0; }),
new STFReader.TokenProcessor("ortsaicrossinghornpattern", () => { if (EnumExtension.GetValue(stf.ReadStringBlock(""), out LevelCrossingHornPattern value))
{
AILevelCrossingHornPattern = value;
}
})
});
private static void ReadOrtsSignalFunctionTypes(STFReader stf)
{
stf.MustMatchBlockStart();
int count = stf.ReadInt(null);
int tokensRead = 0;
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("ortssignalfunctiontype", () => {
stf.MustMatchBlockStart();
if (tokensRead >= count)
{
STFException.TraceWarning(stf, "Skipped extra ORTSFunctionType");
}
else
{
string functionType = stf.ReadString();
// check agains default types
if (EnumExtension.GetValue(functionType, out SignalFunction result))
{
STFException.TraceWarning(stf, "Invalid definition of ORTSFunctionType, type is equal to MSTS defined type : " + functionType);
}
else if (functionType.StartsWith("OR_", StringComparison.OrdinalIgnoreCase) || functionType.StartsWith("ORTS", StringComparison.OrdinalIgnoreCase))
{
STFException.TraceWarning(stf, "Invalid definition of ORTSFunctionType, using reserved type name : " + functionType);
}
else
{
if (OrSignalTypes.Instance.FunctionTypes.Contains(functionType, StringComparer.OrdinalIgnoreCase))
{
STFException.TraceWarning(stf, "Skipped duplicate ORTSSignalFunction definition : " + functionType);
}
else
{
OrSignalTypes.Instance.FunctionTypes.Add(functionType);
tokensRead++;
}
}
}
stf.SkipRestOfBlock();
}),
});
public CabViewGaugeControl(STFReader stf, string basePath)
{
stf.MustMatchBlockStart();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("type", () => { ParseType(stf); }),
new STFReader.TokenProcessor("position", () => { ParsePosition(stf); }),
new STFReader.TokenProcessor("scalerange", () => { ParseScaleRange(stf); }),
new STFReader.TokenProcessor("graphic", () => { ParseGraphic(stf, basePath); }),
new STFReader.TokenProcessor("style", () => { ParseStyle(stf); }),
new STFReader.TokenProcessor("units", () => { ParseUnits(stf); }),
new STFReader.TokenProcessor("zeropos", () => { ZeroPos = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("orientation", () => { Orientation = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("dirincrease", () => { Direction = stf.ReadIntBlock(null); }),
new STFReader.TokenProcessor("area", () => {
stf.MustMatchBlockStart();
area = new Rectangle(stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null), stf.ReadInt(null));
stf.SkipRestOfBlock();
}),
new STFReader.TokenProcessor("positivecolour", () => {
stf.MustMatchBlockStart();
(PositiveColors, PositiveTrigger) = ParseControlColors(stf);
}),
new STFReader.TokenProcessor("negativecolour", () => {
stf.MustMatchBlockStart();
(NegativeColors, NegativeTrigger) = ParseControlColors(stf);
}),
new STFReader.TokenProcessor("decreasecolour", () => {
stf.MustMatchBlockStart();
stf.ReadInt(0);
if (!stf.EndOfBlock())
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("controlcolour", () => { DecreaseColor = ParseControlColor(stf); })
});
}
})
});
