From 68f9263a24a345435d2310ab559ce8a811ef0427 Mon Sep 17 00:00:00 2001
From: Elias Fleckenstein <eliasfleckenstein@web.de>
Date: Wed, 13 May 2020 19:41:30 +0200
Subject: Hacked Client

---
 doc/client_lua_api.md | 1451 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1451 insertions(+)
 create mode 100644 doc/client_lua_api.md

(limited to 'doc/client_lua_api.md')

diff --git a/doc/client_lua_api.md b/doc/client_lua_api.md
new file mode 100644
index 000000000..c24de8d85
--- /dev/null
+++ b/doc/client_lua_api.md
@@ -0,0 +1,1451 @@
+Minetest Lua Client Modding API Reference 5.2.0
+================================================
+* More information at <http://www.minetest.net/>
+* Developer Wiki: <http://dev.minetest.net/>
+
+Introduction
+------------
+
+** WARNING: The client API is currently unstable, and may break/change without warning. **
+
+Content and functionality can be added to Minetest 0.4.15-dev+ by using Lua
+scripting in run-time loaded mods.
+
+A mod is a self-contained bunch of scripts, textures and other related
+things that is loaded by and interfaces with Minetest.
+
+Transferring client-sided mods from the server to the client is planned, but not implemented yet.
+
+If you see a deficiency in the API, feel free to attempt to add the
+functionality in the engine and API. You can send such improvements as
+source code patches on GitHub (https://github.com/minetest/minetest).
+
+Programming in Lua
+------------------
+If you have any difficulty in understanding this, please read
+[Programming in Lua](http://www.lua.org/pil/).
+
+Startup
+-------
+Mods are loaded during client startup from the mod load paths by running
+the `init.lua` scripts in a shared environment.
+
+In order to load client-side mods, the following conditions need to be satisfied:
+
+1) `$path_user/minetest.conf` contains the setting `enable_client_modding = true`
+
+2) The client-side mod located in `$path_user/clientmods/<modname>` is added to
+    `$path_user/clientmods/mods.conf` as `load_mod_<modname> = true`.
+
+Note: Depending on the remote server's settings, client-side mods might not
+be loaded or have limited functionality. See setting `csm_restriction_flags` for reference.
+
+Paths
+-----
+* `RUN_IN_PLACE=1` (Windows release, local build)
+    * `$path_user`: `<build directory>`
+    * `$path_share`: `<build directory>`
+* `RUN_IN_PLACE=0`: (Linux release)
+    * `$path_share`:
+        * Linux: `/usr/share/minetest`
+        * Windows: `<install directory>/minetest-0.4.x`
+    * `$path_user`:
+        * Linux: `$HOME/.minetest`
+        * Windows: `C:/users/<user>/AppData/minetest` (maybe)
+
+Mod load path
+-------------
+Generic:
+
+* `$path_share/clientmods/`
+* `$path_user/clientmods/` (User-installed mods)
+
+In a run-in-place version (e.g. the distributed windows version):
+
+* `minetest-0.4.x/clientmods/` (User-installed mods)
+
+On an installed version on Linux:
+
+* `/usr/share/minetest/clientmods/`
+* `$HOME/.minetest/clientmods/` (User-installed mods)
+
+Modpack support
+----------------
+
+Mods can be put in a subdirectory, if the parent directory, which otherwise
+should be a mod, contains a file named `modpack.conf`.
+The file is a key-value store of modpack details.
+
+* `name`: The modpack name.
+* `description`: Description of mod to be shown in the Mods tab of the main
+                 menu.
+
+Mod directory structure
+------------------------
+
+    clientmods
+    ├── modname
+    │   ├── mod.conf
+    │   ├── init.lua
+    └── another
+
+### modname
+
+The location of this directory.
+
+### mod.conf
+
+An (optional) settings file that provides meta information about the mod.
+
+* `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 main
+                 menu.
+* `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.
+
+### `init.lua`
+
+The main Lua script. Running this script should register everything it
+wants to register. Subsequent execution depends on minetest calling the
+registered callbacks.
+
+**NOTE**: Client mods currently can't provide and textures, sounds or models by
+themselves. Any media referenced in function calls must already be loaded
+(provided by mods that exist on the server).
+
+Naming convention for registered textual names
+----------------------------------------------
+Registered names should generally be in this format:
+
+    "modname:<whatever>" (<whatever> can have characters a-zA-Z0-9_)
+
+This is to prevent conflicting names from corrupting maps and is
+enforced by the mod loader.
+
+### Example
+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.
+
+Sounds
+------
+**NOTE: Connecting sounds to objects is not implemented.**
+
+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.ogg`
+* `foomod_foosound.0.ogg`
+* `foomod_foosound.1.ogg`
+* (...)
+* `foomod_foosound.9.ogg`
+
+Examples of sound parameter tables:
+
+    -- Play locationless
+    {
+        gain = 1.0, -- default
+    }
+    -- Play locationless, looped
+    {
+        gain = 1.0, -- default
+        loop = true,
+    }
+    -- Play in a location
+    {
+        pos = {x = 1, y = 2, z = 3},
+        gain = 1.0, -- default
+    }
+    -- Play connected to an object, looped
+    {
+        object = <an ObjectRef>,
+        gain = 1.0, -- default
+        loop = true,
+    }
+
+Looped sounds must either be connected to an object or played locationless.
+
+### SimpleSoundSpec
+* e.g. `""`
+* e.g. `"default_place_node"`
+* e.g. `{}`
+* e.g. `{name = "default_place_node"}`
+* e.g. `{name = "default_place_node", gain = 1.0}`
+
+Representations of simple things
+--------------------------------
+
+### Position/vector
+
+    {x=num, y=num, z=num}
+
+For helper functions see "Vector helpers".
+
+### pointed_thing
+* `{type="nothing"}`
+* `{type="node", under=pos, above=pos}`
+* `{type="object", id=ObjectID}`
+
+Flag Specifier Format
+---------------------
+Flags 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.
+
+Formspec
+--------
+Formspec defines a menu. It is a string, with a somewhat strange format.
+
+Spaces and newlines can be inserted between the blocks, as is used in the
+examples.
+
+### Examples
+
+#### Chest
+
+    size[8,9]
+    list[context;main;0,0;8,4;]
+    list[current_player;main;0,5;8,4;]
+
+#### Furnace
+
+    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;]
+
+#### Minecraft-like player inventory
+
+    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;]
+
+### Elements
+
+#### `size[<W>,<H>,<fixed_size>]`
+* Define the size of the menu in inventory slots
+* `fixed_size`: `true`/`false` (optional)
+* deprecated: `invsize[<W>,<H>;]`
+
+#### `container[<X>,<Y>]`
+* Start of a container block, moves all physical elements in the container by (X, Y)
+* Must have matching container_end
+* Containers can be nested, in which case the offsets are added
+  (child containers are relative to parent containers)
+
+#### `container_end[]`
+* End of a container, following elements are no longer relative to this container
+
+#### `list[<inventory location>;<list name>;<X>,<Y>;<W>,<H>;]`
+* Show an inventory list
+
+#### `list[<inventory location>;<list name>;<X>,<Y>;<W>,<H>;<starting item index>]`
+* Show an inventory list
+
+#### `listring[<inventory location>;<list name>]`
+* Allows to create a ring of inventory lists
+* Shift-clicking on items in one element of the ring
+  will send them to the next inventory list inside the ring
+* The first occurrence of an element inside the ring will
+  determine the inventory where items will be sent to
+
+#### `listring[]`
+* Shorthand for doing `listring[<inventory location>;<list name>]`
+  for the last two inventory lists added by list[...]
+
+#### `listcolors[<slot_bg_normal>;<slot_bg_hover>]`
+* Sets background color of slots as `ColorString`
+* Sets background color of slots on mouse hovering
+
+#### `listcolors[<slot_bg_normal>;<slot_bg_hover>;<slot_border>]`
+* Sets background color of slots as `ColorString`
+* Sets background color of slots on mouse hovering
+* Sets color of slots border
+
+#### `listcolors[<slot_bg_normal>;<slot_bg_hover>;<slot_border>;<tooltip_bgcolor>;<tooltip_fontcolor>]`
+* Sets background color of slots as `ColorString`
+* Sets background color of slots on mouse hovering
+* Sets color of slots border
+* Sets default background color of tooltips
+* Sets default font color of tooltips
+
+#### `tooltip[<gui_element_name>;<tooltip_text>;<bgcolor>,<fontcolor>]`
+* Adds tooltip for an element
+* `<bgcolor>` tooltip background color as `ColorString` (optional)
+* `<fontcolor>` tooltip font color as `ColorString` (optional)
+
+#### `image[<X>,<Y>;<W>,<H>;<texture name>]`
+* Show an image
+* Position and size units are inventory slots
+
+#### `item_image[<X>,<Y>;<W>,<H>;<item name>]`
+* Show an inventory image of registered item/node
+* Position and size units are inventory slots
+
+#### `bgcolor[<color>;<fullscreen>]`
+* Sets background color of formspec as `ColorString`
+* If `true`, the background color is drawn fullscreen (does not effect the size of the formspec)
+
+#### `background[<X>,<Y>;<W>,<H>;<texture name>]`
+* Use a background. Inventory rectangles are not drawn then.
+* Position and size units are inventory slots
+* Example for formspec 8x4 in 16x resolution: image shall be sized
+  8 times 16px  times  4 times 16px.
+
+#### `background[<X>,<Y>;<W>,<H>;<texture name>;<auto_clip>]`
+* Use a background. Inventory rectangles are not drawn then.
+* Position and size units are inventory slots
+* Example for formspec 8x4 in 16x resolution:
+  image shall be sized 8 times 16px  times  4 times 16px
+* If `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>]`
+* Textual password style field; will be sent to server when a button is clicked
+* When enter is pressed in field, 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 menu
+* `w` and `h` are the size of the field
+* Fields are a set height, but will be vertically centred on `h`
+* Position and size units are inventory slots
+* `name` is the name of the field as returned in fields to `on_receive_fields`
+* `label`, if not blank, will be text printed on the top left above the field
+* See field_close_on_enter to stop enter closing the formspec
+
+#### `field[<X>,<Y>;<W>,<H>;<name>;<label>;<default>]`
+* Textual field; will be sent to server when a button is clicked
+* When enter is pressed in field, 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 menu
+* `w` and `h` are the size of the field
+* Fields are a set height, but will be vertically centred on `h`
+* Position and size units are inventory slots
+* `name` is the name of the field as returned in fields to `on_receive_fields`
+* `label`, if not blank, will be text printed on the top left above the field
+* `default` is the default value of the field
+    * `default` may contain variable references such as `${text}'` which
+      will fill the value from the metadata value `text`
+    * **Note**: no extra text or more than a single variable is supported ATM.
+* See field_close_on_enter to stop enter closing the formspec
+
+#### `field[<name>;<label>;<default>]`
+* As above, but without position/size units
+* When enter is pressed in field, fields.key_enter_field will be sent with the name
+  of this field.
+* Special field for creating simple forms, such as sign text input
+* Must be used without a `size[]` element
+* A "Proceed" button will be added automatically
+* See field_close_on_enter to stop enter closing the formspec
+
+#### `field_close_on_enter[<name>;<close_on_enter>]`
+* <name> is the name of the field
+* if <close_on_enter> is false, pressing enter in the field will submit the form but not close it
+* defaults to true when not specified (ie: no tag for a field)
+
+#### `textarea[<X>,<Y>;<W>,<H>;<name>;<label>;<default>]`
+* Same as fields above, but with multi-line input
+
+#### `label[<X>,<Y>;<label>]`
+* `x` and `y` work as per field
+* `label` is the text on the label
+* Position and size units are inventory slots
+
+#### `vertlabel[<X>,<Y>;<label>]`
+* Textual label drawn vertically
+* `x` and `y` work as per field
+* `label` is the text on the label
+* Position and size units are inventory slots
+
+#### `button[<X>,<Y>;<W>,<H>;<name>;<label>]`
+* Clickable button. When clicked, fields will be sent.
+* `x`, `y` and `name` work as per field
+* `w` and `h` are the size of the button
+* Fixed button height. It will be vertically centred on `h`
+* `label` is the text on the button
+* Position and size units are inventory slots
+
+#### `image_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>]`
+* `x`, `y`, `w`, `h`, and `name` work as per button
+* `texture name` is the filename of an image
+* Position and size units are inventory slots
+
+#### `image_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>;<noclip>;<drawborder>;<pressed texture name>]`
+* `x`, `y`, `w`, `h`, and `name` work as per button
+* `texture name` is the filename of an image
+* Position and size units are inventory slots
+* `noclip=true` means the image button doesn't need to be within specified formsize
+* `drawborder`: draw button border or not
+* `pressed texture name` is the filename of an image on pressed state
+
+#### `item_image_button[<X>,<Y>;<W>,<H>;<item name>;<name>;<label>]`
+* `x`, `y`, `w`, `h`, `name` and `label` work as per button
+* `item name` is the registered name of an item/node,
+   tooltip will be made out of its description
+   to override it use tooltip element
+* Position and size units are inventory slots
+
+#### `button_exit[<X>,<Y>;<W>,<H>;<name>;<label>]`
+* When clicked, fields will be sent and the form will quit.
+
+#### `image_button_exit[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>]`
+* When clicked, fields will be sent and the form will quit.
+
+#### `textlist[<X>,<Y>;<W>,<H>;<name>;<listelem 1>,<listelem 2>,...,<listelem n>]`
+* Scrollable item list showing arbitrary text elements
+* `x` and `y` position the itemlist relative to the top left of the menu
+* `w` and `h` are the size of the itemlist
+* `name` fieldname sent to server on doubleclick value is current selected element
+* `listelements` can be prepended by #color in hexadecimal format RRGGBB (only),
+     * if you want a listelement to start with "#" write "##".
+
+#### `textlist[<X>,<Y>;<W>,<H>;<name>;<listelem 1>,<listelem 2>,...,<listelem n>;<selected idx>;<transparent>]`
+* Scrollable itemlist showing arbitrary text elements
+* `x` and `y` position the item list relative to the top left of the menu
+* `w` and `h` are the size of the item list
+* `name` fieldname sent to server on doubleclick value is current selected element
+* `listelements` can be prepended by #RRGGBB (only) in hexadecimal format
+     * if you want a listelement to start with "#" write "##"
+* Index to be selected within textlist
+* `true`/`false`: draw transparent background
+* See also `minetest.explode_textlist_event` (main menu: `engine.explode_textlist_event`)
+
+#### `tabheader[<X>,<Y>;<name>;<caption 1>,<caption 2>,...,<caption n>;<current_tab>;<transparent>;<draw_border>]`
+* Show a tab**header** at specific position (ignores formsize)
+* `x` and `y` position the itemlist relative to the top left of the menu
+* `name` fieldname data is transferred to Lua
+* `caption 1`...: name shown on top of tab
+* `current_tab`: index of selected tab 1...
+* `transparent` (optional): show transparent
+* `draw_border` (optional): draw border
+
+#### `box[<X>,<Y>;<W>,<H>;<color>]`
+* Simple colored semitransparent box
+* `x` and `y` position the box relative to the top left of the menu
+* `w` and `h` are the size of box
+* `color` is color specified as a `ColorString`
+
+#### `dropdown[<X>,<Y>;<W>;<name>;<item 1>,<item 2>, ...,<item n>;<selected idx>]`
+* Show a dropdown field
+* **Important note**: There are two different operation modes:
+     1. handle directly on change (only changed dropdown is submitted)
+     2. read the value on pressing a button (all dropdown values are available)
+* `x` and `y` position of dropdown
+* Width of dropdown
+* Fieldname data is transferred to Lua
+* Items to be shown in dropdown
+* Index of currently selected dropdown item
+
+#### `checkbox[<X>,<Y>;<name>;<label>;<selected>]`
+* Show a checkbox
+* `x` and `y`: position of checkbox
+* `name` fieldname data is transferred to Lua
+* `label` to be shown left of checkbox
+* `selected` (optional): `true`/`false`
+
+#### `scrollbar[<X>,<Y>;<W>,<H>;<orientation>;<name>;<value>]`
+* Show a scrollbar
+* There are two ways to use it:
+     1. handle the changed event (only changed scrollbar is available)
+     2. read the value on pressing a button (all scrollbars are available)
+* `x` and `y`: position of trackbar
+* `w` and `h`: width and height
+* `orientation`:  `vertical`/`horizontal`
+* Fieldname data is transferred to Lua
+* Value this trackbar is set to (`0`-`1000`)
+* See also `minetest.explode_scrollbar_event` (main menu: `engine.explode_scrollbar_event`)
+
+#### `table[<X>,<Y>;<W>,<H>;<name>;<cell 1>,<cell 2>,...,<cell n>;<selected idx>]`
+* Show scrollable table using options defined by the previous `tableoptions[]`
+* Displays cells as defined by the previous `tablecolumns[]`
+* `x` and `y`: position the itemlist relative to the top left of the menu
+* `w` and `h` are the size of the itemlist
+* `name`: fieldname sent to server on row select or doubleclick
+* `cell 1`...`cell n`: cell contents given in row-major order
+* `selected idx`: index of row to be selected within table (first row = `1`)
+* See also `minetest.explode_table_event` (main menu: `engine.explode_table_event`)
+
+#### `tableoptions[<opt 1>;<opt 2>;...]`
+* Sets options for `table[]`
+* `color=#RRGGBB`
+     * default text color (`ColorString`), defaults to `#FFFFFF`
+* `background=#RRGGBB`
+     * table background color (`ColorString`), defaults to `#000000`
+* `border=<true/false>`
+     * should the table be drawn with a border? (default: `true`)
+* `highlight=#RRGGBB`
+     * highlight background color (`ColorString`), defaults to `#466432`
+* `highlight_text=#RRGGBB`
+     * highlight text color (`ColorString`), defaults to `#FFFFFF`
+* `opendepth=<value>`
+     * all subtrees up to `depth < value` are open (default value = `0`)
+     * only useful when there is a column of type "tree"
+
+#### `tablecolumns[<type 1>,<opt 1a>,<opt 1b>,...;<type 2>,<opt 2a>,<opt 2b>;...]`
+* Sets columns for `table[]`
+* Types: `text`, `image`, `color`, `indent`, `tree`
+    * `text`:   show cell contents as text
+    * `image`:  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)
+* Column options:
+    * `align=<value>`
+        * for `text` and `image`: content alignment within cells.
+          Available values: `left` (default), `center`, `right`, `inline`
+    * `width=<value>`
+        * for `text` and `image`: minimum width in em (default: `0`)
+        * for `indent` and `tree`: indent width in em (default: `1.5`)
+    * `padding=<value>`: padding left of the column, in em (default `0.5`).
+      Exception: defaults to 0 for indent columns
+    * `tooltip=<value>`: tooltip text (default: empty)
+    * `image` column options:
+        * `0=<value>` sets image for image index 0
+        * `1=<value>` sets image for image index 1
+        * `2=<value>` sets image for image index 2
+        * and so on; defined indices need not be contiguous empty or
+          non-numeric cells are treated as `0`.
+    * `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!
+
+Spatial Vectors
+---------------
+* `vector.new(a[, b, c])`: returns a vector:
+    * A copy of `a` if `a` is a vector.
+    * `{x = a, y = b, z = c}`, if all `a, b, c` are defined
+* `vector.direction(p1, p2)`: returns a vector
+* `vector.distance(p1, p2)`: returns a number
+* `vector.length(v)`: returns a number
+* `vector.normalize(v)`: returns a vector
+* `vector.floor(v)`: returns a vector, each dimension rounded down
+* `vector.round(v)`: returns a vector, each dimension rounded to nearest int
+* `vector.apply(v, func)`: returns a vector
+* `vector.equals(v1, v2)`: returns a boolean
+
+For the following functions `x` can be either a vector or a number:
+
+* `vector.add(v, x)`: returns a vector
+* `vector.subtract(v, x)`: returns a vector
+* `vector.multiply(v, x)`: returns a scaled vector or Schur product
+* `vector.divide(v, x)`: returns a scaled vector or Schur quotient
+
+Helper functions
+----------------
+* `dump2(obj, name="_", dumped={})`
+     * Return object serialized as a string, handles reference loops
+* `dump(obj, dumped={})`
+    * Return object serialized as a string
+* `math.hypot(x, y)`
+    * Get the hypotenuse of a triangle with legs x and y.
+      Useful for distance calculation.
+* `math.sign(x, tolerance)`
+    * Get the sign of a number.
+      Optional: Also returns `0` when the absolute value is within the tolerance (default: `0`)
+* `string.split(str, separator=",", include_empty=false, max_splits=-1, sep_is_pattern=false)`
+    * If `max_splits` is negative, do not limit splits.
+    * `sep_is_pattern` specifies if separator is a plain string or a pattern (regex).
+    * e.g. `string:split("a,b", ",") == {"a","b"}`
+* `string:trim()`
+    * e.g. `string.trim("\n \t\tfoo bar\t ") == "foo bar"`
+* `minetest.wrap_text(str, limit)`: returns a string
+    * Adds new lines to the string to keep it within the specified character limit
+    * limit: Maximal amount of characters in one line
+* `minetest.pos_to_string({x=X,y=Y,z=Z}, decimal_places))`: returns string `"(X,Y,Z)"`
+    * Convert position to a printable string
+      Optional: 'decimal_places' will round the x, y and z of the pos to the given decimal place.
+* `minetest.string_to_pos(string)`: returns a position
+    * Same but in reverse. Returns `nil` if the string can't be parsed to a position.
+* `minetest.string_to_area("(X1, Y1, Z1) (X2, Y2, Z2)")`: returns two positions
+    * Converts a string representing an area box into two positions
+* `minetest.is_yes(arg)`
+    * returns whether `arg` can be interpreted as yes
+* `minetest.is_nan(arg)`
+    * returns true true when the passed number represents NaN.
+* `table.copy(table)`: returns a table
+    * returns a deep copy of `table`
+
+Minetest namespace reference
+------------------------------
+
+### Utilities
+
+* `minetest.get_current_modname()`: returns the currently loading mod's name, when we are loading a mod
+* `minetest.get_modpath(modname)`: returns virtual path of given mod including
+   the trailing separator. This is useful to load additional Lua files
+   contained in your mod:
+   e.g. `dofile(minetest.get_modpath(minetest.get_current_modname()) .. "stuff.lua")`
+* `minetest.get_language()`: returns two strings
+   * the current gettext locale
+   * the current language code (the same as used for client-side translations)
+* `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
+    * `data`: string of data to hash
+    * `raw`: return raw bytes instead of hex digits, default: false
+* `minetest.get_csm_restrictions()`: returns a table of `Flags` indicating the
+   restrictions applied to the current mod.
+   * If a flag in this table is set to true, the feature is RESTRICTED.
+   * Possible flags: `load_client_mods`, `chat_messages`, `read_itemdefs`,
+                   `read_nodedefs`, `lookup_nodes`, `read_playerinfo`
+
+### Logging
+* `minetest.debug(...)`
+    * Equivalent to `minetest.log(table.concat({...}, "\t"))`
+* `minetest.log([level,] text)`
+    * `level` is one of `"none"`, `"error"`, `"warning"`, `"action"`,
+      `"info"`, or `"verbose"`.  Default is `"none"`.
+
+### Global callback registration functions
+Call these functions only at load time!
+
+* `minetest.register_globalstep(function(dtime))`
+    * Called every client environment step, usually interval of 0.1s
+* `minetest.register_on_mods_loaded(function())`
+    * Called just after mods have finished loading.
+* `minetest.register_on_shutdown(function())`
+    * Called before client shutdown
+    * **Warning**: If the client terminates abnormally (i.e. crashes), the registered
+      callbacks **will likely not be run**. Data should be saved at
+      semi-frequent intervals as well as on server shutdown.
+* `minetest.register_on_receiving_chat_message(function(message))`
+    * Called always when a client receive a message
+    * Return `true` to mark the message as handled, which means that it will not be shown to chat
+* `minetest.register_on_sending_chat_message(function(message))`
+    * Called always when a client send a message from chat
+    * Return `true` to mark the message as handled, which means that it will not be sent to server
+* `minetest.register_chatcommand(cmd, chatcommand definition)`
+    * Adds definition to minetest.registered_chatcommands
+* `minetest.unregister_chatcommand(name)`
+    * Unregisters a chatcommands registered with register_chatcommand.
+* `minetest.register_on_death(function())`
+    * Called when the local player dies
+* `minetest.register_on_hp_modification(function(hp))`
+    * Called when server modified player's HP
+* `minetest.register_on_damage_taken(function(hp))`
+    * Called when the local player take damages
+* `minetest.register_on_formspec_input(function(formname, fields))`
+    * Called when a button is pressed in the local player's inventory form
+    * Newest functions are called first
+    * If function returns `true`, remaining functions are not called
+* `minetest.register_on_dignode(function(pos, node))`
+    * Called when the local player digs a node
+    * Newest functions are called first
+    * If any function returns true, the node isn't dug
+* `minetest.register_on_punchnode(function(pos, node))`
+    * Called when the local player punches a node
+    * Newest functions are called first
+    * If any function returns true, the punch is ignored
+* `minetest.register_on_placenode(function(pointed_thing, node))`
+    * Called when a node has been placed
+* `minetest.register_on_item_use(function(item, pointed_thing))`
+    * Called when the local player uses an item.
+    * Newest functions are called first.
+    * If any function returns true, the item use is not sent to server.
+* `minetest.register_on_modchannel_message(function(channel_name, sender, message))`
+    * Called when an incoming mod channel message is received
+    * You must have joined some channels before, and server must acknowledge the
+      join request.
+    * If message comes from a server mod, `sender` field is an empty string.
+* `minetest.register_on_modchannel_signal(function(channel_name, signal))`
+    * Called when a valid incoming mod channel signal is received
+    * Signal id permit to react to server mod channel events
+    * Possible values are:
+      0: join_ok
+      1: join_failed
+      2: leave_ok
+      3: leave_failed
+      4: event_on_not_joined_channel
+      5: state_changed
+* `minetest.register_on_inventory_open(function(inventory))`
+    * Called when the local player open inventory
+    * Newest functions are called first
+    * If any function returns true, inventory doesn't open
+### Sounds
+* `minetest.sound_play(spec, parameters)`: returns a handle
+    * `spec` is a `SimpleSoundSpec`
+    * `parameters` is a sound parameter table
+* `minetest.sound_stop(handle)`
+
+### Timing
+* `minetest.after(time, func, ...)`
+    * Call the function `func` after `time` seconds, may be fractional
+    * Optional: Variable number of arguments that are passed to `func`
+* `minetest.get_us_time()`
+    * Returns time with microsecond precision. May not return wall time.
+* `minetest.get_timeofday()`
+    * Returns the time of day: `0` for midnight, `0.5` for midday
+
+### Map
+* `minetest.get_node_or_nil(pos)`
+    * Returns the node at the given position as table in the format
+      `{name="node_name", param1=0, param2=0}`, returns `nil`
+      for unloaded areas or flavor limited areas.
+* `minetest.get_node_light(pos, timeofday)`
+    * Gets the light value at the given position. Note that the light value
+      "inside" the node at the given position is returned, so you usually want
+      to get the light value of a neighbor.
+    * `pos`: The position where to measure the light.
+    * `timeofday`: `nil` for current time, `0` for night, `0.5` for day
+    * Returns a number between `0` and `15` or `nil`
+* `minetest.find_node_near(pos, radius, nodenames, [search_center])`: returns pos or `nil`
+    * `radius`: using a maximum metric
+    * `nodenames`: e.g. `{"ignore", "group:tree"}` or `"default:dirt"`
+    * `search_center` is an optional boolean (default: `false`)
+      If true `pos` is also checked for the nodes
+* `minetest.find_nodes_in_area(pos1, pos2, nodenames)`: returns a list of
+  positions.
+    * `nodenames`: e.g. `{"ignore", "group:tree"}` or `"default:dirt"`
+    * First return value: Table with all node positions
+    * Second return value: Table with the count of each node with the node name
+      as index.
+    * Area volume is limited to 4,096,000 nodes
+* `minetest.find_nodes_in_area_under_air(pos1, pos2, nodenames)`: returns a
+  list of positions.
+    * `nodenames`: e.g. `{"ignore", "group:tree"}` or `"default:dirt"`
+    * Return value: Table with all node positions with a node air above
+    * Area volume is limited to 4,096,000 nodes
+* `minetest.line_of_sight(pos1, pos2)`: returns `boolean, pos`
+    * Checks if there is anything other than air between pos1 and pos2.
+    * Returns false if something is blocking the sight.
+    * Returns the position of the blocking node when `false`
+    * `pos1`: First position
+    * `pos2`: Second position
+* `minetest.raycast(pos1, pos2, objects, liquids)`: returns `Raycast`
+    * Creates a `Raycast` object.
+    * `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`.
+
+* `minetest.find_nodes_with_meta(pos1, pos2)`
+    * Get a table of positions of nodes that have metadata within a region
+      {pos1, pos2}.
+* `minetest.get_meta(pos)`
+    * Get a `NodeMetaRef` at that position
+* `minetest.get_node_level(pos)`
+    * get level of leveled node (water, snow)
+* `minetest.get_node_max_level(pos)`
+    * get max available level for leveled node
+
+### Player
+* `minetest.get_wielded_item()`
+    * Returns the itemstack the local player is holding
+* `minetest.send_chat_message(message)`
+    * Act as if `message` was typed by the player into the terminal.
+* `minetest.run_server_chatcommand(cmd, param)`
+    * Alias for `minetest.send_chat_message("/" .. cmd .. " " .. param)`
+* `minetest.clear_out_chat_queue()`
+    * Clears the out chat queue
+* `minetest.localplayer`
+    * Reference to the LocalPlayer object. See [`LocalPlayer`](#localplayer) class reference for methods.
+
+### Privileges
+* `minetest.get_privilege_list()`
+    * Returns a list of privileges the current player has in the format `{priv1=true,...}`
+* `minetest.string_to_privs(str)`: returns `{priv1=true,...}`
+* `minetest.privs_to_string(privs)`: returns `"priv1,priv2,..."`
+    * Convert between two privilege representations
+
+### Client Environment
+* `minetest.get_player_names()`
+    * Returns list of player names on server (nil if CSM_RF_READ_PLAYERINFO is enabled by server)
+* `minetest.disconnect()`
+    * Disconnect from the server and exit to main menu.
+    * Returns `false` if the client is already disconnecting otherwise returns `true`.
+* `minetest.get_server_info()`
+    * Returns [server info](#server-info).
+* `minetest.send_respawn()`
+    * Sends a respawn request to the server.
+
+### Storage API
+* `minetest.get_mod_storage()`:
+    * returns reference to mod private `StorageRef`
+    * must be called during mod load time
+
+### Mod channels
+![Mod channels communication scheme](docs/mod channels.png)
+
+* `minetest.mod_channel_join(channel_name)`
+    * Client joins channel `channel_name`, and creates it, if necessary. You
+      should listen from incoming messages with `minetest.register_on_modchannel_message`
+      call to receive incoming messages. Warning, this function is asynchronous.
+
+### Particles
+* `minetest.add_particle(particle definition)`
+
+* `minetest.add_particlespawner(particlespawner definition)`
+    * Add a `ParticleSpawner`, an object that spawns an amount of particles over `time` seconds
+    * Returns an `id`, and -1 if adding didn't succeed
+
+* `minetest.delete_particlespawner(id)`
+    * Delete `ParticleSpawner` with `id` (return value from `minetest.add_particlespawner`)
+
+### Misc.
+* `minetest.parse_json(string[, nullvalue])`: returns something
+    * Convert a string containing JSON data into the Lua equivalent
+    * `nullvalue`: returned in place of the JSON null; defaults to `nil`
+    * On success returns a table, a string, a number, a boolean or `nullvalue`
+    * On failure outputs an error message and returns `nil`
+    * Example: `parse_json("[10, {\"a\":false}]")`, returns `{10, {a = false}}`
+* `minetest.write_json(data[, styled])`: returns a string or `nil` and an error message
+    * Convert a Lua table into a JSON string
+    * styled: Outputs in a human-readable format if this is set, defaults to false
+    * Unserializable things like functions and userdata are saved as null.
+    * **Warning**: JSON is more strict than the Lua table format.
+        1. You can only use strings and positive integers of at least one as keys.
+        2. You can not mix string and integer keys.
+           This is due to the fact that JSON has two distinct array and object values.
+    * Example: `write_json({10, {a = false}})`, returns `"[10, {\"a\": false}]"`
+* `minetest.serialize(table)`: returns a string
+    * Convert a table containing tables, strings, numbers, booleans and `nil`s
+      into string form readable by `minetest.deserialize`
+    * Example: `serialize({foo='bar'})`, returns `'return { ["foo"] = "bar" }'`
+* `minetest.deserialize(string)`: returns a table
+    * Convert a string returned by `minetest.deserialize` into a table
+    * `string` is loaded in an empty sandbox environment.
+    * Will load functions, but they cannot access the global environment.
+    * Example: `deserialize('return { ["foo"] = "bar" }')`, returns `{foo='bar'}`
+    * Example: `deserialize('print("foo")')`, returns `nil` (function call fails)
+        * `error:[string "print("foo")"]:1: attempt to call global 'print' (a nil value)`
+* `minetest.compress(data, method, ...)`: returns `compressed_data`
+    * Compress a string of data.
+    * `method` is a string identifying the compression method to be used.
+    * Supported compression methods:
+    *     Deflate (zlib): `"deflate"`
+    * `...` indicates method-specific arguments.  Currently defined arguments are:
+    *     Deflate: `level` - Compression level, `0`-`9` or `nil`.
+* `minetest.decompress(compressed_data, method, ...)`: returns data
+    * Decompress a string of data (using ZLib).
+    * See documentation on `minetest.compress()` for supported compression methods.
+    * currently supported.
+    * `...` indicates method-specific arguments. Currently, no methods use this.
+* `minetest.rgba(red, green, blue[, alpha])`: returns a string
+    * Each argument is a 8 Bit unsigned integer
+    * Returns the ColorString from rgb or rgba values
+    * Example: `minetest.rgba(10, 20, 30, 40)`, returns `"#0A141E28"`
+* `minetest.encode_base64(string)`: returns string encoded in base64
+    * Encodes a string in base64.
+* `minetest.decode_base64(string)`: returns string
+    * Decodes a string encoded in base64.
+* `minetest.gettext(string)` : returns string
+    * look up the translation of a string in the gettext message catalog
+* `fgettext_ne(string, ...)`
+    * call minetest.gettext(string), replace "$1"..."$9" with the given
+      extra arguments and return the result
+* `fgettext(string, ...)` : returns string
+    * same as fgettext_ne(), but calls minetest.formspec_escape before returning result
+* `minetest.pointed_thing_to_face_pos(placer, pointed_thing)`: returns a position
+    * returns the exact position on the surface of a pointed node
+* `minetest.global_exists(name)`
+    * Checks if a global variable has been set, without triggering a warning.
+
+### UI
+* `minetest.ui.minimap`
+    * Reference to the minimap object. See [`Minimap`](#minimap) class reference for methods.
+    * If client disabled minimap (using enable_minimap setting) this reference will be nil.
+* `minetest.camera`
+    * Reference to the camera object. See [`Camera`](#camera) class reference for methods.
+* `minetest.show_formspec(formname, formspec)` : returns true on success
+	* Shows a formspec to the player
+* `minetest.display_chat_message(message)` returns true on success
+	* Shows a chat message to the current player.
+
+Class reference
+---------------
+
+### ModChannel
+
+An interface to use mod channels on client and server
+
+#### Methods
+* `leave()`: leave the mod channel.
+    * Client leaves channel `channel_name`.
+    * No more incoming or outgoing messages can be sent to this channel from client mods.
+    * This invalidate all future object usage
+    * Ensure your set mod_channel to nil after that to free Lua resources
+* `is_writeable()`: returns true if channel is writable and mod can send over it.
+* `send_all(message)`: Send `message` though the mod channel.
+    * If mod channel is not writable or invalid, message will be dropped.
+    * Message size is limited to 65535 characters by protocol.
+
+### Minimap
+An interface to manipulate minimap on client UI
+
+#### Methods
+* `show()`: shows the minimap (if not disabled by server)
+* `hide()`: hides the minimap
+* `set_pos(pos)`: sets the minimap position on screen
+* `get_pos()`: returns the minimap current position
+* `set_angle(deg)`: sets the minimap angle in degrees
+* `get_angle()`: returns the current minimap angle in degrees
+* `set_mode(mode)`: sets the minimap mode (0 to 6)
+* `get_mode()`: returns the current minimap mode
+* `set_shape(shape)`: Sets the minimap shape. (0 = square, 1 = round)
+* `get_shape()`: Gets the minimap shape. (0 = square, 1 = round)
+
+### Camera
+An interface to get or set information about the camera and camera-node.
+Please do not try to access the reference until the camera is initialized, otherwise the reference will be nil.
+
+#### Methods
+* `set_camera_mode(mode)`
+    * Pass `0` for first-person, `1` for third person, and `2` for third person front
+* `get_camera_mode()`
+    * Returns 0, 1, or 2 as described above
+* `get_fov()`
+    * Returns:
+
+```lua
+     {
+         x = number,
+         y = number,
+         max = number,
+         actual = number
+     }
+```
+
+* `get_pos()`
+    * Returns position of camera with view bobbing
+* `get_offset()`
+    * Returns eye offset vector
+* `get_look_dir()`
+    * Returns eye direction unit vector
+* `get_look_vertical()`
+    * Returns pitch in radians
+* `get_look_horizontal()`
+    * Returns yaw in radians
+* `get_aspect_ratio()`
+    * Returns aspect ratio of screen
+
+### LocalPlayer
+An interface to retrieve information about the player.
+
+Methods:
+
+* `get_pos()`
+    * returns current player current position
+* `get_velocity()`
+    * returns player speed vector
+* `get_hp()`
+    * returns player HP
+* `get_name()`
+    * returns player name
+* `is_attached()`
+    * returns true if player is attached
+* `is_touching_ground()`
+    * returns true if player touching ground
+* `is_in_liquid()`
+    * returns true if player is in a liquid (This oscillates so that the player jumps a bit above the surface)
+* `is_in_liquid_stable()`
+    * returns true if player is in a stable liquid (This is more stable and defines the maximum speed of the player)
+* `get_liquid_viscosity()`
+    * returns liquid viscosity (Gets the viscosity of liquid to calculate friction)
+* `is_climbing()`
+    * returns true if player is climbing
+* `swimming_vertical()`
+    * returns true if player is swimming in vertical
+* `get_physics_override()`
+    * returns:
+
+```lua
+    {
+        speed = float,
+        jump = float,
+        gravity = float,
+        sneak = boolean,
+        sneak_glitch = boolean
+    }
+```
+
+* `get_override_pos()`
+    * returns override position
+* `get_last_pos()`
+    * returns last player position before the current client step
+* `get_last_velocity()`
+    * returns last player speed
+* `get_breath()`
+    * returns the player's breath
+* `get_movement_acceleration()`
+    * returns acceleration of the player in different environments:
+
+```lua
+    {
+       fast = float,
+       air = float,
+       default = float,
+    }
+```
+
+* `get_movement_speed()`
+    * returns player's speed in different environments:
+
+```lua
+    {
+       walk = float,
+       jump = float,
+       crouch = float,
+       fast = float,
+       climb = float,
+    }
+```
+
+* `get_movement()`
+    * returns player's movement in different environments:
+
+```lua
+    {
+       liquid_fluidity = float,
+       liquid_sink = float,
+       liquid_fluidity_smooth = float,
+       gravity = float,
+    }
+```
+
+* `get_last_look_horizontal()`:
+    * returns last look horizontal angle
+* `get_last_look_vertical()`:
+    * returns last look vertical angle
+* `get_key_pressed()`:
+    * returns last key typed by the player
+* `hud_add(definition)`
+    * add a HUD element described by HUD def, returns ID number on success and `nil` on failure.
+    * See [`HUD definition`](#hud-definition-hud_add-hud_get)
+* `hud_get(id)`
+    * returns the [`definition`](#hud-definition-hud_add-hud_get) of the HUD with that ID number or `nil`, if non-existent.
+* `hud_remove(id)`
+    * remove the HUD element of the specified id, returns `true` on success
+* `hud_change(id, stat, value)`
+    * change a value of a previously added HUD element
+    * element `stat` values: `position`, `name`, `scale`, `text`, `number`, `item`, `dir`
+    * Returns `true` on success, otherwise returns `nil`
+
+### Settings
+An interface to read config files in the format of `minetest.conf`.
+
+It can be created via `Settings(filename)`.
+
+#### Methods
+* `get(key)`: returns a value
+* `get_bool(key)`: returns a boolean
+* `set(key, value)`
+* `remove(key)`: returns a boolean (`true` for success)
+* `get_names()`: returns `{key1,...}`
+* `write()`: returns a boolean (`true` for success)
+    * write changes to file
+* `to_table()`: returns `{[key1]=value1,...}`
+
+### NodeMetaRef
+Node metadata: reference extra data and functionality stored in a node.
+Can be obtained via `minetest.get_meta(pos)`.
+
+#### Methods
+* `get_string(name)`
+* `get_int(name)`
+* `get_float(name)`
+* `to_table()`: returns `nil` or a table with keys:
+    * `fields`: key-value storage
+    * `inventory`: `{list1 = {}, ...}}`
+
+### `Raycast`
+
+A raycast on the map. It works with selection boxes.
+Can be used as an iterator in a for loop as:
+
+    local ray = Raycast(...)
+    for pointed_thing in ray do
+        ...
+    end
+
+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.
+
+#### Methods
+
+* `next()`: returns a `pointed_thing` with exact pointing location
+    * Returns the next thing pointed by the ray or nil.
+
+-----------------
+### Definitions
+* `minetest.get_node_def(nodename)`
+	* Returns [node definition](#node-definition) table of `nodename`
+* `minetest.get_item_def(itemstring)`
+	* Returns item definition table of `itemstring`
+
+#### Node Definition
+
+```lua
+	{
+		has_on_construct = bool,        -- Whether the node has the on_construct callback defined
+		has_on_destruct = bool,         -- Whether the node has the on_destruct callback defined
+		has_after_destruct = bool,      -- Whether the node has the after_destruct callback defined
+		name = string,                  -- The name of the node e.g. "air", "default:dirt"
+		groups = table,                 -- The groups of the node
+		paramtype = string,             -- Paramtype of the node
+		paramtype2 = string,            -- ParamType2 of the node
+		drawtype = string,              -- Drawtype of the node
+		mesh = <string>,                -- Mesh name if existant
+		minimap_color = <Color>,        -- Color of node on minimap *May not exist*
+		visual_scale = number,          -- Visual scale of node
+		alpha = number,                 -- Alpha of the node. Only used for liquids
+		color = <Color>,                -- Color of node *May not exist*
+		palette_name = <string>,        -- Filename of palette *May not exist*
+		palette = <{                    -- List of colors
+			Color,
+			Color
+		}>,
+		waving = number,                -- 0 of not waving, 1 if waving
+		connect_sides = number,         -- Used for connected nodes
+		connects_to = {                 -- List of nodes to connect to
+			"node1",
+			"node2"
+		},
+		post_effect_color = Color,      -- Color overlayed on the screen when the player is in the node
+		leveled = number,               -- Max level for node
+		sunlight_propogates = bool,     -- Whether light passes through the block
+		light_source = number,          -- Light emitted by the block
+		is_ground_content = bool,       -- Whether caves should cut through the node
+		walkable = bool,                -- Whether the player collides with the node
+		pointable = bool,               -- Whether the player can select the node
+		diggable = bool,                -- Whether the player can dig the node
+		climbable = bool,               -- Whether the player can climb up the node
+		buildable_to = bool,            -- Whether the player can replace the node by placing a node on it
+		rightclickable = bool,          -- Whether the player can place nodes pointing at this node
+		damage_per_second = number,     -- HP of damage per second when the player is in the node
+		liquid_type = <string>,         -- A string containing "none", "flowing", or "source" *May not exist*
+		liquid_alternative_flowing = <string>, -- Alternative node for liquid *May not exist*
+		liquid_alternative_source = <string>, -- Alternative node for liquid *May not exist*
+		liquid_viscosity = <number>,    -- How fast the liquid flows *May not exist*
+		liquid_renewable = <boolean>,   -- Whether the liquid makes an infinite source *May not exist*
+		liquid_range = <number>,        -- How far the liquid flows *May not exist*
+		drowning = bool,                -- Whether the player will drown in the node
+		floodable = bool,               -- Whether nodes will be replaced by liquids (flooded)
+		node_box = table,               -- Nodebox to draw the node with
+		collision_box = table,          -- Nodebox to set the collision area
+		selection_box = table,          -- Nodebox to set the area selected by the player
+		sounds = {                      -- Table of sounds that the block makes
+			sound_footstep = SimpleSoundSpec,
+			sound_dig = SimpleSoundSpec,
+			sound_dug = SimpleSoundSpec
+		},
+		legacy_facedir_simple = bool,   -- Whether to use old facedir
+		legacy_wallmounted = bool       -- Whether to use old wallmounted
+	}
+```
+
+#### Item Definition
+
+```lua
+	{
+		name = string,                  -- Name of the item e.g. "default:stone"
+		description = string,           -- Description of the item e.g. "Stone"
+		type = string,                  -- Item type: "none", "node", "craftitem", "tool"
+		inventory_image = string,       -- Image in the inventory
+		wield_image = string,           -- Image in wieldmesh
+		palette_image = string,         -- Image for palette
+		color = Color,                  -- Color for item
+		wield_scale = Vector,           -- Wieldmesh scale
+		stack_max = number,             -- Number of items stackable together
+		usable = bool,                  -- Has on_use callback defined
+		liquids_pointable = bool,       -- Whether you can point at liquids with the item
+		tool_capabilities = <table>,    -- If the item is a tool, tool capabilities of the item
+		groups = table,                 -- Groups of the item
+		sound_place = SimpleSoundSpec,  -- Sound played when placed
+		sound_place_failed = SimpleSoundSpec, -- Sound played when placement failed
+		node_placement_prediction = string -- Node placed in client until server catches up
+	}
+```
+-----------------
+
+### Chat command definition (`register_chatcommand`)
+
+    {
+        params = "<name> <privilege>", -- Short parameter description
+        description = "Remove privilege from player", -- Full description
+        func = function(param),        -- Called when command is run.
+                                       -- Returns boolean success and text output.
+    }
+### Server info
+```lua
+{
+	address = "minetest.example.org", -- The domain name/IP address of a remote server or "" for a local server.
+	ip = "203.0.113.156",             -- The IP address of the server.
+	port = 30000,                     -- The port the client is connected to.
+	protocol_version = 30             -- Will not be accurate at start up as the client might not be connected to the server yet, in that case it will be 0.
+}
+```
+
+### HUD Definition (`hud_add`, `hud_get`)
+```lua
+    {
+        hud_elem_type = "image", -- see HUD element types, default "text"
+    --  ^ type of HUD element, can be either of "image", "text", "statbar", or "inventory"
+        position = {x=0.5, y=0.5},
+    --  ^ Left corner position of element, default `{x=0,y=0}`.
+        name = "<name>",    -- default ""
+        scale = {x=2, y=2}, -- default {x=0,y=0}
+        text = "<text>",    -- default ""
+        number = 2,         -- default 0
+        item = 3,           -- default 0
+    --  ^ Selected item in inventory.  0 for no item selected.
+        direction = 0,      -- default 0
+    --  ^ Direction: 0: left-right, 1: right-left, 2: top-bottom, 3: bottom-top
+        alignment = {x=0, y=0},   -- default {x=0, y=0}
+    --  ^ See "HUD Element Types"
+        offset = {x=0, y=0},      -- default {x=0, y=0}
+    --  ^ See "HUD Element Types"
+        size = { x=100, y=100 },  -- default {x=0, y=0}
+    --  ^ Size of element in pixels
+    }
+```
+
+Escape sequences
+----------------
+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)`:
+    * `color` is a [ColorString](#colorstring)
+    * The escape sequence sets the text color to `color`
+* `minetest.colorize(color, message)`:
+    * Equivalent to:
+      `minetest.get_color_escape_sequence(color) ..
+       message ..
+       minetest.get_color_escape_sequence("#ffffff")`
+* `minetest.get_background_escape_sequence(color)`
+    * `color` is a [ColorString](#colorstring)
+    * The escape sequence sets the background of the whole text element to
+      `color`. Only defined for item descriptions and tooltips.
+* `minetest.strip_foreground_colors(str)`
+    * Removes foreground colors added by `get_color_escape_sequence`.
+* `minetest.strip_background_colors(str)`
+    * Removes background colors added by `get_background_escape_sequence`.
+* `minetest.strip_colors(str)`
+    * Removes all color escape sequences.
+
+`ColorString`
+-------------
+`#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](http://dev.w3.org/csswg/css-color/#named-colors).
+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.
+
+`Color`
+-------------
+`{a = alpha, r = red, g = green, b = blue}` defines an ARGB8 color.
+
+HUD element types
+-----------------
+The position field is used for all element types.
+
+To account for differing resolutions, the position coordinates are the percentage
+of the screen, ranging in value from `0` to `1`.
+
+The name field is not yet used, but should contain a description of what the
+HUD element represents. The direction field is the direction in which something
+is drawn.
+
+`0` draws from left to right, `1` draws from right to left, `2` draws from
+top to bottom, and `3` draws from bottom to top.
+
+The `alignment` field specifies how the item will be aligned. It ranges from `-1` to `1`,
+with `0` being the center, `-1` is moved to the left/up, and `1` is to the right/down.
+Fractional values can be used.
+
+The `offset` field specifies a pixel offset from the position. Contrary to position,
+the offset is not scaled to screen size. This allows for some precisely-positioned
+items in the HUD.
+
+**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.
+
+### `image`
+Displays an image on the HUD.
+
+* `scale`: The scale of the image, with 1 being the original texture size.
+  Only the X coordinate scale is used (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.
+
+### `text`
+Displays text on the HUD.
+
+* `scale`: Defines the bounding rectangle of the text.
+  A value such as `{x=100, y=100}` should work.
+* `text`: The text to be displayed in the HUD element.
+* `number`: An integer containing the RGB value of the color used to draw the text.
+  Specify `0xFFFFFF` for white text, `0xFF0000` for red, and so on.
+* `alignment`: The alignment of the text.
+* `offset`: offset in pixels from position.
+
+### `statbar`
+Displays a horizontal bar made up of half-images.
+
+* `text`: The name of the texture that is used.
+* `number`: The number of half-textures that are displayed.
+  If odd, will end with a vertically center-split texture.
+* `direction`
+* `offset`: offset in pixels from position.
+* `size`: If used, will force full-image size to this value (override texture pack image size)
+
+### `inventory`
+* `text`: The name of the inventory list to be displayed.
+* `number`: Number of items in the inventory to be displayed.
+* `item`: Position of item that is selected.
+* `direction`
+* `offset`: offset in pixels from position.
+
+### `waypoint`
+Displays 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.
+
+### Particle definition (`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)
+        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 base
+        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
+        vertical = false,
+    --  ^ vertical: if true faces player using y axis only
+        texture = "image.png",
+    --  ^ Uses texture (string)
+    }
-- 
cgit v1.2.3