TrainzOnline - User contributions [en]

CMTM/Link Introduction

2009-09-05T17:00:33Z

Dap:

== Car Movement & Traffic Management System (CMTM System) ==

''' Introduction'''<BR>
The Car Movement & Traffic Management System (CMTM System) is designed to simulate prototype freight traffic patterns and operations in Trainz by providing each freight car on the route a series of destinations that represent freight car movements in prototype operations. Implementing this system is labor intensive to get up and get running and is not for the faint of heart. Think of it as an automated car-card system on steroids.

I developed this system because the built-in WayBill system in Trainz works nothing like the prototype and I like to operate as close to prototypical as possible. Trainz is a fantastic modeling tool for its price, but it is only a $40 software package with many limitations. Consequently, there are some limitations to this system. The first is that you can not save a session and come back to it with the same destinations for the same cars. Another problem, but one that can be overcome, is that CMTM relies on certain data in each vehicles config.txt files to be correct.

Be advised that many vehicles on the DLS have errors in their config.txt files. The work around is to use only those cars that have the information correct or to modify the config.txt files to make the data correct. The two primary Tags that require correction are the category-class code and the Company. The category-class code is a standardized system for referring to the various types of assets. A complete listing for freight cars can be found in Appendix C of this document. (I was surprised by the number of vehicles on the DLS that do not have the correct category-class.) The category-class for a freight car begins with an X, followed by one or two letters that determine the type of freight car. The CMTM system relies on these codes for proper identification.

The second problem tag is the Company tag. The CMTM system relies on this tag to determine if a vehicle is a home road vehicle or a vehicle leased for home road use. This tag must be consistent in all vehicles for each owner company that is used for home road use and must agree with the data entered into the CMTM system. I like to use the call letters of the railroad, but you cannot use the “&” as Trainz does not recognize this as a valid letter. If you enter C&NW or CB&Q, Trainz only sees C or CB because “&” is not recognized as a valid letter and the text is terminated.

The CMTM System assumes that your route has at least one portal and at least one industry to service. The portals represent either the continuation of your railroad (home road) or an interchange with another railroad (foreign road). Your Trainz route can be just one town on a railroad with industries and portals to the rest of the world, or a complete railroad with multiple interchanges to foreign roads, or anything in between.

Industries used in this system do not have to be interactive. Any spot on any spur or side track can be an industry or destination for a freight car. It is recommended that some type of structure be placed at the location and given a name so the location can be readily recognized. This will also make all industries visible on the Trainz Mini-map. If you have an industry that uses open top cars, you may want to make it an interactive industry. Just make sure that your production rates are set appropriately so there is always product to load or unload.

This system does not deal with "Commodities" or the built in "Way Bill" system. If you are using the CMTM System, the built-in "Commodities" and "Way Bill" features should be completely ignored.
CMTM stands for Car Movement and Traffic Management. The Car Movement portion of this system is what directs cars to and from industries. The Traffic Management portion determines the over all flow of through traffic. Through traffic is usually portal to portal traffic, but not always straight thru on the same train. If you have three or more portals, through cars that arrive in a train from portal 1 may be destined for portal 2 or portal 3. You can control the flow of this traffic with the Traffic Management portion of this system.

Operators

2009-04-20T13:43:13Z

Dap:

The operator sections set out below follow the language's preference rules. The earlier the operator appears in the list, the higher the precedence and the earlier the listed operators will be evaluated.__NOEDITSECTION__

==Operators (1), Grouping & Indexing==
{{MethodHeader|( )}}
*Expression grouping.
*In common with most programming languages Trainzscript carries out arithmetical operations in the order defined by operator precedence rules.
*''3 + 2 * 12 - 7'' would return 20, because multiplication is of higher precedence than addition and subtraction.
*You can force the compiler to change this sequence and make your intentions crystal clear by declaring this as ''((3 + 2) * 12) - 7''.

{{MethodHeader|[ i ]}}
*Array and string indexing.
*Arrays are zero based and ''arrayName[0]'' will represent the first element.
*Similarly ''arrayName[arrayName.size() - 1]'' will represent the last element.
*A call to a value outside the range ''[0 … size()-1]'' will generate an exception.
*This notation can also be used to return a single character from a string.

intArray[intArray.size()] = 5 // will add the new value of 5 to the end of the array.

{{MethodHeader|[ i , j ]}}
*Array and String range index.
*The expression ''string[0,string.size()]'' will return the entire string.
*The integers i and j are best thought of as 'cursor' positions where 0 is before the first element and size() is after the last element.
*If i is omitted the range will start at the beginning of the array,
*If j is omitted the range will end after the end of the array.
*To return a single element both i and j are required.
*Given the declaration ''string s = "abcde"''
s[,3] = "abc"
s[2,3] = "c"
s[2,] = "cde"

intArray[2,3] = null // will delete the third element of the array.

{{MethodHeader|[ i , ]}}
*Indexes from i to the end of the string or array inclusively.

{{MethodHeader|[ , j ]}}
*Indexes from the start of the string or array to element b inclusively.

{{MethodHeader|.}}
*Dereference operator as in ''GetAsset().GetConfigSoup();''

{{MethodHeader|!}}
*Not Operator
!true = false
!vehicle = null

==Operators (2), Incremental and Unary Operators==
{{MethodHeader|++}}
*Increments a numeric value by 1.
*Often used for control variables in loops:
for(n = 0; n < list.size(); n++) {
DoStuffWith(n);
}
*Increments n by 1 on each pass through the loop.

