Content and functionality can be added to Minetest using Lua scripting -in run-time loaded mods.
-A mod is a self-contained bunch of scripts, textures and other related -things, which is loaded by and interfaces with Minetest.
-Mods are contained and ran solely on the server side. Definitions and media -files are automatically transferred to the client.
-If you see a deficiency in the API, feel free to attempt to add the -functionality in the engine and API, and to document it here.
-If you have any difficulty in understanding this, please read -Programming in Lua.
-Mods are loaded during server startup from the mod load paths by running
-the init.lua scripts in a shared environment.
Games are looked up from:
- -Where gameid is unique to each game.
The game directory can contain the following files:
-game.conf, which contains:
-minetest.conf:
- Used to set default settings when running this game.settingtypes.txt:
- In the same format as the one in builtin.
- This settingtypes.txt will be parsed by the menu and the settings will be
- displayed in the "Games" category in the advanced settings tab.textures the server will load it as a
- texturepack, overriding mod textures.
- Any server texturepack will override mod textures and the game texturepack.Games can provide custom main menu images. They are put inside a menu
-directory inside the game directory.
The images are named $identifier.png, where $identifier is one of
-overlay, background, footer, header.
-If you want to specify multiple images for one identifier, add additional
-images named like $identifier.$n.png, with an ascending number $n starting
-with 1, and a random image will be chosen from the provided ones.
Generic:
-$path_share/games/gameid/mods/$path_share/mods/$path_user/games/gameid/mods/$path_user/mods/ (User-installed mods)$worldpath/worldmods/In a run-in-place version (e.g. the distributed windows version):
-minetest-0.4.x/games/gameid/mods/minetest-0.4.x/mods/ (User-installed mods)minetest-0.4.x/worlds/worldname/worldmods/On an installed version on Linux:
-/usr/share/minetest/games/gameid/mods/$HOME/.minetest/mods/ (User-installed mods)$HOME/.minetest/worlds/worldname/worldmodsIt is possible to include a game in a world; in this case, no mods or -games are loaded or checked from anywhere else.
-This is useful for e.g. adventure worlds.
-This happens if the following directory exists:
-$world/game/
-Mods should be then be placed in:
-$world/game/mods/
-Mods can be put in a subdirectory, if the parent directory, which otherwise
-should be a mod, contains a file named modpack.txt. This file shall be
-empty, except for lines starting with #, which are comments.
mods
-|-- modname
-| |-- mod.conf
-| |-- screenshot.png
-| |-- settingtypes.txt
-| |-- init.lua
-| |-- models
-| |-- textures
-| | |-- modname_stuff.png
-| | `-- modname_something_else.png
-| |-- sounds
-| |-- media
-| |-- locale
-| `-- <custom data>
-`-- another
-The location of this directory can be fetched by using
-minetest.get_modpath(modname).
A key-value store of mod details.
-name - the mod name. Allows Minetest to determine the mod name even if the
- folder is wrongly named.description - Description of mod to be shown in the Mods tab of the mainmenu.depends - A comma separated list of dependencies. These are mods that must
- be loaded before this mod.optional_depends - A comma separated list of optional dependencies.
- Like a dependency, but no error if the mod doesn't exist.Note: to support 0.4.x, please also provide depends.txt.
-screenshot.pngA screenshot shown in the mod manager within the main menu. It should -have an aspect ratio of 3:2 and a minimum size of 300×200 pixels.
-depends.txtDeprecated: you should use mod.conf instead.
-This file is used if there are no dependencies in mod.conf.
-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. This means that if the specified mod -is missing, it does not prevent this mod from being loaded.
-description.txtDeprecated: you should use mod.conf instead.
-This file is used if there is no description in mod.conf.
-A file containing a description to be shown in the Mods tab of the mainmenu.
-settingtypes.txtA file in the same format as the one in builtin. It will be parsed by the -settings menu and the settings will be displayed in the "Mods" category.
-init.luaThe main Lua script. Running this script should register everything it -wants to register. Subsequent execution depends on minetest calling the -registered callbacks.
-minetest.settings can be used to read custom or existing settings at load
-time, if necessary. (See Settings)
modelsModels for entities or meshnodes.
-textures, sounds, mediaMedia files (textures, sounds, whatever) that will be transferred to the -client and will be available for use by the mod.
-localeTranslation files for the clients. (See Translations)
Registered names should generally be in this format:
-`modname:<whatever>`
-<whatever> can have these characters:
a-zA-Z0-9_
-This is to prevent conflicting names from corrupting maps and is -enforced by the mod loader.
-In the mod experimental, there is the ideal item/node/entity name tnt.
-So the name should be experimental:tnt.
Enforcement can be overridden by prefixing the name with :. This can
-be used for overriding the registrations of some other mod.
Example: Any mod can redefine experimental:tnt by using the name
:experimental:tnt
-when registering it.
-(also that mod is required to have experimental as a dependency)
The : prefix can also be used for maintaining backwards compatibility.
Aliases can be added by using minetest.register_alias(name, convert_to) or
-minetest.register_alias_force(name, convert_to).
This converts anything called name to convert_to.
The only difference between minetest.register_alias and
-minetest.register_alias_force is that if an item called name exists,
-minetest.register_alias will do nothing while
-minetest.register_alias_force will unregister it.
This can be used for maintaining backwards compatibility.
-This can also set quick access names for things, e.g. if
-you have an item called epiclylongmodname:stuff, you could do
minetest.register_alias("stuff", "epiclylongmodname:stuff")
-and be able to use /giveme stuff.
In a game, a certain number of these must be set to tell core mapgens which -of the game's nodes are to be used by the core mapgens. For example:
-minetest.register_alias("mapgen_stone", "default:stone")
-Base terrain:
-"mapgen_stone" -"mapgen_water_source" -"mapgen_river_water_source"
-Caves:
-"mapgen_lava_source"
-Dungeons:
-Only needed for registered biomes where 'node_stone' is stone: -"mapgen_cobble" -"mapgen_stair_cobble" -"mapgen_mossycobble" -Only needed for registered biomes where 'node_stone' is desert stone: -"mapgen_desert_stone" -"mapgen_stair_desert_stone" -Only needed for registered biomes where 'node_stone' is sandstone: -"mapgen_sandstone" -"mapgen_sandstonebrick" -"mapgen_stair_sandstone_block"
-Terrain and biomes:
-"mapgen_stone" -"mapgen_water_source" -"mapgen_lava_source" -"mapgen_dirt" -"mapgen_dirt_with_grass" -"mapgen_sand" -"mapgen_gravel" -"mapgen_desert_stone" -"mapgen_desert_sand" -"mapgen_dirt_with_snow" -"mapgen_snowblock" -"mapgen_snow" -"mapgen_ice"
-Flora:
-"mapgen_tree" -"mapgen_leaves" -"mapgen_apple" -"mapgen_jungletree" -"mapgen_jungleleaves" -"mapgen_junglegrass" -"mapgen_pine_tree" -"mapgen_pine_needles"
-Dungeons:
-"mapgen_cobble" -"mapgen_stair_cobble" -"mapgen_mossycobble" -"mapgen_stair_desert_stone"
-Mods should generally prefix their textures with modname_, e.g. given
-the mod name foomod, a texture could be called:
foomod_foothing.png
-Textures are referred to by their complete name, or alternatively by -stripping out the file extension:
- -There are various texture modifiers that can be used -to generate textures on-the-fly.
-Textures can be overlaid by putting a ^ between them.
Example:
-default_dirt.png^default_grass_side.png
-default_grass_side.png is overlaid over default_dirt.png.
-The texture with the lower resolution will be automatically upscaled to
-the higher resolution texture.
Textures can be grouped together by enclosing them in ( and ).
Example: cobble.png^(thing1.png^thing2.png)
A texture for thing1.png^thing2.png is created and the resulting
-texture is overlaid on top of cobble.png.
Modifiers that accept texture names (e.g. [combine) accept escaping to allow
-passing complex texture names as arguments. Escaping is done with backslash and
-is required for ^ and :.
Example: cobble.png^[lowpart:50:color.png\^[mask\:trans.png
The lower 50 percent of color.png^[mask:trans.png are overlaid
-on top of cobble.png.
Parameters:
- <t> = tile count (in each direction)
- <n> = animation frame count
-* <p> = current animation frame
Draw a step of the crack animation on the texture.
-crack draws it normally, while cracko lays it over, keeping transparent
-pixels intact.
Example:
-default_cobble.png^[crack:10:1
-[combine:<w>x<h>:<x1>,<y1>=<file1>:<x2>,<y2>=<file2>:...Creates a texture of size <w> times <h> and blits the listed files to their
-specified coordinates.
Example:
-[combine:16x32:0,0=default_cobble.png:0,16=default_wood.png
-[resize:<w>x<h>Resizes the texture to the given dimensions.
-Example:
-default_sandstone.png^[resize:16x16
-[opacity:<r>Makes the base image transparent according to the given ratio.
-r must be between 0 and 255.
-0 means totally transparent. 255 means totally opaque.
Example:
-default_sandstone.png^[opacity:127
-[invert:<mode>Inverts the given channels of the base image. -Mode may contain the characters "r", "g", "b", "a". -Only the channels that are mentioned in the mode string will be inverted.
-Example:
-default_apple.png^[invert:rgb
-[brightenBrightens the texture.
-Example:
-tnt_tnt_side.png^[brighten
-[noalphaMakes the texture completely opaque.
-Example:
-default_leaves.png^[noalpha
-[makealpha:<r>,<g>,<b>Convert one color to transparency.
-Example:
-default_cobble.png^[makealpha:128,128,128
-[transform<t><t> = transformation(s) to applyRotates and/or flips the image.
-<t> can be a number (between 0 and 7) or a transform name.
-Rotations are counter-clockwise.
0 I identity
-1 R90 rotate by 90 degrees
-2 R180 rotate by 180 degrees
-3 R270 rotate by 270 degrees
-4 FX flip X
-5 FXR90 flip X then rotate by 90 degrees
-6 FY flip Y
-7 FYR90 flip Y then rotate by 90 degrees
-Example:
-default_stone.png^[transformFXR90
-[inventorycube{<top>{<left>{<right>Escaping does not apply here and ^ is replaced by & in texture names
-instead.
Create an inventory cube texture using the side textures.
-Example:
-[inventorycube{grass.png{dirt.png&grass_side.png{dirt.png&grass_side.png
-Creates an inventorycube with grass.png, dirt.png^grass_side.png and
-dirt.png^grass_side.png textures
[lowpart:<percent>:<file>Blit the lower <percent>% part of <file> on the texture.
Example:
-base.png^[lowpart:25:overlay.png
-[verticalframe:<t>:<n>Crops the texture to a frame of a vertical animation.
-Example:
-default_torch_animated.png^[verticalframe:16:8
-[mask:<file>Apply a mask to the base image.
-The mask is applied using binary AND.
-[sheet:<w>x<h>:<x>,<y>Retrieves a tile at position x,y from the base image -which it assumes to be a tilesheet with dimensions w,h.
-[colorize:<color>:<ratio>Colorize the textures with the given color.
-<color> is specified as a ColorString.
-<ratio> is an int ranging from 0 to 255 or the word "alpha". If
-it is an int, then it specifies how far to interpolate between the
-colors where 0 is only the texture color and 255 is only <color>. If
-omitted, the alpha of <color> will be used as the ratio. If it is
-the word "alpha", then each texture pixel will contain the RGB of
-<color> and the alpha of <color> multiplied by the alpha of the
-texture pixel.
[multiply:<color>Multiplies texture colors with the given color.
-<color> is specified as a ColorString.
-Result is more like what you'd expect if you put a color on top of another
-color. Meaning white surfaces get a lot of your new color while black parts
-don't change very much.
The goal of hardware coloring is to simplify the creation of -colorful nodes. If your textures use the same pattern, and they only -differ in their color (like colored wool blocks), you can use hardware -coloring instead of creating and managing many texture files. -All of these methods use color multiplication (so a white-black texture -with red coloring will result in red-black color).
-This method is useful if you wish to create nodes/items with -the same texture, in different colors, each in a new node/item definition.
-When you register an item or node, set its color field (which accepts a
-ColorSpec) to the desired color.
An ItemStacks static color can be overwritten by the color metadata
-field. If you set that field to a ColorString, that color will be used.
Each tile may have an individual static color, which overwrites every
-other coloring methods. To disable the coloring of a face,
-set its color to white (because multiplying with white does nothing).
-You can set the color property of the tiles in the node's definition
-if the tile is in table format.
For nodes and items which can have many colors, a palette is more -suitable. A palette is a texture, which can contain up to 256 pixels. -Each pixel is one possible color for the node/item. -You can register one node/item, which can have up to 256 colors.
-When using palettes, you always provide a pixel index for the given
-node or ItemStack. The palette is read from left to right and from
-top to bottom. If the palette has less than 256 pixels, then it is
-stretched to contain exactly 256 pixels (after arranging the pixels
-to one line). The indexing starts from 0.
Examples:
-When registering an item, set the item definition's palette field to
-a texture. You can also use texture modifiers.
The ItemStack's color depends on the palette_index field of the
-stack's metadata. palette_index is an integer, which specifies the
-index of the pixel to use.
When registering a node, set the item definition's palette field to
-a texture. You can also use texture modifiers.
-The node's color depends on its param2, so you also must set an
-appropriate paramtype2:
paramtype2 = "color" for nodes which use their full param2 for
- palette indexing. These nodes can have 256 different colors.
- The palette should contain 256 pixels.paramtype2 = "colorwallmounted" for nodes which use the first
- five bits (most significant) of param2 for palette indexing.
- The remaining three bits are describing rotation, as in wallmounted
- paramtype2. Division by 8 yields the palette index (without stretching the
- palette). These nodes can have 32 different colors, and the palette
- should contain 32 pixels.
- Examples:
-paramtype2 = "colorfacedir" for nodes which use the first
- three bits of param2 for palette indexing. The remaining
- five bits are describing rotation, as in facedir paramtype2.
- Division by 32 yields the palette index (without stretching the
- palette). These nodes can have 8 different colors, and the
- palette should contain 8 pixels.
- Examples:
-To colorize a node on the map, set its param2 value (according
-to the node's paramtype2).
Static coloring is the same for both cases, there is no need -for conversion.
-If the ItemStack's metadata contains the color field, it will be
-lost on placement, because nodes on the map can only use palettes.
If the ItemStack's metadata contains the palette_index field, it is
-automatically transferred between node and item forms by the engine,
-when a player digs or places a colored node.
-You can disable this feature by setting the drop field of the node
-to itself (without metadata).
-To transfer the color to a special drop, you need a drop table.
Example:
-minetest.register_node("mod:stone", {
- description = "Stone",
- tiles = {"default_stone.png"},
- paramtype2 = "color",
- palette = "palette.png",
- drop = {
- items = {
- -- assume that mod:cobblestone also has the same palette
- {items = {"mod:cobblestone"}, inherit_color = true },
- }
- }
-})
-Craft recipes only support item strings, but fortunately item strings -can also contain metadata. Example craft recipe registration:
-minetest.register_craft({
- output = minetest.itemstring_with_palette("wool:block", 3),
- type = "shapeless",
- recipe = {
- "wool:block",
- "dye:red",
- },
-})
-To set the color field, you can use minetest.itemstring_with_color.
Metadata field filtering in the recipe field are not supported yet,
-so the craft output is independent of the color of the ingredients.
Sometimes hardware coloring is not enough, because it affects the -whole tile. Soft texture overlays were added to Minetest to allow -the dynamic coloring of only specific parts of the node's texture. -For example a grass block may have colored grass, while keeping the -dirt brown.
-These overlays are 'soft', because unlike texture modifiers, the layers -are not merged in the memory, but they are simply drawn on top of each -other. This allows different hardware coloring, but also means that -tiles with overlays are drawn slower. Using too much overlays might -cause FPS loss.
-For inventory and wield images you can specify overlays which
-hardware coloring does not modify. You have to set inventory_overlay
-and wield_overlay fields to an image name.
To define a node overlay, simply set the overlay_tiles field of the node
-definition. These tiles are defined in the same way as plain tiles:
-they can have a texture name, color etc.
-To skip one face, set that overlay tile to an empty string.
Example (colored grass block):
-minetest.register_node("default:dirt_with_grass", {
- description = "Dirt with Grass",
- -- Regular tiles, as usual
- -- The dirt tile disables palette coloring
- tiles = { {name = "default_grass.png"},
- {name = "default_dirt.png", color = "white"}},
- -- Overlay tiles: define them in the same style
- -- The top and bottom tile does not have overlay
- overlay_tiles = {"", "",
- {name = "default_grass_side.png", tileable_vertical = false}},
- -- Global color, used in inventory
- color = "green",
- -- Palette in the world
- paramtype2 = "color",
- palette = "default_foilage.png",
-})
-Only Ogg Vorbis files are supported.
-For positional playing of sounds, only single-channel (mono) files are -supported. Otherwise OpenAL will play them non-positionally.
-Mods should generally prefix their sounds with modname_, e.g. given
-the mod name "foomod", a sound could be called:
foomod_foosound.ogg
-Sounds are referred to by their name with a dot, a single digit and the -file extension stripped out. When a sound is played, the actual sound file -is chosen randomly from the matching sounds.
-When playing the sound foomod_foosound, the sound is chosen randomly
-from the available ones of the following files:
foomod_foosound.oggfoomod_foosound.0.oggfoomod_foosound.1.oggfoomod_foosound.9.oggExamples of sound parameter tables:
--- Play locationless on all clients
-{
- gain = 1.0, -- default
- fade = 0.0, -- default, change to a value > 0 to fade the sound in
- pitch = 1.0, -- default
-}
--- Play locationless to one player
-{
- to_player = name,
- gain = 1.0, -- default
- fade = 0.0, -- default, change to a value > 0 to fade the sound in
- pitch = 1.0, -- default
-}
--- Play locationless to one player, looped
-{
- to_player = name,
- gain = 1.0, -- default
- loop = true,
-}
--- Play in a location
-{
- pos = {x = 1, y = 2, z = 3},
- gain = 1.0, -- default
- max_hear_distance = 32, -- default, uses an euclidean metric
-}
--- Play connected to an object, looped
-{
- object = <an ObjectRef>,
- gain = 1.0, -- default
- max_hear_distance = 32, -- default, uses an euclidean metric
- loop = true,
-}
-Looped sounds must either be connected to an object or played locationless to
-one player using to_player = name,
SimpleSoundSpec"""default_place_node"{}{name = "default_place_node"}{name = "default_place_node", gain = 1.0}{name = "default_place_node", gain = 1.0, pitch = 1.0}Anything added using certain minetest.register_* functions get added to
-the global minetest.registered_* tables.
minetest.register_entity(name, prototype table)
minetest.registered_entities[name]minetest.register_node(name, node definition)
minetest.register_tool(name, item definition)
minetest.registered_items[name]minetest.register_craftitem(name, item definition)
minetest.registered_items[name]minetest.unregister_item(name)
minetest.register_biome(biome definition)
minetest.unregister_biome(name)
name from minetest.registered_biomeminetest.register_ore(ore definition)
minetest.register_decoration(decoration definition)
minetest.register_schematic(schematic definition)
minetest.registered_schematic with the key of schematic.nameschematic.name is nil, the key is the returned IDminetest.clear_registered_biomes()
minetest.clear_registered_ores()
minetest.clear_registered_decorations()
minetest.clear_registered_schematics()
Note that in some cases you will stumble upon things that are not contained -in these tables (e.g. when a mod has been removed). Always check for -existence before trying to access the fields.
-Example: If you want to check the drawtype of a node, you could do:
-local function get_nodedef_field(nodename, fieldname)
- if not minetest.registered_nodes[nodename] then
- return nil
- end
- return minetest.registered_nodes[nodename][fieldname]
-end
-local drawtype = get_nodedef_field(nodename, "drawtype")
-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]
-end
-Nodes are the bulk data of the world: cubes and other things that take the -space of a cube. Huge amounts of them are handled efficiently, but they -are quite static.
-The definition of a node is stored and can be accessed by name in
-minetest.registered_nodes[node.name]
-See "Registered definitions of stuff".
-Nodes are passed by value between Lua and the engine. -They are represented by a table:
-{name="name", param1=num, param2=num}
-param1 and param2 are 8-bit integers ranging from 0 to 255. The engine uses
-them for certain automated functions. If you don't use these functions, you can
-use them to store arbitrary values.
The functions of param1 and param2 are determined by certain fields in the
-node definition:
param1 is reserved for the engine when paramtype != "none":
paramtype = "light"
-^ The value stores light with and without sun in its upper and lower 4 bits
- respectively. Allows light to propagate from or through the node with
- light value falling by 1 per node. This is essential for a light source
- node to spread its light.
-param2 is reserved for the engine when any of these are used:
liquidtype == "flowing"
-^ The level and some flags of the liquid is stored in param2
-drawtype == "flowingliquid"
-^ The drawn liquid level is read from param2
-drawtype == "torchlike"
-drawtype == "signlike"
-paramtype2 == "wallmounted"
-^ The rotation of the node is stored in param2. You can make this value
- by using minetest.dir_to_wallmounted().
-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 / 4 = axis direction:
- 0 = y+ 1 = z+ 2 = z- 3 = x+ 4 = x- 5 = y-
- facedir modulo 4 = rotation around that axis
-paramtype2 == "leveled"
-^ Only valid for "nodebox" with 'type = "leveled"', and "plantlike_rooted".
- Leveled nodebox:
- The level of the top face of the nodebox is stored in param2.
- The other faces are defined by 'fixed = {}' like 'type = "fixed"'
- nodeboxes.
- The nodebox height is (param2 / 64) nodes.
- The maximum accepted value of param2 is 127.
- Rooted plantlike:
- The height of the 'plantlike' section is stored in param2.
- The height is (param2 / 16) nodes.
-paramtype2 == "degrotate"
-^ Only valid for "plantlike". The rotation of the node is stored in param2.
- Values range 0 - 179. The value stored in param2 is multiplied by two to
- get the actual rotation in degrees of the node.
-paramtype2 == "meshoptions"
-^ Only valid for "plantlike". The value of param2 becomes a bitfield which
- can be used to change how the client draws plantlike nodes.
- Bits 0, 1 and 2 form a mesh selector.
- Currently the following meshes are choosable:
- 0 = a "x" shaped plant (ordinary plant)
- 1 = a "+" shaped plant (just rotated 45 degrees)
- 2 = a "*" shaped plant with 3 faces instead of 2
- 3 = a "#" shaped plant with 4 faces instead of 2
- 4 = a "#" shaped plant with 4 faces that lean outwards
- 5-7 are unused and reserved for future meshes.
- Bits 3 through 7 are optional flags that can be combined and give these
- effects:
- bit 3 (0x08) - Makes the plant slightly vary placement horizontally
- bit 4 (0x10) - Makes the plant mesh 1.4x larger
- bit 5 (0x20) - Moves each face randomly a small bit down (1/8 max)
- bits 6-7 are reserved for future use.
-paramtype2 == "color"
-^ `param2` tells which color is picked from the palette.
- The palette should have 256 pixels.
-paramtype2 == "colorfacedir"
-^ Same as `facedir`, but with colors.
- The first three bits of `param2` tells which color
- is picked from the palette.
- The palette should have 8 pixels.
-paramtype2 == "colorwallmounted"
-^ Same as `wallmounted`, but with colors.
- The first five bits of `param2` tells which color
- is picked from the palette.
- The palette should have 32 pixels.
-paramtype2 == "glasslikeliquidlevel"
-^ Only valid for "glasslike_framed" or "glasslike_framed_optional"
- drawtypes.
- param2 values 0-63 define 64 levels of internal liquid, 0 being empty and
- 63 being full.
- Liquid texture is defined using `special_tiles = {"modname_tilename.png"},`
-Nodes can also contain extra data. See "Node Metadata".
-There are a bunch of different looking node types.
-Look for examples in games/minimal or games/minetest_game.
normalairlikeliquidflowingliquidglasslikeglasslike_framedtiles. The width of the edges used are 1/16th of texture
- size: 1 pixel for 16x16, 2 pixels for 32x32 etc.tiles.glasslike_framed_optionalallfacesallfaces_optionalnormal, glasslike and allfaces according to
- the menu setting: Opaque Leaves / Simple Leaves / Fancy Leaves.special_tiles
- is used instead, if present. This allows a visually thicker texture to be
- used to compensate for how glasslike reduces visual thickness.torchliketiles.tiles.tiles and is perpendicular to that node.signlikeplantlikeparamtype2 == "meshoptions" above for other options.firelikeplantlike plus 4 more surrounding those.fencelikerailliketiles, in order: Straight,
- curved, t-junction, crossing.raillike nodes, in order to create a
- continuous track network.nodeboxmeshplantlike_rootedplantlike without air bubbles around the nodes.plantlike extension above with a height of param2 / 16 nodes.plantlike extension visually passes through any nodes above the
- base cube without affecting them.plantlike
- extension uses the defined special tile, for example:
- special_tiles = { {name = "default_papyrus.png", tileable_vertical = true}},*_optional drawtypes need less rendering time if deactivated
-(always client-side).
Node selection boxes are defined using "node boxes".
-A nodebox is defined as any of:
-{
- -- A normal cube; the default in most things
- type = "regular"
-}
-{
- -- A fixed box (or boxes) (facedir param2 is used, if applicable)
- type = "fixed",
- fixed = box OR {box1, box2, ...}
-}
-{
- -- A variable height box (or boxes) with the top face position defined
- -- by the node parameter 'leveled = ', or if 'paramtype2 == "leveled"'
- -- by param2.
- -- Other faces are defined by 'fixed = {}' as with 'type = "fixed"'.
- type = "leveled",
- fixed = box OR {box1, box2, ...}
-}
-{
- -- A box like the selection box for torches
- -- (wallmounted param2 is used, if applicable)
- type = "wallmounted",
- wall_top = box,
- wall_bottom = box,
- wall_side = box
-}
-{
- -- A node that has optional boxes depending on neighbouring nodes'
- -- presence and type. See also `connects_to`.
- type = "connected",
- fixed = box OR {box1, box2, ...}
- connect_top = box OR {box1, box2, ...}
- connect_bottom = box OR {box1, box2, ...}
- connect_front = box OR {box1, box2, ...}
- connect_left = box OR {box1, box2, ...}
- connect_back = box OR {box1, box2, ...}
- connect_right = box OR {box1, box2, ...}
- -- The following `disconnected_*` boxes are the opposites of the
- -- `connect_*` ones above, i.e. when a node has no suitable neighbour
- -- on the respective side, the corresponding disconnected box is drawn.
- disconnected_top = box OR {box1, box2, ...}
- disconnected_bottom = box OR {box1, box2, ...}
- disconnected_front = box OR {box1, box2, ...}
- disconnected_left = box OR {box1, box2, ...}
- disconnected_back = box OR {box1, box2, ...}
- disconnected_right = box OR {box1, box2, ...}
- disconnected = box OR {box1, box2, ...} -- when there is *no* neighbour
- disconnected_sides = box OR {box1, box2, ...} -- when there are *no*
- neighbours to the sides
-}
-A box is defined as:
{x1, y1, z1, x2, y2, z2}
-A box of a regular node would look like:
-{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
-Perlin noise creates a continuously-varying value depending on the input values. -Usually in Minetest the input values are either 2D or 3D co-ordinates in nodes. -The result is used during map generation to create the terrain shape, vary heat -and humidity to distribute biomes, vary the density of decorations or vary the -structure of ores.
-An 'octave' is a simple noise generator that outputs a value between -1 and 1. -The smooth wavy noise it generates has a single characteristic scale, almost -like a 'wavelength', so on its own does not create fine detail. -Due to this perlin noise combines several octaves to create variation on -multiple scales. Each additional octave has a smaller 'wavelength' than the -previous.
-This combination results in noise varying very roughly between -2.0 and 2.0 and
-with an average value of 0.0, so scale and offset are then used to multiply
-and offset the noise variation.
The final perlin noise variation is created as follows:
-noise = offset + scale * (octave1 + - octave2 * persistence + - octave3 * persistence ^ 2 + - octave4 * persistence ^ 3 + - ...)
-Noise Parameters are commonly called NoiseParams.
offsetAfter the multiplication by scale this is added to the result and is the final
-step in creating the noise value.
-Can be positive or negative.
scaleOnce all octaves have been combined, the result is multiplied by this. -Can be positive or negative.
-spreadFor octave1, this is roughly the change of input value needed for a very large
-variation in the noise value generated by octave1. It is almost like a
-'wavelength' for the wavy noise variation.
-Each additional octave has a 'wavelength' that is smaller than the previous
-octave, to create finer detail. spread will therefore roughly be the typical
-size of the largest structures in the final noise variation.
spread is a vector with values for x, y, z to allow the noise variation to be
-stretched or compressed in the desired axes.
-Values are positive numbers.
seedThis is a whole number that determines the entire pattern of the noise -variation. Altering it enables different noise patterns to be created. -With other parameters equal, different seeds produce different noise patterns -and identical seeds produce identical noise patterns.
-For this parameter you can randomly choose any whole number. Usually it is -preferable for this to be different from other seeds, but sometimes it is useful -to be able to create identical noise patterns.
-When used in mapgen this is actually a 'seed offset', it is added to the -'world seed' to create the seed used by the noise, to ensure the noise has a -different pattern in different worlds.
-octavesThe number of simple noise generators that are combined. -A whole number, 1 or more. -Each additional octave adds finer detail to the noise but also increases the -noise calculation load. -3 is a typical minimum for a high quality, complex and natural-looking noise -variation. 1 octave has a slight 'gridlike' appearence.
-Choose the number of octaves according to the spread and lacunarity, and the
-size of the finest detail you require. For example:
-if spread is 512 nodes, lacunarity is 2.0 and finest detail required is 16
-nodes, octaves will be 6 because the 'wavelengths' of the octaves will be
-512, 256, 128, 64, 32, 16 nodes.
persistenceEach additional octave has an amplitude that is the amplitude of the previous
-octave multiplied by persistence, to reduce the amplitude of finer details,
-as is often helpful and natural to do so.
-Since this controls the balance of fine detail to large-scale detail
-persistence can be thought of as the 'roughness' of the noise.
A positive or negative non-zero number, often between 0.3 and 1.0.
-A common medium value is 0.5, such that each octave has half the amplitude of
-the previous octave.
-This may need to be tuned when altering lacunarity; when doing so consider
-that a common medium value is 1 / lacunarity.
lacunarityEach additional octave has a 'wavelength' that is the 'wavelength' of the -previous octave multiplied by 1 / lacunarity, to create finer detail. -'lacunarity' is often 2.0 so 'wavelength' often halves per octave.
-A positive number no smaller than 1.0. -Values below 2.0 create higher quality noise at the expense of requiring more -octaves to cover a paticular range of 'wavelengths'.
-flagsLeave this field unset for no special handling.
-Currently supported are defaults, eased and absvalue:
defaultsSpecify this if you would like to keep auto-selection of eased/not-eased while -specifying some other flags.
-easedMaps noise gradient values onto a quintic S-curve before performing
-interpolation. This results in smooth, rolling noise.
-Disable this (noeased) for sharp-looking noise with a slightly gridded
-appearence.
-If no flags are specified (or defaults is), 2D noise is eased and 3D noise is
-not eased.
-Easing a 3D noise significantly increases the noise calculation load, so use
-with restraint.
absvalueThe absolute value of each octave's noise variation is used when combining the -octaves. The final perlin noise variation is created as follows:
-noise = offset + scale * (abs(octave1) + - abs(octave2) * persistence + - abs(octave3) * persistence ^ 2 + - abs(octave4) * persistence ^ 3 + - ...)
-For 2D or 3D perlin noise or perlin noise maps:
-np_terrain = {
- offset = 0,
- scale = 1,
- spread = {x = 500, y = 500, z = 500},
- seed = 571347,
- octaves = 5,
- persist = 0.63,
- lacunarity = 2.0,
- flags = "defaults, absvalue",
-}
-For 2D noise the Z component of spread is still defined but is ignored.
-A single noise parameter table can be used for 2D or 3D noise.
These tell in what manner the ore is generated.
-All default ores are of the uniformly-distributed scatter type.
-scatterRandomly 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_threshold, giving the ability to
-create a non-equal distribution of ore.
sheetCreates a sheet of ore in a blob shape according to the 2D perlin noise
-described by noise_params and noise_threshold. This is essentially an
-improved version of the so-called "stratus" ore seen in some unofficial mods.
This sheet consists of vertical columns of uniform randomly distributed height,
-varying between the inclusive range column_height_min and column_height_max.
-If column_height_min is not specified, this parameter defaults to 1.
-If column_height_max is not specified, this parameter defaults to clust_size
-for reverse compatibility. New code should prefer column_height_max.
The column_midpoint_factor parameter controls the position of the column at
-which ore emanates from.
-If 1, columns grow upward. If 0, columns grow downward. If 0.5, columns grow
-equally starting from each direction.
-column_midpoint_factor is a decimal number ranging in value from 0 to 1. If
-this parameter is not specified, the default is 0.5.
The ore parameters clust_scarcity and clust_num_ores are ignored for this
-ore type.
puffCreates a sheet of ore in a cloud-like puff shape.
-As with the sheet ore type, the size and shape of puffs are described by
-noise_params and noise_threshold and are placed at random vertical
-positions within the currently generated chunk.
The vertical top and bottom displacement of each puff are determined by the
-noise parameters np_puff_top and np_puff_bottom, respectively.
blobCreates a deformed sphere of ore according to 3d perlin noise described by
-noise_params. The maximum size of the blob is clust_size, and
-clust_scarcity has the same meaning as with the scatter type.
veinCreates veins of ore varying in density by according to the intersection of two
-instances of 3d perlin noise with different seeds, both described by
-noise_params.
random_factor varies the influence random chance has on placement of an ore
-inside the vein, which is 1 by default. Note that modifying this parameter
-may require adjusting noise_threshold.
The parameters clust_scarcity, clust_num_ores, and clust_size are ignored
-by this ore type.
This ore type is difficult to control since it is sensitive to small changes. -The following is a decent set of parameters to work from:
-noise_params = {
- offset = 0,
- scale = 3,
- spread = {x=200, y=200, z=200},
- seed = 5390,
- octaves = 4,
- persist = 0.5,
- lacunarity = 2.0,
- flags = "eased",
-},
-noise_threshold = 1.6
-WARNING: Use this ore type very sparingly since it is ~200x more -computationally expensive than any other ore.
-stratumCreates a single undulating ore stratum that is continuous across mapchunk -borders and horizontally spans the world.
-The 2D perlin noise described by noise_params defines the Y co-ordinate of
-the stratum midpoint. The 2D perlin noise described by np_stratum_thickness
-defines the stratum's vertical thickness (in units of nodes). Due to being
-continuous across mapchunk borders the stratum's vertical thickness is
-unlimited.
If the noise parameter noise_params is omitted the ore will occur from y_min
-to y_max in a simple horizontal stratum.
A parameter stratum_thickness can be provided instead of the noise parameter
-np_stratum_thickness, to create a constant thickness.
Leaving out one or both noise parameters makes the ore generation less -intensive, useful when adding multiple strata.
-y_min and y_max define the limits of the ore generation and for performance
-reasons should be set as close together as possible but without clipping the
-stratum's Y variation.
Each node in the stratum has a 1-in-clust_scarcity chance of being ore, so a
-solid-ore stratum would require a clust_scarcity of 1.
The parameters clust_num_ores, clust_size, noise_threshold and
-random_factor are ignored by this ore type.
See section "Flag Specifier Format".
-Currently supported flags:
-puff_cliffs, puff_additive_composition.
puff_cliffsIf set, puff ore generation will not taper down large differences in
-displacement when approaching the edge of a puff. This flag has no effect for
-ore types other than puff.
puff_additive_compositionBy default, when noise described by np_puff_top or np_puff_bottom results
-in a negative displacement, the sub-column at that point is not generated. With
-this attribute set, puff ore generation will instead generate the absolute
-difference in noise displacement values. This flag has no effect for ore types
-other than puff.
The varying types of decorations that can be placed.
-simpleCreates a 1 times H times 1 column of a specified node (or a random node from
-a list, if a decoration list is specified). Can specify a certain node it must
-spawn next to, such as water or lava, for example. Can also generate a
-decoration of random height between a specified lower and upper bound.
-This type of decoration is intended for placement of grass, flowers, cacti,
-papyri, waterlilies and so on.
schematicCopies a box of MapNodes from a specified schematic file (or raw description).
-Can specify a probability of a node randomly appearing when placed.
-This decoration type is intended to be used for multi-node sized discrete
-structures, such as trees, cave spikes, rocks, and so on.
A schematic specifier identifies a schematic by either a filename to a
-Minetest Schematic file (.mts) or through raw data supplied through Lua,
-in the form of a table. This table specifies the following fields:
size field is a 3D vector containing the dimensions of the provided
- schematic. (required)yslice_prob field is a table of {ypos, prob} which sets the yposth
- vertical slice of the schematic to have a prob / 256 * 100 chance of
- occurring. (default: 255)data field is a flat table of MapNode tables making up the schematic,
- in the order of [z [y [x]]]. (required)
- Each MapNode table contains:name: the name of the map node to place (required)prob (alias param1): the probability of this node being placed
- (default: 255)param2: the raw param2 value of the node being placed onto the map
- (default: 0)force_place: boolean representing if the node should forcibly overwrite
- any previous contents (default: false)About probability values:
-0 or 1 means that node will never appear
- (0% chance).254 or 255 means the node will always appear
- (100% chance).p is greater than 1, then there is a
- (p / 256 * 100) percent chance that node will appear when the schematic is
- placed on the map.See section "Flag Specifier Format".
-Currently supported flags: place_center_x, place_center_y, place_center_z,
- force_placement.
place_center_x: Placement of this decoration is centered along the X axis.place_center_y: Placement of this decoration is centered along the Y axis.place_center_z: Placement of this decoration is centered along the Z axis.force_placement: Schematic nodes other than "ignore" will replace existing
- nodes.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.
Note: offset will adapt to screen DPI as well as user defined scaling
-factor!
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.
-imageDisplays 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 (positive values).
- Negative values represent that percentage of the screen it
- should take; e.g. x=-100 means 100% (width).text: The name of the texture that is displayed.alignment: The alignment of the image.offset: offset in pixels from position.textDisplays 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.statbarDisplays 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.directionoffset: offset in pixels from position.size: If used, will force full-image size to this value (override texture
- pack image size)inventorytext: 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.directionoffset: offset in pixels from position.waypointDisplays distance to selected world position.
-name: The name of the waypoint.text: Distance suffix. Can be blank.number: An integer containing the RGB value of the color used to draw the
- text.world_pos: World position of the waypoint.{x=num, y=num, z=num}
-For helper functions see "Vector helpers".
-pointed_thingFlags using the standardized flag specifier format can be specified in either -of two ways, by string or table.
-The string format is a comma-delimited set of flag names; whitespace and
-unrecognized flag fields are ignored. Specifying a flag in the string sets the
-flag, and specifying a flag prefixed by the string "no" explicitly
-clears the flag from whatever the default may be.
In addition to the standard string flag format, the schematic flags field can
-also be a table of flag names to boolean values representing whether or not the
-flag is set. Additionally, if a field with the flag name prefixed with "no"
-is present, mapped to a boolean of any value, the specified flag is unset.
E.g. A flag field of value
-{place_center_x = true, place_center_y=false, place_center_z=true}
-is equivalent to
-{place_center_x = true, noplace_center_y=true, place_center_z=true}
-which is equivalent to
-"place_center_x, noplace_center_y, place_center_z"
-or even
-"place_center_x, place_center_z"
-since, by default, no schematic attributes are set.
-There are three kinds of items: nodes, tools and craftitems.
-register_node): A node from the world.register_tool): A tool/weapon that can dig and damage
- things according to tool_capabilities.register_craftitem): A miscellaneous item.All item stacks have an amount between 0 to 65535. It is 1 by -default. Tool item stacks can not have an amount greater than 1.
-Tools use a wear (=damage) value ranging from 0 to 65535. The -value 0 is the default and used is for unworn tools. The values -1 to 65535 are used for worn tools, where a higher value stands for -a higher wear. Non-tools always have a wear value of 0.
-Items and item stacks can exist in three formats: Serializes, table format
-and ItemStack.
This is called "stackstring" or "itemstring". It is a simple string with -1-3 components: the full item identifier, an optional amount and an optional -wear value. Syntax:
-<identifier> [<amount>[ <wear>]]
-Examples:
-'default:apple': 1 apple'default:dirt 5': 5 dirt'default:pick_stone': a new stone pickaxe'default:pick_wood 1 21323': a wooden pickaxe, ca. 1/3 worn outExamples:
-5 dirt nodes:
-{name="default:dirt", count=5, wear=0, metadata=""}
-A wooden pick about 1/3 worn out:
-{name="default:pick_wood", count=1, wear=21323, metadata=""}
-An apple:
-{name="default:apple", count=1, wear=0, metadata=""}
-ItemStackA native C++ format with many helper methods. Useful for converting -between formats. See the Class reference section for details.
-When an item must be passed to a function, it can usually be in any of -these formats.
-In a number of places, there is a group table. Groups define the -properties of a thing (item, node, armor of entity, capabilities of -tool) in such a way that the engine and other mods can can interact with -the thing without actually knowing what the thing is.
-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
-
-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
-useful meaning for a rating for an enabled group, it shall be 1.
When not defined, the rating of a group defaults to 0. Thus when you
-read groups, you must interpret nil and 0 as the same value, 0.
You can read the rating of a group for an item or a node by using
-minetest.get_item_group(itemname, groupname)
-Groups of items can define what kind of an item it is (e.g. wool).
-In addition to the general item things, groups are used to define whether -a node is destroyable and how long it takes to destroy by a tool.
-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 (e.g. {fleshy=100})
-object.set_armor_groups({fleshy=30, cracky=80})
-Groups in tools define which groups of nodes and entities they are -effective towards.
-An example: Make meat soup from any meat, any water and any bowl:
-{
- output = 'food:meat_soup_raw',
- recipe = {
- {'group:meat'},
- {'group:water'},
- {'group:bowl'},
- },
- -- preserve = {'group:bowl'}, -- Not implemented yet (TODO)
-}
-Another example: Make red wool from white wool and red dye:
-{
- type = 'shapeless',
- output = 'wool:red',
- recipe = {'wool:white', 'group:dye,basecolor_red'},
-}
-immortal: Disables the group damage system for an entitypunch_operable: For entities; disables the regular damage mechanism for
- players punching it by hand or a non-tool item, so that it can do something
- else than take damage.level: Can be used to give an additional sense of progression in the game.0 is something that is directly accessible at the start of gameplaydig_immediate: (player can always pick up node without reducing tool wear)
-disable_jump: Player (and possibly other things) cannot jump from nodefall_damage_add_percent: damage speed = speed * (1 + value/100)bouncy: value is bounce speed in percentfalling_node: if there is no walkable block under the node it will fallattached_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 groupconnect_to_raillike: makes nodes of raillike drawtype with same group value
- connect to each otherslippery: Players and items will slide on the node.
- Slipperiness rises steadily with slippery value, starting at 1.crumbly: dirt, sandcracky: tough but crackable stuff like stone.snappy: something that can be cut using fine tools; e.g. leaves, small
- plants, wire, sheets of metalchoppy: something that can be cut using force; e.g. trees, wooden planksfleshy: Living things like animals and the player. This could imply
- some blood effects when hitting.explody: Especially prone to explosionsoddly_breakable_by_hand:
- Can be added to nodes that shouldn't logically be breakable by the
- hand but are. Somewhat similar to dig_immediate, but times are more
- like {[1]=3.50,[2]=2.00,[3]=0.70} and this does not override the
- speed of a tool if the tool can dig at a faster speed than this
- suggests for the hand.Item groups are often used for defining, well, groups of items.
-meat: any meat-kind of a thing (rating might define the size or healing
- ability or be irrelevant -- it is not defined as of yet)eatable: anything that can be eaten. Rating might define HP gain in half
- hearts.flammable: can be set on fire. Rating might define the intensity of the
- fire, affecting e.g. the speed of the spreading of an open fire.wool: any wool (any origin, any color)metal: any metalweapon: any weaponheavy: anything considerably heavyGroups such as crumbly, cracky and snappy are used for this
-purpose. Rating is 1, 2 or 3. A higher rating for such a group implies
-faster digging time.
The level group is used to limit the toughness of nodes a tool can dig
-and to scale the digging times / damage to a greater extent.
Please do understand this, otherwise you cannot use the system to it's -full potential.
-Tools define their properties by a list of parameters for groups. They -cannot dig other groups; thus it is important to use a standard bunch of -groups to enable interaction with tools.
-Tools define:
-When used as a weapon, the tool will do full damage if this time is spent -between punches. If e.g. half the time is spent, the tool will do half -damage.
-Suggests the maximum level of node, when dug with the tool, that will drop -it's useful item. (e.g. iron ore to drop a lump of iron).
-This is not automated; it is the responsibility of the node definition -to implement this.
-Determines how many uses the tool has when it is used for digging a node,
-of this group, of the maximum level. For lower leveled nodes, the use count
-is multiplied by 3^leveldiff.
uses=10, leveldiff=0: actual uses: 10uses=10, leveldiff=1: actual uses: 30uses=10, leveldiff=2: actual uses: 90Tells what is the maximum level of a node of this group that the tool will -be able to dig.
-List of digging times for different ratings of the group, for nodes of the -maximum level.
-For example, as a Lua table, times={2=2.00, 3=0.70}. This would
-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.
If the result digging time is 0, a delay of 0.15 seconds is added between -digging nodes; If the player releases LMB after digging, this delay is set to 0, -i.e. players can more quickly click the nodes away instead of holding LMB.
-List of damage for groups of entities. See "Entity damage mechanism".
-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}}
- }
- damage_groups = {fleshy=2},
-}
-This makes the tool be able to dig nodes that fulfil both of these:
- -Table of resulting digging times:
-crumbly 0 1 2 3 4 <- level
- -> 0 - - - - -
- 1 0.80 1.60 1.60 - -
- 2 0.60 1.20 1.20 - -
- 3 0.40 0.80 0.80 - -
-
-level diff: 2 1 0 -1 -2
-Table of resulting tool uses:
--> 0 - - - - -
- 1 180 60 20 - -
- 2 180 60 20 - -
- 3 180 60 20 - -
-Notes:
-crumbly==0, the node is not diggable.crumbly==3, the level difference digging time divider kicks in and makes
- easy nodes to be quickly breakable.level > 2, the node is not diggable, because it's level > maxlevelDamage calculation:
-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 inexistent 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 -pre-defined somehow (e.g. by defining a sprite animation) (not implemented; -TODO). -Currently a smoke puff will appear when an entity dies.
-The group immortal completely disables normal damage.
Entities can define a special armor group, which is punch_operable. This
-group disables the regular damage mechanism for players punching it by hand or
-a non-tool item, so that it can do something else than take damage.
On the Lua side, every punch calls:
-entity:on_punch(puncher, time_from_last_punch, tool_capabilities, direction, damage)
-This should never be called directly, because damage is usually not handled by -the entity itself.
-puncher is the object performing the punch. Can be nil. Should never be
- accessed unless absolutely required, to encourage interoperability.time_from_last_punch is time from last punch (by puncher) or nil.tool_capabilities can be nil.direction is a unit vector, pointing from the source of the punch to
- the punched object.damage damage that will be done to entity
-Return value of this function will determine if damage is done by this function
-(retval true) or shall be done by engine (retval false)To punch an entity/object in Lua, call:
-object:punch(puncher, time_from_last_punch, tool_capabilities, direction)
-direction equals nil and puncher does not equal nil, direction
- will be automatically filled in based on the location of puncher.The instance of a node in the world normally only contains the three values
-mentioned in "Nodes". However, it is possible to insert extra data into a
-node. It is called "node metadata"; See NodeMetaRef.
Node metadata contains two things:
-Some of the values in the key-value store are handled specially:
-formspec: Defines a right-click inventory menu. See "Formspec".infotext: Text shown on the screen when the node is pointed atExample stuff:
-local meta = minetest.get_meta(pos)
-meta:set_string("formspec",
- "size[8,9]"..
- "list[context;main;0,0;8,4;]"..
- "list[current_player;main;0,5;8,4;]")
-meta:set_string("infotext", "Chest");
-local inv = meta:get_inventory()
-inv:set_size("main", 8*4)
-print(dump(meta:to_table()))
-meta:from_table({
- inventory = {
- main = {[1] = "default:dirt", [2] = "", [3] = "", [4] = "",
- [5] = "", [6] = "", [7] = "", [8] = "", [9] = "",
- [10] = "", [11] = "", [12] = "", [13] = "",
- [14] = "default:cobble", [15] = "", [16] = "", [17] = "",
- [18] = "", [19] = "", [20] = "default:cobble", [21] = "",
- [22] = "", [23] = "", [24] = "", [25] = "", [26] = "",
- [27] = "", [28] = "", [29] = "", [30] = "", [31] = "",
- [32] = ""}
- },
- fields = {
- formspec = "size[8,9]list[context;main;0,0;8,4;]list[current_player;main;0,5;8,4;]",
- infotext = "Chest"
- }
-})
-Item stacks can store metadata too. See ItemStackMetaRef.
Item metadata only contains a key-value store.
-Some of the values in the key-value store are handled specially:
-description: Set the item stack's description. Defaults to
- idef.description.color: A ColorString, which sets the stack's color.palette_index: If the item has a palette, this is used to get the
- current color from the palette.Example stuff:
-local meta = stack:get_meta()
-meta:set_string("key", "value")
-print(dump(meta:to_table()))
-Formspec defines a menu. Currently not much else than inventories are -supported. It is a string, with a somewhat strange format.
-Spaces and newlines can be inserted between the blocks, as is used in the -examples.
-WARNING: Minetest allows you to add elements to every single formspec instance
-using player:set_formspec_prepend(), which may be the reason backgrounds are
-appearing when you don't expect them to. See no_prepend[]
size[8,9]
-list[context;main;0,0;8,4;]
-list[current_player;main;0,5;8,4;]
-size[8,9]
-list[context;fuel;2,3;1,1;]
-list[context;src;2,1;1,1;]
-list[context;dst;5,1;2,2;]
-list[current_player;main;0,5;8,4;]
-size[8,7.5]
-image[1,0.6;1,2;player.png]
-list[current_player;main;0,3.5;8,4;]
-list[current_player;craft;3,0;3,3;]
-list[current_player;craftpreview;7,1;1,1;]
-size[<W>,<H>,<fixed_size>]fixed_size: true/false (optional)invsize[<W>,<H>;]position[<X>,<Y>]size element.anchor point.anchor[<X>,<Y>]size and position (if present) elements.Defaults to the center of the formspec [0.5, 0.5].
-position and anchor elements need suitable values to avoid a formspec
- extending off the game window due to particular game window sizes.
no_prepend[]size, position, and anchor elements (if present).container[<X>,<Y>]container_endcontainer_end[]list[<inventory location>;<list name>;<X>,<Y>;<W>,<H>;]list[<inventory location>;<list name>;<X>,<Y>;<W>,<H>;<starting item index>]listring[<inventory location>;<list name>]listring[]listring[<inventory location>;<list name>]
- for the last two inventory lists added by list[...]listcolors[<slot_bg_normal>;<slot_bg_hover>]ColorStringlistcolors[<slot_bg_normal>;<slot_bg_hover>;<slot_border>]ColorStringlistcolors[<slot_bg_normal>;<slot_bg_hover>;<slot_border>;<tooltip_bgcolor>;<tooltip_fontcolor>]ColorStringtooltip[<gui_element_name>;<tooltip_text>;<bgcolor>;<fontcolor>]<bgcolor> tooltip background color as ColorString (optional)<fontcolor> tooltip font color as ColorString (optional)image[<X>,<Y>;<W>,<H>;<texture name>]item_image[<X>,<Y>;<W>,<H>;<item name>]bgcolor[<color>;<fullscreen>]ColorStringtrue, the background color is drawn fullscreen (does not effect the size
- of the formspec).background[<X>,<Y>;<W>,<H>;<texture name>]background[<X>,<Y>;<W>,<H>;<texture name>;<auto_clip>]true the background is clipped to formspec size
- (x and y are used as offset values, w and h are ignored)pwdfield[<X>,<Y>;<W>,<H>;<name>;<label>]x and y position the field relative to the top left of the menuw and h are the size of the fieldhname is the name of the field as returned in fields to on_receive_fieldslabel, if not blank, will be text printed on the top left above the fieldfield[<X>,<Y>;<W>,<H>;<name>;<label>;<default>]fields.key_enter_field will be sent with
- the name of this field.x and y position the field relative to the top left of the menuw and h are the size of the fieldhname is the name of the field as returned in fields to on_receive_fieldslabel, if not blank, will be text printed on the top left above the fielddefault is the default value of the fielddefault may contain variable references such as ${text}' which
- will fill the value from the metadata value textfield_close_on_enter to stop enter closing the formspecfield[<name>;<label>;<default>]fields.key_enter_field will be sent with
- the name of this field.size[] elementfield_close_on_enter to stop enter closing the formspecfield_close_on_enter[<name>;<close_on_enter>]textarea[<X>,<Y>;<W>,<H>;<name>;<label>;<default>]label[<X>,<Y>;<label>]x and y work as per fieldlabel is the text on the labelvertlabel[<X>,<Y>;<label>]x and y work as per fieldlabel is the text on the labelbutton[<X>,<Y>;<W>,<H>;<name>;<label>]x, y and name work as per fieldw and h are the size of the buttonhlabel is the text on the buttonimage_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>]x, y, w, h, and name work as per buttontexture name is the filename of an imageimage_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>;<noclip>;<drawborder>;<pressed texture name>]x, y, w, h, and name work as per buttontexture name is the filename of an imagenoclip=true means the image button doesn't need to be within specified
- formsize.drawborder: draw button border or notpressed texture name is the filename of an image on pressed stateitem_image_button[<X>,<Y>;<W>,<H>;<item name>;<name>;<label>]x, y, w, h, name and label work as per buttonitem name is the registered name of an item/node,
- tooltip will be made out of its description
- to override it use tooltip elementbutton_exit[<X>,<Y>;<W>,<H>;<name>;<label>]image_button_exit[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>]textlist[<X>,<Y>;<W>,<H>;<name>;<listelem 1>,<listelem 2>,...,<listelem n>]x and y position the itemlist relative to the top left of the menuw and h are the size of the itemlistname fieldname sent to server on doubleclick value is current selected
- element.listelements can be prepended by #color in hexadecimal format RRGGBB
- (only).textlist[<X>,<Y>;<W>,<H>;<name>;<listelem 1>,<listelem 2>,...,<listelem n>;<selected idx>;<transparent>]x and y position the item list relative to the top left of the menuw and h are the size of the item listname fieldname sent to server on doubleclick value is current selected
- element.listelements can be prepended by #RRGGBB (only) in hexadecimal formattrue/false: draw transparent backgroundminetest.explode_textlist_event
- (main menu: engine.explode_textlist_event).tabheader[<X>,<Y>;<name>;<caption 1>,<caption 2>,...,<caption n>;<current_tab>;<transparent>;<draw_border>]x and y position the itemlist relative to the top left of the menuname fieldname data is transferred to Luacaption 1...: name shown on top of tabcurrent_tab: index of selected tab 1...transparent (optional): show transparentdraw_border (optional): draw borderbox[<X>,<Y>;<W>,<H>;<color>]x and y position the box relative to the top left of the menuw and h are the size of boxcolor is color specified as a ColorStringdropdown[<X>,<Y>;<W>;<name>;<item 1>,<item 2>, ...,<item n>;<selected idx>]x and y position of dropdowncheckbox[<X>,<Y>;<name>;<label>;<selected>]x and y: position of checkboxname fieldname data is transferred to Lualabel to be shown left of checkboxselected (optional): true/falsescrollbar[<X>,<Y>;<W>,<H>;<orientation>;<name>;<value>]x and y: position of trackbarw and h: width and heightorientation: vertical/horizontal0-1000)minetest.explode_scrollbar_event
- (main menu: engine.explode_scrollbar_event).table[<X>,<Y>;<W>,<H>;<name>;<cell 1>,<cell 2>,...,<cell n>;<selected idx>]tableoptions[]tablecolumns[]x and y: position the itemlist relative to the top left of the menuw and h are the size of the itemlistname: fieldname sent to server on row select or doubleclickcell 1...cell n: cell contents given in row-major orderselected idx: index of row to be selected within table (first row = 1)minetest.explode_table_event
- (main menu: engine.explode_table_event).tableoptions[<opt 1>;<opt 2>;...]table[]color=#RRGGBBColorString), defaults to #FFFFFFbackground=#RRGGBBColorString), defaults to #000000border=<true/false>true)highlight=#RRGGBBColorString), defaults to #466432highlight_text=#RRGGBBColorString), defaults to #FFFFFFopendepth=<value>depth < value are open (default value = 0)tablecolumns[<type 1>,<opt 1a>,<opt 1b>,...;<type 2>,<opt 2a>,<opt 2b>;...]table[]text, image, color, indent, treetext: show cell contents as textimage: cell contents are an image index, use column options to define
- images.color: cell contents are a ColorString and define color of following
- cell.indent: cell contents are a number and define indentation of following
- cell.tree: same as indent, but user can open and close subtrees
- (treeview-like).align=<value>text and image: content alignment within cells.
- Available values: left (default), center, right, inlinewidth=<value>
-padding=<value>: padding left of the column, in em (default 0.5).
- Exception: defaults to 0 for indent columnstooltip=<value>: tooltip text (default: empty)image column options:
-color column options:span=<value>: number of following columns to affect
- (default: infinite).Note: do not use a element name starting with key_; those names are
-reserved to pass key press events to formspec!
"context": Selected node metadata (deprecated: "current_name")"current_player": Player to whom the menu is shown"player:<name>": Any player"nodemeta:<X>,<Y>,<Z>": Any node metadata"detached:<name>": A detached inventorymain: list containing the default inventorycraft: list containing the craft inputcraftpreview: list containing the craft outputhand: list containing an override for the empty handColorString#RGB defines a color in hexadecimal format.
#RGBA defines a color in hexadecimal format and alpha channel.
#RRGGBB defines a color in hexadecimal format.
#RRGGBBAA defines a color in hexadecimal format and alpha channel.
Named colors are also supported and are equivalent to
-CSS Color Module Level 4.
-To specify the value of the alpha channel, append #AA to the end of the color
-name (e.g. colorname#08). For named colors the hexadecimal string
-representing the alpha value must (always) be two hexadecimal digits.
ColorSpecA ColorSpec specifies a 32-bit color. It can be written in either:
-table form, each element ranging from 0..255 (a, if absent, defaults to 255):
- colorspec = {a=255, r=0, g=255, b=0}
-numerical form, the raw integer value of an ARGB8 quad:
- colorspec = 0xFF00FF00
-or string form, a ColorString (defined above):
- colorspec = "green"
Most text can contain escape sequences, that can for example color the text. -There are a few exceptions: tab headers, dropdowns and vertical labels can't. -The following functions provide escape sequences:
-minetest.get_color_escape_sequence(color):
-minetest.colorize(color, message):minetest.get_color_escape_sequence(color) ..
- message ..
- minetest.get_color_escape_sequence("#ffffff")minetest.get_background_escape_sequence(color)
-minetest.strip_foreground_colors(str)get_color_escape_sequence.minetest.strip_background_colors(str)get_background_escape_sequence.minetest.strip_colors(str)For the following functions, v, v1, v2 are vectors,
-p1, p2 are positions:
vector.new(a[, b, c]):
-vector.direction(p1, p2):
-vector.distance(p1, p2):p1 and p2.vector.length(v):v.vector.normalize(v):
-vector.floor(v):vector.round(v):vector.apply(v, func):func has been applied to each
- component.vector.equals(v1, v2):true if the vectors are identical.vector.sort(v1, v2):v1, v2.For the following functions x can be either a vector or a number:
vector.add(v, x):vector.subtract(v, x):vector.multiply(v, x):vector.divide(v, x):dump2(obj, name, dumped): returns a string which makes obj
- human-readable, handles reference loops.
-dump(obj, dumped): returns a string which makes obj human-readable
-math.hypot(x, y)math.sign(x, tolerance): returns -1, 0 or 1
-string.split(str, separator, include_empty, max_splits, sep_is_pattern)separator: string, default: ","include_empty: boolean, default: falsemax_splits: number, if it's positive, splits aren't limited,
- default: -1sep_is_pattern: boolean, it specifies whether separator is a plain
- string or a pattern (regex), default: false"a,b":split"," returns {"a","b"}string:trim(): returns the string without whitespace pre- and suffixes"\n \t\tfoo bar\t ":trim() returns "foo bar"minetest.wrap_text(str, limit, as_table): returns a string or tablelimit: number, maximal amount of characters in one lineas_table: boolean, if set to true, a table of lines instead of a string
- is returned, default: falseminetest.pos_to_string(pos, decimal_places): returns string "(X,Y,Z)"
-minetest.string_to_pos(string): returns a position or nilminetest.string_to_area("(X1, Y1, Z1) (X2, Y2, Z2)"): returns two positionsminetest.formspec_escape(string): returns a stringminetest.is_yes(arg)minetest.get_us_time()table.copy(table): returns a tabletableminetest.pointed_thing_to_face_pos(placer, pointed_thing): returns a
- position.Texts can be translated client-side with the help of minetest.translate and
-translation files.
Two functions are provided to translate strings: minetest.translate and
-minetest.get_translator.
minetest.get_translator(textdomain) is a simple wrapper around
- minetest.translate, and minetest.get_translator(textdomain)(str, ...) is
- equivalent to minetest.translate(textdomain, str, ...).
- It is intended to be used in the following way, so that it avoids verbose
- repetitions of minetest.translate:
local S = minetest.get_translator(textdomain) -S(str, ...)
-As an extra commodity, if textdomain is nil, it is assumed to be "" instead.
minetest.translate(textdomain, str, ...) translates the string str with
- the given textdomain for disambiguation. The textdomain must match the
- textdomain specified in the translation file in order to get the string
- translated. This can be used so that a string is translated differently in
- different contexts.
- It is advised to use the name of the mod as textdomain whenever possible, to
- avoid clashes with other mods.
- This function must be given a number of arguments equal to the number of
- arguments the translated string expects.
- Arguments are literal strings -- they will not be translated, so if you want
- them to be, they need to come as outputs of minetest.translate as well.For instance, suppose we want to translate "@1 Wool" with "@1" being replaced - by the translation of "Red". We can do the following:
-local S = minetest.get_translator()
-S("@1 Wool", S("Red"))
-This will be displayed as "Red Wool" on old clients and on clients that do
- not have localization enabled. However, if we have for instance a translation
- file named wool.fr.tr containing the following:
@1 Wool=Laine @1
-Red=Rouge
-this will be displayed as "Laine Rouge" on clients with a French locale.
-The output of minetest.translate is a string, with escape sequences adding
-additional information to that string so that it can be translated on the
-different clients. In particular, you can't expect operations like string.length
-to work on them like you would expect them to, or string.gsub to work in the
-expected manner. However, string concatenation will still work as expected
-(note that you should only use this for things like formspecs; do not translate
-sentences by breaking them into parts; arguments should be used instead), and
-operations such as minetest.colorize which are also concatenation.
A translation file has the suffix .[lang].tr, where [lang] is the language
-it corresponds to.
-The file should be a text file, with the following format:
# textdomain: (the space is significant) can be used
- to specify the text domain of all following translations in the file.# are ignored.original=translated. Both original
- and translated can contain escape sequences beginning with @ to insert
- arguments, literal @, = or newline (See ### Escapes below).
- There must be no extraneous whitespace around the = or at the beginning or
- the end of the line.Strings that need to be translated can contain several escapes, preceded by @.
@@ acts as a literal @.@n, where n is a digit between 1 and 9, is an argument for the translated
- string that will be inlined when translation. Due to how translations are
- implemented, the original translation string must have its arguments in
- increasing order, without gaps or repetitions, starting from 1.@= acts as a literal =. It is not required in strings given to
- minetest.translate, but is in translation files to avoid being confused
- with the = separating the original from the translation.@\n (where the \n is a literal newline) acts as a literal newline.
- As with @=, this escape is not required in strings given to
- minetest.translate, but is in translation files.@n acts as a literal newline as well.minetest namespace referenceminetest.get_current_modname(): returns the currently loading mod's name,
- when loading a mod.minetest.get_modpath(modname): returns e.g.
- "/home/user/.minetest/usermods/modname"..lua modules or static data from modminetest.get_modnames(): returns a list of installed modsminetest.get_worldpath(): returns e.g. "/home/user/.minetest/world"minetest.is_singleplayer()minetest.features: Table containing API feature flags{
- glasslike_framed = true,
- nodebox_as_selectionbox = true,
- chat_send_player_param3 = true,
- get_all_craft_recipes_works = true,
- use_texture_alpha = true,
--- ^ The transparency channel of textures can optionally be used on nodes
- no_legacy_abms = true,
--- ^ Tree and grass ABMs are no longer done from C++
- texture_names_parens = true,
--- ^ Texture grouping is possible using parentheses
- area_store_custom_ids = true,
--- ^ Unique Area ID for AreaStore:insert_area
- add_entity_with_staticdata = true,
--- ^ add_entity supports passing initial staticdata to on_activate
- no_chat_message_prediction = true,
--- ^ Chat messages are no longer predicted
- object_use_texture_alpha = true
--- ^ The transparency channel of textures can optionally be used on
--- objects (ie: players and lua entities)
-}
-minetest.has_feature(arg): returns boolean, missing_featuresarg: string or table in format {foo=true, bar=true}missing_features: {foo=true, bar=true}minetest.get_player_information(player_name):{
- address = "127.0.0.1", -- IP address of client
- ip_version = 4, -- IPv4 / IPv6
- min_rtt = 0.01, -- minimum round trip time
- max_rtt = 0.2, -- maximum round trip time
- avg_rtt = 0.02, -- average round trip time
- min_jitter = 0.01, -- minimum packet time jitter
- max_jitter = 0.5, -- maximum packet time jitter
- avg_jitter = 0.03, -- average packet time jitter
- connection_uptime = 200, -- seconds since client connected
- protocol_version = 32, -- protocol version used by client
- -- following information is available on debug build only!!!
- -- DO NOT USE IN MODS
- --ser_vers = 26, -- serialization version used by client
- --major = 0, -- major version number
- --minor = 4, -- minor version number
- --patch = 10, -- patch version number
- --vers_string = "0.4.9-git", -- full version string
- --state = "Active" -- current client state
-}
-minetest.mkdir(path): returns success.path, creating parent directories
- if they don't exist.minetest.get_dir_list(path, [is_dir]): returns list of entry namesminetest.safe_file_write(path, content): returns boolean indicating successlocal f = io.open(path, "wb"); f:write(content); f:close()minetest.get_version(): returns a table containing components of the
- engine version. Components:project: Name of the project, eg, "Minetest"string: Simple version, eg, "1.2.3-dev"hash: Full git version (only set if available),
- eg, "1.2.3-dev-01234567-dirty".
- Use this for informational purposes only. The information in the returned
- table does not represent the capabilities of the engine, nor is it
- reliable or verifiable. Compatible forks will have a different name and
- version entirely. To check for the presence of engine features, test
- whether the functions exported by the wanted features exist. For example:
- if minetest.check_for_falling then ... end.minetest.sha1(data, [raw]): returns the sha1 hash of data
-minetest.debug(...)minetest.log(table.concat({...}, "\t"))minetest.log([level,] text)level is one of "none", "error", "warning", "action",
- "info", or "verbose". Default is "none".Call these functions only at load time!
-minetest.register_entity(name, prototype table)minetest.register_abm(abm definition)minetest.register_lbm(lbm definition)minetest.register_node(name, node definition)minetest.register_tool(name, item definition)minetest.register_craftitem(name, item definition)minetest.unregister_item(name)minetest.register_alias(name, convert_to)minetest.register_alias_force(name, convert_to)minetest.register_craft(recipe)minetest.clear_craft(recipe)minetest.register_craft(recipe). For output specify only the item,
- without a quantity.minetest.register_ore(ore definition)minetest.register_biome(biome definition)minetest.register_decoration(decoration definition)minetest.override_item(name, redefinition)minetest.override_item("default:mese", {light_source=LIGHT_MAX})minetest.clear_registered_ores()minetest.clear_registered_biomes()minetest.clear_registered_decorations()Call these functions only at load time!
-minetest.register_globalstep(func(dtime))minetest.register_on_shutdown(func())minetest.register_on_placenode(func(pos, newnode, placer, oldnode, itemstack, pointed_thing))
-minetest.register_on_dignode(func(pos, oldnode, digger))on_destruct or after_dig_node in node
- definition whenever possible.minetest.register_on_punchnode(func(pos, node, puncher, pointed_thing))minetest.register_on_generated(func(minp, maxp, blockseed))minetest.register_on_newplayer(func(ObjectRef))minetest.register_on_punchplayer(func(player, hitter, time_from_last_punch, tool_capabilities, dir, damage))player - ObjectRef - Player that was punchedhitter - ObjectRef - Player that hittime_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.damage - number that represents the damage calculated by the enginetrue to prevent the default damage mechanismminetest.register_on_player_hpchange(func(player, hp_change, reason), modifier)player: ObjectRef of the playerhp_change: the amount of change. Negative when it is damage.reason: a PlayerHPChangeReason table.
-modifier: when true, the function should return the actual hp_change.
- Note: modifiers only get a temporary hp_change that can be modified by later modifiers.
- modifiers can return true as a second argument to stop the execution of further functions.
- Non-modifiers receive the final hp change calculated by the modifiers.minetest.register_on_dieplayer(func(ObjectRef, reason))reason: a PlayerHPChangeReason table, see register_on_player_hpchangeminetest.register_on_respawnplayer(func(ObjectRef))minetest.register_on_prejoinplayer(func(name, ip))minetest.register_on_joinplayer(func(ObjectRef))minetest.register_on_leaveplayer(func(ObjectRef, timed_out))timed_out: True for timeout, false for other reasons.minetest.register_on_auth_fail(func(name, ip))
-minetest.register_on_cheat(func(ObjectRef, cheat))
-minetest.register_on_chat_message(func(name, message))true to mark the message as handled, which means that it will
- not be sent to other players.minetest.register_on_player_receive_fields(func(player, formname, fields))true, remaining functions are not calledminetest.register_on_craft(func(itemstack, player, old_craft_grid, craft_inv))
-minetest.register_craft_predict(func(itemstack, player, old_craft_grid, craft_inv))minetest.register_on_protection_violation(func(pos, name))builtin and mods when a player violates protection at a
- position (eg, digs a node or punches a protected entity).minetest.record_protection_violation.minetest.register_on_item_eat(func(hp_change, replace_with_item, itemstack, user, pointed_thing))
-minetest.register_on_priv_grant(function(name, granter, priv))granter grants the priv priv to name.minetest.register_on_priv_revoke(function(name, revoker, priv))revoker revokes the priv priv from name.minetest.register_can_bypass_userlimit(function(name, ip))
-minetest.register_on_modchannel_message(func(channel_name, sender, message))sender field is an empty string.minetest.register_chatcommand(cmd, chatcommand definition)minetest.registered_chatcommandsminetest.override_chatcommand(name, redefinition)register_chatcommand.minetest.unregister_chatcommand(name)register_chatcommand.minetest.register_privilege(name, definition)definition: "description text"definition:
- {description = "description text", give_to_singleplayer = boolean}
- the default of give_to_singleplayer is true.basic_privs to grant, see basic_privs
- minetest.conf setting.on_grant(name, granter_name): Called when given to player name by
- granter_name.
- granter_name will be nil if the priv was granted by a mod.on_revoke(name, revoker_name): Called when taken from player name by
- revoker_name.
- revoker_name will be nil if the priv was revoked by a modminetest.register_authentication_handler(authentication handler definition)minetest.settings: Settings object containing all of the settings from the
- main config file (minetest.conf).minetest.setting_get_pos(name): Loads a setting from the main settings and
- parses it as a position (in the format (1,2,3)). Returns a position or nil.minetest.string_to_privs(str): returns {priv1=true,...}minetest.privs_to_string(privs): returns "priv1,priv2,..."minetest.get_player_privs(name) -> {priv1=true,...}minetest.check_player_privs(player_or_name, ...):
- returns bool, missing_privs
player_or_name: Either a Player object or the name of a player.... is either a list of strings, e.g. "priva", "privb" or
- a table, e.g. { priva = true, privb = true }.minetest.check_password_entry(name, entry, password)
get_auth() call on the auth handler.minetest.get_password_hash(name, raw_password)minetest.check_password_entry instead.minetest.get_player_ip(name): returns an IP address string for the player
- name.
minetest.get_auth_handler(): Return the currently active auth handler
minetest.notify_authentication_modified(name)name: string; if omitted, all auth data should be considered modifiedminetest.set_player_password(name, password_hash): Set password hash of
- player name.minetest.set_player_privs(name, {priv1=true,...}): Set privileges of player
- name.minetest.auth_reload()reload() in authentication handler definitionminetest.set_player_password, minetest_set_player_privs,
-minetest_get_player_privs and minetest.auth_reload call the authentication
-handler.
minetest.set_node(pos, node)minetest.add_node(pos, node): alias tominetest.set_node`
-minetest.bulk_set_node({pos1, pos2, pos3, ...}, node)minetest.bulk_set_node({ {x=0, y=1, z=1}, {x=1, y=2, z=2}}, {name="default:stone"})minetest.set_node callminetest.swap_node(pos, node)minetest.remove_node(pos)minetest.set_node(pos, {name="air"})minetest.get_node(pos){name="node_name", param1=0, param2=0},
- returns {name="ignore", param1=0, param2=0} for unloaded areas.minetest.get_node_or_nil(pos)get_node but returns nil for unloaded areas.minetest.get_node_light(pos, timeofday)pos: The position where to measure the light.timeofday: nil for current time, 0 for night, 0.5 for day0 and 15 or nilminetest.place_node(pos, node)minetest.dig_node(pos)true if successful, false on failure (e.g. protected location)minetest.punch_node(pos)minetest.spawn_falling_node(pos)
true if successful, false on failureminetest.find_nodes_with_meta(pos1, pos2)
minetest.get_meta(pos)NodeMetaRef at that positionminetest.get_node_timer(pos)
NodeTimerRefminetest.add_entity(pos, name, [staticdata]): Spawn Lua-defined entity at
- position.
ObjectRef, or nil if failedminetest.add_item(pos, item): Spawn itemObjectRef, or nil if failedminetest.get_player_by_name(name): Get an ObjectRef to a playerminetest.get_objects_inside_radius(pos, radius): returns a list of
- ObjectRefs.radius: using an euclidean metricminetest.set_timeofday(val)val is between 0 and 1; 0 for midnight, 0.5 for middayminetest.get_timeofday()minetest.get_gametime(): returns the time, in seconds, since the world was
- created.minetest.get_day_count(): returns number days elapsed since world was
- created.minetest.find_node_near(pos, radius, nodenames, [search_center]): returns
- pos or nil.
-minetest.find_nodes_in_area(pos1, pos2, nodenames): returns a list of
- positions.nodenames: e.g. {"ignore", "group:tree"} or "default:dirt"minetest.find_nodes_in_area_under_air(pos1, pos2, nodenames): returns a
- list of positions.nodenames: e.g. {"ignore", "group:tree"} or "default:dirt"minetest.get_perlin(noiseparams)minetest.get_perlin(seeddiff, octaves, persistence, scale)int(worldseed)+seeddiff)minetest.get_voxel_manip([pos1, pos2])minetest.set_gen_notify(flags, {deco_ids})flags is a flag field with the available flags:minetest.get_gen_notify()deco_ids.nil on failure.minetest.get_mapgen_object(objectname)minetest.get_heat(pos)nil on failure.minetest.get_humidity(pos)nil on failure.minetest.get_biome_data(pos)
-minetest.get_biome_id(biome_name)minetest.get_biome_data(pos), for a given biome_name string.minetest.get_biome_name(biome_id)
-minetest.get_mapgen_params()
-minetest.set_mapgen_params(MapgenParams)minetest.set_mapgen_setting(name, value, override)
- instead.on_mapgen_init.flags contains a comma-delimited string of flags to set, or if the
- prefix "no" is attached, clears instead.flags is in the same format and has the same options as mg_flags in
- minetest.conf.minetest.get_mapgen_setting(name)minetest.get_mapgen_setting_noiseparams(name)name exists and is a valid NoiseParams.minetest.set_mapgen_setting(name, value, [override_meta])value, and will take effect if the corresponding
- mapgen setting is not already present in map_meta.txt.override_meta is an optional boolean (default: false). If this is set
- to true, the setting will become the active setting regardless of the map
- metafile contents."seed", not "fixed_map_seed".minetest.set_mapgen_setting_noiseparams(name, value, [override_meta])minetest.set_noiseparams(name, noiseparams, set_default)
-minetest.get_noiseparams(name)minetest.generate_ores(vm, pos1, pos2)
-minetest.generate_decorations(vm, pos1, pos2)
-minetest.clear_objects([options])mode.
-minetest.emerge_area(pos1, pos2, [callback], [param])pos1 to pos2, inclusive, to be
- asynchronously fetched from memory, loaded from disk, or if inexistent,
- generates them.callback is a valid Lua function, this will be called for each block
- emerged.function EmergeAreaCallback(blockpos, action, calls_remaining, param)blockpos is the block coordinates of the block that had been
- emerged.action could be one of the following constant values:
-calls_remaining is the number of callbacks to be expected after
- this one.param is the user-defined parameter passed to emerge_area (or
- nil if the parameter was absent).minetest.delete_area(pos1, pos2)minetest.line_of_sight(pos1, pos2): returns boolean, pos
-minetest.raycast(pos1, pos2, objects, liquids): returns Raycast
-minetest.find_path(pos1,pos2,searchdistance,max_jump,max_drop,algorithm)pos1 to pos2 or
- nil.pos1: start positionpos2: end positionsearchdistance: number of blocks to search in each direction using a
- maximum metric.max_jump: maximum height difference to consider walkablemax_drop: maximum height difference to consider droppablealgorithm: One of "A*_noprefetch" (default), "A*", "Dijkstra"minetest.spawn_tree (pos, {treedef})pos with definition in treedef tableminetest.transforming_liquid_add(pos)minetest.get_node_max_level(pos)minetest.get_node_level(pos)minetest.set_node_level(pos, level)
-minetest.add_node_level(pos, level)
-minetest.fix_light(pos1, pos2): returns true/falsepos1 is the corner of the cuboid with the least coordinates
- (in node coordinates), inclusive.pos2 is the opposite corner of the cuboid, inclusive.false if the area is not fully generated,
- true otherwiseminetest.check_single_for_falling(pos)group:falling_node node to fall and causes an
- unattached group:attached_node node to fall.minetest.check_for_falling(pos)group:falling_node node to fall and causes an
- unattached group:attached_node node to fall.minetest.get_spawn_level(x, z)nil for an unsuitable spawn point.water_level and water_level + 16, and in mgv7 well away from rivers,
- so nil will be returned for many (x, z) co-ordinates.You can find mod channels communication scheme in docs/mod_channels.png.
minetest.mod_channel_join(channel_name)channel_name, and creates it if necessary. You
- should listen from incoming messages with
- minetest.register_on_modchannel_message call to receive incoming
- messages.minetest.get_inventory(location): returns an InvRef
location = e.g.
-minetest.create_detached_inventory(name, callbacks, [player_name]): returns
- an InvRef.player_name: Make detached inventory available to one player
- exclusively, by default they will be sent to every player (even if not
- used).
- Note that this parameter is mostly just a workaround and will be removed
- in future releases.minetest.do_item_eat(hp_change, replace_with_item, itemstack, user, pointed_thing):
- returns left over ItemStack.minetest.item_eat and minetest.register_on_item_eatminetest.show_formspec(playername, formname, formspec)
-minetest.close_formspec(playername, formname)playername: name of player to close formspecformname: has to exactly match the one given in show_formspec, or the
- formspec will not close.show_formspec(playername, formname, "") is equal to this
- expression.minetest.close_formspec(playername, "").
- USE THIS ONLY WHEN ABSOLUTELY NECESSARY!minetest.formspec_escape(string): returns a stringminetest.explode_table_event(string): returns a table
-minetest.explode_textlist_event(string): returns a table
-minetest.explode_scrollbar_event(string): returns a table
-minetest.inventorycube(img1, img2, img3)minetest.get_pointed_thing_position(pointed_thing, above)pointed_thing (that you can get from somewhere)minetest.dir_to_facedir(dir, is6d)
-minetest.facedir_to_dir(facedir)minetest.dir_to_wallmounted(dir)paramtype2="wallmounted".minetest.wallmounted_to_dir(wallmounted)minetest.dir_to_yaw(dir)minetest.yaw_to_dir(yaw)minetest.is_colored_paramtype(ptype)true if the given paramtype2 contains
- color information (color, colorwallmounted or colorfacedir).minetest.strip_param2_color(param2, paramtype2)
-minetest.get_node_drops(nodename, toolname)minetest.get_craft_result(input): returns output, decremented_inputinput.method = "normal" or "cooking" or "fuel"input.width = for example 3input.items = for example
- {stack1, stack2, stack3, stack4, stack 5, stack 6, stack 7, stack 8, stack 9}output.item = ItemStack, if unsuccessful: empty ItemStackoutput.time = a number, if unsuccessful: 0output.replacements = list of ItemStacks that couldn't be placed in
- decremented_input.itemsdecremented_input = like inputminetest.get_craft_recipe(output): returns inputoutput is a node or item type such as "default:torch"input.method = "normal" or "cooking" or "fuel"input.width = for example 3input.items = for example
- {stack1, stack2, stack3, stack4, stack 5, stack 6, stack 7, stack 8, stack 9}input.items = nil if no recipe foundminetest.get_all_craft_recipes(query item): returns a table or nilnil 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]={method = "cooking", width = 3, output = "default:gold_ingot",
- items = {1 = "default:gold_lump"}},
- [2]={method = "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 (e.g. dropping items on
- ground)
- minetest.itemstring_with_palette(item, palette_index): returns an item
- string.
- * Creates an item string which contains palette index information
- for hardware colorization. You can use the returned string
- as an output in a craft recipe.
- * item: the item stack which becomes colored. Can be in string,
- table and native form.
- * palette_index: this index is added to the item stack
-* minetest.itemstring_with_color(item, colorstring): returns an item string
- * Creates an item string which contains static color information
- for hardware colorization. Use this method if you wish to colorize
- an item that does not own a palette. You can use the returned string
- as an output in a craft recipe.
- * item: the item stack which becomes colored. Can be in string,
- table and native form.
- * colorstring: the new color of the item stack
minetest.rollback_get_node_actions(pos, range, seconds, limit):
- returns { {actor, pos, time, oldnode, newnode}, ...}actor: "player:<name>", also "liquid".minetest.rollback_revert_actions_by(actor, seconds): returns
- boolean, log_messages.actor: "player:<name>", also "liquid".on_* item definition functionsThese functions return the leftover itemstack.
-minetest.item_place_node(itemstack, placer, pointed_thing, param2)
-minetest.item_place_object(itemstack, placer, pointed_thing)minetest.item_place(itemstack, placer, pointed_thing, param2)
-minetest.item_drop(itemstack, dropper, pos)minetest.item_eat(hp_change, replace_with_item)
-on_punch and on_dig node definition callbacksminetest.node_punch(pos, node, puncher, pointed_thing)minetest.register_on_punchnode()minetest.node_dig(pos, node, digger)minetest.registered_on_dignodes()minetest.sound_play(spec, parameters): returns a handle
-minetest.sound_stop(handle)minetest.sound_fade(handle, step, gain)
-minetest.after(time, func, ...)
-minetest.request_shutdown([message],[reconnect],[delay]): request for
- server shutdown. Will display message to clients.
-minetest.cancel_shutdown_requests(): cancel current delayed shutdownminetest.get_server_status(): returns server status stringminetest.get_server_uptime(): returns the server uptime in secondsminetest.remove_player(name): remove player from database (if they are not
- connected).minetest.remove_player_auth(name): remove player authentication dataminetest.get_ban_list(): returns the ban list
- (same as minetest.get_ban_description("")).minetest.get_ban_description(ip_or_name): returns ban description (string)minetest.ban_player(name): ban a playerminetest.unban_player_or_ip(name): unban player or IP addressminetest.kick_player(name, [reason]): disconnect a player with a optional
- reason.minetest.add_particle(particle definition)
minetest.add_particle(pos, velocity, acceleration,
- expirationtime, size, collisiondetection, texture, playername)minetest.add_particlespawner(particlespawner definition)
ParticleSpawner, an object that spawns an amount of particles
- over time seconds.id, and -1 if adding didn't succeedDeprecated: minetest.add_particlespawner(amount, time,
- minpos, maxpos,
- minvel, maxvel,
- minacc, maxacc,
- minexptime, maxexptime,
- minsize, maxsize,
- collisiondetection, texture, playername)minetest.delete_particlespawner(id, player)
ParticleSpawner with id (return value from
- minetest.add_particlespawner).minetest.create_schematic(p1, p2, probability_list, filename, slice_prob_list)
probability_list.probability_list is an array of tables containing two fields, pos
- and prob.pos is the 3D vector specifying the absolute coordinates of the
- node being modified,prob is an integer value from 0 to 255 that encodes
- probability and per-node force-place. Probability has levels
- 0-127, then 128 may be added to encode per-node force-place.
- For probability stated as 0-255, divide by 2 and round down to
- get values 0-127, then add 128 to apply per-node force-place.pos is not inside the box formed by p1 and p2, it is
- ignored.probability_list equals nil, no probabilities are applied.slice_prob_list.
-minetest.place_schematic(pos, schematic, rotation, replacements, force_placement, flags)
pos.rotation can equal "0", "90", "180", "270", or "random".rotation parameter is omitted, the schematic is not rotated.replacements = {["old_name"] = "convert_to", ...}force_placement is a boolean indicating whether nodes other than air
- and ignore are replaced by the schematic.flags is a flag field with the available flags:minetest.place_schematic_on_vmanip(vmanip, pos, schematic, rotation, replacement, force_placement, flags):
vmanip instead of the
- map.flags is a flag field with the available flags:minetest.serialize_schematic(schematic, format, options)
format of either "mts" or "lua".options is a table containing the following optional parameters:lua_use_comments is true and format is "lua", the Lua code
- generated will have (X, Z) position comments for every X row
- generated in the schematic data for easier reading.lua_num_indent_spaces is a nonzero number and format is "lua",
- the Lua code generated will use that number of spaces as indentation
- instead of a tab character.minetest.request_http_api():HTTPApiTable containing http functions if the calling mod has
- been granted access by being listed in the secure.http_mods or
- secure.trusted_mods setting, otherwise returns nil.fetch, fetch_async and
- fetch_async_get described below.HTTPApiTable.fetch(HTTPRequest req, callback)function(HTTPRequestResult res)HTTPApiTable.fetch_async(HTTPRequest req): returns handleHTTPApiTable.fetch_async_getHTTPApiTable.fetch_async_get(handle): returns HTTPRequestResultminetest.get_mod_storage():StorageRefminetest.get_connected_players(): returns list of ObjectRefsminetest.is_player(o): boolean, whether o is a playerminetest.player_exists(name): boolean, whether player exists
- (regardless of online status)minetest.hud_replace_builtin(name, hud_definition)
-minetest.send_join_message(player_name)minetest.send_leave_message(player_name, timed_out)minetest.hash_node_position(pos): returns an 48-bit integerpos: table {x=number, y=number, z=number},minetest.get_position_from_hash(hash): returns a positionminetest.hash_node_positionminetest.get_item_group(name, group): returns a rating0 means: not in group)minetest.get_node_group(name, group): returns a ratingminetest.raillike_group(name): returns a ratingminetest.get_content_id(name): returns an integernameminetest.get_name_from_content_id(content_id): returns a stringminetest.parse_json(string[, nullvalue]): returns somethingnullvalue: returned in place of the JSON null; defaults to nilnullvaluenilparse_json("[10, {\"a\":false}]"), returns {10, {a = false}}minetest.write_json(data[, styled]): returns a string or nil and an error
- message.write_json({10, {a = false}}),
- returns "[10, {\"a\": false}]"minetest.serialize(table): returns a string
-minetest.deserialize(string): returns a tableminetest.deserialize into a tablestring is loaded in an empty sandbox environment.deserialize('return { ["foo"] = "bar" }'),
- returns {foo='bar'}deserialize('print("foo")'), returns nil
- (function call fails), returns
- error:[string "print("foo")"]:1: attempt to call global 'print' (a nil value)minetest.compress(data, method, ...): returns compressed_data
-minetest.decompress(compressed_data, method, ...): returns dataminetest.compress() for supported compression
- methods.... indicates method-specific arguments. Currently, no methods use thisminetest.rgba(red, green, blue[, alpha]): returns a stringminetest.rgba(10, 20, 30, 40), returns "#0A141E28"minetest.encode_base64(string): returns string encoded in base64minetest.decode_base64(string): returns stringminetest.is_protected(pos, name): returns boolean
name shouldn't be able to dig at pos or do
- other actions, definable by mods, due to some mod-defined ownership-like
- concept.name will be "" for non-players or unknown players.local old_is_protected = minetest.is_protected
-function minetest.is_protected(pos, name)
- if mymod:position_protected_from(pos, name) then
- return true
- end
- return old_is_protected(pos, name)
-end
-minetest.record_protection_violation(pos, name)minetest.register_on_protection_violation.player_name may not modify
- in the specified cuboid between pos1 and pos2.false if no protections were found.is_protected() to a 3D lattice of points in the defined volume.
- The points are spaced evenly throughout the volume and have a spacing
- similar to, but no larger than, interval.interval defaults to 4.interval should be carefully chosen and maximised to avoid an excessive
- number of points being checked.minetest.is_protected, this function may be extended or
- overwritten by mods to provide a faster implementation to check the
- cuboid for intersections.minetest.rotate_and_place(itemstack, placer, pointed_thing, infinitestacks, orient_flags)itemstack, and place it accordingly (on-wall, on the floor,
- or hanging from the ceiling). Stacks are handled normally if the
- infinitestacks field is false or omitted (else, the itemstack is not
- changed). orient_flags is an optional table containing extra tweaks to
- the placement code:invert_wall: if true, place wall-orientation on the ground and
- ground-orientation on the wall.force_wall : if true, always place the node in wall orientation.force_ceiling: if true, always place on the ceiling.force_floor: if true, always place the node on the floor.force_facedir: if true, forcefully reset the facedir to north
- when placing on the floor or ceiling.minetest.rotate_node(itemstack, placer, pointed_thing)rotate_and_place() with infinitestacks set according to the state
- of the creative mode setting, and checks for "sneak" to set the
- invert_wall parameter.minetest.forceload_block(pos[, transient])
minetest.forceload_free_block(pos[, transient])
minetest.request_insecure_environment(): returns an environment containing
- insecure functions if the calling mod has been listed as trusted in the
- secure.trusted_mods setting or security is disabled, otherwise returns
- nil.
minetest.global_exists(name)
minetest.env: EnvRef of the server environment and world.minetest.env:somefunction(somearguments)
- instead of minetest.somefunction(somearguments)minetest.registered_itemsminetest.registered_nodesminetest.registered_craftitemsminetest.registered_toolsminetest.registered_entitiesminetest.object_refsminetest.luaentitiesminetest.registered_chatcommandsminetest.registered_oresminetest.registered_biomesminetest.registered_decorationsAn interface to use mod channels on client and server
-leave(): leave the mod channel.channel_name.is_writeable(): returns true if channel is writeable and mod can send over
- it.send_all(message): Send message though the mod channel.MetaDataRefSee StorageRef, NodeMetaRef and ItemStackMetaRef.
set_string(name, value)get_string(name)set_int(name, value)get_int(name)set_float(name, value)get_float(name)to_table(): returns nil or a table with keys:
-from_table(nil or {})true on successequals(other)true if this metadata has the same key-value pairs as otherNodeMetaRefNode metadata: reference extra data and functionality stored in a node.
-Can be obtained via minetest.get_meta(pos).
get_inventory(): returns InvRefmark_as_private(name or {name1, name2, ...}): Mark specific vars as private
- This will prevent them from being sent to the client. Note that the "private"
- status will only be remembered if an associated key-value pair exists,
- meaning it's best to call this when initializing all other meta (e.g.
- on_construct).ItemStackMetaRefItemStack metadata: reference extra data and functionality stored in a stack.
-Can be obtained via item:get_meta().
set_tool_capabilities([tool_capabilities])StorageRefMod metadata: per mod metadata, saved automatically.
-Can be obtained via minetest.get_mod_storage() during load time.
NodeTimerRefNode Timers: a high resolution persistent per-node timer.
-Can be gotten via minetest.get_node_timer(pos).
set(timeout,elapsed)
-start(timeout)set(timeout,0)stop()get_timeout(): returns current timeout in secondstimeout equals 0, timer is inactiveget_elapsed(): returns current elapsed time in secondson_timer function will be called after (timeout - elapsed)
- seconds.is_started(): returns boolean state of timertrue if timer is started, otherwise falseObjectRefMoving things in the game are generally these.
-This is basically a reference to a C++ ServerActiveObject
remove(): remove object (after returning from Lua)minetest.kick_player insteadget_pos(): returns {x=num, y=num, z=num}set_pos(pos); pos={x=num, y=num, z=num}move_to(pos, continuous=false): interpolated movepunch(puncher, time_from_last_punch, tool_capabilities, direction)
-right_click(clicker); clicker is another ObjectRefget_hp(): returns number of hitpoints (2 * number of hearts)set_hp(hp, reason): set number of hitpoints (2 * number of hearts).get_inventory(): returns an InvRefget_wield_list(): returns the name of the inventory list the wielded item
- is in.get_wield_index(): returns the index of the wielded itemget_wielded_item(): returns an ItemStackset_wielded_item(item): replaces the wielded item, returns true if
- successful.set_armor_groups({group1=rating, group2=rating, ...})get_armor_groups(): returns a table with the armor group ratingsset_animation(frame_range, frame_speed, frame_blend, frame_loop)
-get_animation(): returns range, frame_speed, frame_blend and
- frame_loop.set_animation_frame_speed(frame_speed)frame_speed: number, default: 15.0set_attach(parent, bone, position, rotation)
-get_attach(): returns parent, bone, position, rotation or nil if it isn't
- attached.set_detach()set_bone_position(bone, position, rotation)
-get_bone_position(bone): returns position and rotation of the boneset_properties(object property table)get_properties(): returns object property tableis_player(): returns true for players, false otherwiseget_nametag_attributes()set_nametag_attributes(attributes)attributes:
- {
- color = ColorSpec,
- text = "My Nametag",
- }set_velocity(vel)vel is a vector, e.g. {x=0.0, y=2.3, z=1.0}get_velocity(): returns the velocity, a vectorset_acceleration(acc)acc is a vectorget_acceleration(): returns the acceleration, a vectorset_yaw(radians)get_yaw(): returns number in radiansset_texture_mod(mod)get_texture_mod() returns current texture modifierset_sprite(p, num_frames, framelength, select_horiz_by_yawpitch)p: {x=number, y=number}, the coordinate of the first frame
- (x: column, y: row), default: {x=0, y=0}num_frames: number, default: 1framelength: number, default: 0.2select_horiz_by_yawpitch: boolean, this was once used for the Dungeon
- Master mob, default: falseget_entity_name() (Deprecated: Will be removed in a future version)get_luaentity()get_player_name(): returns "" if is not a playerget_player_velocity(): returns nil if is not a player, otherwise a
- table {x, y, z} representing the player's instantaneous velocity in nodes/sget_look_dir(): get camera direction as a unit vectorget_look_vertical(): pitch in radiansget_look_horizontal(): yaw in radiansset_look_vertical(radians): sets look pitchset_look_horizontal(radians): sets look yawget_look_pitch(): pitch in radians - Deprecated as broken. Use
- get_look_vertical.get_look_yaw(): yaw in radians - Deprecated as broken. Use
- get_look_horizontal.set_look_pitch(radians): sets look pitch - Deprecated. Use
- set_look_vertical.set_look_yaw(radians): sets look yaw - Deprecated. Use
- set_look_horizontal.get_breath(): returns players breathset_breath(value): sets players breath
-set_attribute(attribute, value):
-get_attribute(attribute):nil if no attribute found.set_inventory_formspec(formspec)on_joinplayerget_inventory_formspec(): returns a formspec stringset_formspec_prepend(formspec):get_formspec_prepend(formspec): returns a formspec string.get_player_control(): returns table with player pressed keys{jump=false, right=true, left=false, LMB=false, RMB=false,
- sneak=true, aux1=false, down=false, up=false}get_player_control_bits(): returns integer with bit packed player pressed
- keys.set_physics_override(override_table)override_table is a table with the following fields:speed: multiplier to default walking speed value (default: 1)jump: multiplier to default jump value (default: 1)gravity: multiplier to default gravity value (default: 1)sneak: whether player can sneak (default: true)sneak_glitch: whether player can use the new move code replications
- of the old sneak side-effects: sneak ladders and 2 node sneak jump
- (default: false)new_move: use new move/sneak code. When false the exact old code
- is used for the specific old sneak behaviour (default: true)get_physics_override(): returns the table given to set_physics_overridehud_add(hud definition): add a HUD element described by HUD def, returns ID
- number on successhud_remove(id): remove the HUD element of the specified idhud_change(id, stat, value): change a value of a previously added HUD
- element.stat values:
- position, name, scale, text, number, item, dirhud_get(id): gets the HUD element definition structure of the specified IDhud_set_flags(flags): sets specified HUD flags to true/falseflags: (is visible) hotbar, healthbar, crosshair, wielditem,
- breathbar, minimap, minimap_radartrue/false value of each flag to be set or
- unset.nil, the flag is not modifiedminimap modifies the client's permission to view the
- minimap - the client may locally elect to not view the minimap.radar is only usable when minimap is truehud_get_flags(): returns a table containing status of hud flags{hotbar=true, healthbar=true, crosshair=true, wielditem=true,
- breathbar=true, minimap=true, minimap_radar=true}hud_set_hotbar_itemcount(count): sets number of items in builtin hotbarcount: number of items, must be between 1 and 23hud_get_hotbar_itemcount: returns number of visible itemshud_set_hotbar_image(texturename)hud_get_hotbar_image: returns texturenamehud_set_hotbar_selected_image(texturename)hud_get_hotbar_selected_image: returns texturenameset_sky(bgcolor, type, {texture names}, clouds)
-get_sky(): returns bgcolor, type, table of textures, cloudsset_clouds(parameters): set cloud parametersparameters is a table with the following optional fields:density: from 0 (no clouds) to 1 (full clouds) (default 0.4)color: basic cloud color with alpha channel, ColorSpec
- (default #fff0f0e5).ambient: cloud color lower bound, use for a "glow at night" effect.
- ColorSpec (alpha ignored, default #000000)height: cloud height, i.e. y of cloud base (default per conf,
- usually 120)thickness: cloud thickness in nodes (default 16)speed: 2D cloud speed + direction in nodes per second
- (default {x=0, z=-2}).get_clouds(): returns a table with the current cloud parameters as in
- set_clouds.override_day_night_ratio(ratio or nil)
-get_day_night_ratio(): returns the ratio or nil if it isn't overriddenset_local_animation(stand/idle, walk, dig, walk+dig, frame_speed=frame_speed):
- set animation for player model in third person viewset_local_animation({x=0, y=79}, -- < stand/idle animation key frames
- {x=168, y=187}, -- < walk animation key frames
- {x=189, y=198}, -- < dig animation key frames
- {x=200, y=219}, -- < walk+dig animation key frames
- frame_speed=30): -- < animation frame speed
-get_local_animation(): returns stand, walk, dig, dig+walk tables and
- frame_speed.set_eye_offset({x=0,y=0,z=0},{x=0,y=0,z=0}): defines offset value for
- camera per player.{x=-10/10,y=-10,15,z=-5/5})get_eye_offset(): returns offset_first and offset_thirdInvRefAn InvRef is a reference to an inventory.
is_empty(listname): return true if list is emptyget_size(listname): get size of a listset_size(listname, size): set size of a listfalse on error (e.g. invalid listname or size)get_width(listname): get width of a listset_width(listname, width): set width of list; currently used for craftingget_stack(listname, i): get a copy of stack index i in listset_stack(listname, i, stack): copy stack to index i in listget_list(listname): return full listset_list(listname, list): set full list (size will not change)get_lists(): returns list of inventory listsset_lists(lists): sets inventory lists (size will not change)add_item(listname, stack): add item somewhere in list, returns leftover
- ItemStack.room_for_item(listname, stack): returns true if the stack of items
- can be fully added to the listcontains_item(listname, stack, [match_meta]): returns true if
- the stack of items can be fully taken from the list.
- If match_meta is false, only the items' names are compared
- (default: false).remove_item(listname, stack): take as many items as specified from the
- list, returns the items that were actually removed (as an ItemStack)
- -- note that any item metadata is ignored, so attempting to remove a specific
- unique item this way will likely remove the wrong one -- to do that use
- set_stack with an empty ItemStack.get_location(): returns a location compatible to
- minetest.get_inventory(location).{type="undefined"} in case location is not knownAreaStoreA fast access data structure to store areas, and find areas near a given
-position or area.
-Every area has a data string attribute to store additional information.
-You can create an empty AreaStore by calling AreaStore(), or
-AreaStore(type_name).
-If you chose the parameter-less constructor, a fast implementation will be
-automatically chosen for you.
get_area(id, include_borders, include_data): returns the area with the id
- id.
- (optional) Boolean values include_borders and include_data control what's
- copied.
- Returns nil if specified area id does not exist.get_areas_for_pos(pos, include_borders, include_data): returns all areas
- that contain the position pos.
- (optional) Boolean values include_borders and include_data control what's
- copied.get_areas_in_area(edge1, edge2, accept_overlap, include_borders, include_data):
- returns all areas that contain all nodes inside the area specified by edge1
- and edge2 (inclusive).
- If accept_overlap is true, also areas are returned that have nodes in
- common with the specified area.
- (optional) Boolean values include_borders and include_data control what's
- copied.insert_area(edge1, edge2, data, [id]): inserts an area into the store.
- Returns the new area's ID, or nil if the insertion failed.
- The (inclusive) positions edge1 and edge2 describe the area.
- data is a string stored with the area. If passed, id will be used as the
- internal area ID, it must be a unique number between 0 and 2^32-2. If you use
- the id parameter you must always use it, or insertions are likely to fail
- due to conflicts.reserve(count): reserves resources for at most count many contained
- areas.
- Only needed for efficiency, and only some implementations profit.remove_area(id): removes the area with the given id from the store, returns
- success.set_cache_params(params): sets params for the included prefiltering cache.
- Calling invalidates the cache, so that its elements have to be newly
- generated.params:
- {
- enabled = boolean, -- whether to enable, default true
- block_radius = number, -- the radius (in nodes) of the areas the cache
- generates prefiltered lists for, minimum 16,
- default 64.
- limit = number, -- the cache's size, minimum 20, default 1000
- }to_string(): Experimental. Returns area store serialized as a (binary)
- string.to_file(filename): Experimental. Like to_string(), but writes the data to
- a file.from_string(str): Experimental. Deserializes string and loads it into the
- AreaStore.
- Returns success and, optionally, an error message.from_file(filename): Experimental. Like from_string(), but reads the data
- from a file.ItemStackAn ItemStack is a stack of items.
It can be created via ItemStack(x), where x is an ItemStack,
-an itemstring, a table or nil.
is_empty(): returns true if stack is empty.get_name(): returns item name (e.g. "default:stone").set_name(item_name): returns a boolean indicating whether the item was
- cleared.get_count(): Returns number of items on the stack.set_count(count): returns a boolean indicating whether the item was clearedcount: number, unsigned 16 bit integerget_wear(): returns tool wear (0-65535), 0 for non-tools.set_wear(wear): returns boolean indicating whether item was clearedwear: number, unsigned 16 bit integerget_meta(): returns ItemStackMetaRef. See section for more detailsget_metadata(): (DEPRECATED) Returns metadata (a string attached to an item
- stack).set_metadata(metadata): (DEPRECATED) Returns true.clear(): removes all items from the stack, making it empty.replace(item): replace the contents of this stack.item can also be an itemstring or table.to_string(): returns the stack in itemstring form.to_table(): returns the stack in Lua table form.get_stack_max(): returns the maximum size of the stack (depends on the
- item).get_free_space(): returns get_stack_max() - get_count().is_known(): returns true if the item name refers to a defined item type.get_definition(): returns the item definition table.get_tool_capabilities(): returns the digging properties of the item,
- or those of the hand if none are defined for this item typeadd_wear(amount)
-add_item(item): returns leftover ItemStackitem_fits(item): returns true if item or stack can be fully added to
- this one.take_item(n): returns taken ItemStack
-peek_item(n): returns taken ItemStack
-PseudoRandomA 16-bit pseudorandom number generator. -Uses a well-known LCG algorithm introduced by K&R.
-It can be created via PseudoRandom(seed).
next(): return next integer random number [0...32767]next(min, max): return next integer random number [min...max]((max - min) == 32767) or ((max-min) <= 6553)) must be true
- due to the simple implementation making bad distribution otherwise.PcgRandomA 32-bit pseudorandom number generator. -Uses PCG32, an algorithm of the permuted congruential generator family, -offering very strong randomness.
-It can be created via PcgRandom(seed) or PcgRandom(seed, sequence).
next(): return next integer random number [-2147483648...2147483647]next(min, max): return next integer random number [min...max]rand_normal_dist(min, max, num_trials=6): return normally distributed
- random number [min...max].
-SecureRandomInterface for the operating system's crypto-secure PRNG.
-It can be created via SecureRandom(). The constructor returns nil if a
-secure random device cannot be found on the system.
next_bytes([count]): return next count (default 1, capped at 2048) many
- random bytes, as a string.PerlinNoiseA perlin noise generator.
-It can be created via PerlinNoise(seed, octaves, persistence, scale)
-or PerlinNoise(noiseparams).
-Alternatively with minetest.get_perlin(seeddiff, octaves, persistence, scale)
-or minetest.get_perlin(noiseparams).
get_2d(pos): returns 2D noise value at pos={x=,y=}get_3d(pos): returns 3D noise value at pos={x=,y=,z=}PerlinNoiseMapA fast, bulk perlin noise generator.
-It can be created via PerlinNoiseMap(noiseparams, size) or
-minetest.get_perlin_map(noiseparams, size).
Format of size is {x=dimx, y=dimy, z=dimz}. The z component is omitted
-for 2D noise, and it must be must be larger than 1 for 3D noise (otherwise
-nil is returned).
For each of the functions with an optional buffer parameter: If buffer is
-not nil, this table will be used to store the result instead of creating a new
-table.
get_2d_map(pos): returns a <size.x> times <size.y> 2D array of 2D noise
- with values starting at pos={x=,y=}get_3d_map(pos): returns a <size.x> times <size.y> times <size.z>
- 3D array of 3D noise with values starting at pos={x=,y=,z=}.get_2d_map_flat(pos, buffer): returns a flat <size.x * size.y> element
- array of 2D noise with values starting at pos={x=,y=}get_3d_map_flat(pos, buffer): Same as get2dMap_flat, but 3D noisecalc_2d_map(pos): Calculates the 2d noise map starting at pos. The result
- is stored internally.calc_3d_map(pos): Calculates the 3d noise map starting at pos. The result
- is stored internally.get_map_slice(slice_offset, slice_size, buffer): In the form of an array,
- returns a slice of the most recently computed noise results. The result slice
- begins at coordinates slice_offset and takes a chunk of slice_size.
- E.g. to grab a 2-slice high horizontal 2d plane of noise starting at buffer
- offset y = 20:
- noisevals = noise:get_map_slice({y=20}, {y=2})
- It is important to note that slice_offset offset coordinates begin at 1,
- and are relative to the starting position of the most recently calculated
- noise.
- To grab a single vertical column of noise starting at map coordinates
- x = 1023, y=1000, z = 1000:
- noise:calc_3d_map({x=1000, y=1000, z=1000})
-noisevals = noise:get_map_slice({x=24, z=1}, {x=1, z=1})VoxelManipVoxelManip is a scripting interface to the internal 'Map Voxel Manipulator' -facility. The purpose of this object is for fast, low-level, bulk access to -reading and writing Map content. As such, setting map nodes through VoxelManip -will lack many of the higher level features and concepts you may be used to -with other methods of setting nodes. For example, nodes will not have their -construction and destruction callbacks run, and no rollback information is -logged.
-It is important to note that VoxelManip is designed for speed, and not ease
-of use or flexibility. If your mod requires a map manipulation facility that
-will handle 100% of all edge cases, or the use of high level node placement
-features, perhaps minetest.set_node() is better suited for the job.
In addition, VoxelManip might not be faster, or could even be slower, for your
-specific use case. VoxelManip is most effective when setting large areas of map
-at once - for example, if only setting a 3x3x3 node area, a
-minetest.set_node() loop may be more optimal. Always profile code using both
-methods of map manipulation to determine which is most appropriate for your
-usage.
A recent simple test of setting cubic areas showed that minetest.set_node()
-is faster than a VoxelManip for a 3x3x3 node cube or smaller.
A VoxelManip object can be created any time using either:
-VoxelManip([p1, p2]), or minetest.get_voxel_manip([p1, p2]).
If the optional position parameters are present for either of these routines,
-the specified region will be pre-loaded into the VoxelManip object on creation.
-Otherwise, the area of map you wish to manipulate must first be loaded into the
-VoxelManip object using VoxelManip:read_from_map().
Note that VoxelManip:read_from_map() returns two position vectors. The region
-formed by these positions indicate the minimum and maximum (respectively)
-positions of the area actually loaded in the VoxelManip, which may be larger
-than the area requested. For convenience, the loaded area coordinates can also
-be queried any time after loading map data with VoxelManip:get_emerged_area().
Now that the VoxelManip object is populated with map data, your mod can fetch a
-copy of this data using either of two methods. VoxelManip:get_node_at(),
-which retrieves an individual node in a MapNode formatted table at the position
-requested is the simplest method to use, but also the slowest.
Nodes in a VoxelManip object may also be read in bulk to a flat array table -using:
-VoxelManip:get_data() for node content (in Content ID form, see section
- 'Content IDs'),VoxelManip:get_light_data() for node light levels, andVoxelManip:get_param2_data() for the node type-dependent "param2" values.See section 'Flat array format' for more details.
-It is very important to understand that the tables returned by any of the above -three functions represent a snapshot of the VoxelManip's internal state at the -time of the call. This copy of the data will not magically update itself if -another function modifies the internal VoxelManip state. -Any functions that modify a VoxelManip's contents work on the VoxelManip's -internal state unless otherwise explicitly stated.
-Once the bulk data has been edited to your liking, the internal VoxelManip -state can be set using:
-VoxelManip:set_data() for node content (in Content ID form, see section
- 'Content IDs'),VoxelManip:set_light_data() for node light levels, andVoxelManip:set_param2_data() for the node type-dependent param2 values.The parameter to each of the above three functions can use any table at all in
-the same flat array format as produced by get_data() etc. and is not required
-to be a table retrieved from get_data().
Once the internal VoxelManip state has been modified to your liking, the
-changes can be committed back to the map by calling VoxelManip:write_to_map()
Let
- Nx = p2.X - p1.X + 1,
- Ny = p2.Y - p1.Y + 1, and
- Nz = p2.Z - p1.Z + 1.
Then, for a loaded region of p1..p2, this array ranges from 1 up to and
-including the value of the expression Nx * Ny * Nz.
Positions offset from p1 are present in the array with the format of:
-[
- (0, 0, 0), (1, 0, 0), (2, 0, 0), ... (Nx, 0, 0),
- (0, 1, 0), (1, 1, 0), (2, 1, 0), ... (Nx, 1, 0),
- ...
- (0, Ny, 0), (1, Ny, 0), (2, Ny, 0), ... (Nx, Ny, 0),
- (0, 0, 1), (1, 0, 1), (2, 0, 1), ... (Nx, 0, 1),
- ...
- (0, Ny, 2), (1, Ny, 2), (2, Ny, 2), ... (Nx, Ny, 2),
- ...
- (0, Ny, Nz), (1, Ny, Nz), (2, Ny, Nz), ... (Nx, Ny, Nz)
-]
and the array index for a position p contained completely in p1..p2 is:
-(p.Z - p1.Z) * Ny * Nx + (p.Y - p1.Y) * Nx + (p.X - p1.X) + 1
Note that this is the same "flat 3D array" format as
-PerlinNoiseMap:get3dMap_flat().
-VoxelArea objects (see section 'VoxelArea') can be used to simplify calculation
-of the index for a single point in a flat VoxelManip array.
A Content ID is a unique integer identifier for a specific node type.
-These IDs are used by VoxelManip in place of the node name string for
-VoxelManip:get_data() and VoxelManip:set_data(). You can use
-minetest.get_content_id() to look up the Content ID for the specified node
-name, and minetest.get_name_from_content_id() to look up the node name string
-for a given Content ID.
-After registration of a node, its Content ID will remain the same throughout
-execution of the mod.
-Note that the node being queried needs to have already been been registered.
The following builtin node types have their Content IDs defined as constants:
-minetest.CONTENT_UNKNOWN: ID for "unknown" nodesminetest.CONTENT_AIR: ID for "air" nodesminetest.CONTENT_IGNORE: ID for "ignore" nodesInside of on_generated() callbacks, it is possible to retrieve the same
-VoxelManip object used by the core's Map Generator (commonly abbreviated
-Mapgen). Most of the rules previously described still apply but with a few
-differences:
minetest.get_mapgen_object("voxelmanip")VoxelManip:read_from_map() before using
- a Mapgen VoxelManip.on_generated() callbacks of some mods may place individual nodes in the
- generated area using non-VoxelManip map modification methods. Because the
- same Mapgen VoxelManip object is passed through each on_generated()
- callback, it becomes necessary for the Mapgen VoxelManip object to maintain
- consistency with the current map state. For this reason, calling any of the
- following functions:
- minetest.add_node(), minetest.set_node(), or minetest.swap_node()
- will also update the Mapgen VoxelManip object's internal state active on the
- current thread.VoxelManip:calc_lighting() or VoxelManip:set_lighting().If any VoxelManip contents were set to a liquid node,
-VoxelManip:update_liquids() must be called for these liquid nodes to begin
-flowing. It is recommended to call this function only after having written all
-buffered data back to the VoxelManip object, save for special situations where
-the modder desires to only have certain liquid nodes begin flowing.
The functions minetest.generate_ores() and minetest.generate_decorations()
-will generate all registered decorations and ores throughout the full area
-inside of the specified VoxelManip object.
minetest.place_schematic_on_vmanip() is otherwise identical to
-minetest.place_schematic(), except instead of placing the specified schematic
-directly on the map at the specified position, it will place the schematic
-inside the VoxelManip.
VoxelManip:get_data(), and an
- "ignore" node at any position for VoxelManip:get_node_at().on_generated()
- callback, consider passing a file-scoped table as the optional parameter to
- VoxelManip:get_data(), which serves as a static buffer the function can use
- to write map data to instead of returning a new table each call. This greatly
- enhances performance by avoiding unnecessary memory allocations.read_from_map(p1, p2): Loads a chunk of map into the VoxelManip object
- containing the region formed by p1 and p2.pmin, actual emerged pmaxwrite_to_map([light]): Writes the data loaded from the VoxelManip back to
- the map.VoxelManip:set_data() before
- calling this.light is true, then lighting is automatically recalculated.
- The default value is true.
- If light is false, no light calculations happen, and you should correct
- all modified blocks with minetest.fix_light() as soon as possible.
- Keep in mind that modifying the map where light is incorrect can cause
- more lighting bugs.get_node_at(pos): Returns a MapNode table of the node currently loaded in
- the VoxelManip at that positionset_node_at(pos, node): Sets a specific MapNode in the VoxelManip at
- that position.get_data([buffer]): Retrieves the node content data loaded into the
- VoxelManip object.buffer is present, this table will be used to store the
- result instead.set_data(data): Sets the data contents of the VoxelManip objectupdate_map(): Does nothing, kept for compatibility.set_lighting(light, [p1, p2]): Set the lighting within the VoxelManip to
- a uniform value.
-get_light_data(): Gets the light data read into the VoxelManip object
-set_light_data(light_data): Sets the param1 (light) contents of each node
- in the VoxelManip.get_light_data() returnsget_param2_data([buffer]): Gets the raw param2 data read into the
- VoxelManip object.
-set_param2_data(param2_data): Sets the param2 contents of each node in
- the VoxelManip.calc_lighting([p1, p2], [propagate_shadow]): Calculate lighting within the
- VoxelManip.VoxelManip object from
- minetest.get_mapgen_object.p1, p2) is the area in which lighting is set, defaults to the whole
- area if left out or nil.propagate_shadow is an optional boolean deciding whether shadows in a
- generated mapchunk above are propagated down into the mapchunk, defaults
- to true if left out.update_liquids(): Update liquid flowwas_modified(): Returns true or false if the data in the voxel
- manipulator had been modified since the last read from map, due to a call to
- minetest.set_data() on the loaded area elsewhere.get_emerged_area(): Returns actual emerged minimum and maximum positions.VoxelAreaA helper class for voxel areas.
-It can be created via VoxelArea:new{MinEdge=pmin, MaxEdge=pmax}.
-The coordinates are inclusive, like most other things in Minetest.
getExtent(): returns a 3D vector containing the size of the area formed by
- MinEdge and MaxEdge.getVolume(): returns the volume of the area formed by MinEdge and
- MaxEdge.index(x, y, z): returns the index of an absolute position in a flat array
- starting at 1.VoxelManip, raw Schematic specifiers,
- PerlinNoiseMap:get2d/3dMap, and so on.indexp(p): same as above, except takes a vectorposition(i): returns the absolute position vector corresponding to index
- i.contains(x, y, z): check if (x,y,z) is inside area formed by
- MinEdge and MaxEdge.containsp(p): same as above, except takes a vectorcontainsi(i): same as above, except takes an index iiter(minx, miny, minz, maxx, maxy, maxz): returns an iterator that returns
- indices.minx,miny,minz) to (maxx,maxy,maxz) in the order of
- [z [y [x]]].iterp(minp, maxp): same as above, except takes a vectorSettingsAn interface to read config files in the format of minetest.conf.
It can be created via Settings(filename).
get(key): returns a valueget_bool(key, [default]): returns a boolean
-get_np_group(key): returns a NoiseParams tableset(key, value)
-set_bool(key, value)set_np_group(key, value)value is a NoiseParams table.remove(key): returns a boolean (true for success)get_names(): returns {key1,...}write(): returns a boolean (true for success)to_table(): returns {[key1]=value1,...}RaycastA raycast on the map. It works with selection boxes. -Can be used as an iterator in a for loop.
-The map is loaded as the ray advances. If the
-map is modified after the Raycast is created,
-the changes may or may not have an effect on
-the object.
It can be created via Raycast(pos1, pos2, objects, liquids) or
-minetest.raycast(pos1, pos2, objects, liquids) where:
- pos1: start of the ray
- pos2: end of the ray
- objects : if false, only nodes will be returned. Default is true.
- `liquids' : if false, liquid nodes won't be returned. Default is false.
next(): returns a pointed_thingA mapgen object is a construct used in map generation. Mapgen objects can be
-used by an on_generate callback to speed up operations by avoiding
-unnecessary recalculations, these can be retrieved using the
-minetest.get_mapgen_object() function. If the requested Mapgen object is
-unavailable, or get_mapgen_object() was called outside of an on_generate()
-callback, nil is returned.
The following Mapgen objects are currently available:
-voxelmanipThis returns three values; the VoxelManip object to be used, minimum and
-maximum emerged position, in that order. All mapgens support this object.
heightmapReturns an array containing the y coordinates of the ground levels of nodes in -the most recently generated chunk by the current mapgen.
-biomemapReturns an array containing the biome IDs of nodes in the most recently -generated chunk by the current mapgen.
-heatmapReturns an array containing the temperature values of nodes in the most -recently generated chunk by the current mapgen.
-humiditymapReturns an array containing the humidity values of nodes in the most recently -generated chunk by the current mapgen.
-gennotifyReturns a table mapping requested generation notification types to arrays of
-positions at which the corresponding generated structures are located within
-the current chunk. To set the capture of positions of interest to be recorded
-on generate, use minetest.set_gen_notify().
-For decorations, the returned positions are the ground surface 'place_on'
-nodes, not the decorations themselves. A 'simple' type decoration is often 1
-node above the returned position and possibly displaced by 'place_offset_y'.
Possible fields of the table returned are:
- -Decorations have a key in the format of "decoration#id", where id is the
-numeric unique decoration ID.
self:
-on_activate(self, staticdata, dtime_s)dtime_s is the time passed since the object was unloaded, which can
- be used for updating the entity state.on_step(self, dtime)dtime is usually 0.1 seconds, as per the dedicated_server_step
- setting in minetest.conf.on_punch(self, puncher, time_from_last_punch, tool_capabilities, dir)puncher: an 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.on_death(self, killer)killer: an ObjectRef (can be nil)on_rightclick(self, clicker)get_staticdata(self)on_activate when
- the object is instantiated the next time.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, if no seed is provided, the engine
- will create one.
-}
-G: move forward one unit with the pen upF: move forward one unit with the pen down drawing trunks and branchesf: move forward one unit with the pen down drawing leaves (100% chance)T: move forward one unit with the pen down drawing trunks onlyR: move forward one unit with the pen down placing fruitA: replace with rules set AB: replace with rules set BC: replace with rules set CD: replace with rules set Da: 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 infoSpawn a small apple tree:
-pos = {x=230,y=20,z=4}
-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)
-{
- hp_max = 1,
--- ^ For players: Defaults to `minetest.PLAYER_MAX_HP_DEFAULT`
- breath_max = 0,
--- ^ For players only. Defaults to `minetest.PLAYER_MAX_BREATH_DEFAULT`
- zoom_fov = 0.0,
--- ^ For players only. Zoom FOV in degrees.
--- Note that zoom loads and/or generates world beyond the server's
--- maximum send and generate distances, so acts like a telescope.
--- Smaller zoomFOV values increase the distance loaded and/or generated.
--- Defaults to 15 in creative mode, 0 in survival mode.
--- zoom_fov = 0 disables zooming for the player.
- eye_height = 1.625,
--- ^ For players only. Camera height above feet position in nodes.
--- Defaults to 1.625.
- physical = true,
- collide_with_objects = true,
--- ^ Collide with other objects if physical = true.
- weight = 5,
- collisionbox = {-0.5, 0.0, -0.5, 0.5, 1.0, 0.5},
- selectionbox = {-0.5, 0.0, -0.5, 0.5, 1.0, 0.5},
--- ^ Default, uses collision box dimensions when not set.
--- ^ For both boxes: {xmin, ymin, zmin, xmax, ymax, zmax} in nodes from
--- object position.
- pointable = true,
--- ^ Overrides selection box when false.
- visual = "cube" / "sprite" / "upright_sprite" / "mesh" / "wielditem",
--- ^ "cube" is a node-sized cube.
--- ^ "sprite" is a flat texture always facing the player.
--- ^ "upright_sprite" is a vertical flat texture.
--- ^ "mesh" uses the defined mesh model.
--- ^ "wielditem" is used for dropped items
--- (see builtin/game/item_entity.lua).
--- For this use 'textures = {itemname}'.
--- If the item has a 'wield_image' the object will be an extrusion of
--- that, otherwise:
--- If 'itemname' is a cubic node or nodebox the object will appear
--- identical to 'itemname'.
--- If 'itemname' is a plantlike node the object will be an extrusion of
--- its texture.
--- Otherwise for non-node items, the object will be an extrusion of
--- 'inventory_image'.
- visual_size = {x = 1, y = 1},
--- ^ `x` multiplies horizontal (X and Z) visual size.
--- ^ `y` multiplies vertical (Y) visual size.
- mesh = "model",
- textures = {},
--- ^ Number of required textures depends on visual.
--- ^ "cube" uses 6 textures in the way a node does.
--- ^ "sprite" uses 1 texture.
--- ^ "upright_sprite" uses 2 textures: {front, back}.
--- ^ "wielditem" expects 'textures = {itemname}' (see 'visual' above).
- colors = {},
--- ^ Number of required colors depends on visual.
- use_texture_alpha = false,
--- ^ Use texture's alpha channel, excludes "upright_sprite" and "wielditem"
--- ^ Note: currently causes visual issues when viewed through other
--- ^ semi-transparent materials such as water.
- spritediv = {x = 1, y = 1},
--- ^ Used with spritesheet textures for animation and/or frame selection
--- according to position relative to player.
--- ^ Defines the number of columns and rows in the spritesheet:
--- {columns, rows}.
- initial_sprite_basepos = {x = 0, y = 0},
--- ^ Used with spritesheet textures.
--- ^ Defines the {column, row} position of the initially used frame in the
--- spritesheet.
- is_visible = true,
- makes_footstep_sound = false,
- automatic_rotate = 0,
--- ^ Set constant rotation in radians per second, positive or negative.
--- ^ Set to 0 to disable constant rotation.
- stepheight = 0,
- automatic_face_movement_dir = 0.0,
--- ^ Automatically set yaw to movement direction, offset in degrees,
--- 'false' to disable.
- automatic_face_movement_max_rotation_per_sec = -1,
--- ^ Limit automatic rotation to this value in degrees per second,
--- value < 0 no limit.
- backface_culling = true,
--- ^ Set to false to disable backface_culling for model.
- glow = 0,
--- ^ Add this much extra lighting when calculating texture color.
--- Value < 0 disables light's effect on texture color.
--- For faking self-lighting, UI style entities, or programmatic coloring
--- in mods.
- nametag = "",
--- ^ By default empty, for players their name is shown if empty.
- nametag_color = <color>,
--- ^ Sets color of nametag as ColorSpec.
- infotext = "",
--- ^ By default empty, text to be shown when pointed at object.
- static_save = true,
--- ^ If false, never save this object statically. It will simply be
--- deleted when the block gets unloaded.
--- The get_staticdata() callback is never called then.
--- Defaults to 'true'
-}
-register_entity){
--- Deprecated: Everything in object properties is read directly from here
-
- initial_properties = --[[<initial object properties>]],
-
- on_activate = function(self, staticdata, dtime_s),
- on_step = function(self, dtime),
- on_punch = function(self, puncher, time_from_last_punch, tool_capabilities, dir),
- on_rightclick = function(self, clicker),
- get_staticdata = function(self),
--- ^ Called sometimes; the string returned is passed to on_activate when
--- the entity is re-activated from static state
-
- _custom_field = whatever,
--- ^ You can define arbitrary member variables here (see item definition
--- for more info) by using a '_' prefix.
-}
-register_abm){
- label = "Lava cooling",
- ^ Descriptive label for profiling purposes (optional).
- Definitions with identical labels will be listed as one.
- nodenames = {"default:lava_source"},
- ^ Apply `action` function to these nodes.
- ^ `group:groupname` can also be used here.
- neighbors = {"default:water_source", "default:water_flowing"},
- ^ Only apply `action` to nodes that have one of, or any
- combination of, these neighbors.
- ^ If left out or empty, any neighbor will do.
- ^ `group:groupname` can also be used here.
- interval = 1.0,
- ^ Operation interval in seconds.
- chance = 1,
- ^ Chance of triggering `action` per-node per-interval is 1.0 / this
- value.
- catch_up = true,
- ^ If true, catch-up behaviour is enabled: The `chance` value is
- temporarily reduced when returning to an area to simulate time lost
- by the area being unattended. Note that the `chance` value can often
- be reduced to 1.
- action = function(pos, node, active_object_count, active_object_count_wider),
- ^ Function triggered for each qualifying node.
- ^ `active_object_count` is number of active objects in the node's
- mapblock.
- ^ `active_object_count_wider` is number of active objects in the node's
- mapblock plus all 26 neighboring mapblocks. If any neighboring
- mapblocks are unloaded an estmate is calculated for them based on
- loaded mapblocks.
-}
-register_lbm){
- label = "Upgrade legacy doors",
--- ^ Descriptive label for profiling purposes (optional).
--- Definitions with identical labels will be listed as one.
- name = "modname:replace_legacy_door",
- nodenames = {"default:lava_source"},
--- ^ List of node names to trigger the LBM on.
--- Also non-registered nodes will work.
--- Groups (as of group:groupname) will work as well.
- run_at_every_load = false,
--- ^ Whether to run the LBM's action every time a block gets loaded,
--- and not just for blocks that were saved last time before LBMs were
--- introduced to the world.
- action = func(pos, node),
-}
-register_node, register_craftitem, register_tool){
- description = "Steel Axe",
- groups = {}, -- key = name, value = rating; rating = 1..3.
- if rating not applicable, use 1.
- e.g. {wool = 1, fluffy = 3}
- {soil = 2, outerspace = 1, crumbly = 1}
- {bendy = 2, snappy = 1},
- {hard = 1, metal = 1, spikes = 1}
- inventory_image = "default_tool_steelaxe.png",
- inventory_overlay = "overlay.png",
- ^ An overlay which does not get colorized.
- wield_image = "",
- wield_overlay = "",
- palette = "",
- --[[
- ^ An image file containing the palette of a node.
- ^ You can set the currently used color as the
- ^ "palette_index" field of the item stack metadata.
- ^ The palette is always stretched to fit indices
- ^ between 0 and 255, to ensure compatibility with
- ^ "colorfacedir" and "colorwallmounted" nodes.
- ]]
- color = "0xFFFFFFFF",
- ^ The color of the item. The palette overrides this.
- wield_scale = {x = 1, y = 1, z = 1},
- stack_max = 99,
- range = 4.0,
- liquids_pointable = false,
- tool_capabilities = {
- full_punch_interval = 1.0,
- max_drop_level = 0,
- groupcaps = {
- -- For example:
- choppy = {times = {[1] = 2.50, [2] = 1.40, [3] = 1.00},
- uses = 20, maxlevel = 2},
- },
- damage_groups = {groupname = damage},
- },
- node_placement_prediction = nil,
- --[[
- ^ If nil and item is node, prediction is made automatically
- ^ If nil and item is not a node, no prediction is made
- ^ If "" and item is anything, no prediction is made
- ^ 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.
- ]]
- node_dig_prediction = "air",
- --[[
- ^ if "", no prediction is made
- ^ if "air", node is removed
- ^ Otherwise should be name of node which the client immediately places
- upon digging. Server will always update actual result shortly.
- ]]
- sound = {
- breaks = "default_tool_break", -- tools only
- place = --[[<SimpleSoundSpec>]],
- },
-
- on_place = func(itemstack, placer, pointed_thing),
- --[[
- ^ Shall place item and return the leftover itemstack
- ^ The placer may be any ObjectRef or nil.
- ^ default: minetest.item_place ]]
- on_secondary_use = func(itemstack, user, pointed_thing),
- --[[
- ^ Same as on_place but called when pointing at nothing.
- ^ The user may be any ObjectRef or nil.
- ^ pointed_thing : always { type = "nothing" }
- ]]
- on_drop = func(itemstack, dropper, pos),
- --[[
- ^ Shall drop item and return the leftover itemstack
- ^ The dropper may be any ObjectRef or nil.
- ^ default: minetest.item_drop ]]
- on_use = func(itemstack, user, pointed_thing),
- --[[
- ^ default: nil
- ^ Function must return either nil if no item shall be removed from
- inventory, or an itemstack to replace the original itemstack.
- e.g. itemstack:take_item(); return itemstack
- ^ Otherwise, the function is free to do what it wants.
- ^ The user may be any ObjectRef or nil.
- ^ The default functions handle regular use cases.
- ]]
- after_use = func(itemstack, user, node, digparams),
- --[[
- ^ default: nil
- ^ If defined, should return an itemstack and will be called instead of
- wearing out the tool. If returns nil, does nothing.
- If after_use doesn't exist, it is the same as:
- function(itemstack, user, node, digparams)
- itemstack:add_wear(digparams.wear)
- return itemstack
- end
- ^ The user may be any ObjectRef or nil.
- ]]
- _custom_field = whatever,
- --[[
- ^ Add your own custom fields. By convention, all custom field names
- should start with `_` to avoid naming collisions with future engine
- usage.
- ]]
-}
-"image.png"{name="image.png", animation={Tile Animation definition}}{name="image.png", backface_culling=bool, tileable_vertical=bool,
- tileable_horizontal=bool, align_style="node"/"world"/"user", scale=int}glasslike_framed_optional.
- Note: supported by solid nodes and nodeboxes only.scale) nodes,
- instead of just one, in each direction. Works for world-aligned
- textures only.
- Note that as the effect is applied on per-mapblock basis, 16 should
- be equally divisible by scale or you may get wrong results.{name="image.png", color=ColorSpec}image (name){
- type = "vertical_frames",
- aspect_w = 16,
- -- ^ specify width of a frame in pixels
- aspect_h = 16,
- -- ^ specify height of a frame in pixels
- length = 3.0,
- -- ^ specify full loop length
-}
-
-{
- type = "sheet_2d",
- frames_w = 5,
- -- ^ specify width in number of frames
- frames_h = 3,
- -- ^ specify height in number of frames
- frame_length = 0.5,
- -- ^ specify length of a single frame
-}
-register_node){
- -- <all fields allowed in item definitions>,
-
- drawtype = "normal", -- See "Node drawtypes"
- visual_scale = 1.0, --[[
- ^ Supported for drawtypes "plantlike", "signlike", "torchlike",
- ^ "firelike", "mesh".
- ^ For plantlike and firelike, the image will start at the bottom of the
- ^ node, for the other drawtypes the image will be centered on the node.
- ^ Note that positioning for "torchlike" may still change. ]]
- tiles = {tile definition 1, def2, def3, def4, def5, def6}, --[[
- ^ Textures of node; +Y, -Y, +X, -X, +Z, -Z
- ^ Old field name was 'tile_images'.
- ^ List can be shortened to needed length ]]
- overlay_tiles = {tile definition 1, def2, def3, def4, def5, def6}, --[[
- ^ Same as `tiles`, but these textures are drawn on top of the
- ^ base tiles. You can use this to colorize only specific parts of
- ^ your texture. If the texture name is an empty string, that
- ^ overlay is not drawn. Since such tiles are drawn twice, it
- ^ is not recommended to use overlays on very common nodes. ]]
- special_tiles = {tile definition 1, Tile definition 2}, --[[
- ^ Special textures of node; used rarely
- ^ Old field name was 'special_materials'.
- ^ List can be shortened to needed length ]]
- color = ColorSpec, --[[
- ^ The node's original color will be multiplied with this color.
- ^ If the node has a palette, then this setting only has an effect
- ^ in the inventory and on the wield item. ]]
- use_texture_alpha = false,
- ^ Use texture's alpha channel.
- palette = "palette.png", --[[
- ^ The node's `param2` is used to select a pixel from the image
- ^ (pixels are arranged from left to right and from top to bottom).
- ^ The node's color will be multiplied with the selected pixel's
- ^ color. Tiles can override this behavior.
- ^ Only when `paramtype2` supports palettes. ]]
- post_effect_color = "green#0F",
- ^ Screen tint if player is inside node, see "ColorSpec".
- paramtype = "none", --[[
- ^ See "Nodes".
- ^ paramtype = "light" allows light to propagate from or through the
- ^ node with light value falling by 1 per node. This line is essential
- ^ for a light source node to spread its light. ]]
- paramtype2 = "none", -- See "Nodes"
- place_param2 = nil, -- Force value for param2 when player places node
- is_ground_content = true,
- ^ If false, the cave generator will not carve through this node.
- sunlight_propagates = false,
- ^ If true, sunlight will go infinitely through this.
- walkable = true, -- If true, objects collide with node
- pointable = true, -- If true, can be pointed at
- diggable = true, -- If false, can never be dug
- climbable = false, -- If true, can be climbed on (ladder)
- buildable_to = false, -- If true, placed nodes can replace this node
- floodable = false, --[[
- ^ If true, liquids flow into and replace this node.
- ^ Warning: making a liquid node 'floodable' will cause problems. ]]
- liquidtype = "none", -- "none"/"source"/"flowing"
- 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, --[[
- ^ If true, a new liquid source can be created by placing two or more
- sources nearby. ]]
- leveled = 16, --[[
- ^ Only valid for "nodebox" drawtype with 'type = "leveled"'.
- ^ Allows defining the nodebox height without using param2.
- ^ The nodebox height is 'leveled' / 64 nodes.
- ^ The maximum value of 'leveled' is 127. ]]
- liquid_range = 8, -- number of flowing nodes around source (max. 8)
- drowning = 0,
- ^ Player will take this amount of damage if no bubbles are left.
- light_source = 0, --[[
- ^ Amount of light emitted by node.
- ^ To set the maximum (currently 14), use the value
- ^ 'minetest.LIGHT_MAX'.
- ^ A value outside the range 0 to minetest.LIGHT_MAX causes undefined
- ^ behavior.]]
- damage_per_second = 0,
- ^ If player is inside node, this damage is caused.
- node_box = {type="regular"}, -- See "Node boxes"
- connects_to = nodenames, --[[
- ^ Used for nodebox nodes with the type == "connected"
- ^ Specifies to what neighboring nodes connections will be drawn
- ^ e.g. `{"group:fence", "default:wood"}` or `"default:stone"` ]]
- connect_sides = { "top", "bottom", "front", "left", "back", "right" },
- -- [[
- ^ Tells connected nodebox nodes to connect only to these sides of this
- ^ node. ]]
- mesh = "model",
- 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.
- waving = 0, --[[
- ^ Valid for mesh, nodebox, plantlike, allfaces_optional nodes.
- ^ 1 - wave node like plants (top of node moves, bottom is fixed)
- ^ 2 - wave node like leaves (whole node moves side-to-side)
- ^ caveats: not all models will properly wave.
- ^ plantlike drawtype nodes can only wave like plants.
- ^ allfaces_optional drawtype nodes can only wave like leaves. --]]
- sounds = {
- footstep = <SimpleSoundSpec>,
- dig = <SimpleSoundSpec>, -- "__group" = group-based sound (default)
- dug = <SimpleSoundSpec>,
- place = <SimpleSoundSpec>,
- place_failed = <SimpleSoundSpec>,
- },
- drop = "",
- ^ Name of dropped node when dug. Default is the node itself.
- ^ Alternatively:
- drop = {
- max_items = 1, -- Maximum number of items to drop.
- items = { -- Choose max_items randomly from this list.
- {
- items = {"foo:bar", "baz:frob"}, -- Items to drop.
- rarity = 1, -- Probability of dropping is 1 / rarity.
- inherit_color = true, -- To inherit palette color from the
- node.
- },
- },
- },
-
- on_construct = func(pos), --[[
- ^ Node constructor; called after adding node
- ^ Can set up metadata and stuff like that
- ^ Not called for bulk node placement (i.e. schematics and VoxelManip)
- ^ default: nil ]]
-
- on_destruct = func(pos), --[[
- ^ Node destructor; called before removing node
- ^ Not called for bulk node placement (i.e. schematics and VoxelManip)
- ^ default: nil ]]
-
- after_destruct = func(pos, oldnode), --[[
- ^ Node destructor; called after removing node
- ^ Not called for bulk node placement (i.e. schematics and VoxelManip)
- ^ default: nil ]]
-
- on_flood = func(pos, oldnode, newnode), --[[
- ^ Called when a liquid (newnode) is about to flood oldnode, if
- ^ it has `floodable = true` in the nodedef. Not called for bulk
- ^ node placement (i.e. schematics and VoxelManip) or air nodes. If
- ^ return true the node is not flooded, but on_flood callback will
- ^ most likely be called over and over again every liquid update
- ^ interval. Default: nil.
- ^ Warning: making a liquid node 'floodable' will cause problems. ]]
-
- preserve_metadata = func(pos, oldnode, oldmeta, drops) --[[
- ^ Called when oldnode is about be converted to an item, but before the
- ^ node is deleted from the world or the drops are added. This is
- ^ generally the result of either the node being dug or an attached node
- ^ becoming detached.
- ^ drops is a table of ItemStacks, so any metadata to be preserved can
- ^ be added directly to one or more of the dropped items. See
- ^ "ItemStackMetaRef".
- ^ default: nil ]]
-
- after_place_node = func(pos, placer, itemstack, pointed_thing) --[[
- ^ Called after constructing node when node was placed using
- ^ minetest.item_place_node / minetest.place_node
- ^ If return true no item is taken from itemstack
- ^ `placer` may be any valid ObjectRef or nil
- ^ 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.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, pointed_thing), --[[
- ^ default: minetest.node_punch
- ^ By default: Calls minetest.register_on_punchnode callbacks ]]
-
- on_rightclick = func(pos, node, clicker, itemstack, pointed_thing),
- --[[
- ^ default: nil
- ^ itemstack will hold clicker's wielded item
- ^ Shall return the leftover itemstack
- ^ Note: pointed_thing can be nil, if a mod calls this function
- ^ This function does not get triggered by clients <=0.4.16 if the
- ^ "formspec" node metadata field is set ]]
-
- 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 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. ]]
-
- on_receive_fields = func(pos, formname, fields, sender), --[[
- ^ fields = {name1 = value1, name2 = value2, ...}
- ^ Called when an UI form (e.g. 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_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 ]]
-}
-register_craft (shaped){
- output = 'default:pick_stone',
- recipe = {
- {'default:cobble', 'default:cobble', 'default:cobble'},
- {'', 'default:stick', ''},
- {'', 'default:stick', ''}, -- Also groups; e.g. 'group:crumbly'
- },
- replacements = --[[<optional list of item pairs,
- replace one input item with another item on crafting>]]
-}
-register_craft (shapeless){
- type = "shapeless",
- output = 'mushrooms:mushroom_stew',
- recipe = {
- "mushrooms:bowl",
- "mushrooms:mushroom_brown",
- "mushrooms:mushroom_red",
- },
- replacements = --[[<optional list of item pairs,
- replace one input item with another item on crafting>]]
-}
-register_craft (tool repair){
- type = "toolrepair",
- additional_wear = -0.02,
-}
-register_craft (cooking){
- type = "cooking",
- output = "default:glass",
- recipe = "default:sand",
- cooktime = 3,
-}
-register_craft (furnace fuel){
- type = "fuel",
- recipe = "default:leaves",
- burntime = 1,
-}
-register_ore)See 'Ore types' section above for essential information.
-
-{
- ore_type = "scatter",
- ore = "default:stone_with_coal",
- ore_param2 = 3,
--- ^ Facedir rotation. Default is 0 (unchanged rotation)
- wherein = "default:stone",
--- ^ a list of nodenames is supported too
- clust_scarcity = 8 * 8 * 8,
--- ^ Ore has a 1 out of clust_scarcity chance of spawning in a node
--- ^ If the desired average distance between ores is 'd', set this to
--- ^ d * d * d.
- 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 3 * 3 * 3 cluster where 8 out of the 27
--- ^ nodes are coal ore.
- y_min = -31000,
- y_max = 64,
--- ^ Lower and upper limits for ore.
- flags = "",
--- ^ Attributes for this ore generation, see 'Ore attributes' section
--- ^ above.
- noise_threshold = 0.5,
--- ^ If noise is above this threshold, 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.7
- },
--- ^ NoiseParams structure describing one of the perlin noises used for
--- ^ ore distribution.
--- ^ Needed by "sheet", "puff", "blob" and "vein" ores.
--- ^ Omit from "scatter" ore for a uniform ore distribution.
--- ^ Omit from "stratum ore for a simple horizontal strata from y_min to
--- ^ y_max.
- biomes = {"desert", "rainforest"}
--- ^ List of biomes in which this decoration occurs.
--- ^ Occurs in all biomes if this is omitted, and ignored if the Mapgen
--- ^ being used does not support biomes.
--- ^ Can be a list of (or a single) biome names, IDs, or definitions.
- column_height_min = 1,
- column_height_max = 16,
- column_midpoint_factor = 0.5,
--- ^ See 'Ore types' section above.
--- ^ The above 3 parameters are only valid for "sheet" ore.
- np_puff_top = {
- offset = 4,
- scale = 2,
- spread = {x = 100, y = 100, z = 100},
- seed = 47,
- octaves = 3,
- persist = 0.7
- },
- np_puff_bottom = {
- offset = 4,
- scale = 2,
- spread = {x = 100, y = 100, z = 100},
- seed = 11,
- octaves = 3,
- persist = 0.7
- },
--- ^ See 'Ore types' section above.
--- ^ The above 2 parameters are only valid for "puff" ore.
- random_factor = 1.0,
--- ^ See 'Ore types' section above.
--- ^ Only valid for "vein" ore.
- np_stratum_thickness = {
- offset = 8,
- scale = 4,
- spread = {x = 100, y = 100, z = 100},
- seed = 17,
- octaves = 3,
- persist = 0.7
- },
- stratum_thickness = 8,
--- ^ See 'Ore types' section above.
--- ^ The above 2 parameters are only valid for "stratum" ore.
-}
-register_biome){
- name = "tundra",
- node_dust = "default:snow",
--- ^ Node dropped onto upper surface after all else is generated.
- node_top = "default:dirt_with_snow",
- depth_top = 1,
--- ^ Node forming surface layer of biome and thickness of this layer.
- node_filler = "default:permafrost",
- depth_filler = 3,
--- ^ Node forming lower layer of biome and thickness of this layer.
- node_stone = "default:bluestone",
--- ^ Node that replaces all stone nodes between roughly y_min and y_max.
- node_water_top = "default:ice",
- depth_water_top = 10,
--- ^ Node forming a surface layer in seawater with the defined thickness.
- node_water = "",
--- ^ Node that replaces all seawater nodes not in the defined surface
--- ^ layer.
- node_river_water = "default:ice",
--- ^ Node that replaces river water in mapgens that use
--- ^ default:river_water.
- node_riverbed = "default:gravel",
- depth_riverbed = 2,
--- ^ Node placed under river water and thickness of this layer.
- y_max = 31000,
- y_min = 1,
--- ^ Upper and lower limits for biome.
--- ^ Alternatively you can use xyz limits as shown below.
- max_pos = {x = 31000, y = 128, z = 31000},
- min_pos = {x = -31000, y = 9, z = -31000},
--- ^ xyz limits for biome, an alternative to using 'y_min' and 'y_max'.
--- ^ Biome is limited to a cuboid defined by these positions.
--- ^ Any x, y or z field left undefined defaults to -31000 in 'min_pos' or
--- ^ 31000 in 'max_pos'.
- vertical_blend = 8,
--- ^ Vertical distance in nodes above 'y_max' over which the biome will
--- ^ blend with the biome above.
--- ^ Set to 0 for no vertical blend. Defaults to 0.
- heat_point = 0,
- humidity_point = 50,
--- ^ Characteristic temperature and humidity for the biome.
--- ^ These values create 'biome points' on a voronoi diagram with heat and
--- ^ humidity as axes. The resulting voronoi cells determine the
--- ^ distribution of the biomes.
--- ^ Heat and humidity have average values of 50, vary mostly between
--- ^ 0 and 100 but can exceed these values.
-}
-register_decoration){
- deco_type = "simple", -- See "Decoration types"
- place_on = "default:dirt_with_grass",
--- ^ Node (or list of nodes) that the decoration can be placed on
- sidelen = 8,
--- ^ Size of the square divisions of the mapchunk being generated.
--- ^ Determines the resolution of noise variation if used.
--- ^ If the chunk size is not evenly divisible by sidelen, sidelen is made
--- ^ equal to the chunk size.
- fill_ratio = 0.02,
--- ^ The value determines 'decorations per surface node'.
--- ^ Used only if noise_params is not specified.
- noise_params = {
- offset = 0,
- scale = 0.45,
- spread = {x = 100, y = 100, z = 100},
- seed = 354,
- octaves = 3,
- persist = 0.7,
- lacunarity = 2.0,
- flags = "absvalue"
- },
--- ^ NoiseParams structure describing the perlin noise used for decoration
--- ^ distribution.
--- ^ A noise value is calculated for each square division and determines
--- ^ 'decorations per surface node' within each division.
- biomes = {"Oceanside", "Hills", "Plains"},
--- ^ List of biomes in which this decoration occurs. Occurs in all biomes
--- ^ if this is omitted, and ignored if the Mapgen being used does not
--- ^ support biomes.
--- ^ Can be a list of (or a single) biome names, IDs, or definitions.
- y_min = -31000
- y_max = 31000
--- ^ Lower and upper limits for decoration.
--- ^ These parameters refer to the Y co-ordinate of the 'place_on' node.
- spawn_by = "default:water",
--- ^ Node (or list of nodes) that the decoration only spawns next to.
--- ^ Checks two horizontal planes of 8 neighbouring nodes (including
--- ^ diagonal neighbours), one plane level with the 'place_on' node and a
--- ^ plane one node above that.
- num_spawn_by = 1,
--- ^ Number of spawn_by nodes that must be surrounding the decoration
--- ^ position to occur.
--- ^ If absent or -1, decorations occur next to any nodes.
- flags = "liquid_surface, force_placement, all_floors, all_ceilings",
--- ^ Flags for all decoration types.
--- ^ "liquid_surface": Instead of placement on the highest solid surface
--- ^ in a mapchunk column, placement is on the highest liquid surface.
--- ^ Placement is disabled if solid nodes are found above the liquid
--- ^ surface.
--- ^ "force_placement": Nodes other than "air" and "ignore" are replaced
--- ^ by the decoration.
--- ^ "all_floors", "all_ceilings": Instead of placement on the highest
--- ^ surface in a mapchunk the decoration is placed on all floor and/or
--- ^ ceiling surfaces, for example in caves.
--- ^ Ceiling decorations act as an inversion of floor decorations so the
--- ^ effect of 'place_offset_y' is inverted.
--- ^ If a single decoration registration has both flags the floor and
--- ^ ceiling decorations will be aligned vertically and may sometimes
--- ^ meet to form a column.
-
- ----- Simple-type parameters
- decoration = "default:grass",
--- ^ The node name used as the decoration.
--- ^ If instead a list of strings, a randomly selected node from the list
--- ^ is placed as the decoration.
- height = 1,
--- ^ Decoration height in nodes.
--- ^ If height_max is not 0, this is the lower limit of a randomly
--- ^ selected height.
- height_max = 0,
--- ^ Upper limit of the randomly selected height.
--- ^ If absent, the parameter 'height' is used as a constant.
- param2 = 0,
--- ^ Param2 value of decoration nodes.
--- ^ If param2_max is not 0, this is the lower limit of a randomly
--- ^ selected param2.
- param2_max = 0,
--- ^ Upper limit of the randomly selected param2.
--- ^ If absent, the parameter 'param2' is used as a constant.
- place_offset_y = 0,
--- ^ Y offset of the decoration base node relative to the standard base
--- ^ node position.
--- ^ Can be positive or negative. Default is 0.
--- ^ Effect is inverted for "all_ceilings" decorations.
--- ^ Ignored by 'y_min', 'y_max' and 'spawn_by' checks, which always refer
--- ^ to the 'place_on' node.
-
- ----- Schematic-type parameters
- schematic = "foobar.mts",
--- ^ If schematic is a string, it is the filepath relative to the current
--- ^ working directory of the specified Minetest schematic file.
--- ^ - OR -, could be the ID of a previously registered schematic
--- ^ - OR -, could instead be a table containing two mandatory fields,
--- ^ size and data, and an optional table yslice_prob:
- schematic = {
- size = {x = 4, y = 6, z = 4},
- data = {
- {name = "default:cobble", param1 = 255, param2 = 0},
- {name = "default:dirt_with_grass", param1 = 255, param2 = 0},
- {name = "air", param1 = 255, param2 = 0},
- ...
- },
- yslice_prob = {
- {ypos = 2, prob = 128},
- {ypos = 5, prob = 64},
- ...
- },
- },
--- ^ See 'Schematic specifier' for details.
- replacements = {["oldname"] = "convert_to", ...},
- flags = "place_center_x, place_center_y, place_center_z",
--- ^ Flags for schematic decorations. See 'Schematic attributes'.
- rotation = "90",
--- ^ Rotation can be "0", "90", "180", "270", or "random".
- place_offset_y = 0,
--- ^ If the flag 'place_center_y' is set this parameter is ignored.
--- ^ Y offset of the schematic base node layer relative to the 'place_on'
--- ^ node.
--- ^ Can be positive or negative. Default is 0.
--- ^ Effect is inverted for "all_ceilings" decorations.
--- ^ Ignored by 'y_min', 'y_max' and 'spawn_by' checks, which always refer
--- ^ to the 'place_on' node.
-}
-register_chatcommand){
- params = "<name> <privilege>", -- Short parameter description
- description = "Remove privilege from player", -- Full description
- privs = {privs=true}, -- Require the "privs" privilege to run
- func = function(name, param), -- Called when command is run.
- -- Returns boolean success and text
- -- output.
-}
-Note that in params, use of symbols is as follows:
-<> signifies a placeholder to be replaced when the command is used. For
- example, when a player name is needed: <name>[] signifies param is optional and not required when the command is used.
- For example, if you require param1 but param2 is optional:
- <param1> [<param2>]| signifies exclusive or. The command requires one param from the options
- provided. For example: <param1> | <param2>() signifies grouping. For example, when param1 and param2 are both
- required, or only param3 is required: (<param1> <param2>) | <param3>{
- 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
-
- 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
-
- 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),
- 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
-}
-hud_add, hud_get){
- hud_elem_type = "image", -- see HUD element types
--- ^ type of HUD element, can be either of "image", "text", "statbar",
- "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"
- size = { x=100, y=100 },
--- ^ Size of element in pixels
-}
-add_particle){
- pos = {x=0, y=0, z=0},
- velocity = {x=0, y=0, z=0},
- acceleration = {x=0, y=0, z=0},
--- ^ Spawn particle at pos with velocity and acceleration
- expirationtime = 1,
--- ^ Disappears after expirationtime seconds
- size = 1,
- collisiondetection = false,
--- ^ collisiondetection: if true collides with physical objects
- collision_removal = false,
--- ^ collision_removal: if true then particle is removed when it collides,
--- ^ requires collisiondetection = true to have any effect
- vertical = false,
--- ^ vertical: if true faces player using y axis only
- texture = "image.png",
--- ^ Uses texture (string)
- playername = "singleplayer",
--- ^ optional, if specified spawns particle only on the player's client
- animation = {Tile Animation definition},
--- ^ optional, specifies how to animate the particle texture
- glow = 0
--- ^ optional, specify particle self-luminescence in darkness
-}
-ParticleSpawner definition (add_particlespawner){
- amount = 1,
- time = 1,
--- ^ If time is 0 has infinite lifespan and spawns the amount on a
--- ^ per-second basis.
- minpos = {x=0, y=0, z=0},
- maxpos = {x=0, y=0, z=0},
- minvel = {x=0, y=0, z=0},
- maxvel = {x=0, y=0, z=0},
- minacc = {x=0, y=0, z=0},
- maxacc = {x=0, y=0, z=0},
- minexptime = 1,
- maxexptime = 1,
- minsize = 1,
- maxsize = 1,
--- ^ The particle's properties are random values in between the bounds:
--- ^ minpos/maxpos, minvel/maxvel (velocity),
--- ^ minacc/maxacc (acceleration), minsize/maxsize,
--- ^ minexptime/maxexptime (expirationtime).
- collisiondetection = false,
--- ^ collisiondetection: if true uses collision detection
- collision_removal = false,
--- ^ collision_removal: if true then particle is removed when it collides,
--- ^ requires collisiondetection = true to have any effect
- attached = ObjectRef,
--- ^ attached: if defined, particle positions, velocities and
--- ^ accelerations are relative to this object's position and yaw.
- vertical = false,
--- ^ vertical: if true faces player using y axis only
- texture = "image.png",
--- ^ Uses texture (string)
- playername = "singleplayer"
--- ^ Playername is optional, if specified spawns particle only on the
--- ^ player's client.
- animation = {Tile Animation definition},
--- ^ optional, specifies how to animate the particle texture
- glow = 0
--- ^ optional, specify particle self-luminescence in darkness
-}
-HTTPRequest definition (HTTPApiTable.fetch_async, HTTPApiTable.fetch_async){
- url = "http://example.org",
- timeout = 10,
--- ^ Timeout for connection in seconds. Default is 3 seconds.
- post_data = "Raw POST request data string" OR {field1 = "data1", field2 = "data2"},
--- ^ Optional, if specified a POST request with post_data is performed.
--- ^ Accepts both a string and a table. If a table is specified, encodes
--- ^ table as x-www-form-urlencoded key-value pairs.
--- ^ If post_data ist not specified, a GET request is performed instead.
- user_agent = "ExampleUserAgent",
--- ^ Optional, if specified replaces the default minetest user agent with
--- ^ given string.
- extra_headers = { "Accept-Language: en-us", "Accept-Charset: utf-8" },
--- ^ Optional, if specified adds additional headers to the HTTP request.
--- ^ You must make sure that the header strings follow HTTP specification
--- ^ ("Key: Value").
- multipart = boolean
--- ^ Optional, if true performs a multipart HTTP request.
--- ^ Default is false.
-}
-HTTPRequestResult definition (HTTPApiTable.fetch callback, HTTPApiTable.fetch_async_get){
- completed = true,
--- ^ If true, the request has finished (either succeeded, failed or timed
- out).
- succeeded = true,
--- ^ If true, the request was successful
- timeout = false,
--- ^ If true, the request timed out
- code = 200,
--- ^ HTTP status code
- data = "response"
-}
-{
- get_auth = func(name),
--- ^ Get authentication data for existing player `name` (`nil` if player
- doesn't exist).
--- ^ returns following structure:
--- ^ `{password=<string>, privileges=<table>, last_login=<number or nil>}`
- create_auth = func(name, password),
--- ^ Create new auth data for player `name`
--- ^ Note that `password` is not plain-text but an arbitrary
--- ^ representation decided by the engine
- delete_auth = func(name),
--- ^ Delete auth data of player `name`, returns boolean indicating success
--- ^ (false if player nonexistant).
- set_password = func(name, password),
--- ^ Set password of player `name` to `password`
- Auth data should be created if not present
- set_privileges = func(name, privileges),
--- ^ Set privileges of player `name`
--- ^ `privileges` is in table form, auth data should be created if not
--- ^ present.
- reload = func(),
--- ^ Reload authentication data from the storage location
--- ^ Returns boolean indicating success
- record_login = func(name),
--- ^ Called when player joins, used for keeping track of last_login
- iterate = func(),
--- ^ Returns an iterator (use with `for` loops) for all player names
--- ^ currently in the auth database.
-}
-
-for li in lis:
- code = li.find_all('code')
- if len(code) > 0:
- key = get_key(index, li, code[0].string)
- if key is not None:
- index[key] = True
- #print("Created " + key)
- new_tag = soup.new_tag('a', href="#" + key)
- new_tag['class'] = "anchor"
- new_tag['name'] = key
- new_tag.string = "#"
- li.insert(0, new_tag)
-
-
-html = str(soup)
-
-#
-# Writing to file
-#
-print("Writing to file...")
-file = open("lua_api.html", "w")
-file.write("---\ntitle: Lua Modding API Reference\nlayout: default\n---\n")
-file.write("\n")
-file.write("This is lua_api.txt nicely formated: I did not write this
\n")
-file.write(credit)
-file.write("\n")
-file.write("Table of Contents
\n")
-file.write(md.toc)
-file.write(html)
-file.close()
-
-print("Done")