path: root/advtrains/api_doc.txt

Advanced Trains [advtrains] API documentation
--------
To use the API, mods must depend on 'advtrains'.
All boolean values in definition tables default to 'false' and can be omitted.
### Wagons
Wagons are registered using the function

advtrains.register_wagon(name, prototype, description, inventory_image)
- 'name' is the internal name of the wagon. It should follow the mod naming convention, however, this is not enforced.
	For compatibility reasons, if a mod name is omitted, the wagon will be registered in the advtrains: namespace.
	Example: A wagon with name="engine_tgv" will be registered as "advtrains:engine_tgv".
	!IMPORTANT! You must not append a ":" at the start of the name, even if you want to bypass the mod naming convention check. This is because internally the register_wagon function
	appends a ":" automatically.
- 'prototype' is the lua entity prototype. The regular definition keys for luaentites apply. Additional required and optional properties see below. DO NOT define 'on_step', 'on_activate', 'on_punch', 'on_rightclick' and 'get_staticdata' since these will be overridden. Use 'custom_*' instead.
- 'description' is the description of the inventory item that is used to place the wagon.
- 'inventory_image' is the inventory image of said item.

# Wagon prototype properties
{
	... all regular luaentity properties (mesh, textures, collisionbox a.s.o)...
	drives_on = {default=true},
	^- used to define the tracktypes (see below) that wagon can drive on. The tracktype identifiers are given as keys, similar to privileges)
	max_speed = 10,
	^- optional, default 10: defines the maximum speed this wagon can drive. The maximum speed of a train is determined by the wagon with the lowest max_speed value.
	seats = {
	^- contains zero or more seat definitions. A seat is a place where a player can be attached when getting on a wagon.
		{
			name="Left front window",
			^- display name of this seat
			attach_offset={x=0, y=10, z=0},
			^- this value is passed to 'set_attach'
			view_offset={x=0, y=6, z=0},
			^- player:set_eye_offset is called with this parameter.
			group="default"
			^- optional. Defines the seat group. See 'seat_groups' below
			-!- Note: driving_ctrl_access field has moved to seat group definition,
			-!- but is still partwise supported here. If you don't use seat groups yet,
			-!- you really should change NOW!
		},
	},
	seat_groups = {
	^- If defined, activates advanced seating behavior. See "seating behavior".
		default = {
			name = "Seats"
			^- name of this seat group, to be shown in get-on menu.
			access_to = {"foo", "bar"}
			^- List of seat groups you can access from this seat using the menu when sitting inside the train.
			require_doors_open = true
			^- Only allow getting on and off if doors are open.
			driving_ctrl_access=false,
			^- If the seat is a driver stand, and players sitting here should get access to the train's driving control.
		}
	}
	assign_to_seat_group = {"default"},
	^- optional, like seat_groups. When player right_clicks the wagon, player will be assigned to the first free seat group in the list.
	
	doors={
	^- optional. If defined, defines door animation frames. Opposite door has to be closed during animation period.
	^- Remember, advtrains can't handle doors on both sides opened simultaneously.
		open={
			[-1]={frames={x=0, y=20}, time=1}, -- open left doors
			[1]={frames={x=40, y=60}, time=1}  -- open right doors
			sound = <simpleSoundSpec>
			^- The sound file of the doors opening. If none is specified, nothing is played.
		},
		close={
			[-1]={frames={x=20, y=40}, time=1}, -- close left doors
			[1]={frames={x=60, y=80}, time=1} -- close right doors
			sound = <simpleSoundSpec>
			^- The sound file of the doors closing. If none is specified, nothing is played.
		}
	},
	door_entry={ 1.5, -1.5 }
	^- optional. If defined, defines the locations of the doors on the model as distance from the object center on the path.
	^- Getting on by walking in then takes effect.
	^- Positive values mean front, negative ones back. Resulting position is automatically shifted to the right side.

	coupler_types_front = {scharfenberg=true},
	coupler_types_back = {chain=true},
	^- Defines the available coupler types on this wagon on the front and back side. Wagon will only couple to wagons that have a matching coupler. (this property does not have any visual impact)
	^- Default: not given (nil) - causes the wagon to couple to any other wagon regardless of coupler type.
	^- Empty table ({}): This wagon does not couple to any other wagon (e.g. for Linetrack vehicles)
	^- Register coupler types using ''advtrains.register_coupler_type(type, name)''. advtrains defines the default types "chain" (Buffer and Chain) and "scharfenberg" (Scharfenberg coupler).

	wagon_span=2,
	^- How far this wagon extends from its base position. Is the half of the wagon length.
	^- Used to determine in which distance the other wagons have to be positioned. Will require tweaking.
	wheel_positions = {1.5, -1.5},
	^- Optional: if defined, the wagon will be placed so that these 2 wheel positions are on the track
	^- This parameter is recommended for long wagons (wagon_span >= 2).
	^- The position is a distance relative to the center of the wagon.
	^- Must have exactly 2 entries, corresponding to the front (1) and rear (2) wheel of the wagon object. 1st must be greater than 2nd.
	^- If not provided, the simple 1-position positioning logic will be used (wagon is positioned with the center on the track)

	extent_h = 1,
	^- Determines the collision box extent in x/z direction. Defaults to 1 (=3x3)
	^- The actual bounding box size is (extent_h*2)+1, so 0 means 1x1, 1 means 3x3 and 2 means 5x5
	extent_v = 2,
	^- Determines the collision box extent in y direction. Defaults to 2 (=3).
	^- The actual bounding box size is extent_v+1, so 0 means 1, 1 means 2, 2 means 3 a.s.o.
	horn_sound = <simpleSoundSpec>,
	^- The sound file of the horn. If none is specified, this wagon can't sound a horn. The specified sound file will be looped.
	
	drops = {"default:steelblock 3"}
	^- List of itemstrings what to drop when the wagon is destroyed
	
	has_inventory = false
	^- If this wagon has an inventory. The inventory is saved with the wagon.
	^- the following settings are ignored if not.
	inventory_list_sizes = {
		box=8*6,
	},
	^- List of assignments of type list_name=size.
	^- For every entry, an inventory list is created with the specified size.
	get_inventory_formspec = function(self, player_name, inventory_name)
		return "<a formspec>"
	end,
	^- Function that should return the formspec to be displayed when <player> requests to open the wagon's inventory.
	^- advtrains.standard_inventory_formspec can be used for ordinary wagons with inventories to show
	^- both the inventory grid and a 'Wagon properties' button.
	^- Use "list["..inventory_name..";<list_name>;<X>,<Y>;<W>,<H>;<Start>]" to display a wagon's inventory list.

	text_hud = function(train, flip) end
	^- optional: Text HUD to show to the driver. The inside display is automatically prepended.
	graphical_hud = function(train, flip) end
	^- optional: Graphical HUD to show to the driver.
	The HUD formats defined by advtrains are used by default.
	hud_without_text_inside = false
	^- optional: whether the inside display should be excluded from the text HUD

	custom_on_step = function(self, dtime) end
	^- optional: Execute custom code on every step
	custom_on_activate = function(self, dtime_s) end
	^- optional: Execute custom code on activate. Staticdata does not need to be saved and restored since all properties written in 'self' are preserved over unloads.
	custom_on_velocity_change = function(self, velocity, old_velocity) end
	^- optional: Function that is called whenever the train's velocity changes or every 2 seconds. Used to call 'self.object:update_animation()' if needed.
	^- for compatibility reasons the name 'update_animation' for this function is still supported. 

}