{{MethodHeader|--}}
*Decrements a numeric value by 1.
*Often used for control variables in loops:
n = list.size() - 1;
while(n >= 0) {
DoStuffWith(n);
n--;
}
*Decrements n by 1 on each pass through the loop.

{{MethodHeader|+}}
*Unary plus.
*Used to denote that a value is positive.

{{MethodHeader|-}}
*Unary minus.
*Used to denote that a value is negative.

==Operators (3), Casts==
{{MethodHeader|<h5>(bool)</h5>}}
*Boolean type cast.
(bool) 0 = false
(bool) 0.0 = false
(bool) n = true //where n is greater than zero

{{MethodHeader|<h5>(int)</h5>}}
*Integer type cast.
(int) 5.0 = 5
(int) true = 1

{{MethodHeader|<h5>(float)</h5>}}
*Float type cast.
(float) 100 = 100.0
(float) false = 0.0

{{MethodHeader|<h5>(string)</h5>}}
*String type cast.
(string) 1 = "1"
(string) 0.99 = "0.99"
(string) false = "false";

{{MethodHeader|(''reference'')}}
*Class type cast.
<font color=red>How is this used and how is it different from cast<Class>?</font>

{{MethodHeader|<h5>cast</h5>}}
*Dynamic cast.
*Returns null if the reference cannot be converted to the class specified by className.
*Note that ancestors of the specified class will be returned.
Vehicle vehicle = cast<Vehicle>msg.src;

MeshObject meshObject;
GameObject gameObject = cast<GameObject>meshObject; // returns meshObject if the object exists, null otherwise

{{MethodHeader|<h5>size()</h5>}}
*Returns the number of members of an array or the length of a string.
*In the case of an array this does not necessarily mean that all (or any) of the members actually contain values.
given string s = "abcde";
s.size() = 5;

int[] numbers = new int[5]; // creates an empty array of 5 integers
numbers.size() = 5;

{{MethodHeader|<h5>copy()</h5>}}
*Creates a copy of an array or string.
*This is different from a simple assignment which points a variable to the same memory address as an existing variable.
*Array.copy() or string.copy() creates an additional copy of the data.
int[] numbers = new int[5];
int[] moreNumbers;

moreNumbers.copy(numbers); // duplicates numbers

{{MethodHeader|<h5>isclass()</h5>}}
*Used in the declaration of a new class identifier
class MyScript isclass Vehicle {
classMethods();
};
*Used to test whether a given reference is to a specific class.
given the declaration:
TrackLoadInfo info = new TrackLoadInfo();

info.isclass(TrackLoadInfo); // returns true

{{MethodHeader|<h5>new</h5>}}
*Creates a new instance of the specified type.
int[] numbers = new int[4]; // creates an integer array containing 4 members.
TrackLoadInfo info = new TrackLoadInfo(); // creates a new instance of the TrackLoadInfo class.
*new does not initialise the members.
*GameObject classes cannot be created using new.

==Operators (4), Multiplication & Division==
{{MethodHeader|*}}
*Multiplication.
*If both terms are integers the result will be an integer.
*If either term is a float the result will be a float.
2 * 5 = 10;
2 * 5.0 = 10.0;

{{MethodHeader|/}}
*Division.
*If both terms are integers the result will be an integer, possibly with a remainder.
*If either term is a float the result will be a float.
10 / 5 = 2;
10 / 5.0 = 2.0;
10 / 6 = 1;

{{MethodHeader|%}}
*Remainder or modulus operator.
*Returns the remainder from an integer division.
5 % 2 = 1;
105 % 50 = 5;
105 % 100 = 5;

==Operators (5), Addition & Subtraction==
{{MethodHeader|+}}
*Addition
*If both terms are integers the result will be an integer.
*If either term is a float the result will be a float.
1 + 1 = 2;
1 + 1.0 = 2.0;

{{MethodHeader|-}}
*Subtraction
*If both terms are integers the result will be an integer.
*If either term is a float the result will be a float.
2 - 1 = 1;
2 - 1.0 = 1.0;

==Operators (6), Shifts==
{{MethodHeader|<<}}
*Shift Left
*Bitwise operator moves all of the binary values to the left by the number of places specified in the second term.
*Binary zero is appended.
*Provided there is no overflow the result is a doubling of the value for each shift.
8 << 1 = 16
8 << 2 = 32

{{MethodHeader|>>}}
*Shift Right
*Bitwise operator moves all of the binary values one place to the right by the number of places specified in the second term.
*Binary zero is prepended and any displaced bits are discarded.
*The result is an integral halving of the value for each shift.
8 >> 1 = 4
9 >> 2 = 2

==Operators (7), Comparisons==
{{MethodHeader|<}}
*Comparison operator which can be used on string, float, integer and bool values.
*Returns true if the first term is less than the second.
1 < 2 = true;
false < false = false;
"abc" < "def" = true;

{{MethodHeader|<=}}
*Comparison operator which can be used on string, float, integer and bool values.
*Returns true if the first term is less than or equal to the second.
1 <= 2 = true;
false <= false = true;
"abc" <= "def" = true;

{{MethodHeader|>}}
*Comparison operator which can be used on string, float, integer and bool values.
*Returns true if the first term is greater than the second.
1 > 2 = false;
true > false = true;
"abc" > "def" = false;

{{MethodHeader|>=}}
*Comparison operator which can be used on string, float, integer and bool values.
*Returns true if the first term is greater than or equal to the second.
1 >= 2 = false;
true >= true = true;
"abc" >= "def" = false;

