The Traffic Timetable File

Preface

This is the description of the syntax and semantics of the Timetable file in the Traffic Screensaver

This description is not a course book - it endeavors to cover the entire subject, but not in a didactic form. If you are new to the Traffic Screensaver, you should read also the "How to write a Timetable file for the Traffic Screensaver" file. That document shows the step by step usage of several commands, starting with some very simple examples, with several illustrations. It is the suggested introduction--even when not complete; it does not cover all the commands and possibilities the program is capable of.

This document describes the elements of the Timetable file from the top down: it begins with the commands--complex structures of the Timetable file you'll see if you read such a file--and expands on the constituent syntactical elements. You will better understand a command (especially the Movement commands) if you follow this rubric and read all the information about the ingredients and the syntax elements used.

Special thanks for James McDonald, who revised this description - not only correcting its language, but sometimes explaining things, which seemed for the author evident.

General Rules

The Timetable file is a text file which determines the composition of trains and their Movements on the screen, as well as contains settings for the configuration of the program.

Each command in the Timetable should be in a single line of code. This, however, can be difficult to read when programming so there are a few conventions to be aware of which make reading and programming easier.

• Lines which begin with the characters # ; / or * are comment lines. They are not analyzed by the computer and can be used to make comments about the program code.
• If a string of code becomes too long it is possible to "break" the string into several lines. Simply place a \ at the very end of each extra line break but bear in mind that no characters are allowed to follow the   \  character including spaces and tabs).
• Tabs can be used to indent text and ease readability without having any effect on the code itself.
• The program code is not case sensitive.

Attentive observers will notice that there are often commands or parameter values which have different codes but identical meanings. This is because these codes are often abbreviations in different languages. You can choose the one you can most easily remember.

In the following syntax descriptions the double equal sign ( == ) means "is defined as" and the double vertical bar ( || ) means "or." Bold characters denote exactly the character or text which appears in bold. The elements between   <   and   >  are the syntax elements defined by abstract rules. At the moment there are only parts of the syntax shown in these abstract forms. How does one read these syntax descriptions ?

Let's see a simple example:

<Simple> == <Digit> || <Simple> <Digit>
<Digit> == 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9

Here we see the definition of an integer number. A digit is - not surprisingly - one of the number characters. The double bars between the numbers mean: one of them. Digit is 0 or 1 or 2 or 3 ... and so on. What does <Simple> mean? The left part of the rule says: <Simple> == <Digit>, that is, a single digit (a number character) corresponds to the definition. The second part you can read so: <Simple> == <Simple> <Digit> . Which means: if you have already a character sequence which corresponds to the rules of <Simple>, you can append a digit to it, and you get also a <Simple> . This recursive definition describes the entity <Simple> completely: an integer number.

The syntax check of the Timetable file is not as strict as one would find in a compiler. If you use a correct expression suitable for the following rules, you should get the behavior described in this document - even in a future release of the program. If you use an expression violating the rules here, perhaps you will get an error message. These appear in the form of a message box, or in the form of a white square traveling in the place of the vehicle picture, with the error text written on it. Or perhaps you will get some functional result. For example, giving a real number in the place where only an integer number is specified, can lead to error, but can also lead to the usage of the same number rounded to the next integer. Using special characters in picture names can cause errors or misinterpretation in some expressions or-- with some luck-- you may get the result you desire. However, it is better to avoid such constructs - perhaps the same expression will cause an error in the next program version, or invoke a new feature - with undesired results.

Conditional Evaluation

You can customize your Timetable file by using conditional evaluations. Conditional evaluations ask "what if," the operative part of the evaluation being "if." The syntax of these conditional strings is as follows:

These conditions are evaluated first, and only the lines or line parts passed through the conditional statement will be analyzed and acted upon. You can modify any element of a Timetable file (commands, Movements, single parameters, vehicle names, modification commands) with these conditional expressions.

The configuration options must be referenced in the first few lines of the Timetable file by using the $OPT command described below. The value of these options (selected or unselected) can then be modified from the Traffic main window using the Options menu commands.

Individual configuration strings can be linked together to create combinations of their outcomes. The linking process is similar to an algebraic equation. The individual options can be enclosed in parentheses and are linked together with either & (meaning "and") or | (meaning "or"). Placing a ! (exclamation point) in front of the string returns the opposite or negative value of the string. If you place a ! in front of a command string contained in parentheses it will return the negative value of whatever the final outcome of the command(s) in parentheses is.

The second question mark and the <false_part> parameter are optional. Individual parts of the statement can be fed into each other. For example: {Norway?E116|E117{Diesel?|Di6}}

The conditional evaluations described here and the conditional modifiers controlled by criteria are fully different things. The conditional modifiers ( [<Condition>!<Command>:...] or [< <Command>:...]) base their outcome on the existence of the criteria modifiers in the train expressions - you can select in the Timetable file among the possibilities (to obey a modifier or not) you defined in macro definitions in the same Timetable file, in an included Timetable file or in the Stock List; and you can select among the possibilities based on the actual direction of the trains - it can be the result of a random decision made by the computer. The conditional modifiers help to define the vehicles generally - with and without smoke, with and without load, the same picture for vehicles traveling left or right (by mirroring the whole vehicle or only parts of it). The conditional evaluation ( { <condition> ? <true_part> ? <false_part> } ) based on the options in contrary relies on the decision of the human - as the options can be set and cleared in the configuration menu. The same conditional modifier can behave differently along a screensaver run, as it's decision is based on the actual environment - in which context the vehicle macro is invoked. The same conditional evaluation behaves always the same way in a single run, as the value of the options is analyzed at program start, and only that parts of the Timetable file will be stored and obeyed, which fulfill the conditions in the { ? } constructs.

Timetable Commands

Timetable commands begin with the $ symbol. Several Timetable command have multiple names - you can select between short and descriptive names. These forms are fully identical in their syntax and behavior.

$OPTION K=<Name>; V=<Boolean>; N=<Text>; <Language>=<Text>;
$OPT

$INCLUDE <Filename>
$INC

$END
$EXIT

$STOCK <Filename>

$USECACHE <Simple>

$PHASESTEP <Real>
$PH   $PHSTEP

This parameter changes the distance the vehicles should move across the screen before the phase pictures are alternated. The diameter of the wheels (given by the   +/<Diameter>   parameter in the macro defining the picture) is multiplied by the $PHASESTEP value and divided by the number of phases. The geometrically correct value for the $PHASESTEP command is pi, or 3.14 - but to many people the movements look better if the phases are changed at shorter intervals. You can modify this parameter to get the best result for your personal taste.

$NOSTOPONMOVE <Boolean>

$NOSTOPONCLICK <Boolean>

$NOSTOPONKEY <Boolean>

$SKIPERR <Boolean>

$BGCOLOR <Color>
$BACKGROUND

$SPEED <Integer>

