-Minetest Lua Modding API Reference 0.4.0
-==========================================
+Minetest Lua Modding API Reference 0.4.6
+========================================
More information at http://c55.me/minetest/
Introduction
Mods are loaded during server startup from the mod load paths by running
the init.lua scripts in a shared environment.
+Paths
+-----
+RUN_IN_PLACE=1: (Windows release, local build)
+ $path_user: Linux: <build directory>
+ Windows: <build directory>
+ $path_share: Linux: <build directory>
+ Windows: <build directory>
+
+RUN_IN_PLACE=0: (Linux release)
+ $path_share: Linux: /usr/share/minetest
+ Windows: <install directory>/minetest-0.4.x
+ $path_user: Linux: ~/.minetest
+ Windows: C:/users/<user>/AppData/minetest (maybe)
+
+Games
+-----
+Games are looked up from:
+ $path_share/games/gameid/
+ $path_user/games/gameid/
+where gameid is unique to each game.
+
+The game directory contains the file game.conf, which contains these fields:
+ name = <Human-readable full name of the game>
+eg.
+ name = Minetest
+
+The game directory can contain the file minetest.conf, which will be used
+to set default settings when running the particular game.
+
Mod load path
-------------
Generic:
$path_share/games/gameid/mods/
- $path_share/mods/gameid/
+ $path_share/mods/
$path_user/games/gameid/mods/
- $path_user/mods/gameid/ <-- User-installed mods
+ $path_user/mods/ <-- User-installed mods
$worldpath/worldmods/
In a run-in-place version (eg. the distributed windows version):
List of mods that have to be loaded before loading this mod.
A single line contains a single modname.
+ Optional dependencies can be defined by appending a question mark
+ to a single modname. Their meaning is that if the specified mod
+ is missing, that does not prevent this mod from being loaded.
+
+optdepends.txt:
+ An alternative way of specifying optional dependencies.
+ Like depends.txt, a single line contains a single modname.
+
+ NOTE: This file exists for compatibility purposes only and
+ support for it will be removed from the engine by the end of 2013.
+
init.lua:
The main Lua script. Running this script should register everything it
wants to register. Subsequent execution depends on minetest calling the
Examples of sound parameter tables:
-- Play locationless on all clients
{
- gain = 1.0, -- default
+ gain = 1.0, -- default
}
-- Play locationless to a player
{
- to_player = name,
- gain = 1.0, -- default
+ to_player = name,
+ gain = 1.0, -- default
}
-- Play in a location
{
- pos = {x=1,y=2,z=3},
- gain = 1.0, -- default
- max_hear_distance = 32, -- default
+ pos = {x=1,y=2,z=3},
+ gain = 1.0, -- default
+ max_hear_distance = 32, -- default
}
-- Play connected to an object, looped
{
Example: minetest.get_item_group(name, group) has been implemented as:
function minetest.get_item_group(name, group)
- if not minetest.registered_items[name] or not
- minetest.registered_items[name].groups[group] then
- return 0
- end
- return minetest.registered_items[name].groups[group]
+ if not minetest.registered_items[name] or not
+ minetest.registered_items[name].groups[group] then
+ return 0
+ end
+ return minetest.registered_items[name].groups[group]
end
Nodes
paramtype2 == "facedir"
^ The rotation of the node is stored in param2. Furnaces and chests are
rotated this way. Can be made by using minetest.dir_to_facedir().
+ Values range 0 - 23
+ facedir modulo 4 = axisdir
+ 0 = y+ 1 = z+ 2 = z- 3 = x+ 4 = x- 5 = y-
+ facedir's two less significant bits are rotation around the axis
Nodes can also contain extra data. See "Node Metadata".
- liquid
- flowingliquid
- glasslike
+- glasslike_framed
- allfaces
- allfaces_optional
- torchlike
A box of a regular node would look like:
{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+Ore types
+---------------
+These tell in what manner the ore is generated.
+All default ores are of the uniformly-distributed scatter type.
+
+- scatter
+ Randomly chooses a location and generates a cluster of ore.
+ If noise_params is specified, the ore will be placed if the 3d perlin noise at
+ that point is greater than the noise_threshhold, giving the ability to create a non-equal
+ distribution of ore.
+- sheet
+ Creates a sheet of ore in a blob shape according to the 2d perlin noise described by noise_params.
+ The relative height of the sheet can be controlled by the same perlin noise as well, by specifying
+ a non-zero 'scale' parameter in noise_params. IMPORTANT: The noise is not transformed by offset or
+ scale when comparing against the noise threshhold, but scale is used to determine relative height.
+ The height of the blob is randomly scattered, with a maximum height of clust_size.
+ clust_scarcity and clust_num_ores are ignored.
+ This is essentially an improved version of the so-called "stratus" ore seen in some unofficial mods.
+- claylike - NOT YET IMPLEMENTED
+ Places ore if there are no more than clust_scarcity number of specified nodes within a Von Neumann
+ neighborhood of clust_size radius.
+
+Ore attributes
+-------------------
+Currently supported flags: absheight
+ - absheight
+ Also produce this same ore between the height range of -height_max and -height_min.
+ Useful for having ore in sky realms without having to duplicate ore entries.
+
+HUD element types
+-------------------
+The position field is used for all element types.
+To account for differing resolutions, the position coordinates are the percentage of the screen,
+ranging in value from 0 to 1.
+The name field is not yet used, but should contain a description of what the HUD element represents.
+The direction field is the direction in which something is drawn.
+0 draws from left to right, 1 draws from right to left, 2 draws from top to bottom, and 3 draws from bottom to top.
+The alignment field specifies how the item will be aligned. It ranges from -1 to 1,
+with 0 being the center, -1 is moved to the left/up, and 1 is to the right/down. Fractional
+values can be used.
+The offset field specifies a pixel offset from the position. Contrary to position,
+the offset is not scaled to screen size. This allows for some precisely-positioned
+items in the HUD.
+Below are the specific uses for fields in each type; fields not listed for that type are ignored.
+
+Note: Future revisions to the HUD API may be incompatible; the HUD API is still in the experimental stages.
+
+- image
+ Displays an image on the HUD.
+ - scale: The scale of the image, with 1 being the original texture size.
+ Only the X coordinate scale is used.
+ - text: The name of the texture that is displayed.
+ - alignment: The alignment of the image.
+ - offset: offset in pixels from position.
+- text
+ Displays text on the HUD.
+ - scale: Defines the bounding rectangle of the text.
+ A value such as {x=100, y=100} should work.
+ - text: The text to be displayed in the HUD element.
+ - number: An integer containing the RGB value of the color used to draw the text.
+ Specify 0xFFFFFF for white text, 0xFF0000 for red, and so on.
+ - alignment: The alignment of the text.
+ - offset: offset in pixels from position.
+- statbar
+ Displays a horizontal bar made up of half-images.
+ - text: The name of the texture that is used.
+ - number: The number of half-textures that are displayed.
+ If odd, will end with a vertically center-split texture.
+ - direction
+ - offset: offset in pixels from position.
+- inventory
+ - text: The name of the inventory list to be displayed.
+ - number: Number of items in the inventory to be displayed.
+ - item: Position of item that is selected.
+ - direction
+
Representations of simple things
--------------------------------
Position/vector:
- Groups are stored in a table, having the group names with keys and the
group ratings as values. For example:
groups = {crumbly=3, soil=1}
- ^ Default dirt (soil group actually currently not defined; TODO)
+ ^ Default dirt
groups = {crumbly=2, soil=1, level=2, outerspace=1}
^ A more special dirt-kind of thing
- Groups always have a rating associated with them. If there is no
Groups of entities
-------------------
For entities, groups are, as of now, used only for calculating damage.
+The rating is the percentage of damage caused by tools with this damage group.
+See "Entity damage mechanism".
-object.get_armor_groups() -> a group-rating table (eg. {fleshy=3})
-object.set_armor_groups({level=2, fleshy=2, cracky=2})
+object.get_armor_groups() -> a group-rating table (eg. {fleshy=100})
+object.set_armor_groups({fleshy=30, cracky=80})
Groups of tools
----------------
}
An another example: Make red wool from white wool and red dye
{
- type = 'shapeless',
+ type = 'shapeless',
output = 'wool:red',
recipe = {'wool:white', 'group:dye,basecolor_red'},
}
- level: Can be used to give an additional sense of progression in the game.
- A larger level will cause eg. a weapon of a lower level make much less
damage, and get weared out much faster, or not be able to get drops
- from destroyed nodes.
+ from destroyed nodes.
- 0 is something that is directly accessible at the start of gameplay
- There is no upper limit
- dig_immediate: (player can always pick up node without tool wear)
- 3: node is removed without tool wear immediately (torch)
- disable_jump: Player (and possibly other things) cannot jump from node
- fall_damage_add_percent: damage speed = speed * (1 + value/100)
+- bouncy: value is bounce speed in percent
+- falling_node: if there is no walkable block under the node it will fall
+- attached_node: if the node under it is not a walkable block the node will be
+ dropped as an item. If the node is wallmounted the
+ wallmounted direction is checked.
+- soil: saplings will grow on nodes in this group
+- connect_to_raillike: makes nodes of raillike drawtype connect to
+ other group members with same drawtype
Known damage and digging time defining groups
----------------------------------------------
-Valid ratings for these are 0, 1, 2 and 3, unless otherwise stated.
- crumbly: dirt, sand
- cracky: tough but crackable stuff like stone.
- snappy: something that can be cut using fine tools; eg. leaves, small
* Uses (until the tool breaks)
* Maximum level (usually 0, 1, 2 or 3)
* Digging times
+ * Damage groups
**Full punch interval**:
When used as a weapon, the tool will do full damage if this time is spent
result in the tool to be able to dig nodes that have a rating of 2 or 3
for this group, and unable to dig the rating 1, which is the toughest.
Unless there is a matching group that enables digging otherwise.
- * For entities, damage equals the amount of nodes dug in the time spent
- between hits, with a maximum time of ''full_punch_interval''.
+
+**Damage groups**
+List of damage for groups of entities. See "Entity damage mechanism".
Example definition of the capabilities of a tool
-------------------------------------------------
tool_capabilities = {
- full_punch_interval=1.5,
- max_drop_level=1,
- groupcaps={
- crumbly={maxlevel=2, uses=20, times={[1]=1.60, [2]=1.20, [3]=0.80}}
- }
+ full_punch_interval=1.5,
+ max_drop_level=1,
+ groupcaps={
+ crumbly={maxlevel=2, uses=20, times={[1]=1.60, [2]=1.20, [3]=0.80}}
+ }
+ damage_groups = {fleshy=2},
}
This makes the tool be able to dig nodes that fullfill both of these:
Entity damage mechanism
------------------------
Damage calculation:
-- Take the time spent after the last hit
-- Limit time to full_punch_interval
-- Take the damage groups and imagine a bunch of nodes that have them
-- Damage in HP is the amount of nodes destroyed in this time.
+damage = 0
+foreach group in cap.damage_groups:
+ damage += cap.damage_groups[group] * limit(actual_interval / cap.full_punch_interval, 0.0, 1.0)
+ * (object.armor_groups[group] / 100.0)
+ -- Where object.armor_groups[group] is 0 for inexisting values
+return damage
Client predicts damage based on damage groups. Because of this, it is able to
give an immediate response when an entity is damaged or dies; the response is
Example stuff:
-local meta = minetest.env:get_meta(pos)
+local meta = minetest.get_meta(pos)
meta:set_string("formspec",
"invsize[8,9;]"..
"list[context;main;0,0;8,4;]"..
^ Show an image
^ Position and size units are inventory slots
+item_image[<X>,<Y>;<W>,<H>;<item name>]
+^ Show an inventory image of registered item/node
+^ Position and size units are inventory slots
+
+background[<X>,<Y>;<W>,<H>;<texture name>]
+^ Use a background. Inventory rectangles are not drawn then.
+^ Position and size units are inventory slots
+^ Example for formspec 8x4 in 16x resolution: image shall be sized 8*16px x 4*16px
+
field[<X>,<Y>;<W>,<H>;<name>;<label>;<default>]
^ Textual field; will be sent to server when a button is clicked
^ x and y position the field relative to the top left of the menu
^ default is the default value of the field
^ default may contain variable references such as '${text}' which
will fill the value from the metadata value 'text'
- ^ Note: no extra text or more than a single variable is supported ATM.
+ ^ Note: no extra text or more than a single variable is supported ATM.
field[<name>;<label>;<default>]
^ as above but without position/size units
^ must be used without a size[] element
^ a 'Proceed' button will be added automatically
+textarea[<X>,<Y>;<W>,<H>;<name>;<label>;<default>]
+^ same as fields above, but with multi-line input
+
label[<X>,<Y>;<label>]
^ x and y work as per field
^ label is the text on the label
^ image is the filename of an image
^ Position and size units are inventory slots
+item_image_button[<X>,<Y>;<W>,<H>;<item name>;<name>;<label>]
+^ x, y, w, h, name and label work as per button
+^ item name is the registered name of an item/node,
+ tooltip will be made out of its descritption
+^ Position and size units are inventory slots
+
button_exit[<X>,<Y>;<W>,<H>;<name>;<label>]
^ When clicked, fields will be sent and the form will quit.
minetest.pos_to_string({x=X,y=Y,z=Z}) -> "(X,Y,Z)"
^ Convert position to a printable string
minetest.string_to_pos(string) -> position
+^ Same but in reverse
+minetest.formspec_escape(string) -> string
+^ escapes characters like [, ], and \ that can not be used in formspecs
minetest namespace reference
-----------------------------
+Utilities:
minetest.get_current_modname() -> string
minetest.get_modpath(modname) -> eg. "/home/user/.minetest/usermods/modname"
^ Useful for loading additional .lua modules or static data from mod
minetest.get_worldpath() -> eg. "/home/user/.minetest/world"
^ Useful for storing custom data
minetest.is_singleplayer()
+minetest.features
+^ table containing API feature flags: {foo=true, bar=true}
+minetest.has_feature(arg) -> bool, missing_features
+^ arg: string or table in format {foo=true, bar=true}
+^ missing_features: {foo=true, bar=true}
+Logging:
minetest.debug(line)
^ Always printed to stderr and logfile (print() is redirected here)
minetest.log(line)
minetest.register_craftitem(name, item definition)
minetest.register_alias(name, convert_to)
minetest.register_craft(recipe)
+minetest.register_ore(ore definition)
Global callback registration functions: (Call these only at load time)
minetest.register_globalstep(func(dtime))
^ Called every server step, usually interval of 0.05s
-minetest.register_on_placenode(func(pos, newnode, placer, oldnode))
+minetest.register_on_shutdown(func())
+^ Called before server shutdown
+^ WARNING: If the server terminates abnormally (i.e. crashes), the registered
+ callbacks WILL LIKELY NOT BE RUN. Data should be saved at
+ semi-frequent intervals as well as on server shutdown.
+minetest.register_on_placenode(func(pos, newnode, placer, oldnode, itemstack))
^ Called when a node has been placed
-^ Deprecated: Use on_construct or after_place_node in node definition instead
+^ If return true no item is taken from itemstack
+^ Not recommended; use on_construct or after_place_node in node definition
+^ whenever possible
minetest.register_on_dignode(func(pos, oldnode, digger))
^ Called when a node has been dug.
-^ Deprecated: Use on_destruct or after_dig_node in node definition instead
+^ Not recommended: Use on_destruct or after_dig_node in node definition
+^ whenever possible
minetest.register_on_punchnode(func(pos, node, puncher))
^ Called when a node is punched
minetest.register_on_generated(func(minp, maxp, blockseed))
minetest.setting_get(name) -> string or nil
minetest.setting_getbool(name) -> boolean value or nil
minetest.setting_get_pos(name) -> position or nil
+minetest.setting_save() -> nil, save all settings to config file
minetest.add_to_creative_inventory(itemstring)
Authentication:
^ These call the authentication handler
minetest.check_player_privs(name, {priv1=true,...}) -> bool, missing_privs
^ A quickhand for checking privileges
+minetest.get_player_ip(name) -> IP address string
Chat:
minetest.chat_send_all(text)
-minetest.chat_send_player(name, text)
+minetest.chat_send_player(name, text, prepend)
+^ prepend: optional, if it is set to false "Server -!- " will not be prepended to the message
+
+Environment access:
+
+minetest.set_node(pos, node)
+minetest.add_node(pos, node): alias set_node(pos, node)
+^ Set node at position (node = {name="foo", param1=0, param2=0})
+minetest.remove_node(pos)
+^ Equivalent to set_node(pos, "air")
+minetest.get_node(pos)
+^ Returns {name="ignore", ...} for unloaded area
+minetest.get_node_or_nil(pos)
+^ Returns nil for unloaded area
+minetest.get_node_light(pos, timeofday) -> 0...15 or nil
+^ timeofday: nil = current time, 0 = night, 0.5 = day
+
+minetest.place_node(pos, node)
+^ Place node with the same effects that a player would cause
+minetest.dig_node(pos)
+^ Dig node with the same effects that a player would cause
+minetest.punch_node(pos)
+^ Punch node with the same effects that a player would cause
+
+minetest.get_meta(pos) -- Get a NodeMetaRef at that position
+minetest.get_node_timer(pos) -- Get NodeTimerRef
+
+minetest.add_entity(pos, name): Spawn Lua-defined entity at position
+^ Returns ObjectRef, or nil if failed
+minetest.add_item(pos, item): Spawn item
+^ Returns ObjectRef, or nil if failed
+minetest.get_player_by_name(name) -- Get an ObjectRef to a player
+minetest.get_objects_inside_radius(pos, radius)
+minetest.set_timeofday(val): val: 0...1; 0 = midnight, 0.5 = midday
+minetest.get_timeofday()
+minetest.find_node_near(pos, radius, nodenames) -> pos or nil
+^ nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
+minetest.find_nodes_in_area(minp, maxp, nodenames) -> list of positions
+^ nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
+minetest.get_perlin(seeddiff, octaves, persistence, scale)
+^ Return world-specific perlin noise (int(worldseed)+seeddiff)
+minetest.clear_objects()
+^ clear all objects in the environments
+minetest.line_of_sight(pos1,pos2,stepsize) ->true/false
+^ checkif there is a direct line of sight between pos1 and pos2
+^ pos1 First position
+^ pos2 Second position
+^ stepsize smaller gives more accurate results but requires more computing
+ time. Default is 1.
+minetest.find_path(pos1,pos2,searchdistance,max_jump,max_drop,algorithm)
+^ -> table containing path
+^ returns a table of 3d points representing a path from pos1 to pos2 or nil
+^ pos1: start position
+^ pos2: end position
+^ searchdistance: number of blocks to search in each direction
+^ max_jump: maximum height difference to consider walkable
+^ max_drop: maximum height difference to consider droppable
+^ algorithm: A*_noprefetch(default), A*, Dijkstra
+minetest.spawn_tree (pos, {treedef})
+^ spawns L-System tree at given pos with definition in treedef table
Inventory:
minetest.get_inventory(location) -> InvRef
minetest.create_detached_inventory(name, callbacks) -> InvRef
^ callbacks: See "Detached inventory callbacks"
^ Creates a detached inventory. If it already exists, it is cleared.
+minetest.show_formspec(playername, formname, formspec)
+^ playername: name of player to show formspec
+^ formname: name passed to on_player_receive_fields callbacks
+^ should follow "modname:<whatever>" naming convention
+^ formspec: formspec to display
Item handling:
minetest.inventorycube(img1, img2, img3)
^ output.time = number, if unsuccessful: 0
^ decremented_input = like input
minetest.get_craft_recipe(output) -> input
+^ returns last registered recipe for output item (node)
^ output is a node or item type such as 'default:torch'
^ input.method = 'normal' or 'cooking' or 'fuel'
^ input.width = for example 3
^ input.items = for example { stack 1, stack 2, stack 3, stack 4,
stack 5, stack 6, stack 7, stack 8, stack 9 }
^ input.items = nil if no recipe found
+minetest.get_all_craft_recipes(query item) -> table or nil
+^ returns indexed table with all registered recipes for query item (node)
+ or nil if no recipe was found
+ recipe entry table:
+ {
+ method = 'normal' or 'cooking' or 'fuel'
+ width = 0-3, 0 means shapeless recipe
+ items = indexed [1-9] table with recipe items
+ output = string with item name and quantity
+ }
+ Example query for default:gold_ingot will return table:
+ {
+ 1={type = "cooking", width = 3, output = "default:gold_ingot",
+ items = {1 = "default:gold_lump"}},
+ 2={type = "normal", width = 1, output = "default:gold_ingot 9",
+ items = {1 = "default:goldblock"}}
+ }
+minetest.handle_node_drops(pos, drops, digger)
+^ drops: list of itemstrings
+^ Handles drops from nodes after digging: Default action is to put them into
+ digger's inventory
+^ Can be overridden to get different functionality (eg. dropping items on
+ ground)
Rollbacks:
minetest.rollback_get_last_node_actor(p, range, seconds) -> actor, p, seconds
^ Place item as-is
minetest.item_place(itemstack, placer, pointed_thing)
^ Use one of the above based on what the item is.
+^ Calls on_rightclick of pointed_thing.under if defined instead
+^ Note: is not called when wielded item overrides on_place
minetest.item_drop(itemstack, dropper, pos)
^ Drop the item
minetest.item_eat(hp_change, replace_with_item)
minetest.sound_stop(handle)
Timing:
-minetest.after(time, func, param)
+minetest.after(time, func, ...)
^ Call function after time seconds
-^ param is optional; to pass multiple parameters, pass a table.
+^ Optional: Variable number of arguments that are passed to func
Server:
minetest.request_shutdown() -> request for server shutdown
minetest.ban_player(name) -> ban a player
minetest.unban_player_or_ip(name) -> unban player or IP address
+Particles:
+minetest.add_particle(pos, velocity, acceleration, expirationtime,
+ size, collisiondetection, texture, playername)
+^ Spawn particle at pos with velocity and acceleration
+^ Disappears after expirationtime seconds
+^ collisiondetection: if true collides with physical objects
+^ Uses texture (string)
+^ Playername is optional, if specified spawns particle only on the player's client
+
+minetest.add_particlespawner(amount, time,
+ minpos, maxpos,
+ minvel, maxvel,
+ minacc, maxacc,
+ minexptime, maxexptime,
+ minsize, maxsize,
+ collisiondetection, texture, playername)
+^ Add a particlespawner, an object that spawns an amount of particles over time seconds
+^ The particle's properties are random values in between the boundings:
+^ minpos/maxpos, minvel/maxvel (velocity), minacc/maxacc (acceleration),
+^ minsize/maxsize, minexptime/maxexptime (expirationtime)
+^ collisiondetection: if true uses collisiondetection
+^ Uses texture (string)
+^ Playername is optional, if specified spawns particle only on the player's client
+^ If time is 0 has infinite lifespan and spawns the amount on a per-second base
+^ Returns and id
+
+minetest.delete_particlespawner(id, player)
+^ Delete ParticleSpawner with id (return value from add_particlespawner)
+^ If playername is specified, only deletes on the player's client,
+^ otherwise on all clients
+
Random:
minetest.get_connected_players() -> list of ObjectRefs
minetest.hash_node_position({x=,y=,z=}) -> 48-bit integer
Global objects:
minetest.env - EnvRef of the server environment and world.
-^ Using this you can access nodes and entities
+^ Any function in the minetest namespace can be called using the syntax
+ minetest.env:somefunction(somearguments)
+ instead of
+ minetest.somefunction(somearguments)
+^ Deprecated, but support is not to be dropped soon
Global tables:
minetest.registered_items
Class reference
----------------
-EnvRef: basically ServerEnvironment and ServerMap combined.
-methods:
-- set_node(pos, node)
-- add_node(pos, node): alias set_node(pos, node)
- ^ Set node at position (node = {name="foo", param1=0, param2=0})
-- remove_node(pos)
- ^ Equivalent to set_node(pos, "air")
-- get_node(pos)
- ^ Returns {name="ignore", ...} for unloaded area
-- get_node_or_nil(pos)
- ^ Returns nil for unloaded area
-- get_node_light(pos, timeofday) -> 0...15 or nil
- ^ timeofday: nil = current time, 0 = night, 0.5 = day
-
-- place_node(pos, node)
- ^ Place node with the same effects that a player would cause
-- dig_node(pos)
- ^ Dig node with the same effects that a player would cause
-- punch_node(pos)
- ^ Punch node with the same effects that a player would cause
-
-- get_meta(pos) -- Get a NodeMetaRef at that position
-- get_node_timer(pos) -- Get NodeTimerRef
-
-- add_entity(pos, name): Spawn Lua-defined entity at position
- ^ Returns ObjectRef, or nil if failed
-- add_item(pos, item): Spawn item
- ^ Returns ObjectRef, or nil if failed
-- get_player_by_name(name) -- Get an ObjectRef to a player
-- get_objects_inside_radius(pos, radius)
-- set_timeofday(val): val: 0...1; 0 = midnight, 0.5 = midday
-- get_timeofday()
-- find_node_near(pos, radius, nodenames) -> pos or nil
- ^ nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
-- find_nodes_in_area(minp, maxp, nodenames) -> list of positions
- ^ nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
-- get_perlin(seeddiff, octaves, persistence, scale)
- ^ Return world-specific perlin noise (int(worldseed)+seeddiff)
-- clear_objects()
- ^ clear all objects in the environments
-Deprecated:
-- add_rat(pos): Add C++ rat object (no-op)
-- add_firefly(pos): Add C++ firefly object (no-op)
-
NodeMetaRef: Node metadata - reference extra data and functionality stored
in a node
-- Can be gotten via minetest.env:get_nodemeta(pos)
+- Can be gotten via minetest.get_nodemeta(pos)
methods:
- set_string(name, value)
- get_string(name)
^ See "Node Metadata"
NodeTimerRef: Node Timers - a high resolution persistent per-node timer
-- Can be gotten via minetest.env:get_node_timer(pos)
+- Can be gotten via minetest.get_node_timer(pos)
methods:
- set(timeout,elapsed)
^ set a timer's state
- punch(puncher, time_from_last_punch, tool_capabilities, direction)
^ puncher = an another ObjectRef,
^ time_from_last_punch = time since last punch action of the puncher
+ ^ direction: can be nil
- right_click(clicker); clicker = an another ObjectRef
- get_hp(): returns number of hitpoints (2 * number of hearts)
- set_hp(hp): set number of hitpoints (2 * number of hearts)
- get_wielded_item() -> ItemStack
- set_wielded_item(item): replaces the wielded item, returns true if successful
- set_armor_groups({group1=rating, group2=rating, ...})
+- set_animation({x=1,y=1}, frame_speed=15, frame_blend=0)
+- set_attach(parent, bone, position, rotation)
+ ^ bone = string
+ ^ position = {x=num, y=num, z=num} (relative)
+ ^ rotation = {x=num, y=num, z=num}
+- set_detach()
+- set_bone_position(bone, position, rotation)
+ ^ bone = string
+ ^ position = {x=num, y=num, z=num} (relative)
+ ^ rotation = {x=num, y=num, z=num}
- set_properties(object property table)
LuaEntitySAO-only: (no-op for other objects)
- setvelocity({x=num, y=num, z=num})
- get_look_dir(): get camera direction as a unit vector
- get_look_pitch(): pitch in radians
- get_look_yaw(): yaw in radians (wraps around pretty randomly as of now)
+- set_look_pitch(radians): sets look pitch
+- set_look_yaw(radians): sets look yaw
- set_inventory_formspec(formspec)
^ Redefine player's inventory form
^ Should usually be called in on_joinplayer
- get_inventory_formspec() -> formspec string
+- get_player_control(): returns table with player pressed keys
+ {jump=bool,right=bool,left=bool,LMB=bool,RMB=bool,sneak=bool,aux1=bool,down=bool,up=bool}
+- get_player_control_bits(): returns integer with bit packed player pressed keys
+ bit nr/meaning: 0/up ,1/down ,2/left ,3/right ,4/jump ,5/aux1 ,6/sneak ,7/LMB ,8/RMB
+- set_physics_override(speed, jump, gravity)
+ modifies per-player walking speed, jump height, and gravity.
+ Values default to 1 and act as offsets to the physics settings
+ in minetest.conf. nil will keep the current setting.
+- hud_add(hud definition): add a HUD element described by HUD def, returns ID number on success
+- hud_remove(id): remove the HUD element of the specified id
+- hud_change(id, stat, value): change a value of a previously added HUD element
+ ^ element stat values: position, name, scale, text, number, item, dir
+- hud_get(id): gets the HUD element definition structure of the specified ID
+- hud_set_flags(flags): sets specified HUD flags to true/false
+ ^ flags: (is visible) hotbar, healthbar, crosshair, wielditem
+ ^ pass a table containing a true/false value of each flag to be set or unset
+ ^ if a flag is nil, the flag is not modified
+- hud_set_hotbar_itemcount(count): sets number of items in builtin hotbar
+ ^ count: number of items, must be between 1 and 23
InvRef: Reference to an inventory
methods:
can be fully taken from the list
remove_item(listname, stack): take as many items as specified from the list,
returns the items that were actually removed (as an ItemStack)
+- get_location() -> location compatible to minetest.get_inventory(location)
+ -> {type="undefined"} in case location is not known
ItemStack: A stack of items.
- Can be created via ItemStack(itemstack or itemstring or table or nil)
PerlinNoise: A perlin noise generator
- Can be created via PerlinNoise(seed, octaves, persistence, scale)
-- Also minetest.env:get_perlin(seeddiff, octaves, persistence, scale)
+- Also minetest.get_perlin(seeddiff, octaves, persistence, scale)
methods:
- get2d(pos) -> 2d noise value at pos={x=,y=}
- get3d(pos) -> 3d noise value at pos={x=,y=,z=}
^ puncher: ObjectRef (can be nil)
^ time_from_last_punch: Meant for disallowing spamming of clicks (can be nil)
^ tool_capabilities: capability table of used tool (can be nil)
- ^ dir: unit vector of direction of punch. Always defined. Points from
- the puncher to the punched.
+ ^ dir: unit vector of direction of punch. Always defined. Points from
+ the puncher to the punched.
- on_rightclick(self, clicker)
- get_staticdata(self)
^ Should return a string that will be passed to on_activate when
the object is instantiated the next time.
+L-system trees
+---------------
+treedef={
+ axiom, - string initial tree axiom
+ rules_a, - string rules set A
+ rules_b, - string rules set B
+ rules_c, - string rules set C
+ rules_d, - string rules set D
+ trunk, - string trunk node name
+ leaves, - string leaves node name
+ leaves2, - string secondary leaves node name
+ leaves2_chance,- num chance (0-100) to replace leaves with leaves2
+ angle, - num angle in deg
+ iterations, - num max # of iterations, usually 2 -5
+ random_level, - num factor to lower nr of iterations, usually 0 - 3
+ trunk_type, - string single/double/crossed) type of trunk: 1 node, 2x2 nodes or 3x3 in cross shape
+ thin_branches, - boolean true -> use thin (1 node) branches
+ fruit, - string fruit node name
+ fruit_chance, - num chance (0-100) to replace leaves with fruit node
+ seed, - num random seed
+ }
+
+Key for Special L-System Symbols used in Axioms
+ G - move forward one unit with the pen up
+ F - move forward one unit with the pen down drawing trunks and branches
+ f - move forward one unit with the pen down drawing leaves (100% chance)
+ T - move forward one unit with the pen down drawing trunks only
+ R - move forward one unit with the pen down placing fruit
+ A - replace with rules set A
+ B - replace with rules set B
+ C - replace with rules set C
+ D - replace with rules set D
+ a - replace with rules set A, chance 90%
+ b - replace with rules set B, chance 80%
+ c - replace with rules set C, chance 70%
+ d - replace with rules set D, chance 60%
+ + - yaw the turtle right by angle parameter
+ - - yaw the turtle left by angle parameter
+ & - pitch the turtle down by angle parameter
+ ^ - pitch the turtle up by angle parameter
+ / - roll the turtle to the right by angle parameter
+ * - roll the turtle to the left by angle parameter
+ [ - save in stack current state info
+ ] - recover from stack state info
+
+Example usage: spawn small apple tree
+apple_tree={
+ axiom="FFFFFAFFBF",
+ rules_a="[&&&FFFFF&&FFFF][&&&++++FFFFF&&FFFF][&&&----FFFFF&&FFFF]",
+ rules_b="[&&&++FFFFF&&FFFF][&&&--FFFFF&&FFFF][&&&------FFFFF&&FFFF]",
+ trunk="default:tree",
+ leaves="default:leaves",
+ angle=30,
+ iterations=2,
+ random_level=0,
+ trunk_type="single",
+ thin_branches=true,
+ fruit_chance=10,
+ fruit="default:apple"
+ }
+minetest.spawn_tree(pos,apple_tree)
+
Definition tables
------------------
physical = true,
weight = 5,
collisionbox = {-0.5,-0.5,-0.5, 0.5,0.5,0.5},
- visual = "cube"/"sprite"/"upright_sprite",
+ visual = "cube"/"sprite"/"upright_sprite"/"mesh",
visual_size = {x=1, y=1},
+ mesh = "model",
textures = {}, -- number of required textures depends on visual
+ colors = {}, -- number of required colors depends on visual
spritediv = {x=1, y=1},
initial_sprite_basepos = {x=0, y=0},
is_visible = true,
initial_properties = <initial object properties>,
- on_activate = function(self, staticdata),
+ on_activate = function(self, staticdata, dtime_s),
on_step = function(self, dtime),
on_punch = function(self, hitter),
on_rightclick = function(self, clicker),
max_drop_level=0,
groupcaps={
-- For example:
- fleshy={times={[2]=0.80, [3]=0.40}, maxwear=0.05, maxlevel=1},
snappy={times={[2]=0.80, [3]=0.40}, maxwear=0.05, maxlevel=1},
choppy={times={[3]=0.90}, maxwear=0.05, maxlevel=0}
- }
+ },
+ damage_groups = {groupname=damage},
}
node_placement_prediction = nil,
^ If nil and item is node, prediction is made automatically
^ Otherwise should be name of node which the client immediately places
on ground when the player places the item. Server will always update
actual result to client in a short moment.
+ sound = {
+ place = <SimpleSoundSpec>,
+ }
on_place = func(itemstack, placer, pointed_thing),
^ Shall place item and return the leftover itemstack
drawtype = "normal", -- See "Node drawtypes"
visual_scale = 1.0,
tiles = {tile definition 1, def2, def3, def4, def5, def6},
- ^ Textures of node; +Y, -Y, +X, -X, +Z, -Z (old field name: tile_images)
+ ^ Textures of node; +Y, -Y, +X, -X, +Z, -Z (old field name: tile_images)
^ List can be shortened to needed length
special_tiles = {tile definition 1, Tile definition 2},
- ^ Special textures of node; used rarely (old field name: special_materials)
+ ^ Special textures of node; used rarely (old field name: special_materials)
^ List can be shortened to needed length
alpha = 255,
+ use_texture_alpha = false, -- Use texture's alpha channel
post_effect_color = {a=0, r=0, g=0, b=0}, -- If player is inside node
paramtype = "none", -- See "Nodes"
paramtype2 = "none", -- See "Nodes"
liquid_alternative_flowing = "", -- Flowing version of source liquid
liquid_alternative_source = "", -- Source version of flowing liquid
liquid_viscosity = 0, -- Higher viscosity = slower flow (max. 7)
+ liquid_renewable = true, -- Can new liquid source be created by placing
+ two or more sources nearly?
light_source = 0, -- Amount of light emitted by node
damage_per_second = 0, -- If player is inside node, this damage is caused
node_box = {type="regular"}, -- See "Node boxes"
selection_box = {type="regular"}, -- See "Node boxes"
+ ^ If drawtype "nodebox" is used and selection_box is nil, then node_box is used
legacy_facedir_simple = false, -- Support maps made in and before January 2012
legacy_wallmounted = false, -- Support maps made in and before January 2012
sounds = {
footstep = <SimpleSoundSpec>,
dig = <SimpleSoundSpec>, -- "__group" = group-based sound (default)
dug = <SimpleSoundSpec>,
+ place = <SimpleSoundSpec>,
},
on_construct = func(pos),
^ Node destructor; always called after removing node
^ default: nil
- after_place_node = func(pos, placer),
+ after_place_node = func(pos, placer, itemstack),
^ Called after constructing node when node was placed using
- minetest.item_place_node / minetest.env:place_node
+ minetest.item_place_node / minetest.place_node
+ ^ If return true no item is taken from itemstack
^ default: nil
after_dig_node = func(pos, oldnode, oldmetadata, digger),
^ oldmetadata is in table format
^ Called after destructing node when node was dug using
- minetest.node_dig / minetest.env:dig_node
+ minetest.node_dig / minetest.dig_node
^ default: nil
can_dig = function(pos,player)
^ returns true if node can be dug, or false if not
^ default: nil
-
+
on_punch = func(pos, node, puncher),
^ default: minetest.node_punch
^ By default: does nothing
+ on_rightclick = func(pos, node, clicker, itemstack),
+ ^ default: nil
+ ^ if defined, itemstack will hold clicker's wielded item
+ Shall return the leftover itemstack
on_dig = func(pos, node, digger),
^ default: minetest.node_dig
^ By default: checks privileges, wears out tool and removes node
on_timer = function(pos,elapsed),
^ default: nil
- ^ called by NodeTimers, see EnvRef and NodeTimerRef
+ ^ called by NodeTimers, see minetest.get_node_timer and NodeTimerRef
^ elapsed is the total time passed since the timer was started
^ return true to run the timer for another cycle with the same timeout value
^ Called when an UI form (eg. sign text input) returns data
^ default: nil
- allow_metadata_inventory_move = func(pos, from_list, from_index,
- to_list, to_index, count, player),
- ^ Called when a player wants to move items inside the inventory
- ^ Return value: number of items allowed to move
-
- allow_metadata_inventory_put = func(pos, listname, index, stack, player),
- ^ Called when a player wants to put something into the inventory
- ^ Return value: number of items allowed to put
- ^ Return value: -1: Allow and don't modify item count in inventory
+ allow_metadata_inventory_move = func(pos, from_list, from_index,
+ to_list, to_index, count, player),
+ ^ Called when a player wants to move items inside the inventory
+ ^ Return value: number of items allowed to move
+
+ allow_metadata_inventory_put = func(pos, listname, index, stack, player),
+ ^ Called when a player wants to put something into the inventory
+ ^ Return value: number of items allowed to put
+ ^ Return value: -1: Allow and don't modify item count in inventory
- allow_metadata_inventory_take = func(pos, listname, index, stack, player),
- ^ Called when a player wants to take something out of the inventory
- ^ Return value: number of items allowed to take
- ^ Return value: -1: Allow and don't modify item count in inventory
-
- on_metadata_inventory_move = func(pos, from_list, from_index,
- to_list, to_index, count, player),
- on_metadata_inventory_put = func(pos, listname, index, stack, player),
- on_metadata_inventory_take = func(pos, listname, index, stack, player),
- ^ Called after the actual action has happened, according to what was allowed.
- ^ No return value
+ allow_metadata_inventory_take = func(pos, listname, index, stack, player),
+ ^ Called when a player wants to take something out of the inventory
+ ^ Return value: number of items allowed to take
+ ^ Return value: -1: Allow and don't modify item count in inventory
+
+ on_metadata_inventory_move = func(pos, from_list, from_index,
+ to_list, to_index, count, player),
+ on_metadata_inventory_put = func(pos, listname, index, stack, player),
+ on_metadata_inventory_take = func(pos, listname, index, stack, player),
+ ^ Called after the actual action has happened, according to what was allowed.
+ ^ No return value
+
+ on_blast = func(pos, intensity),
+ ^ intensity: 1.0 = mid range of regular TNT
+ ^ If defined, called when an explosion touches the node, instead of
+ removing the node
}
Recipe for register_craft: (shaped)
burntime = 1,
}
+Ore definition (register_ore)
+{
+ ore_type = "scatter" -- See "Ore types"
+ ore = "default:stone_with_coal",
+ wherein = "default:stone",
+ clust_scarcity = 8*8*8,
+ ^ Ore has a 1 out of clust_scarcity chance of spawning in a node
+ ^ This value should be *MUCH* higher than your intuition might tell you!
+ clust_num_ores = 8,
+ ^ Number of ores in a cluster
+ clust_size = 3,
+ ^ Size of the bounding box of the cluster
+ ^ In this example, there is a 3x3x3 cluster where 8 out of the 27 nodes are coal ore
+ height_min = -31000,
+ height_max = 64,
+ flags = "",
+ ^ Attributes for this ore generation
+ noise_threshhold = 0.5,
+ ^ If noise is above this threshhold, ore is placed. Not needed for a uniform distribution
+ noise_params = {offset=0, scale=1, spread={x=100, y=100, z=100}, seed=23, octaves=3, persist=0.70}
+ ^ NoiseParams structure describing the perlin noise used for ore distribution.
+ ^ Needed for sheet ore_type. Omit from scatter ore_type for a uniform ore distribution
+}
+
Chatcommand definition (register_chatcommand)
{
params = "<name> <privilege>", -- short parameter description
Detached inventory callbacks
{
- allow_move = func(inv, from_list, from_index, to_list, to_index, count, player),
+ allow_move = func(inv, from_list, from_index, to_list, to_index, count, player),
^ Called when a player wants to move items inside the inventory
- ^ Return value: number of items allowed to move
-
+ ^ Return value: number of items allowed to move
+
allow_put = func(inv, listname, index, stack, player),
^ Called when a player wants to put something into the inventory
- ^ Return value: number of items allowed to put
- ^ Return value: -1: Allow and don't modify item count in inventory
+ ^ Return value: number of items allowed to put
+ ^ Return value: -1: Allow and don't modify item count in inventory
allow_take = func(inv, listname, index, stack, player),
^ Called when a player wants to take something out of the inventory
- ^ Return value: number of items allowed to take
- ^ Return value: -1: Allow and don't modify item count in inventory
-
- on_move = func(inv, from_list, from_index, to_list, to_index, count, player),
+ ^ Return value: number of items allowed to take
+ ^ Return value: -1: Allow and don't modify item count in inventory
+
+ on_move = func(inv, from_list, from_index, to_list, to_index, count, player),
on_put = func(inv, listname, index, stack, player),
on_take = func(inv, listname, index, stack, player),
- ^ Called after the actual action has happened, according to what was allowed.
- ^ No return value
+ ^ Called after the actual action has happened, according to what was allowed.
+ ^ No return value
}
+HUD Definition (hud_add, hud_get)
+{
+ hud_elem_type = "image", -- see HUD element types
+ ^ type of HUD element, can be either of "image", "text", "statbar", or "inventory"
+ position = {x=0.5, y=0.5},
+ ^ Left corner position of element
+ name = "<name>",
+ scale = {x=2, y=2},
+ text = "<text>",
+ number = 2,
+ item = 3,
+ ^ Selected item in inventory. 0 for no item selected.
+ direction = 0,
+ ^ Direction: 0: left-right, 1: right-left, 2: top-bottom, 3: bottom-top
+ alignment = {x=0, y=0},
+ ^ See "HUD Element Types"
+ offset = {x=0, y=0},
+ ^ See "HUD Element Types"
+}
projects / dragonfireclient.git / blobdiff