==Operators (8), Equality==
{{MethodHeader|==}}
*Comparison operator which can be used on string, float, integer and bool values and on object references.
*Returns true if the first and second terms are equal or if they evaluate to the same object.
int a = 0;
int b = 0;
a == b; // returns true
*Note that ''a = b'' is an assignment and will always return true. Mistyping '''''=''''' for '''''==''''' is one of the most common semantic errors in Trainzscript.

{{MethodHeader|!=}}
*Comparison operator which can be used on string, float, integer and bool values and on object references.
*Returns true if the first and second terms are not equal and do not evaluate to the same object.
int a = 0;
int b = 0;
a != b; // returns false

==Operators (9), Bitwise Operators==
{{MethodHeader|&}}
*Bitwise AND
*Performs a bit by bit comparison of two integers and returns a new value.
*Each bit in the result is set if BOTH of the corresponding bits in the arguments are set
0000 1111
& 0001 0111
= 0000 0111

15 & 23 = 7

{{MethodHeader|^}}
*Bitwise XOR
*Performs a bit by bit comparison of two integers and returns a new value.
*Each bit in the result is set if EITHER BUT NOT BOTH of the corresponding bits in the arguments are set
0000 1111
^ 0001 0111
= 0001 1000

15 ^ 23 = 24

{{MethodHeader|¦}}
*Bitwise OR
*Performs a bit by bit comparison of two integers and returns a new value.
*Each bit in the result is set if EITHER of the corresponding bits in the arguments are set
0000 1111
| 0001 0111
= 0001 1111

15 | 23 = 31

{{MethodHeader|~}}
*Bitwise Inverse Operator for integer values
*Takes the binary representation of the integer and inverts each bit.
*Useful in masking out values from bitfields (eg. flags &= ~SOME_FLAG; switches off the SOME_FLAG bit from 'flags')
~0011 1101 = 1100 0010
~1000 0100 = 0111 1011

~0 = -1
~255 = -256
~5 = -6

==Operators (10), Logical Operators==
{{MethodHeader|<h5>and</h5>}}
*Logical AND
*Enables multiple boolean expressions to be combined.
if (msg.minor == "Enter" and doorsOpen)

{{MethodHeader|<h5>or</h5>}}
*Logical OR
*Enables multiple boolean expressions to be combined.
if (msg.minor == "Enter" or doorsOpen)
if ((msg.minor == "Enter" and doorsOpen) or (msg.minor == "Leave" and !doorsOpen))

==Operators (11), Assignment==
{{MethodHeader|=}}
*Assignment Operator
a = 1;
Train train = World.GetTrainList()[0];

Apparently there are 2 types in Trainz gamescript that don't support direct assignment of themselves: arrays and strings. When arrays and strings appear singlely on the right hand side in assignment statements only a reference to the original is created. So in effect only the original copy exists. The original name and the new name both reference the same object. To make an assignment to a new object that is a copy of the original you can use the copy() operator.

{{MethodHeader|,}}
*Expression or parameter separator.

Class World

2009-03-08T02:38:21Z

Dap: changed 36.0 to 3600.0 in TIME_HOUR=TIME_MINUTE

*[[TrainzScript Langage Reference|API Hierarchy]]
**World
<br>
*World is a static class used to access various aspects of the Trainz environment.
<br>

==Constants==
*These constants are used to define various values and can be used as mnenomics.
*If accessed from scripts the values must be prefixed ''World.'', for example:
World.SetWeather(World.WEATHER_TYPE_LIGHT_SNOW,World.WEATHER_CHANGEABILITY_PERIODIC);
<br>

===Camera View Modes===
----
*These values can be used either to choose the current camera viewing mode through World.SetCameraMode(), or to restrict certain camera modes from being accessed through methods such as World.SetCamera().

{{TableHeader|width=95%|margin=15px}}
|width=375|public define int CAMERA_INTERNAL = 1||Internal cabin camera view.
|-
|public define int CAMERA_EXTERNAL = 2||External train camera view
|-
|public define int CAMERA_TRACKING = 4||External tracking camera view.
|-
|public define int CAMERA_ROAMING = 128||Roaming camera view.
|}
<br>

===Camera Flags===
----
*These flags are used in addition to the Camera Mode Flags to allow or disallow specific camera actions.
{{TableHeader|width=95%|margin=15px}}
|width=375|public define int CAMERA_SWITCH_VIEWS = 8||User permitted to swap between the camera views.
|-
|public define int CAMERA_SWITCH_VEHICLES = 16||User permitted to swap vehicles within the current train.
|-
|public define int CAMERA_SWITCH_TRAINS = 32||User permitted to swap to other trains which are in the consist menu.
|-
|public define int CAMERA_LOCKED = 64||User is NOT permitted to adjust camera (i.e. zoom, pan etc.).
|-
|public define int CAMERA_NORMAL = * ||Normal camera mode where everything is permitted.
|-
|colspan=2|<sup>* NOTE: CAMERA_NORMAL = CAMERA_INTERNAL | CAMERA_EXTERNAL | CAMERA_TRACKING | CAMERA_SWITCH_VIEWS | CAMERA_SWITCH_VEHICLES | CAMERA_SWITCH_TRAINS</sup>
|}
<br>