An overall multiplier for the speed the vehicles travel across the screen. Each unit (vehicle) has its individual speed value determined by the modification command [#V: ] attached to one of its vehicles (usually the first vehicle), by the V= parameter in the Movement line, or by a random number generator if none of the above is hard coded. The $SPEED command changes the moving speed of every vehicle (the relative speed of the vehicles to each other is not affected) - but does not changes the wait times.

$WAY A=<Row>; E=<Row>; M=<Row>; R=<Row>; T=<Row>; L=<Row>;

This command changes the overall setting of which right of way pictures will be used. You can change the right of way pictures individually for each line or each Movement by specifying the W= parameter in the $SECTION, $GROUP, $LINE or in the Movement commands.

$DEF <Name> = <Text>
$DEFINE   $DEFINE_MACRO

Sections, Groups and Lines

The most important elements of the Timetable File are the Movements - the lines not beginning with $ and which are not comments. They describe trains (sets of single vehicles back to back), and how they are moved on the screen. The Movements (in this program version) use always a single track.

The Movements need space on the screen in order to run. The screensaver reads the next Movement (selected according to the $RANDOM command) from the Timetable file and then checks if there is enough space for the Movement on the screen. If there are multiple possibilities, it selects a vertical position for the Movement by random, allocates the space, and starts the Movement (first by drawing its background and foreground picture(s), when used). Then it selects the next Movement, places it, and so on. If it cannot find sufficient room for the Movement, it waits until other Movements finish and free up space on the screen.

A section (the commands $SECTION , the corresponding terminate command $ENDSECTION , and the Movements and further sections contained between them) behaves like a single Movement: it requires a defined amount of screen area, occupies it and runs a while, terminates and frees the screen area. However, inside the section, it behaves like a screen: it provides space on the screen for its subsections ("children"), the Movements and other sections contained between its $SECTION and $ENDSECTION commands.

The $GROUP is a simpler construct - it behaves not like a screen, but like a single line. It can only contain Movements but it cannot contain any further $SECTION, $GROUP or $LINE commands in between the $GROUP and $ENDGROUP commands. All the Movements will run in the exact same area of the screen. If the $GROUP command has any of the FG= ; BG= ; W= ; WP= ; parameters the background and foreground image(s) (or simply the right of way) will be drawn before the first Movement starts and will be deleted after the last Movement finishes. That means, the background picture remains on the screen during the entire run of anything contained in the $GROUP. (The points along the track are defined along with the right of way or foreground/background picture(s) so in this case you cannot define points in the Movements individually; you should do so in the $GROUP command.)

The first version of the Traffic Screensaver was able to use only fixed lines - all the Movements ran on a set of lines and their positions were fixed at the program's start. The number and the positions of the lines were calculated based on the ABOVE, BELOW, MINSPACE, MAXLINE parameters (and the IMGY parameter, the maximal vehicle height, which was fixed at the value contained in the Stock List). The primary method of placing lines for the Movements in the present version is by random selection, but you can get the fixed method back by placing $LINE commands into the Timetable file. As a $SECTION command acts for its child lines as if it were the whole screen, you can place $LINE commands not only on their own in the Timetable, but inside a $SECTION command too. The possible number of such fixed lines and their position (the distance between them) will be calculated according to the values of the ABOVE, IMGY, BELOW, MINSPACE, MAXLINE parameters: the MAXLINE parameter determines the number of lines possible. If the height of the screen or the section divided by the amount of space needed by each individual line (the sum of the ABOVE, IMGY, MINSPACE and MAXLINE parameter) results in a different value - the lesser of them is used. This calculation determines the possible number and positions of the fixed lines inside a section or inside the screensaver window (the implicit section).

The Movements between a $LINE and a following $ENDLINE command belong to that line. For compatibility (and because you cannot recursively insert a $LINE into another $LINE) you do not have to close the set of Movements belonging to the $LINE command with a corresponding $ENDLINE command. The set is automatically closed by a $ENDSECTION, $GROUP, $SECTION or by the next $LINE command.

There are two formats for the $LINE command: with and without the L= ; line number parameter. If a $LINE command has this parameter, it will occupy exactly the lines that are listed in this parameter. If there is more than one line, the Movements will be dynamically selected for these lines from the set of the Movements belonging this $LINE command. That is, the track which has just finished its Movement will get the next Movement (selected accordingly to the SEQUENCE parameter). If there are numbers in the line list greater than the number of available lines, these numbers will be discarded. If all the numbers of a line list are discarded the Movements belonging to this $LINE command will never be executed.

If the $LINE command has no L= parameter the Movements belonging to this $LINE command will occupy all the remaining tracks after all of the $LINE commands with line numbers are processed. In this case all of the space on the screen (or inside a section) is allocated to fixed lines. No groups, segments or Movements beyond the Movements belonging to a $LINE command can run (they will be ignored by the program).

If you use only some $LINE commands with an explicit line list, it is possible that sufficient space remains in the section or on the screen to run elements beyond the range of the $LINE commands too. This other Movements will be placed at random positions inside the section, selecting only places not occupied by the $LINE commands.

How long do the complex elements (sections, groups, fixed lines) remain on the screen? The fixed lines have no lifetime of their own, they exist only as long as their containing section exists. The implicit section (the window or full screen the screensaver is running in) exists until the user terminates the program by pressing a key on the keyboard, by a menu item, or by a mouse movement (if the $NOSTOPONMOVE command or the similar configuration setting allows it). The default lifetime of a section or a group is until all of their children are run one time. You can change this lifetime with some parameters - the lifetime can be limited by the exact number of the Movements to be run, by time in seconds, or it can be unlimited.

All of the sections, groups and lines have their own set of Movements (or - in case of sections - perhaps some included subsections too). They select the next Movement to appear on the screen according their own sequence setting. If a dedicated sequence setting is missing, they inherit the sequence setting from their parent section. You can set the sequence for the implicit section by the top level command $SEQUENCE. If it is missing, the configuration window contains the default setting (selectively for full screen and windowed mode).

The lifetime of a section and the sequence of the Movements contained within it are two independent properties. Each section "remembers" which of its Movements were already run. If the lifetime of the section is shorter than all of the Movements in the section (some Movements were not shown in the first lifetime), and the selected sequence is not the full random sequence, the section will continue its work the next time it comes on the screen. When FIXED or CONTINUED sequence is turned on it continues with the next Movement following the last Movement started in the previous run. When RANDOM_SEQUENCE is on, it will avoid repeating a Movement until all the Movements are run. The only difference between the FIXED and CONTINUED sequences is when you stop the screensaver, and then it starts again (or you start it with the Test button in the configuration window) the FIXED sequence always starts from the beginning, the CONTINUED sequence remembers to start up right where it left off.

In the following paragraph we describe the individual parameters of the $SECTION, $GROUP and $LINE commands. The common parameters defining lifetime, sequence and default values for the Movements are described together with the corresponding commands (referring to the implicit section, the whole window) in a subsequent chapter.

$LINE L=<LineList>; PathwayParameters;

$ENDLINE
$EL   $ENDL   $ELINE

Closes the set of the Movements belonging to the previous $LINE command. The use of this command is mostly optional - any of a following $LINE, $GROUP, $SECTION, $ENDSECTION, $END commands closes the $LINE block.

$SECTION HEIGHT=<BlockHeight>; N=<Simple>; SEQ=<RandomP>; LifetimeParameters; DimensionParameters; PathwayParameters;
$SECT

<BlockHeight> == <Integer> || <Integer>% || FULL

The height of the section on the screen is determined by the HEIGHT= or the N= parameter. If the HEIGHT= parameter is given, it means the height of the section in pixels or in percentage of the containing section (or implicit section: the whole window or screen). If you append the percent sign  %  to the number, the height is expressed relative to the containing section. (You can use random expressions for the height, but you cannot mix the pixel and the percent form: 72|200-400 is a valid expression - all data in pixels -, 30-45% is a valid expression too, meaning a percentage between 30% and 45%, 55%|320 (55 percent or 320 pixels) is illegal. The height of a section is limited on one hand by the height of the section in which it is contained and on the other hand by the vehicle height plus 2 (allowing the screensaver to draw single width lines for the rail/street and for the catenary).

If the HEIGHT= parameter is missing, the N= parameter is read. It defines the number of tracks in the section, each track possessing space equal to the ABOVE+VEHICLE_HEIGHT+BELOW sum. Of course, the height is limited by the parent section's height in this case too.

If neither the HEIGHT= nor the N= parameters are given, the section inherits its parent's height.

$ENDSECTION
$ES   $ENDS   $ESECT   $ESECTION

Closes the set of lines - Movements, further $SECTION and $GROUP commands. As a section can include sections and groups, you should explicitly close the sections with this command - the only exception: the very last section is closed automatically at the end of the file or by the $END command.

$GROUP SEQ=<RandomP>; LifetimeParameters; DimensionParameters; PathwayParameters;

$ENDGROUP
$EG   $ENDG   $EGRP   $EGROUP

You can treat the whole screen (or the window surface of the screensaver's window in windowed mode), as an implicit section. Several parameters of the $SECTION and $GROUP commands consequently have a command equivalent - these command equivalents apply only to this implicit section: the initial screen surface of the screensaver In the following chapter these command equivalents and the corresponding $SECTION or $GROUP parameters are discussed together.

Lifetime Parameters

The lifetime parameters determine how long a $SECTION or $GROUP command (and consequently the Movements belonging to these commands) remain on the screen. As described already, it is independent of the Movement sequence but you can select a lifetime allowing all the Movements to run once inside a section.

If the lifetime is over, the section will not start more Movements. Additionally, you can also specify how fast the section disappears from the screen: is it allowed to finish the Movements already running, or it should abort all Movements immediately.

The lifetime parameters do not have a command format - the implicit section (the screensaver window) is active until user intervention.

SEQUENCE = <RandomP>;
SEQ= ;   RANDOM= ;
$RANDOM <RandomC>
$SEQ   $SEQUENCE

<RandomP> == 0 || F || FIX ||
            1 || C || CONTINUED ||
            2 || Q || RSEQ || RANDOM_SEQUENCE ||
            3 || R || RANDOM
<RandomC> == 0 || 1 || 2 || 3

• 0, F, FIX: Fixed from Begin - Always starts with the first train each time the program starts
• 1, C, CONTINUED: Fixed Continued - Starts from wherever it last stopped
• 2, Q, RSEQ, RANDOM_SEQUENCE: Random in Block - Random train selection, but no trains are repeated until all have run.
• 3, R, RANDOM: Random - Completely random selection of each train. Trains can repeat.

LIMIT_TIME = <Integer>;
LT= ;   TIME= ;

Determines the duration (in seconds) of how long a section remains on the screen.

LIMIT_MOVEMENT = <Integer>;
LC= ;   COUNT= ;

Determines the number of Movements started in the section. All Movements started in child section count towards this limit.

UNLIMITED;
NL;   NO_LIMIT;

The section runs unlimited. This can be overridden by a parent section's limit. If the parent section terminates it terminates all of its active children.

This parameter is a single keyword only, there is no value belonging to this parameter.

FINISH_MODE = <FinMode>;
FIN= ;

<FinMode> == A || ABORT || N || NO_MORE || W || WAIT

This parameter determines how a section terminates when its lifetime expires.

A   ABORT - All Movements will be aborted immediately.
N   NO_MORE - The M=FOLLOW; Movements will not start any more trains, the trains already on the screen and all other Movements will finish normally.
W   WAIT - All Movements will finish normally.

Dimension Parameters

VEHICLE_HEIGHT = <Simple>;
VH= ;   IMGY= ;
$VEHICLE_HEIGHT <Simple>
$IMGY

The maximum height of the vehicles is defined in the Stock List file - it is the size that most vehicles do not exceed; the usual height of the catenary wire. The Traffic Screensaver reserves so much vertical space for the moving vehicles in each line - and so much space for each vehicle in the Stock List window. If you have a few higher vehicles (some electric locomotives with higher catenaries, some big airplanes, ships, etc.) it is not worth enlarging the overall height limit, because the number of vehicle pictures which fit in a Stock List window will be reduced. Furthermore, all lines on the screen should be as high as this general parameter. Therefore you can change this value for a $SECTION or a $GROUP - only for a single line, or a limited set of lines.

If the command is not specified in the Timetable file, the setting in the Stock List is valid for the implicit section. If the parameter is not specified, the value of the parent section is inherited.

ABOVE = <Simple>;
AB= ;
$ABOVE <Simple>
$AB

BELOW = <Simple>;
BL = ;
$BELOW <Simple>
$BL

MINSPACE = <Simple>;
MS = ;
$MINSPACE <Simple>
$MS

MAXLINE = <Simple>;
ML = ;
$MAXLINE <Simple>
$ML

The maximum number of lines/trains shown on the screen or in the section at one time - it is the direct way to limit the number of the lines (the other way is with the ABOVE, BELOW, MINSPACE parameters). If both ways are used the number of lines is limited by the lower of the two values.

LEFT=<Integer>;

The left position of the screen area of a $SECTION, $GROUP, $LINE command. The Movements contained by this commands do not use the given amount of pixels to the left - the trains appear in the middle of the screen, and track, catenary and other background-foreground elements are limited too. It appears as if the given amount of pixels was covered with a black square.

The sections, groups, lines inherit their place from their parent sections - if you do not specify the $LEFT parameter. If you enter a number, the place will be yet more restricted: this parameter defines an additional left border to the parent section's left border.

WIDTH=<Integer>;

The width of the screen area of a $SECTION, $GROUP, $LINE command. It establishes a right margin on the screen not used by the background and by the vehicles.

The width is limited by the parent section - if the sum of the LEFT= and WIDTH= parameters is greater than the width of the parent section, the width will be shorten to fit.

The main purpose for the WIDTH= parameter is the usage of full-size background pictures - for example, landscape photos - on wider screens.

Pathway Parameters

BG = <FgBg>;

The background picture behind the moving trains. The possibilities and format of the parameter is described in the Syntax Elements chapter.

FG = <FgBg>;

The foreground picture in front of the moving trains. See the <FgBg> syntax element for the detailed description.

W = <Row>;

A simple background picture only below and above the train path: some simple track pictures (rail, street, catenary as single line, Transrapid track) are contained in the Traffic Screensaver program itself and they are available by means of this W= parameter.

If the vehicle pictures contained in the Stock List have their default track type usually you get a track picture without specifying this parameter.

WP = <PointList>;

Waypoints - point along the track. You can assign animation actions to the waypoints, the train front or back passing such waypoints can start several actions.

Movements

Strings which do not start with $ are the train consist (Movement) commands. The basic syntax is:

The type of Movement determines which values one can or should input. The Movements have more than one name - these names are, however, identical in behavior.

The default setting for the Movement type is M=SIMPLE; . If there is no M= parameter in the line, the trains themselves are input with the parameter C= and ended with a semicolon ";". The C=<Train>; of every Movement must always be input in order to have a train. Without any other parameters modifying it, the default commands apply or are specified by those values carried by the individual vehicles in their respective Stock List entries ([#A: ],[#B: ],[#V: ],[#W: ], the setting of the right of way in the Stock List, etc.)

In the following tables the common parameters which always have the same meaning will not be discussed individually - see the description of the corresponding syntax element. Some special considerations are mentioned for the first Movements but are not repeated for each Movement. The screensaver treats the different Movements similarly if possible.

A Train is defined as a vehicle consist - vehicle pictures back to back. A train may consist of a single picture - and, odd as it may seem, perhaps even a picture of an airplane, a car, a ship, a bird - it should not be strictly a train.

The Movement commands and their parameters:

M=SIMPLE;
M=M1;

M=FOLLOW;
M=M2;

M=STOP;
M=M3;

M=BACK;
M=M4;

M=CUT;
M=M5;

M=CHANGE;
M=M6;

M=OPEN;
M=M7;

M=UNIT;
M=M8;

M=PUT;
M=M9;

M=GET;
M=M10;

M=ECHG;
M=SYSTEM_CHANGE;   M=ECHANGE;   M=M11;

M=HEAD;
M=TERMINUS_ARRIVE;   M=XBACK;   M=M10;

M=PUSH;
M=TERMINUS_DEPART;   M=M13;

(Other Movements are in development. I'd be grateful for any suggestions.)

Composing Trains

<Train> == <VehicleList> || <GlobalModifiers> <VehicleList>
<GlobalModifiers> == <GlobalModifier> || <GlobalModifiers> <GlobalModifier>
<GlobalModifier> == < || > || [MP:<Number>] || [MI:<Number>] || <PantographState>
<VehicleList> == <Repetition> || <VehicleList> , <Repetition>
<Repetition> == <SelElement> || <RepeatCount> * <SelOrElem> || <RepeatCount> @ <SelOrElem>
<SelOrElem> == <Element> || <Selection>
<Selection> == <Choice> | <Choice> || <Selection> | <Choice>
<Choice> == <Element> || <Probability> : <Element>
<Element> == <Vehicle> || ( <VehicleList> )
<Probability> == <Simple>
<RepeatAmount> == <Integer>

A train is - in its simplest form - a list of vehicles separated by commas (or a single vehicle). You can use random selections (simple or weighted), and repetitions in the list.

<Choice₁> | <Choice₂> | ... <Choices>

<Probability₁> : <Choice₁> | <Probability₂> : <Choice₂> | ...

<RepeatCount> * <SelOrElem>

<RepeatCount> @ <SelOrElem>

These forms can be enclosed in parentheses. For example:

This string means that there is a 50% chance that the train will appear with a BR103 or two BR218s and a 60% chance that it will come with mail car. Then it has three, four or five Bpmz or Bvmz coaches and either two Avmz or two Apmz coaches at the end.

Global Modifiers

The vehicle pictures of trains should generally be input in the direction of travel and separated from each other by commas. The following symbols can modify the composition of a train or the vehicles contained in it when placed in front of its command string:

<

>

[!<Criteria>]

[MP:<Number>]

[MI:<Number>]

[PDO], [PNO], [PD], [PN] - All pantographs down
[PLU], [P1U] - Left pantograph up
[PRU], [P2U] - Right pantograph up
[PMU], [P3U] - Third (usually the inner or inner left) pantograph up
[P4U] - Fourth (inner right) pantograph up
[PDU], [P12U], [PU] - First and second (on a standard locomotive that means all) pantographs up
[PFU] - Forward pantograph up (relative to direction of travel)
[PBU] - Rear pantograph up (relative to direction of travel)
[PFIU] - Forward inner pantograph up (relative to direction of travel - useful for multi-system locomotive)
[PBIU] - Rear inner pantograph up (relative to direction of travel - useful for multi-system locomotive)
[PHU] - First pantograph of the train up relative to direction of travel (useful for multi-unit trains)
[PTU] - Last pantograph of the train up relative to direction of travel (useful for multiunit trains)

The pantograph commands change only the behavior of the vehicles having no other pantograph commands built into the vehicle macro.

The pantographs should be input in the following order:

1. outer left
2. outer right
3. inner left
4. inner right

Inputting a Vehicle with Phase Pictures

To replicate a vehicle's moving parts (spoked wheels, side rods, etc.) several pictures, each making up a frame or "phase" of the whole motion, are used. If the vehicle is moving on the screen these phase pictures are shown one after another in sequence. As the vehicle moves along, the part of the picture showing the moving parts is changed at predetermined distances using a mathematical equation to determine what part of the phase should be shown at the particular point or "step" of the motion.

The syntax is:

<Vehicle> == <BasePicture> || <AnimatedPicture> <StepLength> || <Vehicle> <Modifier>
<BasePicture> == <PictureName> || <PictureName> < <PictureName> ||
                <PictureName> > <PictureName> || <BasePicture> <Modifier>
<AnimatedPicture> == <BasePicture> || <AnimatedPicture> <Connection> <PhasePicture>
<Connection> == +> || +< || + || +* || + <Simple>
<PhasePicture> == <PictureName> || <PhasePicture> <Modifier>
<StepLength> == + . <StepPixel> || + / <Diameter> || +
<PixelStep> == <Simple>
<Diameter> == <Simple>

The first picture <BasePicture> is the picture of the entire vehicle. For the MM&MM screensaver these multi-phasic base pictures are denoted with a _0 suffix. The first picture can have a direction-dependent overlay. The subsequent phase pictures are then attached with the + sign. The + sign has additional modifiers allowing one to specify exactly how the pictures connect.

Phase pictures always appear at the bottom of the base picture. The phase pictures should only contain the rectangular area of the part that changes. If the phase pictures are transparent, the transparent pictures are copied to the vehicle picture too. The transparency of the vehicle can change as the moving parts (spokes, rods) let you see through to the background in different places.

So that the vehicle's motion appears to change at realistic times, the phase pictures replace each other in sequence when the vehicle has traveled a specific length in pixels. This length can be input in pixels with the parameter:

+.<PixelStep>

There is another way to input the phase speed:

+/<Diameter>

where the number is the diameter of the wheel. In the default setting all vehicles are given a geometrically correct value, but with the command $PHSTEP one can set the phase speed to one's own taste. The number given in the $PHSTEP command multiplied with the wheel diameter determines how many pixels must be traversed for a complete rotation of the wheel, thereby timing the phases to occur at points which reflect realistic motion. In the Traffic Screensaver it is possible to use more (or less) than four phase pictures. Without the $PHSTEP command, the basic setting is 3.14 (pi). If a faster phase transition is desired a smaller number can be used. (The +/<Diameter> parameter is equivalent with a parameter in the +.<PixelStep> form having the value:

<PixelStep> = <Diameter> * <PhStep> / <Number_of_phase_pictures>

If the phase pictures do not show a full wheel rotation, rather, only part of it (for example with bogies, showing the movement of the wheels), the +/<Diameter> form is not the best solution.

Modifiers

The modifiers apply to the entire phase picture. One can apply as many to the phase picture as one desires, but the base picture can only expand on it's vertical axis. (It can become higher say, for example, with a load). The coordinates are measured from the bottom left, and begin at 0. The coordinates and sizes are integer numbers in pixels.

Customization commands:

[<Condition> <CommandCode> : <Parameter> , <Parameter> ... ]

One condition can be the direction of travel: the < sign means left and the > sign means right. You can define other conditions by appending an exclamation mark ! to a name: [<Criteria> ! <CommandCode>: <Parameter> ... ]. This criteria is fulfilled if the expanded vehicle macro contains an [!<Criteria>] element.

Some criteria names are used by the standard Stock List. At the moment no function fixes these names explicitly, but some editing commands in the Macro Editor/Graphic Testpad window menus rely on these names already:

[!L]   Left: the other side of the vehicle
[!C]   Cold: a steam locomotive without smoke
[!E]   Empty: freight wagons without load

It is suggested you use this convention as perhaps in a future version of Traffic some commands or modifiers will rely on this convention (it is expected that the L and C criteria will be implemented in the near future).

If the vehicle is composed of phase pictures, you can use the modification commands after each individual phase picture, or after the full picture. Being used after the full picture means that the modification command(s) appear after the +.<Integer> or +/<Integer> parameter, or, if the distance at which the picture changes is not given, after a single + character.

• The modifiers after the first phase picture act on the base picture - which serves as the base for all other phase pictures. If the other phase pictures do not cover the whole area of the vehicle, the parts not covered by the phase pictures are copied from the base picture, but the covered parts will be visible only in the first phase.
• The modifiers after the other phase pictures act on the phases they follow. They can modify not only the part of the vehicle which is covered by the picture in question, but the whole phase picture, included the parts copied from the base picture.
• The modifiers after the whole picture (after a +.<Number> , +/<Number> parameter or after a single + sign) act on all of the phases - they will be obeyed separately by each phase picture after any individual modifier(s) which may be attached to the individual phase pictures.

Do not forget: if you append a [...] modifier directly after the last phase picture's name, without having a step distance or a single plus sign in-between, the modifier acts only on the last phase picture, not on the whole animated picture!

Modification Commands beginning with the # sign set default values for certain properties and apply to the entire train. These values can be superseded by parameters in the lines defining the Movements in the Timetable file. If in a single train there are several vehicles which have the same modification command, only the last (in sequence, not in direction of travel) command will have precedence. Such modification commands are generally only applied to locomotives and railcars in the Stock List. They define the default behavior of the vehicle.

[#A:<Acceleration>]

[#B:<Deceleration>]

[#V:<Speed>]

[#W:<Row>]

[A:<AnimationRules>, <PictureName>, <TargetX>, <TargetY>, <FrameWidth>, <FrameHeight>, <SourceX>, <SourceY>, <Time>, <NumberOfFrames>, <StepX>, <StepY>] (Animation)
[A:<AnimationRules>, <PictureName>, <TargetX>, <TargetY>]

[DIL:<Color_or_picture>,<X>,<Y>,<W>,<H>,<Time>,<NumberOfFrames>] (Door Inside Left)
[DIR:<Color_or_picture>,<X>,<Y>,<W>,<H>,<Time>,<NumberOfFrames>] (Door Inside Right)
[DID:<Color_or_picture>,<X>,<Y>,<W>,<H>,<Time>,<NumberOfFrames>] (Door Inside Double)
[DOL:<Color_or_picture>,<X>,<Y>,<W>,<H>,<Time>,<NumberOfFrames>] (Door Outside Left)
[DOR:<Color_or_picture>,<X>,<Y>,<W>,<H>,<Time>,<NumberOfFrames>] (Door Outside Right)
[DOD:<Color_or_picture>,<X>,<Y>,<W>,<H>,<Time>,<NumberOfFrames>] (Door Outside Double)

<Color_or_picture> == <PictureName> || <HexColor>

Creates an animation of a door. You do not need to define each phase step individually, you need only define the picture behind the opened door - the individual frames will be automatically generated by the screensaver You can define the open state with a picture or only with a color code (only the hexadecimal form, beginning with #, is accepted for inputting color values here as the program needs to distinguish between a picture and a color). If only a color is defined, the open state will be a filled rectangle - filled by the defined color.

The [DIL: ... ], [DIR: ... ], [DID: ... ] commands create a door that slides into the car's wall - as is common on underground/metro vehicles. The [DOL: ... ], [DOR: ... ], [DOD: ... ] commands create a door which slides outside the car body - you see the entire door at all times, it just moves left or right to reveal the opening. The <X> and <Y> parameters place the door on the vehicle picture: the lower left corner of the door is used as the starting coordinate. With the external door commands DOL, DOR and DOD you should use the X coordinate of the opening as well because the animation created by the screensaver will be wider and perhaps, placed to X position, less than the door's corner as the door moves outside the vehicle body.

The <W> and <H> parameters define the size of the door opening. If the opened state is defined by a picture, the default values for these parameters are the dimensions of the picture - you can therefore omit them. The <Time> parameter has a default value of 15 (150 ms between the animation steps) and the <NumberOfFrames> parameter's default value is the step count needed to fully open the door - these can be omitted too. If the <NumberOfFrames> parameter is less than the number of steps needed to fully open the door-- the width of the door for the left and right commands or half of the door width for the double type (in this latter case the door moves in two halves, the left half to left, the right half to right) -- the door won't fully open and a narrow space remains in the opening. In the case of inside doors the <NumberOfFrames> parameter is limited to the maximum step count. For the outside version the value is not limited - you can let the door move further past the opening, allowing the vehicle's side wall between the door and the opening be seen.

The door animations created by this commands can be used the same as the animations created by a [A:DOOR, ... ] command - they act on the OPEN and CLOSE events.

[DA:<PictureName>,<Y>,<XList>] (Door Animations)

<XList> == <#><X> || <XList>,<#><X>

This modifier is a simple form of defining more than one door(s) having the same frame pictures. The parameters for the frame pictures (size, placement, step time) should be defined at the <PictureName> frame pictures, using the [DOOR: ] or [ANIM:DOOR, ] modifier. The [DA: ] modifier defines the <Y> common height for the animations and only the X coordinate for each door. If a # precedes the X coordinate it means the frame pictures should be mirrored.

[E:<#><PictureName>, <TargetX>, <TargetY>, <FrameWidth>, <FrameHeight>, <SourceX>, <SourceY>, <Time>, <NumberOfFrames>, <StepX>, <StepY>] (Electric)
[E:<#><PictureName>, <TargetX>, <TargetY>]

With this command one can input a functioning pantograph. When the pantograph is drawn as an animation, this command is equivalent with the [A:PAN, ..] command . When the last form of the [E: ] command is used and there is no [PAN: <FrameWidth>, <FrameHeight>, ... , <StepY>] command for the pantograph picture the picture referenced in <PictureName> will show the pantograph in its raised state. This will mean that the pantograph "jumps" up immediately to the contact wire whenever the animation is called. The screensaver itself creates an animation having only the two final states, the lower state is copied from the original picture, the raised state is the picture <PictureName>, the dimensions of the animated area are defined by the width and height of the <PictureName> picture).

If you precede the <PictureName> by a #, the picture (either all frame pictures, or the single picture of the raised pantograph) will be mirrored. As most electric locomotives have similar pantographs, placed mirrored on the both ends of the roof, you can spare yourself the trouble of drawing one of them. But beware: if the wires, isolators and other details on the roof of the locomotive, which go in on the square the pantographs is in are not symmetrical, you must draw both pantographs individually, as in this case the picture you should see are not the exact mirrors of each other.

[ED:<#><PictureName>, <X>, <Y> ] (Electric Down)

Similar to the last form of the [E: ] modifier: the original picture has a pantograph in raised state, and the <PictureName> picture shows it in lowered state. The modifier creates a pantograph animation, the pantograph will jump between its two states.

The picture with the lowered state should cover the full height of the raised pantograph in order to remove the upper parts from the picture too!

[EU:<PictureName>, <Y>] (Electric Up)

A relative to the _SAR pictures which are used to show the left pantograph down and the right one up. The [EU: ] modifier assumes that both pantographs are lowered on the original picture, and the <PictureName> picture shows them both in raised state. The <Y> parameter define the bottom point of the <PictureName> picture - you should not draw the whole locomotive with the raised pantographs, it is enough only to draw the upper part, that part which changes.

This modifier assumes that the left pantograph is located on the left half of the picture, and the right pantograph is on the right half of the original picture. It is true almost for every electric locomotive, but it isn't true for all trolleycars and EMUs - so be cautious when using this modifier.

[EX:<UpX>,<Y>,<W>,<H>,<DownX>] (Electric eXchange)

<UpX> == <X>
<DownX> == <X>

The [EX: ] modifier assumes, there are two identical pantographs on the original vehicle picture, one of them is raised, the other is lowered. The [EX: ] modifier creates jumping animations for both pantographs, using the square on the coordinates <UpX>,<Y> as the picture of the raised state and the square on the coordinates <DownX>,<Y> as the lowered state. Both square's size is <W>,<H>. Regardless of the states of the left and right pantographs (which one is raised - and so understood as first) the pantograph with the lower X coordinate will be the first, and the one with the higher X coordinate will be the second generated pantograph animation - so you can control the pantographs defined by [EX: ] with the usual pantograph state modifiers and actions.

If the <DownX> parameter is missing, Traffic assumes the pantographs are placed symmetrically and determines the position of the lowered state picture accordingly.

[EM:<UpX>,<Y>,<W>,<H>,<DownX>] (Electric Mirror)

Similar to the [EX: ] modifier with the difference that the two pantograph pictures are mirrored so that the one can be used as the other pantograph.

If there are wires, isolators, etc. on the roof of the vehicle, you should check that they are exactly mirrored - it not, you cannot use the [EM: ] modifier. In this case you should draw the other states of the pantographs individually and use the [E: ] and [ED: ] modifiers.

The modifiers [ED: ], [EU: ], [EX: ], [EM: ], and the usage of the _SAR pictures in a <BasePicture> < <_SAR_Picture> construct are intended only for ease the usage of existing pictures originally drawn for other screensavers. The preferred method for defining pantographs for Traffic is to draw several frame pictures to have a smoothly animated pantograph. The second choice is to draw the locomotive with both pantographs lowered, and to draw the pantographs separately

[L:<Name>] (Label)

The labels can help you to address the actions (the start of animation sequences) in order to start animations of same type(s) only in limited number. That means, not to start all of the animations having the same action name, but only one or a few animations among them (for example: to open only the door of the baggage coach at a stop along the track).

[<AnimationRules>: <FrameWidth>, <FrameHeight>, <SourceX>, <SourceY>, <Time>, <NumberOfFrames>, <StepX>, <StepY>]

The following pantograph modifiers determine the state of the pantographs the vehicle initially has when it appears on the screen:

[PDO], [PNO], [PD], [PN] - All pantographs down
[PLU], [P1U] - Left pantograph up
[PRU], [P2U] - Right pantograph up
[PMU], [P3U] - Third (usually the inner or inner left) pantograph up
[P4U] - Fourth (inner right) pantograph up
[PDU], [P12U], [PU] - First and second (on a standard locomotive that means all) pantographs up
[PFU] - Forward pantograph up (relative to direction of travel)
[PBU] - Rear pantograph up (relative to direction of travel)
[PFIU] - Forward inner pantograph up (relative to direction of travel - useful for multi-system locomotive)
[PBIU] - Rear inner pantograph up (relative to direction of travel - useful for multi-system locomotive)
[PHU] - First pantograph of the train up relative to direction of travel (useful for multiunit trains)
[PTU] - Last pantograph of the train up relative to direction of travel (useful for multiunit trains)
[PA] - All pantographs up

They are similar to the pantograph actions (the keywords starting animations, the sequence of frame pictures inside a wait phase, in the <WaitTime> parameter), but not the same.

[CB:<Simple>] (Couple Base)

[CL:<#><PictureName>,<BaseX>,<AddX>,<Y>] (Couple Left)
[CR:<#><PictureName>,<BaseX>,<AddX>,<Y>] (Couple Right)

Append a picture next to the existing one so that part of the new picture overlays the existing one. These two modifiers are the only ones which can extend the horizontal size of a picture.

This modifier was implemented to allow you to combine a truck with a semitrailer. Neither the truck, nor the semitrailer has the full length of the consist and the overlay the squares of each other.

Both the <BaseX> and <AddX> parameter specify a "contact point" in the vehicles. The <BaseX> parameter is the distance of this contact point from the side of the original picture in the direction the picture will be extended (CL: left, CR: right). The <AddX> parameter is the distance to the contact point in the overlay picture, measured from the other side of its border - in case of the CL command, from the right side, in case of the CR command from the left side. The overlay picture will be placed so that both contact points cover each other ( NewWidth = OriginalWidth + OverlayWidth - <BaseX> - <AddX> ).

The contact point is intended to be the place of the coupling mechanism in case of a truck and a semitrailer. As you can combine many trucks with many semi-trailers, and the place of the contact point is always the same, there is a possibility to predefine the contact point distance by means of the [CB:...] command. If the original picture has a [CB:...] modifier before the actual CL or CR modifiers, the default value for the <BaseX> parameter is the value given by the CB modifier (if you omit the <BaseX> parameter, you get the value of the CB, but you can specify another value too). If the overlay picture has a [CB:...] modifier anywhere in its attached macro in the Stock List, the default value for the <AddX> parameter is this value.

You can also use this command to place loads on a truck or wagon whose size exceeds the size of the vehicle. If you want to place a single picture of a huge load on two or more vehicles, you should unite the vehicle pictures as one single picture (in this special case both the <BaseX> and <AddX> parameter are 0, the pictures do not overlap), and after this step you can place the picture of the load as if it were on only a single vehicle. You can extend the horizontal size of the vehicle several times if you specify this modifier several times but do not forget, the combined vehicle inherits only the macro and properties of the original vehicle you started with. The overlay vehicles contribute only their pictures but not their macros and properties.

[N:<#><Type>,<#><PictureName>, <Y>] (Neighbors)

[NL:<#><Type>,<#><PictureName>, <Y>] (Neighbor left)

[NR:<#><Type>,<#><PictureName>, <Y>] (Neighbor right)

[NT:<Type>] (Neighbor type)

[TN:<#><Type>,<#><PictureName>, <Y>] (Transparent Neighbors)
[TL:<#><Type>,<#><PictureName>, <Y>] (Transparent Neighbor left)
[TR:<#><Type>,<#><PictureName>, <Y>] (Transparent Neighbor right)
[TT:<Type>] (Transparent neighbor Type)

The [TN: ... ], [TL: ... ], [TR: ... ] modifiers are similar to the [N: ... ], [NL: ... ], [NR: ... ] respectively. The only difference: the [TX: ... ] commands use a transparent copy - the transparent pixels in the <PictureName> won't be copied, the pixels of the original picture remain visible. This is an additive process. You cannot clear an existing connection (for example, a cab or air hose), you can only add such connections - but you can do this with the same picture of the connection to several vehicle pictures having different colors or ends - there are not as many types of connections as there are vehicles.

[NC:<Type>,<W>,<H>,<Y>] (Neighbor connection Clear)

Modification of the end of the vehicle based on the neighbors. If the neighbor doesn't have the type <Type>, a rectangular area with width <W> and height <H> , bottom position <Y> (and directly on the side of the vehicle, therefore no <X> parameter) will be cleared: the rectangle will be filled with the background color, if the original picture is opaque, or the area will be made transparent if the picture is transparent. This modifier acts on both sides of a vehicle.

[NCL:<Type>,<W>,<H>,<Y>] (Neighbor connection Clear Left)

Modification of the left end of the vehicle based on the left neighbor. If the neighbor doesn't have the type <Type>, a rectangular area with width <W> and height <H> , bottom position <Y> (and directly on the left side of the vehicle, on X=0 position) will be cleared: the rectangle will be filled with the background color, if the original picture is opaque, or the area will be made transparent if the picture is transparent. This modifier acts only on the left side of a vehicle.

[NCR:<Type>,<W>,<H>,<Y>] (Neighbor connection Clear Right)

Modification of the right end of the vehicle based on the right neighbor. If the neighbor doesn't have the type <Type>, a rectangular area with width <W> and height <H> , bottom position <Y> (and directly on the right side of vehicle, therefore no <X> parameter) will be cleared: the rectangle will be filled with the background color, if the original picture is opaque, or the area will be made transparent if the picture is transparent. This modifier acts only on the right side of a vehicle.

[C:<Color>,<NewColor>, ... ] (Color)

[F:<X>,<Y>,<Color>] (Flood Fill)

[M:<X>,<Y>,<W>,<H> ... ] (Mirror)

[MP:<X>,<Y>,<W>,<H> ... ] (Mirror part)

The picture inside the square the bottom left point of which has the coordinates <X> and <Y>, width of <W> and height of <H> will be mirrored.

[MX:<X>,<Y>,<W>,<H>] (Mirror exchange)

The square area of the picture at the position <X>,<Y> and size <W>,<H> will be mirrored inside itself and than exchanged with the content of the square area lying on the mirrored position (inside the original place). An example: with a tramcar able to travel in both directions, when you want it to travel into the other direction you should exchange the picture of the driver in the front of the tram with the empty part of the rear of the tram.

[R:<X>,<Y>,<W>,<H> ... ] (Reverse)

[B:<X>,<Y>,<W>,<H>,<Color>] (Block fill)

[BT:<X>,<Y>,<W>,<H> ... ] (Block Transparent)

[CP:<SourceX>,<SourceY>,<W>,<H>,<TargetX>,<TargetY>] (Copy)

<SourceX> == <X>
<SourceY> == <Y>
<TargetX> == <Integer>
<TargetY> == <Integer>

Copies part of a picture from one place to another inside the border of the picture.

[O:<PictureName>,<X>,<Y>,<D>] (Overlay)

[OT:<PictureName>,<X>,<Y>,<D>] (Overlay transparent)

[OB:<PictureName>,<X>,<Y>,<D>] (Overlay behind)

[P:<PointName>,<X>,<Y>,<D>] (Point)
[PT:<PointName>,<X>,<Y>,<D>] (Point Transparent)
[PB:<PointName>,<X>,<Y>,<D>] (Point Behind)

[D:<OverlayName>,<PictureName>,<X>,<Y>,<D>] (Define)
[DT:<OverlayName>,<PictureName>,<X>,<Y>,<D>] (Define transparent)
[dB:<OverlayName>,<PictureName>,<X>,<Y>,<D>] (Define behind)

<OverlayName> == <Name>

[T:<#><TextToWrite>,<X>,<Y>,<PictureName>,<NewColor>,<Border>]
[ABC:<Characters>,<Delim>,<CharWidth>, ... ]

<TextToWrite> == <Text> || # <Integer>
<Characters> == <Text>
<Delim> == <Simple>
<CharWidth> == <Simple>
<Border> == <Simple>

Write text on the picture with a predefined set of letters. The letters must be a picture in the Stock List, and must have a modifier [ABC: ] with the parameters defining the character set. The first parameter is a string describing which characters are drawn. You can include every character in the string. If you have other characters, such as letters, numbers and underscore characters, you should enclose the string in double quotation marks   " "  . The double quotation marks inside the string should be coded by two consecutive quotation marks: "ABC""D" is the string ABC"D. The <Delim> parameter determines how many pixels of space will be remain between the characters when they are written on the picture. In the ABC definition the characters should be typed next to each other without any delimiting space. The ABC definition should specify the character widths also. If no one <CharWidth> parameter follows the delimiter all the characters have the same width and the character width is calculated by dividing the ABC picture width by the length of the <Characters> string (the number of characters the ABC contains). If you have an ABC with variable character widths, you should specify the width for each character individually, having as many <CharWidth> parameters, as characters in the ABC.

The text to write is the first parameter of the [T: ] modifier. The place is specified by the <X>,<Y> parameters - remember, you can use several alignment options to specify a position. The size of the whole text will be used for calculating the position of a centered or right aligned text.

You have 3 different possibilities for the text color.

• If you do not specify any color value for the <NewColor> parameter, then the pixels which are black in the ABC picture preserve their original color. Any other pixels will be copied to the destination: you write transparent characters with the original color as it is drawn in the ABC.
• If you specify only a single color for the <NewColor> parameter, the black pixels in the ABC remain unchanged, any other pixels will be set with the specified color: you write transparent characters with the specified color.
• If you specify both the colors before and after the slash, the non black pixels in the ABC become the first color, the black pixels the second color: you write an opaque text with the specified foreground/background color.

The <Border> parameter specifies the width of the border, which will be filled with the background (the second) color. This parameter will be counted when determining the position of the text too: you place the whole square occupied by the text and the border.

You have two possibilities to let Traffic to write random items. You can use the selection construct by any text, or you can let Traffic to choose a number by specifying an <Integer> - a number expression with selections and intervals - preceded by a # character.

The [T: ] modifier can be used to write numbers on the locomotives - with a selection or interval you can get random numbers, which correspond to existing serial numbers - or you can write on background picture, for example, to write a station's name on a table.

[NAME:<PictureName>] (Name)

Syntax Elements

In the syntax description below, the text between the < and > signs show the parameters of the modifiers and the Timetable commands. These parameters can be as follows:

<Filename>

<Name>

<PictureName>

<PictureName == <Name> || <Name> ~ <Name> || <Filename>

You can use pictures either in the Stock List of the Traffic Screensaver, or independent picture files.

An independent picture file is given by its path name. A picture name is a path name, if it contains at least one slash, backslash or point ( \ / . ) character. If the filename does not contain an extension, .GIF is assumed. A .BMP or .DIB file is treated as non transparent.

A picture in the Stock List is given by its name.

<#>

<#> == || #

This syntax element is either nothing, or a # character. It slightly modifies the meaning of the parameter following it. If this element precedes a <PictureName> it generally means that the picture should be mirrored before it is used.

<Simple>

<Simple> == <Digit> || <Simple> <Digit>
<Digit> == 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9

<Simple> is a simple integer number - you cannot use random selection or interval for this parameters

<Integer>

<Integer> == <Simple> || <IntInterval> || <IntSelection>
<IntInterval> == <Simple> - <Simple>
<IntSelection> == <IntSelItem> || <IntSelection> | <IntSelItem>
<IntSelItem> == <Simple> || <Simple> : <Simple>

<Integer> is an integer number you can type in directly or let it be generated by a random number generator. You have two main forms for the random number generation:

• interval
• selection

An interval is given by two simple numbers connected by a minus sign ( - ). Both the end values and all the numbers between them will have the same probability.

A selection is given by the numbers to be selected from separated by vertical bars. All the numbers have the same probability at the selection.

If you want to modify the probabilities, you can assign a weight to a value, selected by a colon ( : ) from the value itself. The weight constants are integer numbers. You can write mixed selection expressions: some values have a assigned weight, some others do not - in these cases all of the values without a weight number have the weight 1 for the random selection.

Some examples:

4		Single number, the value is always 4
2-5		Interval, the value is a random selection between 2,3,4 and 5 - all the 4 choices having a probability of 25%
2|5|7		Selection, the value is a random selection between 2,5 and 7 - all the 3 choices having a probability of 33%
3:2|4|5:6|8		Selection, the value is a random selection between 2,4,6 and 8 - 2 with 30%, 4 with 10%, 6 with 50% and 8 with 10% probability

<Real>

<Boolean>

<Direction>

<Speed>

<Acceleration>

<Deceleration>

<Row>

a b u
A B U
r
R
0
1
2
3
4
5
q
Q
p
P
g
G
j
J
k
K
h H
X	nothing, the place is left blank

<X>, <Y>

<X> == <Align> <Integer> || <Align> || <Integer> ||
<Y> == <Align> <Integer> || <Align> || <Integer> ||
<Align> == <AlignLeftOrBottom> || <AlignRightOrTop> || <AlignCenter>
<AlignLeftOrBottom> == < || _ || L || B || A || D || U
<AlignRightOrTop> == > || ^ || R || J || T || F
<AlignCenter> == * || M || K

Position inside a picture. The coordinates are measured from left and bottom, they begin with 0.

If   < _ L B A D   or   U   precede the X coordinate, the left side of the placed object (an overlay picture, a filled rectangle) will be placed at the given position. When placed before the Y coordinate they denote the bottom of the rectangle. If   * M  or   K   precede the number, the middle of the object is placed at the coordinates. Correspondingly, the   > ^ R J T F   characters denote the right or top side of the rectangle.

In the case that the number or both the alignment and the number are missing, there is usually a default value depending on the command. For example, the [O: ] command places the overlay picture in case of a missing <X> parameter horizontally in the middle; when the <Y> parameter is missing the vertical overlay picture will be placed on top of the existing picture. A pantograph placed with the [E: ] command will reach up to the catenary height.

<W>, <H>

<W> == <Integer>
<H> == <Integer>

Width and height of an area on the picture.

<AnimationRules>

<WaitTime>

<Place>

<Place> == <PlacePoint> || <Align> <PlacePoint>
<Align> == * || < || > || @+ || @- || @*
<PlacePoint> == <PlaceBase> || <PlaceBase> + <PlaceOffset> || <PlaceBase> - <PlaceOffset>
<PlaceBase> == <Integer>
<PlaceOffset> == <Integer>

<Point>

<Point> == <Place> , <ActionList> || <Name> = <Place> , <ActionList>
<ActionList> == <ActionCmd> || <ActionList> , <ActionCmd>
<ActionCmd> == <Direction> <ActionPoint> : <AnimCmd>
<Direction> == || < || >
<ActionPoint> == TB || TE

Point along the path of a vehicle starting an action, when the vehicle passes it. The point is input similar to the places (stopping points): the position can be composed from a procentual part and an absolute part, giving you the possibility to define the place in harmony with the screen size and background elements.

You can give a name for such a point. It has no usage in this version at all, but it is planned to let you use this named point in the definition of further points or places.

The position of the point is followed by an action (or by a list of actions), separated by commas. A single action is composed from a <Direction> defining from which direction the vehicle must pass the point (< means from right to left, > means from left to right, nothing means passing the point in both directions starts the action), an <ActionPoint>, defining which part of the vehicle must pass the point (TB means the front of a train - a full consist, TE means the end of a train), and a colon ( : ) followed by an animation command.. The animation command has exactly the same syntax as in the <WaitTime> parameter.

<PointList>

<PointList> == <Point> || ( <Points> )
<Points> == <Point> || <Points> ; <Point>

As the <PointList> is a parameter for $SECTION, $GROUP and $LINE commands and for the Movement commands, if you define more points separated by semicolons you need to enclose the list in parenthesis.

<FgBg>

<Language>

<Text>

<Color>

<NewColor>

<NewColor> == <Color> || <Color> / <Color>

<Train>

<TrainList>

<TrainList> == <Train> || ( <Trains> )
<Trains> == <Train> || <Trains> ; <Train>

A train list is either a single train (in this case it has exactly the same format, as the <Train> syntax element), or multiple train definitions separated by semicolon ( ; ) and the whole list enclosed in parentheses. The <TrainList> syntax element is used in the M=FOLLOW; Movement.
(The vehicles composing a train are separated by comma, so the trains could not be separated by comma too - therefore the delimiting character is the semicolon. However, the Movement parameters are separated with semicolons too, but the <TrainList> is a single parameter, therefore you should enclose the list in parentheses).