# Notes on wagons

- Every wagon has the field 'id' which assigns each wagon a random id.
- Properties written in the Lua Entity (self) are discarded when the wagon entity is unloaded. At the moment there is no way to store data inside a wagon persistently.
- Assuming Z Axis as the axis parallel to the tracks and Y Axis as the one pointing into the sky, wagon models should be dimensioned in a way that:
	- their origin is centered in X and Z direction
	- their origin lies 0.5 units above the bottom of the model
	- the overall extent in X and Y direction is <=3 units
- wagon_span is then the distance between the model origin and the Z axis extent.

# Seating behavior
If the advanced seating behavior is active, clicking on a wagon will immediately get you on that wagon depending on the entries in assign_to_seat_group.
If all seat groups are full, if the doors are closed or if you are not authorized to enter this seat group(e.g. driver stands), will show a warning.
On a train, right-clicking the wagon will make you get off the train unless:
- the doors are closed and it requires open doors.
- you have access to a seat group specified in access_to (you may enter it and it's not full)
- you are the owner and can access the wagon preferences
In case there's no possibility, does nothing.
In case there are multiple possibilities, will show a form.

If you can't enter or leave a train because the doors are closed, holding the Sneak key while right-clicking bypasses the "doors have to be open" enforcement.

# Train HUD
The text_hud and graphical_hud fields of the wagons allow you to specify the look of your driver HUDs.
* The text_hud function should return a string that will be shown to the driver. Usually this should not include the inside display.
* The graphical_hud function should return a texture string and the height of the texture. This is used to allow proper positioning of the text HUD.

There are currently a few pre-defined elements that can help create the graphical HUD. These functions are in the advtrains.hud table:
* texture_escape(str): a trivial function that escapes the textures
* digit(digit, x, y, w, h, pc, nc): displays a single digit
	* digit: the digit to display
	* x, y: the upper-left corner of the digit display
	* w, h: the width and height of a horizontal segment
	* pc: the color to show when a given segment is lit
	* nc: the color to show when a given segment is not lit
* number(num, length, x, y, w, h, margin, pc, nc): displays a non-negative integer, possibly using multiple 7-segment displays:
	* num: the number to display
	* length: the numbers of digits to display (if nil: the number of digits in the number).
	* x, y: the upper-left corner of the digit display
	* w, h, pc, nc: (see above)
	* margin: the margin between each digit
	* The behavior of num>=10^length is undefined.
* leverof(train): returns the lever of the train. This should be preferred over train.lever
* lever(lever, x, y, w1, w2, h): draws a lever
	* lever: the lever of the train
	* x, y: the upper-left corner of the lever
	* w1: the width of the merkers beside the lever
	* w2: the width of the handle
	* h: the height of the lever
	* In the context of drawing (i.e. the description of the x, y, w1, w2, and h arguments), "the lever" refers to the area that the actual lever is drawn in, not the lever itself.
* door(o, x, y, w, h, m): draws a simple door indicator
	* o: the state of the door
	* x, y, w, h: the upper-left corner and the size of the indicator
	* m: the margin between the elements of the indicator
	* The indicator includes an indicator for each door and a simple shape showing a vehicle
	* Due to the internals of this function, it is recommended that (w-2*m) is a multiple of 4
* speed_horizontal(train, x, y, w, h, m): draws a horizontal bar showing the speed
	* train: the train table
	* x, y, w, h: the upper-left cornder and the size of the indicator
	* m: the margin between the elements of the indicator
	* h must be greater than 10
	* Due to the internals of this function, it is recommended that (w-19*m) is a multiple of 20
* In the above functions, the behavior of negative coordinates and magnitudes (e.g. width, height, margin) and invalid data is undefined.

### Tracks
Most modders will be satisfied with the built-in tracks. If cog railways, maglev trains and mine trains are added, it is necessary to understand the definition of tracks. Although the tracks API is there, explaining it would require more effort than me creating the wanted definitions myself. Contact me if you need to register your own rails using my registration functions.

However, it is still possible to register single rails by understanding the node properties of rails.
minetest.register_node(nodename, {
	... usual node definition ...
	groups = {
		advtrains_track = 1,
		advtrains_track_<tracktype>=1
		^- these groups tell that the node is a track
		not_blocking_trains=1,
		^- this group tells that the node should not block trains although it's walkable.
	},
	
	at_rail_y = 0,
	^- Height of this rail node (the y position of a wagon that stands centered on this rail)
	at_conns = {
		  [1] = { c=0..15, y=0..1 },
		  [2] = { c=0..15, y=0..1 },
		( [3] = { c=0..15, y=0..1 }, )
		( [4] = { c=0..15, y=0..1 }, )
	}
	^- Connections of this rail. There can be up to 4 connections.
	   2 connections are a normal rail, 3 connections a turnout (1->2 and 2/3->1) and 4 connections a crossing (1<>2 and 3<>4)
	   c is the direction of the connection (0-16) and y is the height of the connection (rail will only connect when this matches)

	can_dig=function(pos)
		return not advtrains.get_train_at_pos(pos)
	end,
	after_dig_node=function(pos)
		advtrains.ndb.update(pos)
	end,
	after_place_node=function(pos)
		advtrains.ndb.update(pos)
	end,
	^- the code in these 3 default minetest API functions is required for advtrains to work, however you can add your own code
	
	advtrains = {
		on_train_enter=function(pos, train_id, train, index) end
		^- called when a train enters the rail
		on_train_leave=function(pos, train_id, train, index) end
		^- called when a train leaves the rail
		
		-- The following function is only in effect when interlocking is enabled:
		on_train_approach = function(pos, train_id, train, index, has_entered, lzbdata)
		^- called when a train is approaching this position, called exactly once for every path recalculation (which can happen at any time)
		^- This is called so that if the train would start braking now, it would come to halt about(wide approx) 5 nodes before the rail.
		^- has_entered: when true, the train is already standing on this node with its front tip, and the enter callback has already been called.
		   Possibly, some actions need not to be taken in this case. Only set if it's the very first node the train is standing on.
		^- lzbdata should be ignored and nothing should be assigned to it
	}
})