===Weather Type Constants===
----
*Define the current state of the weather in Trainz.
*A variety of weather conditions are supported and can be changed by using one of these values with the World.SetWeather() method.
{{TableHeader|width=95%|margin=15px}}
|width=375|public define int WEATHER_TYPE_CLEAR = 0||Clear weather, no clouds, rain or snow.
|-
|public define int WEATHER_TYPE_CLOUDY = 1||Cloudy weather, no rain.
|-
|public define int WEATHER_TYPE_DRIZZLE = 2||Drizzle, light rain.
|-
|public define int WEATHER_TYPE_RAIN = 3||Rainy weather.
|-
|public define int WEATHER_TYPE_STORMY = 4||Stormy weather that includes lightning and thunder.
|-
|public define int WEATHER_TYPE_LIGHT_SNOW = 5||Snowing lightly.
|-
|public define int WEATHER_TYPE_MEDIUM_SNOW = 6||Medium level snow fall.
|-
|public define int WEATHER_TYPE_HEAVY_SNOW = 7||Heavy snow fall.
|}
<br>

===Weather Changeability Constants===
----
*Define the changeability settings for the weather.
*Weather changeability refers to variability of weather conditions rather than to a specific weather type.
{{TableHeader|width=95%|margin=15px}}
|width=375|public define int WEATHER_CHANGEABILITY_NONE = 0||Weather remains static.
|-
|public define int WEATHER_CHANGEABILITY_PERIODIC = 1||Periodic changes in weather.
|-
|public define int WEATHER_CHANGEABILITY_EXTREME = 2||Extreme and frequent changes in weather.
|}
<br>

===Time Values===
----
*Time constants defined in seconds.
{{TableHeader|width=95%|margin=15px}}
|width=375|public define float TIME_SECOND = 1.0f||One second.
|-
|public define float TIME_MINUTE = TIME_SECOND * 60.0f||One minute, 60.0 seconds.
|-
|public define float TIME_HOUR = TIME_MINUTE * 60.0f||One hour, 60.0 minutes, 3600.0 seconds.
|-
|public define float TIME_DAY = TIME_HOUR * 24.0f||One day, 24 hours, 1440.0 minutes, 86400.0 seconds.
|}
<br>

===Time Rate Constants===
----
*Values that define the time rates relative to normal time.
*These constants can be used to set the time rate that Trainz runs out through the World.SetGameTimeRate() method.
{{TableHeader|width=95%|margin=15px}}
|width=375|public define int TIME_RATE_1X = 0||Real time (i.e. time in Trainz passes at the same rate as in the real world)
|-
|public define int TIME_RATE_2X = 1||Time passes at twice normal speed.
|-
|public define int TIME_RATE_4X = 2||
|-
|public define int TIME_RATE_8X = 3||
|-
|public define int TIME_RATE_16X = 4||
|-
|public define int TIME_RATE_32X = 5||
|-
|public define int TIME_RATE_60X = 6||
|-
| public define int TIME_RATE_120X = 7||
|-
| public define int TIME_RATE_240X = 8||
|-
|public define int TIME_RATE_360X = 9||
|-
|public define int TIME_RATE_480X = 10||
|-
|public define int TIME_RATE_720X = 11||
|-
|public define int TIME_RATE_960X = 12||
|-
|public define int TIME_RATE_1200X = 13||
|-
|public define int TIME_RATE_1440X = 14||
|}
<br>

===Trainz Modules===
----
*Trainz module mode constants.
*These values define the various module environments that Trainz can be in.
{{TableHeader|width=95%|margin=15px}}
|width=375|public define int NO_MODULE = 0||Trainz not running in a module.
|-
|public define int SURVEYOR_MODULE = 1||Trainz is currently running in Surveyor.
|-
|public define int DRIVER_MODULE = 2||Trainz is currently running in Driver.
|}
<br>

==Related Messages==
* [[TrainzScript Message Reference]]<br>
* [[Camera Messages]]<br>
* [[Interface Messages]]<br>
* [[ModuleInit Message]]<br>
<br>

==AddDriverCharacter==
{{MethodHeader|public native DriverCharacter AddDriverCharacter(Asset driverCharacterAsset)}}
;Parameters
*'''driverCharacterAsset''' = Asset containing character to be added.
;Returned Value
*Reference to the DriverCharacter if successful, null otherwise.
;Syntax
DriverCharacter Casey = World.AddDriverCharacter(CaseyJones);
;Notes
<br>

==AddDriverCommand==
{{MethodHeader|public native DriverCommand AddDriverCommand(Asset driverCommandAsset)}}
;Parameters
*'''driverCommandAsset''' = Asset containing command to be added.
;Returned Value
*Reference to the DriverCommand if successful, null otherwise.
;Syntax
DriverCommand GoFaster = World.AddDriverCommand(accelerate);
;Notes
<br>

==CreateBehavior==
{{MethodHeader|public native ScenarioBehavior CreateBehavior(KUID kuid, Soup initialProperties)}}
;Parameters
*'''kuid''' = KUID of scenario.
'''initialProperties''' = Soup object containing initial properties for scenario.
;Returned Value
*Reference to the ScenarioBehavior created if successful, null otherwise.
;Syntax
ScenarioBehavior scenario = World.CreateBehavior(scenarioAsset, scenarioSoup);
;Notes
*The returned ScenarioBehavior object may be ended by releasing all references to it (resetting all references to null).
<br>

==CreateTrain==
{{MethodHeader|public native Train CreateTrain(KUID[ ] consist, string trackmarkName, bool direction)<br>public native Train CreateTrain(KUID[ ] consist, TrackMark trackmark, bool direction)<br>public native Train CreateTrain(KUID[ ] consist, Buildable buildable, string trackName, float position, bool direction)}}
;Parameters
*'''consist''' = An array of vehicle KUIDs used to describe the required Train object.
*'''trackmarkName''' = Name of Trackmark at which the consist is to be formed.
*'''buildable''' = Buildable on which the consist is to be formed.
*'''trackName''' = Name of track within Buildable object.
*'''position''' = Distance at which the Train is to be placed relative to the start of the track.
*'''trackmark''' = Reference to Trackmark at which the consist is to be formed.
*'''direction''' = Orientation of Train relative to direction of track or trackmark.
;Returned Value
*Reference to the Train created if successful, null otherwise.
;Syntax
Train train = World.CreateTrain(consist, buildable, "Track 1", 10.0, true);
;Notes
*These methods create a train from a list of vehicles in a consist array.
*Depending on the variant of the method used, the train can be created at a Trackmark, specified by name or reference, or at a Buildable or Industry object.
*It is the responsibility of the script programmer to ensure that sufficient track exists at the given location to allow the train to be created.
<br>

==DeleteTrain==
{{MethodHeader|public native void DeleteTrain(Train train)}}
;Parameters
*'''train''' = train to be deleted from map.
;Returned Value
*None
;Syntax
World.DeleteTrain(flyingScotsman);
;Notes
*Once a train has been deleted, care should be taken to avoid using its reference.
<br>

==DeleteVehicle==
{{MethodHeader|public native void DeleteVehicle(Vehicle vehicle)}}
;Parameters
*'''vehicle''' = vehicle to be deleted from its train.
;Returned Value
*None
;Syntax
World.DeleteVehicle(vehicles[vehicles.size()-1]);
;Notes
*Use Train.GetVehicles() to obtain an array of vehicles for a given train.
*Use Vehicle.GetMyTrain() to obtain a train reference for a given vehicle.
<br>

==FindAsset==
{{MethodHeader|public native Asset FindAsset(KUID kuid)}}
;Parameters
*'''kuid''' = KUID of Asset to return.
;Returned Value
*Given a valid KUID parameter, this method return an Asset reference if successful, null otherwise.
;Syntax
Asset asset = World.FindAsset(kuid);
;Notes
*See also Asset.FindAsset()
<br>

==FindDriverCommand==
{{MethodHeader|public native DriverCommand FindDriverCommand(Asset driverCommandAsset)}}
;Parameters
*'''driverCommandAsset''' = Asset containing command to be added.
;Returned Value
*Reference to the DriverCommand if successful, null otherwise.
;Syntax
DriverCommand GoFaster = World.FindDriverCommand(accelerate);
;Notes
<br>

==GetAssetList==
{{MethodHeader|public native Asset[ ] GetAssetList(string kind)}}
;Parameters
*'''kind''' = String representing the Kind of asset to return.
;Returned Value
*A list of all assets of the given ''kind''
;Syntax
Asset[] Libraries = World.GetAssetList("Library");
;Notes
*All installed assets of the given ''kind'' are returned, irrespective of whether or not they are in use on the current map.
<br>

==GetBadWeatherFog==
{{MethodHeader|public native float GetBadWeatherFog(void)}}
;Parameters
*None
;Returned Value
*Bad weather fog distance as a float in the range 0.0..1.0.
;Syntax
float dist = World.GetBadWeatherFog();
;Notes
<br>

==GetBehaviors==
{{MethodHeader|public native ScenarioBehavior[ ] GetBehaviors(void)}}
;Parameters
*None
;Returned Value
*A list of top-level behaviors or rules on the currently loaded route.
;Syntax
ScenarioBehavior[] rules = World.GetBehaviors();
;Notes
<br>

==GetCameraPositionX==
{{MethodHeader|public native float GetCameraPositionX(void)}}
;Parameters
*None
;Returned Value
*X Coordinate of the current camera position.
;Syntax
float X = World.GetCameraPositionX();
*Notes
<br>

==GetCameraPositionY==
{{MethodHeader|public native float GetCameraPositionY(void)}}
;Parameters
*None
;Returned Value
*Y Coordinate of the current camera position.
;Syntax
float Y = World.GetCameraPositionY();
*Notes
<br>

==GetCameraPositionZ==
{{MethodHeader|public native float GetCameraPositionZ(void)}}
;Parameters
*None
;Returned Value
*Z Coordinate of the current camera position.
;Syntax
float Z = World.GetCameraPositionZ();
*Notes
<br>

==GetCurrentModule==
{{MethodHeader|public native int GetCurrentModule(void)}}
;Parameters
*None
;Returned Value
*An integer representing the current Trainz module.
;Syntax
int module = World,GetCurrentModule();
;Notes
* See [[#Trainz Modules|Trainz Modules]] for details of the constants associated with this method.
* See [[ModuleInit Message]] for further details.
<br>

==GetDriverCharacterList==
{{MethodHeader|public native DriverCharacter[ ] GetDriverCharacterList(void)}}
;Parameters
*None
;Returned Value
*An array of DriverCharacter objects installed in the current world.
;Syntax
DriverCharacter[] drivers = World.GetDriverCharacterList();
;Notes
<br>

==GetDriverCommandList==
{{MethodHeader|public native DriverCommand[ ] GetDriverCommandList(void)}}
;Parameters
*None
;Returned Value
*An array of DriverCommand objects installed in the current world.
;Syntax
DriverCommand[] commands = World.GetDriverCommandList();
;Notes
<br>

==GetGameTime==
{{MethodHeader|public native float GetGameTime(void)}}
;Parameters
*None
;Returned value
*Current game time.
;Syntax
float Now = World.GetGameTime();
;Notes
*The returned time is normalised to a value between 0.0 and 1.0
*0.0 = midday.
*0.5 = midnight
*Use the [[#Time_Values|Time Value]] constants to convert the normalised values to human readable times.
<br>

==GetGoodWeatherFog==
{{MethodHeader|public native float GetGoodWeatherFog(void)}}
;Parameters
*None
;Returned Value
*Good weather fog distance as a float in the range 0.0..1.0.
;Syntax
float dist = World.GetGoodWeatherFog();
;Notes
<br>

==GetGroundDrawDistance==
{{MethodHeader|public native float GetGroundDrawDistance(void)}}
;Parameters
*None
;Returned Value
*Ground draw distance in metres.
;Syntax
float dist = World.GetGroundDrawDistance();
;Notes
<br>

==GetIndustryList==
{{MethodHeader|public native GameObject[ ] GetIndustryList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the Industry objects for the current route.
;Syntax
GameObject[] Industries = World.GetIndustryList();
;Notes
<br>

==GetJunctionList==
{{MethodHeader|public native Junction[ ] GetJunctionList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the trackside junction objects for the current route.
;Syntax
Junction[] junctions = World.GetJunctionList();
;Notes
*Junction objects attached to fixed track junctions are not currently returned by this method.
<br>

==GetLibrary==
{{MethodHeader|public native Library GetLibrary(KUID kuid)}}
;Parameters
*'''kuid''' = KUID of script library asset to load.
;Returned Value
*A reference to the script library asset if successful, null otherwise.
;Syntax
Library codelib = World.GetLibrary(LibraryKUID);
;Notes
*The [[Class Library|Library]] asset is initialised when this method is first called in a session.
*Since only one instance can exist, subsequent calls return a reference to the existing Library object.
*See [[Class Library|Library]] for notes on how to use this method.
<br>

==GetSceneryDrawDistance==
{{MethodHeader|public native float GetSceneryDrawDistance(void)}}
;Parameters
*None
;Returned Value
*Scenery draw distance in metres.
;Syntax
float dist = World.GetSceneryDrawDistance();
;Notes
<br>

==GetSeconds==
{{MethodHeader|public native float GetSeconds(void)}}
;Parameters
*None
;Returned Value
*The current value of a floating point number incrementing once per second in real time.
;Syntax
float start = World.GetSeconds();
// do stuff
float finish = World.GetSeconds();
float period = finish - start;
;Notes
*Each call will return a float value containing the current value of an internal counter.
*Subtracting a later value from a value saved at an earlier call will enable the delay between the two calls to be established.
<br>

==GetSignalList==
{{MethodHeader|public native Signal[ ] GetSignalList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the signal objects for the current route.
;Syntax
Signal[] signals = World.GetSignalList();
;Notes
<br>

==GetStringTable==
{{MethodHeader|public native StringTable GetStringTable(void)}}
;Parameters
*None
;Returned Value
*The StringTable for the current session.
;Syntax
StringTable data = World.GetStringTable();
;Notes
<br>

==GetSurveyorSavedConsist==
{{MethodHeader|public native Soup GetSurveyorSavedConsistList(string name)}}
;Parameters
*'''name''' = Name of the consist to retireiev.
;Returned Value
*Returns a Soup definition of the named consist if it exists, null otherwise.
;Syntax
Soup consist = World.GetSurveyorSavedConsist("Brighton Belle");
;Notes
*Remember that the returned data is in a Soup format, which is not the same thing as a Train.
*TrainUtil.CreateTrainFormSoup() can be used to create a train from the returned Soup.
*This method only works in Surveyor.
<br>

==GetSurveyorSavedConsistList==
{{MethodHeader|public native string[ ] GetSurveyorSavedConsistList()}}
;Parameters
*None
;Returned Value
*An array of names of all the saved consist objects in Surveyor.
;Syntax
string[] consists = World.GetSurveyorSavedConsistList();
;Notes
*This method only works in Surveyor.
<br>

==GetTrackmarkList==
{{MethodHeader|public native TrackMark[ ] GetTrackmarkList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the trackmark objects for the current route.
;Syntax
Trackmark[] trackmarks = World.GetTrackmarkList();
;Notes
<br>

==GetTrainList==
{{MethodHeader|public native Train[ ] GetTrainList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the trains for the current route.
;Syntax
Train[] trains = World.GetTrainList();
;Notes
<br>

==GetTrainzBuild==
{{MethodHeader|public native int GetTrainzBuild(void)}}
;Parameters;
*None
;Returned Value
*Gets the current build number of Trainz.
;Syntax
int build = World.GetTrainzBuild();
;Notes
*The value returned corresponds to the build number you can see in the bottom-right side of the main Trainz menu screen.
<br>

==GetTrainzVersion==
{{MethodHeader|public native float GetTrainzVersion(void)}}
;Parameters
*None
;Returned Value
*The TRS version number.
;Syntax
float version = World.GetTrainzVersion();
;Notes
*The value returned corresponds to the version number you can see in the bottom-right side of the main Trainz menu screen.
<br>

==GetTriggerList==
{{MethodHeader|public native Trigger[ ] GetTriggerList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the trigger objects for the current route.
;Syntax
Trigger[] triggers = World.GetTriggerList();
;Notes
*This method does not return scenery triggers, ie those attached to SceneryWithTrack objects and their descendants.
<br>

==GetVehicleList==
{{MethodHeader|public native Vehicle[ ] GetVehicleList(void)}}
;Parameters
*None
;Returned Value
*An array of references to all of the vehicles in the current route.
;Syntax
Vehicle[] vehicles = World.GetVehicleList();
;Notes
<br>

==GetWeatherChangeability==
{{MethodHeader|public native int GetWeatherChangeability(void)}}
;Parameter
*None
;Returned Value
*One of the [[#Weather_Changeability_Constants|Weather Changeability Constants]] denoting the variability of weather conditions.
;Syntax
int variability = World.GetWeatherChangeability();
;Notes
<br>

==GetWeatherType==
{{MethodHeader|public native int GetWeatherType(void)}}
;Parameter
*None
;Returned Value
*One of the [[#Weather_Type_Constants|Weather Type Constants]] denoting the current weather conditions.
;Syntax
int weather = World.GetWeatherType();
;Notes
<br>

==LoadMap==
{{MethodHeader|public native bool LoadMap(KUID kuid)}}
;Parameters
*'''kuid''' = KUID of map to load.
;Returned Value
*True if successful, false otherwise.
;Syntax
if (World.LoadMap(mapKUID) Interface.Print("Map loaded OK");
else Interface.Print("Map load failed");
;Notes
<br>

==Play2DSound==
{{MethodHeader|public float Play2DSound(Asset asset, string wave)}}
;Parameters
*'''asset''' = Asset where the sound file is located.
*'''wave''' = Name of the ''*.wav'' file to be played, a relative path can be included.
;Returned Value
*The length of the sound file in seconds.
;Syntax
// Play the sound and continues script execution.
World.Play2DSound(soundAsset,"sounds/allaboard.wav");
// Wait until sound has completed before continuing.
Sleep(World.Play2DSound(soundAsset,"sounds/allaboard.wav"));
;Notes
*Plays a ''.wav" sound file from the given asset's folder.
*The sound is non directional and can be mono or stereo.
*This method does not return after the sound has finished playing, it returns with the length of the sound as soon as it is called.
*This means your code will keep on executing while Trainz is playing the sound.
*If you want to wait for the sound to complete playing before moving on, wrap the Play2DSound() call up in a Sleep() call.
*Remember that Sleep() can't always be used.
<br>

==PlaySound==
{{MethodHeader|public native float PlaySound<br>    (Asset asset, string wave, float vol, float near, float far, GameObject target, string pt)<br>    (Asset asset, string wave, float vol, float near, float far, GameObject target, string pt, bool loop)}}
;Parameters
*'''asset''' = Asset where the sound file is located.
*'''wave''' = Name of the ''*.wav'' file to be played, a relative path can be included.
*'''vol''' = Volume level to play the sound at
*'''near''' = Distance from the target asset at which the sound will be played at maximum volume.
*'''far''' = Distance from the target asset at which the sound will become inaudible.
*'''target''' = GameObject to which the sound will be attached if a 3d sound is required, null for 2D.
*'''pt''' = Name of attachment point in the target object if a 3d sound is required, null for 2D.
*'''loop''' = (Optional) If true the sound will loop continuously.
;Returned Value
*The length of the sound file in seconds.
;Syntax
// Play the sound and continues script execution.
World.PlaySound(soundAsset,"sounds/allaboard.wav",1000.0,10.0,100.0,Station,"a.loudspeaker");
// Wait until sound has completed before continuing.
Sleep(World.PlaySound(soundAsset,"sounds/allaboard.wav",1000.0,10.0,100.0,Station,"a.loudspeaker"));
;Notes
*Plays a ''.wav'' sound file from the given asset's folder.
*If the sound is to be directional a mono sound file is required.
*This method does not return after the sound has finished playing, it returns with the length of the sound as soon as it is called.
*This means your code will keep on executing while Trainz is playing the sound.
*If you want to wait for the sound to complete playing before moving on, wrap the PlaySound() call up in a Sleep() call.
*Remember that Sleep() can't always be used.
*The sound volume will be at a maximum for a camera position at or less than the value of the ''near'' parameter and will reduce with distance until the hearing position reaches ''far'', when the sound will be inaudible.
<br>

==RemoveDriverCharacter==
{{MethodHeader|public native void RemoveDriverCharacter(DriverCharacter driver)}}
;Parameters
*'''driver''' = DriverCharacter to remove.
;Returned Value
*None
;Syntax
World.RemoveDriverCharacter(dave);
;Notes
<br>

==RemoveDriverCommand==
{{MethodHeader|public native void RemoveDriverCommand(DriverCommand command)}}
;Parameters
*'''command''' = DriverCommand to remove.
;Returned Value
*None
;Syntax
World.RemoveDriverCommand(driverCommand);
;Notes
<br>

==SetBadWeatherFog==
{{MethodHeader|public native void SetBadWeatherFog(float distance)}}
;Parameters
*'''distance''' = Bad weather fog distance to set.
;Returned Value
*None
;Syntax
World.SetBadWeatherFog(0.5);
;Notes
<br>

==SetCamera==
{{MethodHeader|public native bool SetCamera(MapObject focus)<br>public native void SetCamera(Junction focus)<br>public native void SetCamera(Vehicle focus, int cameraMode)<br>public native void SetCamera(Train focus, int cameraMode)}}
;Parameters
*'''focus''' = Object on which the camera is to be focused.
*''cameraMode''' = One of the [[#Camera_View_Modes|Camera View Mode]] constants defining the view which should be assigned to the camera.
;Returned Value
*The first variant returns a boolean to indicate success or failure.
*Remaining variants do not return a value
'Syntax
World.SetCamera(train.GetVehicles[0],World.CAMERA_TRACKING); // sets the camera to track the first vehicle in the train.
<br>

==SetCameraAngle==
{{MethodHeader|public void SetCameraAngle(int yaw, int pitch, float radius)}}
;Parameters
*'''yaw''' = Camera rotation in degrees, 90 is a direct front view.
*'''pitch''' = Camera angle relative to the horizon, 0 is horizontal, 90 points vertically upwards.
*'''radius''' = Distance in metres to the object in focus.
;Returned Value
*None
;Syntax
World.SetCameraAngle(90,0,25); // Sets the camera to a direct frontal view at 25 metres from the currently focused object.
;Notes
*''Radius'' is measured from the object origin point (0,0,0).
<br>

==SetCameraFlags==
{{MethodHeader|public native void SetCameraFlags(int flags)}}
;Parameter
*'''flags''' integer value defining what the user is permitted to do with the game camera.
;Returned Value
*None
;Syntax
// User is permitted to select External or Tracking views only.
World.SetCameraFlags(World.CAMERA_EXTERNAL | World.CAMERA_TRACKING);
;Notes
*Use any combination of [[#Camera_Flags|Camera Flags]] and [[#Camera_View_Modes|Camera View Modes]] to set the parameter.
<br>

==SetCameraMode==
{{MethodHeader|public void SetCameraMode(int mode)}}
;Parameter
*'''mode''' = Camera mode to select.
;Returned Value
*None
;Syntax
World.SetCameraMode(World.CAMERA_TRACKING);
;Notes
*Use one of the [[#Camera_View_Modes|Camera View Modes]] to set the parameter.
<br>

==SetGameTime==
{{MethodHeader|public void SetGameTime(float time)}}
;Parameters
*'''time''' = new gane time to set.
;Returned Value
*None
;Syntax
World.SetGameTime(0.5); // sets time to midnight
;Notes
*Game time is normalised to a value between 0.0 and 1.0
*0.0 = midday.
*0.5 = midnight
*Use the [[#Time_Values|Time Value]] constants to convert human readable times to normalised values.
<br>

==SetGameTimeRate==
{{MethodHeader|public native void SetGameTimeRate(float rate)}}
;Parameters
*'''rate''' = New time rate to set.
;Returned Value
*None
;Syntax
World.SetGameTimeRate(World.TIME_RATE_8X); // sets game time to advance by 8 minutes per minute of real world time.
;Notes
*Use one of the [[#Time_Rate_Constants|Time Rate Constants]] to define the parameter.
<br>

==SetGoodWeatherFog==
{{MethodHeader|public native void SetGoodWeatherFog(float distance)}}
;Parameters
*'''distance''' = Good weather fog distance to set.
;Returned Value
*None
;Syntax
World.SetGoodWeatherFog(0.5);
;Notes
<br>

==SetGroundDrawDistance==
{{MethodHeader|public native void SetGroundDrawDistance(float distance)}}
;Parameters
*'''distance''' = Ground draw distance in metres.
;Returned Value
*None
;Syntax
World.SetGroundDrawDistance(1000.0);
;Notes
*Compatibility warning: Use of this function is not recommended, it may become non-functional in future Trainz versions.
<br>

==SetSceneryDrawDistance==
{{MethodHeader|public native void SetSceneryDrawDistance(float distance)}}
;Parameters
*'''distance''' = Scenery draw distance in metres.
;Returned Value
*None
;Syntax
World.SetSceneryDrawDistance(1000.0);
;Notes
*Compatibility warning: Use of this function is not recommended, it may become non-functional in future Trainz versions.
<br>

==SetTargetObserver==
{{MethodHeader|public void SetTargetObserver(GameObject observer)}}
;Parameters
*'''observer''' = ?
;Returned Value
*None
;Syntax
?
;Notes
*<font color=red>One of the great unsolved mysteries of Trainz</font>
<br>

==SetWeather==
{{MethodHeader|public native void SetWeather(int type, int changeability)}}
;Parameters
*'''type''' = Weather conditions as defined by one of the [[#Weather_Type_Constants|Weather Type Constants]].
*'''change''' = Weather variation as defined by one of the [[#Weather_Changeability_Constants|Weather Changeability Constants]].
;Returned Value
*None
;Syntax
World.SetWeather(World.WEATHER_TYPE_HEAVY_SNOW,World.WEATHER_CHANGEABILITY_EXTREME); // April in Paris.
;Notes
<br>

==UserSetCamera==
{{MethodHeader|public native bool UserSetCamera(GameObject target)}}
;Parameters
*'''target''' = GameObject to set focus to.
;Returned Value
*True if successful, false otherwise.
;Syntax
World.UserSetCamera(Router,GetGameObject("Junction 5"));
;Notes
<br>

==UserSetCameraMode==
{{MethodHeader|public native void UserSetCameraMode(int mode)}}
;Parameters
*'''mode''' = One of the [[#Camera_View_Modes|Camera View Modes]]
;Returned Value
*None
;Syntax
World.UserSetCameraMode(World.CAMERA_ROAMING); // switches to roaming view if permitted.
;Notes
*This method respects the current [[#Camera_Flags|Camera Flag]] settings, disallowing any change which the flags do not permit.
<br>

==Categories==
[[Category:Script Class]]

Content

2009-01-12T05:01:58Z

Dap:

This page aims to list and describe all content available for [[TS2009]].

Content detail pages should have a 'Content/' prefix and are linked by inclusion in one of the following categories. Each individual content page should include a description of the content including real-life photos, compatibility and usage information, a link to the content creator's wiki page and a download station helper link. It is recommended that content detail pages do not include off-site links, as Trainz users will not be able to follow these.

* [[:Category:Rolling Stock]]
* [[:Category:Scenery]]
* [[:Category:Routes]]
* [[:Category:Scripts]]
* [[:Category:Track]]
* [[:Category:Operations]]