minetest-0.4.15+repack/0000755000175000017500000000000013036240443013011 5ustar apoapominetest-0.4.15+repack/CONTRIBUTING.md0000644000175000017500000001437213027050071015245 0ustar apoapo# Contributing Contributions are welcome! Here's how you can help: - [Contributing code](#code) - [Reporting issues](#issues) - [Requesting features](#feature-requests) - [Translating](#translations) - [Donating](#donations) ## Code If you are planning to start some significant coding, you would benefit from asking first on [our IRC channel](http://www.minetest.net/irc/) before starting. 1. [Fork](https://help.github.com/articles/fork-a-repo/) the repository and [clone](https://help.github.com/articles/cloning-a-repository/) your fork. 2. Start coding! - Refer to the [Lua API](https://github.com/minetest/minetest/blob/master/doc/lua_api.txt), [Developer Wiki](http://dev.minetest.net/Main_Page) and other [documentation](https://github.com/minetest/minetest/tree/master/doc). - Follow the [C/C++](http://dev.minetest.net/Code_style_guidelines) and [Lua](http://dev.minetest.net/Lua_code_style_guidelines) code style guidelines. - Check your code works as expected and document any changes to the Lua API. 3. Commit & [push](https://help.github.com/articles/pushing-to-a-remote/) your changes to a new branch (not `master`, one change per branch) - Commit messages should: - Use the present tense - Have a title which begins with a capital letter - Be descriptive. (e.g. no `Update init.lua` or `Fix a problem`) - Have a first line with less than *80 characters* and have a second line that is *empty* - Do **not** [sign your commits](https://git-scm.com/book/uz/v2/Git-Tools-Signing-Your-Work), as Minetest offers automatically built ppas over launchpad and it [would break](https://bugs.launchpad.net/bzr-git/+bug/1084403) if there were signed commits in master 4. Once you are happy with your changes, submit a pull request. - Open the [pull-request form](https://github.com/minetest/minetest/pull/new/master) - Add a short description explaining briefly what you've done (or if it's a work-in-progress - what you need to do) ##### A pull-request is considered merge-able when: 1. It follows the [roadmap](https://forum.minetest.net/viewtopic.php?t=9177) in some way and fits the whole picture of the project. 2. It works. 3. It follows the code style for [C/C++](http://dev.minetest.net/Code_style_guidelines) or [Lua](http://dev.minetest.net/Lua_code_style_guidelines). 4. The code's interfaces are well designed, regardless of other aspects that might need more work in the future. 5. It uses protocols and formats which include the required compatibility. ## Issues If you experience an issue, we would like to know the details - especially when a stable release is on the way. 1. Do a quick search on GitHub to check if the issue has already been reported. 2. Is it an issue with the Minetest *engine*? If not, report it [elsewhere](http://www.minetest.net/development/#reporting-issues). 3. [Open an issue](https://github.com/minetest/minetest/issues/new) and describe the issue you are having - you could include: - Error logs (check the bottom of the `debug.txt` file) - Screenshots - Ways you have tried to solve the issue, and whether they worked or not - Your Minetest version and the content (subgames, mods or texture packs) you have installed - Your platform (e.g. Windows 10 or Ubuntu 15.04 x64) After reporting you should aim to answer questions or clarifications as this helps pinpoint the cause of the issue (if you don't do this your issue may be closed after 1 month). ## Feature requests Feature requests are welcome but take a moment to see if your idea follows the [roadmap](https://forum.minetest.net/viewtopic.php?t=9177) in some way and fits the whole picture of the project. You should provide a clear explanation with as much detail as possible. ## Translations Translations of Minetest are performed using Weblate. You can access the project page with a list of current languages [here](https://hosted.weblate.org/projects/minetest/minetest/). ### Donations If you'd like to monetarily support Minetest development, you can find donation methods on [our website](http://www.minetest.net/development/#donate). # Maintaining *This is a concise version of the [Rules & Guidelines](http://dev.minetest.net/Category:Rules_and_Guidelines) on the developer wiki.* These notes are for those who have push access Minetest (core developers / maintainers). - See the [project organisation](http://dev.minetest.net/Organisation) for the people involved. ## Reviewing pull requests Pull requests should be reviewed and, if appropriate, checked if they achieve their intended purpose. You can show that you are in the process of, or will review the pull request by commenting *"Looks good"* or something similar. **If the pull-request is not [merge-able](#a-pull-request-is-considered-merge-able-when):** Submit a comment explaining to the author what they need to change to make the pull-request merge-able. - If the author comments or makes changes to the pull-request, it can be reviewed again. - If no response is made from the author within 1 month (when improvements are suggested or a question is asked), it can be closed. **If the pull-request is [merge-able](#a-pull-request-is-considered-merge-able-when):** Submit a :+1: (+1) or "Looks good" comment to show you believe the pull-request should be merged. "Looks good" comments often signify that the patch might require (more) testing. - Two core developers must agree to the merge before it is carried out and both should +1 the pull request. - Who intends to merge the pull-request should follow the commit rules: - The title should follow the commit guidelines (title starts with a capital letter, present tense, descriptive). - Don't modify history older than 10 minutes. - Use rebase, not merge to get linear history: - `curl https://github.com/minetest/minetest/pull/1.patch | git am` ## Reviewing issues and feature requests - If an issue does not get a response from its author within 1 month (when requiring more details), it can be closed. - When an issue is a duplicate, refer to the first ones and close the later ones. - Tag issues with the appropriate [labels](https://github.com/minetest/minetest/labels) for devices, platforms etc. ## Releasing a new version *Refer to [dev.minetest.net/Releasing_Minetest](http://dev.minetest.net/Releasing_Minetest)* minetest-0.4.15+repack/mods/0000755000175000017500000000000013027050071013747 5ustar apoapominetest-0.4.15+repack/mods/mods_here.txt0000644000175000017500000000033413027050071016455 0ustar apoapoYou can install Minetest mods by copying (and extracting) them into this folder. To enable them, go to the configure world window in the main menu or write load_mod_ = true in world.mt in the world directory. minetest-0.4.15+repack/doc/0000755000175000017500000000000013027050071013552 5ustar apoapominetest-0.4.15+repack/doc/menu_lua_api.txt0000644000175000017500000002004113027050071016746 0ustar apoapoMinetest Lua Mainmenu API Reference 0.4.15 ======================================== Introduction ------------- The main menu is defined as a formspec by Lua in builtin/mainmenu/ Description of formspec language to show your menu is in lua_api.txt Callbacks --------- core.buttonhandler(fields): called when a button is pressed. ^ fields = {name1 = value1, name2 = value2, ...} core.event_handler(event) ^ event: "MenuQuit", "KeyEnter", "ExitButton" or "EditBoxEnter" Gamedata -------- The "gamedata" table is read when calling core.start(). It should contain: { playername = , password = , address = , port = , selected_world = , -- 0 for client mode singleplayer = , } Functions --------- core.start() core.close() Filesystem: core.get_builtin_path() ^ returns path to builtin root core.get_modpath() (possible in async calls) ^ returns path to global modpath core.get_modstore_details(modid) (possible in async calls) ^ modid numeric id of mod in modstore ^ returns { id = , title = , basename = , description = , author = , download_url= , license = , rating = } core.get_modstore_list() (possible in async calls) ^ returns { [1] = { id = , title = , basename = } } core.get_gamepath() (possible in async calls) ^ returns path to global gamepath core.get_texturepath() (possible in async calls) ^ returns path to default textures core.create_dir(absolute_path) (possible in async calls) ^ absolute_path to directory to create (needs to be absolute) ^ returns true/false core.delete_dir(absolute_path) (possible in async calls) ^ absolute_path to directory to delete (needs to be absolute) ^ returns true/false core.copy_dir(source,destination,keep_soure) (possible in async calls) ^ source folder ^ destination folder ^ keep_source DEFAULT true --> if set to false source is deleted after copying ^ returns true/false core.extract_zip(zipfile,destination) [unzip within path required] ^ zipfile to extract ^ destination folder to extract to ^ returns true/false core.download_file(url,target) (possible in async calls) ^ url to download ^ target to store to ^ returns true/false core.get_version() (possible in async calls) ^ returns current core version core.sound_play(spec, looped) -> handle ^ spec = SimpleSoundSpec (see lua-api.txt) ^ looped = bool core.sound_stop(handle) core.get_video_drivers() ^ get list of video drivers supported by engine (not all modes are guaranteed to work) ^ returns list of available video drivers' settings name and 'friendly' display name ^ e.g. { {name="opengl", friendly_name="OpenGL"}, {name="software", friendly_name="Software Renderer"} } ^ first element of returned list is guaranteed to be the NULL driver Formspec: core.update_formspec(formspec) core.get_table_index(tablename) -> index ^ can also handle textlists core.formspec_escape(string) -> string ^ escapes characters [ ] \ , ; that can not be used in formspecs core.explode_table_event(string) -> table ^ returns e.g. {type="CHG", row=1, column=2} ^ type: "INV" (no row selected), "CHG" (selected) or "DCL" (double-click) core.explode_textlist_event(string) -> table ^ returns e.g. {type="CHG", index=1} ^ type: "INV" (no row selected), "CHG" (selected) or "DCL" (double-click) GUI: core.set_background(type, texturepath,[tile],[minsize]) ^ type: "background", "overlay", "header" or "footer" ^ tile: tile the image instead of scaling (background only) ^ minsize: minimum tile size, images are scaled to at least this size prior ^ doing tiling (background only) core.set_clouds() core.set_topleft_text(text) core.show_keys_menu() core.file_open_dialog(formname,caption) ^ shows a file open dialog ^ formname is base name of dialog response returned in fields ^ -if dialog was accepted "_accepted" ^^ will be added to fieldname containing the path ^ -if dialog was canceled "_cancelled" ^ will be added to fieldname value is set to formname itself ^ returns nil or selected file/folder core.get_screen_info() ^ returns { density = , display_width = , display_height = , window_width = , window_height = } Games: core.get_game(index) ^ returns { id = , path = , gamemods_path = , name = , menuicon_path = , DEPRECATED: addon_mods_paths = {[1] = ,}, } core.get_games() -> table of all games in upper format (possible in async calls) core.get_mapgen_names([include_hidden=false]) -> table of map generator algorithms registered in the core (possible in async calls) Favorites: core.get_favorites(location) -> list of favorites (possible in async calls) ^ location: "local" or "online" ^ returns { [1] = { clients = , clients_max = , version = , password = , creative = , damage = , pvp = , description = , name = , address =
, port = }, } core.delete_favorite(id, location) -> success Logging: core.debug(line) (possible in async calls) ^ Always printed to stderr and logfile (print() is redirected here) core.log(line) (possible in async calls) core.log(loglevel, line) (possible in async calls) ^ loglevel one of "error", "action", "info", "verbose" Settings: core.setting_set(name, value) core.setting_get(name) -> string or nil (possible in async calls) core.setting_setbool(name, value) core.setting_getbool(name) -> bool or nil (possible in async calls) core.setting_save() -> nil, save all settings to config file Worlds: core.get_worlds() -> list of worlds (possible in async calls) ^ returns { [1] = { path = , name = , gameid = , }, } core.create_world(worldname, gameid) core.delete_world(index) Helpers: core.get_us_time() ^ returns time with microsecond precision core.gettext(string) -> string ^ look up the translation of a string in the gettext message catalog fgettext_ne(string, ...) ^ call core.gettext(string), replace "$1"..."$9" with the given ^ extra arguments and return the result fgettext(string, ...) -> string ^ same as fgettext_ne(), but calls core.formspec_escape before returning result core.parse_json(string[, nullvalue]) -> something (possible in async calls) ^ see core.parse_json (lua_api.txt) dump(obj, dumped={}) ^ Return object serialized as a string string:split(separator) ^ eg. string:split("a,b", ",") == {"a","b"} string:trim() ^ eg. string.trim("\n \t\tfoo bar\t ") == "foo bar" core.is_yes(arg) (possible in async calls) ^ returns whether arg can be interpreted as yes minetest.encode_base64(string) (possible in async calls) ^ Encodes a string in base64. minetest.decode_base64(string) (possible in async calls) ^ Decodes a string encoded in base64. Version compat: core.get_min_supp_proto() ^ returns the minimum supported network protocol version core.get_max_supp_proto() ^ returns the maximum supported network protocol version Async: core.handle_async(async_job,parameters,finished) ^ execute a function asynchronously ^ async_job is a function receiving one parameter and returning one parameter ^ parameters parameter table passed to async_job ^ finished function to be called once async_job has finished ^ the result of async_job is passed to this function Limitations of Async operations -No access to global lua variables, don't even try -Limited set of available functions e.g. No access to functions modifying menu like core.start,core.close, core.file_open_dialog Class reference ---------------- Settings: see lua_api.txt minetest-0.4.15+repack/doc/world_format.txt0000644000175000017500000003726513027050071017027 0ustar apoapo============================= Minetest World Format 22...25 ============================= This applies to a world format carrying the block serialization version 22...25, used at least in - 0.4.dev-20120322 ... 0.4.dev-20120606 (22...23) - 0.4.0 (23) - 24 was never released as stable and existed for ~2 days The block serialization version does not fully specify every aspect of this format; if compliance with this format is to be checked, it needs to be done by detecting if the files and data indeed follows it. Legacy stuff ============= Data can, in theory, be contained in the flat file directory structure described below in Version 17, but it is not officially supported. Also you may stumble upon all kinds of oddities in not-so-recent formats. Files ====== Everything is contained in a directory, the name of which is freeform, but often serves as the name of the world. Currently the authentication and ban data is stored on a per-world basis. It can be copied over from an old world to a newly created world. World |-- auth.txt ----- Authentication data |-- env_meta.txt - Environment metadata |-- ipban.txt ---- Banned ips/users |-- map_meta.txt - Map metadata |-- map.sqlite --- Map data |-- players ------ Player directory | |-- player1 -- Player file | '-- Foo ------ Player file `-- world.mt ----- World metadata auth.txt --------- Contains authentication data, player per line. :: Legacy format (until 0.4.12) of password hash is SHA1'd, in the base64 encoding. Format (since 0.4.13) of password hash is #1##, with the parts inside <> encoded in the base64 encoding. is an RFC 2945 compatible SRP verifier, of the given salt, password, and the player's name lowercased, using the 2048-bit group specified in RFC 5054 and the SHA-256 hash function. Example lines: - Player "celeron55", no password, privileges "interact" and "shout": celeron55::interact,shout - Player "Foo", password "bar", privilege "shout", with a legacy password hash: foo:iEPX+SQWIR3p67lj/0zigSWTKHg:shout - Player "Foo", password "bar", privilege "shout", with a 0.4.13 pw hash: foo:#1#hPpy4O3IAn1hsNK00A6wNw#Kpu6rj7McsrPCt4euTb5RA5ltF7wdcWGoYMcRngwDi11cZhPuuR9i5Bo7o6A877TgcEwoc//HNrj9EjR/CGjdyTFmNhiermZOADvd8eu32FYK1kf7RMC0rXWxCenYuOQCG4WF9mMGiyTPxC63VAjAMuc1nCZzmy6D9zt0SIKxOmteI75pAEAIee2hx4OkSXRIiU4Zrxo1Xf7QFxkMY4x77vgaPcvfmuzom0y/fU1EdSnZeopGPvzMpFx80ODFx1P34R52nmVl0W8h4GNo0k8ZiWtRCdrJxs8xIg7z5P1h3Th/BJ0lwexpdK8sQZWng8xaO5ElthNuhO8UQx1l6FgEA:shout - Player "bar", no password, no privileges: bar:: env_meta.txt ------------- Simple global environment variables. Example content (added indentation): game_time = 73471 time_of_day = 19118 EnvArgsEnd ipban.txt ---------- Banned IP addresses and usernames. Example content (added indentation): 123.456.78.9|foo 123.456.78.10|bar map_meta.txt ------------- Simple global map variables. Example content (added indentation): seed = 7980462765762429666 [end_of_params] map.sqlite ----------- Map data. See Map File Format below. player1, Foo ------------- Player data. Filename can be anything. See Player File Format below. world.mt --------- World metadata. Example content (added indentation): gameid = mesetint Player File Format =================== - Should be pretty self-explanatory. - Note: position is in nodes * 10 Example content (added indentation): hp = 11 name = celeron55 pitch = 39.77 position = (-5231.97,15,1961.41) version = 1 yaw = 101.37 PlayerArgsEnd List main 32 Item default:torch 13 Item default:pick_steel 1 50112 Item experimental:tnt Item default:cobble 99 Item default:pick_stone 1 13104 Item default:shovel_steel 1 51838 Item default:dirt 61 Item default:rail 78 Item default:coal_lump 3 Item default:cobble 99 Item default:leaves 22 Item default:gravel 52 Item default:axe_steel 1 2045 Item default:cobble 98 Item default:sand 61 Item default:water_source 94 Item default:glass 2 Item default:mossycobble Item default:pick_steel 1 64428 Item animalmaterials:bone Item default:sword_steel Item default:sapling Item default:sword_stone 1 10647 Item default:dirt 99 Empty Empty Empty Empty Empty Empty Empty Empty EndInventoryList List craft 9 Empty Empty Empty Empty Empty Empty Empty Empty Empty EndInventoryList List craftpreview 1 Empty EndInventoryList List craftresult 1 Empty EndInventoryList EndInventory Map File Format ================ Minetest maps consist of MapBlocks, chunks of 16x16x16 nodes. In addition to the bulk node data, MapBlocks stored on disk also contain other things. History -------- We need a bit of history in here. Initially Minetest stored maps in a format called the "sectors" format. It was a directory/file structure like this: sectors2/XXX/ZZZ/YYYY For example, the MapBlock at (0,1,-2) was this file: sectors2/000/ffd/0001 Eventually Minetest outgrow this directory structure, as filesystems were struggling under the amount of files and directories. Large servers seriously needed a new format, and thus the base of the current format was invented, suggested by celeron55 and implemented by JacobF. SQLite3 was slammed in, and blocks files were directly inserted as blobs in a single table, indexed by integer primary keys, oddly mangled from coordinates. Today we know that SQLite3 allows multiple primary keys (which would allow storing coordinates separately), but the format has been kept unchanged for that part. So, this is where it has come. So here goes ------------- map.sqlite is an sqlite3 database, containing a single table, called "blocks". It looks like this: CREATE TABLE `blocks` (`pos` INT NOT NULL PRIMARY KEY,`data` BLOB); The key -------- "pos" is created from the three coordinates of a MapBlock using this algorithm, defined here in Python: def getBlockAsInteger(p): return int64(p[2]*16777216 + p[1]*4096 + p[0]) def int64(u): while u >= 2**63: u -= 2**64 while u <= -2**63: u += 2**64 return u It can be converted the other way by using this code: def getIntegerAsBlock(i): x = unsignedToSigned(i % 4096, 2048) i = int((i - x) / 4096) y = unsignedToSigned(i % 4096, 2048) i = int((i - y) / 4096) z = unsignedToSigned(i % 4096, 2048) return x,y,z def unsignedToSigned(i, max_positive): if i < max_positive: return i else: return i - 2*max_positive The blob --------- The blob is the data that would have otherwise gone into the file. See below for description. MapBlock serialization format ============================== NOTE: Byte order is MSB first (big-endian). NOTE: Zlib data is in such a format that Python's zlib at least can directly decompress. u8 version - map format version number, see serialisation.h for the latest number u8 flags - Flag bitmasks: - 0x01: is_underground: Should be set to 0 if there will be no light obstructions above the block. If/when sunlight of a block is updated and there is no block above it, this value is checked for determining whether sunlight comes from the top. - 0x02: day_night_differs: Whether the lighting of the block is different on day and night. Only blocks that have this bit set are updated when day transforms to night. - 0x04: lighting_expired: If true, lighting is invalid and should be updated. If you can't calculate lighting in your generator properly, you could try setting this 1 to everything and setting the uppermost block in every sector as is_underground=0. I am quite sure it doesn't work properly, though. - 0x08: generated: True if the block has been generated. If false, block is mostly filled with CONTENT_IGNORE and is likely to contain eg. parts of trees of neighboring blocks. u8 content_width - Number of bytes in the content (param0) fields of nodes if map format version <= 23: - Always 1 if map format version >= 24: - Always 2 u8 params_width - Number of bytes used for parameters per node - Always 2 zlib-compressed node data: if content_width == 1: - content: u8[4096]: param0 fields u8[4096]: param1 fields u8[4096]: param2 fields if content_width == 2: - content: u16[4096]: param0 fields u8[4096]: param1 fields u8[4096]: param2 fields - The location of a node in each of those arrays is (z*16*16 + y*16 + x). zlib-compressed node metadata list - content: if map format version <= 22: u16 version (=1) u16 count of metadata foreach count: u16 position (p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X) u16 type_id u16 content_size u8[content_size] content of metadata. Format depends on type_id, see below. if map format version >= 23: u8 version (=1) -- Note the type is u8, while for map format version <= 22 it's u16 u16 count of metadata foreach count: u16 position (p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X) u32 num_vars foreach num_vars: u16 key_len u8[key_len] key u32 val_len u8[val_len] value serialized inventory - Node timers if map format version == 23: u8 unused version (always 0) if map format version == 24: (NOTE: Not released as stable) u8 nodetimer_version if nodetimer_version == 0: (nothing else) if nodetimer_version == 1: u16 num_of_timers foreach num_of_timers: u16 timer position (z*16*16 + y*16 + x) s32 timeout*1000 s32 elapsed*1000 if map format version >= 25: -- Nothing right here, node timers are serialized later u8 static object version: - Always 0 u16 static_object_count foreach static_object_count: u8 type (object type-id) s32 pos_x_nodes * 10000 s32 pos_y_nodes * 10000 s32 pos_z_nodes * 10000 u16 data_size u8[data_size] data u32 timestamp - Timestamp when last saved, as seconds from starting the game. - 0xffffffff = invalid/unknown timestamp, nothing should be done with the time difference when loaded u8 name-id-mapping version - Always 0 u16 num_name_id_mappings foreach num_name_id_mappings u16 id u16 name_len u8[name_len] name - Node timers if map format version == 25: u8 length of the data of a single timer (always 2+4+4=10) u16 num_of_timers foreach num_of_timers: u16 timer position (z*16*16 + y*16 + x) s32 timeout*1000 s32 elapsed*1000 EOF. Format of nodes ---------------- A node is composed of the u8 fields param0, param1 and param2. if map format version <= 23: The content id of a node is determined as so: - If param0 < 0x80, content_id = param0 - Otherwise content_id = (param0<<4) + (param2>>4) if map format version >= 24: The content id of a node is param0. The purpose of param1 and param2 depend on the definition of the node. The name-id-mapping -------------------- The mapping maps node content ids to node names. Node metadata format for map format versions <= 22 --------------------------------------------------- The node metadata are serialized depending on the type_id field. 1: Generic metadata serialized inventory u32 len u8[len] text u16 len u8[len] owner u16 len u8[len] infotext u16 len u8[len] inventory drawspec u8 allow_text_input (bool) u8 removal_disabled (bool) u8 enforce_owner (bool) u32 num_vars foreach num_vars u16 len u8[len] name u32 len u8[len] value 14: Sign metadata u16 text_len u8[text_len] text 15: Chest metadata serialized inventory 16: Furnace metadata TBD 17: Locked Chest metadata u16 len u8[len] owner serialized inventory Static objects --------------- Static objects are persistent freely moving objects in the world. Object types: 1: Test object 2: Item 3: Rat (deprecated) 4: Oerkki (deprecated) 5: Firefly (deprecated) 6: MobV2 (deprecated) 7: LuaEntity 1: Item: u8 version version 0: u16 len u8[len] itemstring 7: LuaEntity: u8 version version 1: u16 len u8[len] entity name u32 len u8[len] static data s16 hp s32 velocity.x * 10000 s32 velocity.y * 10000 s32 velocity.z * 10000 s32 yaw * 1000 Itemstring format ------------------ eg. 'default:dirt 5' eg. 'default:pick_wood 21323' eg. '"default:apple" 2' eg. 'default:apple' - The wear value in tools is 0...65535 - There are also a number of older formats that you might stumble upon: eg. 'node "default:dirt" 5' eg. 'NodeItem default:dirt 5' eg. 'ToolItem WPick 21323' Inventory serialization format ------------------------------- - The inventory serialization format is line-based - The newline character used is "\n" - The end condition of a serialized inventory is always "EndInventory\n" - All the slots in a list must always be serialized. Example (format does not include "---"): --- List foo 4 Item default:sapling Item default:sword_stone 1 10647 Item default:dirt 99 Empty EndInventoryList List bar 9 Empty Empty Empty Empty Empty Empty Empty Empty Empty EndInventoryList EndInventory --- ============================================== Minetest World Format used as of 2011-05 or so ============================================== Map data serialization format version 17. 0.3.1 does not use this format, but a more recent one. This exists here for historical reasons. Directory structure: sectors/XXXXZZZZ or sectors2/XXX/ZZZ XXXX, ZZZZ, XXX and ZZZ being the hexadecimal X and Z coordinates. Under these, the block files are stored, called YYYY. There also exists files map_meta.txt and chunk_meta, that are used by the generator. If they are not found or invalid, the generator will currently behave quite strangely. The MapBlock file format (sectors2/XXX/ZZZ/YYYY): ------------------------------------------------- NOTE: Byte order is MSB first. u8 version - map format version number, this one is version 17 u8 flags - Flag bitmasks: - 0x01: is_underground: Should be set to 0 if there will be no light obstructions above the block. If/when sunlight of a block is updated and there is no block above it, this value is checked for determining whether sunlight comes from the top. - 0x02: day_night_differs: Whether the lighting of the block is different on day and night. Only blocks that have this bit set are updated when day transforms to night. - 0x04: lighting_expired: If true, lighting is invalid and should be updated. If you can't calculate lighting in your generator properly, you could try setting this 1 to everything and setting the uppermost block in every sector as is_underground=0. I am quite sure it doesn't work properly, though. zlib-compressed map data: - content: u8[4096]: content types u8[4096]: param1 values u8[4096]: param2 values zlib-compressed node metadata - content: u16 version (=1) u16 count of metadata foreach count: u16 position (= p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X) u16 type_id u16 content_size u8[content_size] misc. stuff contained in the metadata u16 mapblockobject_count - always write as 0. - if read != 0, just fail. foreach mapblockobject_count: - deprecated, should not be used. Length of this data can only be known by properly parsing it. Just hope not to run into any of this. u8 static object version: - currently 0 u16 static_object_count foreach static_object_count: u8 type (object type-id) s32 pos_x * 1000 s32 pos_y * 1000 s32 pos_z * 1000 u16 data_size u8[data_size] data u32 timestamp - Timestamp when last saved, as seconds from starting the game. - 0xffffffff = invalid/unknown timestamp, nothing will be done with the time difference when loaded (recommended) Node metadata format: --------------------- Sign metadata: u16 string_len u8[string_len] string Furnace metadata: TBD Chest metadata: TBD Locking Chest metadata: u16 string_len u8[string_len] string TBD // END minetest-0.4.15+repack/doc/protocol.txt0000644000175000017500000000662713027050071016167 0ustar apoapoMinetest protocol (incomplete, early draft): Updated 2011-06-18 A custom protocol over UDP. Integers are big endian. Refer to connection.{h,cpp} for further reference. Initialization: - A dummy reliable packet with peer_id=PEER_ID_INEXISTENT=0 is sent to the server: - Actually this can be sent without the reliable packet header, too, i guess, but the sequence number in the header allows the sender to re-send the packet without accidentally getting a double initialization. - Packet content: # Basic header u32 protocol_id = PROTOCOL_ID = 0x4f457403 u16 sender_peer_id = PEER_ID_INEXISTENT = 0 u8 channel = 0 # Reliable packet header u8 type = TYPE_RELIABLE = 3 u16 seqnum = SEQNUM_INITIAL = 65500 # Original packet header u8 type = TYPE_ORIGINAL = 1 # And no actual payload. - Server responds with something like this: - Packet content: # Basic header u32 protocol_id = PROTOCOL_ID = 0x4f457403 u16 sender_peer_id = PEER_ID_INEXISTENT = 0 u8 channel = 0 # Reliable packet header u8 type = TYPE_RELIABLE = 3 u16 seqnum = SEQNUM_INITIAL = 65500 # Control packet header u8 type = TYPE_CONTROL = 0 u8 controltype = CONTROLTYPE_SET_PEER_ID = 1 u16 peer_id_new = assigned peer id to client (other than 0 or 1) - Then the connection can be disconnected by sending: - Packet content: # Basic header u32 protocol_id = PROTOCOL_ID = 0x4f457403 u16 sender_peer_id = whatever was gotten in CONTROLTYPE_SET_PEER_ID u8 channel = 0 # Control packet header u8 type = TYPE_CONTROL = 0 u8 controltype = CONTROLTYPE_DISCO = 3 - Here's a quick untested connect-disconnect done in PHP: # host: ip of server (use gethostbyname(hostname) to get from a dns name) # port: port of server function check_if_minetestserver_up($host, $port) { $socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); $timeout = array("sec" => 1, "usec" => 0); socket_set_option($socket, SOL_SOCKET, SO_RCVTIMEO, $timeout); $buf = "\x4f\x45\x74\x03\x00\x00\x00\x03\xff\xdc\x01"; socket_sendto($socket, $buf, strlen($buf), 0, $host, $port); $buf = socket_read($socket, 1000); if($buf != "") { # We got a reply! read the peer id from it. $peer_id = substr($buf, 9, 2); # Disconnect $buf = "\x4f\x45\x74\x03".$peer_id."\x00\x00\x03"; socket_sendto($socket, $buf, strlen($buf), 0, $host, $port); socket_close($socket); return true; } return false; } - Here's a Python script for checking if a minetest server is up, confirmed working #!/usr/bin/env python import sys, time, socket address = "" port = 30000 if len(sys.argv) <= 1: print("Usage: %s
" % sys.argv[0]) exit() if ':' in sys.argv[1]: address = sys.argv[1].split(':')[0] try: port = int(sys.argv[1].split(':')[1]) except ValueError: print("Please specify a valid port") exit() else: address = sys.argv[1] try: start = time.time() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.settimeout(2.0) buf = "\x4f\x45\x74\x03\x00\x00\x00\x01" sock.sendto(buf, (address, port)) data, addr = sock.recvfrom(1000) if data: peer_id = data[12:14] buf = "\x4f\x45\x74\x03" + peer_id + "\x00\x00\x03" sock.sendto(buf, (address, port)) sock.close() end = time.time() print("%s is up (%0.5fms)" % (sys.argv[1],end-start)) else: print("%s seems to be down " % sys.argv[1]) except: print("%s seems to be down " % sys.argv[1]) minetest-0.4.15+repack/doc/minetestserver.60000644000175000017500000000002513027050071016715 0ustar apoapo.so man6/minetest.6 minetest-0.4.15+repack/doc/main_page.dox0000644000175000017500000000036713027050071016214 0ustar apoapo/** @mainpage The Minetest engine internal documentation Welcome to the Minetest engine Doxygen documentation site!\n This page documents the internal structure of the Minetest engine's C++ code.\n Use the tree view at the left to navigate. */ minetest-0.4.15+repack/doc/lua_api.txt0000644000175000017500000055736713027050071015754 0ustar apoapoMinetest Lua Modding API Reference 0.4.15 ========================================= * More information at * Developer Wiki: Introduction ------------ Content and functionality can be added to Minetest 0.4 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. 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. You can send such improvements as source code patches to . 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 server startup from the mod load paths by running the `init.lua` scripts in a shared environment. Paths ----- * `RUN_IN_PLACE=1` (Windows release, local build) * `$path_user`: * Linux: `` * Windows: `` * `$path_share` * Linux: `` * Windows: `` * `RUN_IN_PLACE=0`: (Linux release) * `$path_share` * Linux: `/usr/share/minetest` * Windows: `/minetest-0.4.x` * `$path_user`: * Linux: `$HOME/.minetest` * Windows: `C:/users//AppData/minetest` (maybe) Games ----- Games are looked up from: * `$path_share/games/gameid/` * `$path_user/games/gameid/` where `gameid` is unique to each game. The game directory contains the file `game.conf`, which contains these fields: name = e.g. name = Minetest The game directory can contain the file minetest.conf, which will be used to set default settings when running the particular game. It can also contain a 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 settings tab. ### Menu images 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. Mod load path ------------- 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/worldmods` Mod load path for world-specific games -------------------------------------- It 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/ Modpack support ---------------- 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. Mod directory structure ------------------------ mods |-- modname | |-- depends.txt | |-- screenshot.png | |-- description.txt | |-- settingtypes.txt | |-- init.lua | |-- models | |-- textures | | |-- modname_stuff.png | | `-- modname_something_else.png | |-- sounds | |-- media | `-- `-- another ### modname The location of this directory can be fetched by using `minetest.get_modpath(modname)`. ### `depends.txt` List of mods that have to be loaded before loading this mod. A single line contains a single modname. Optional dependencies can be defined by appending a question mark to a single modname. Their meaning is that if the specified mod is missing, that does not prevent this mod from being loaded. ### `screenshot.png` A 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. ### `description.txt` A File containing description to be shown within mainmenu. ### `settingtypes.txt` A 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.lua` The main Lua script. Running this script should register everything it wants to register. Subsequent execution depends on minetest calling the registered callbacks. `minetest.setting_get(name)` and `minetest.setting_getbool(name)` can be used to read custom or existing settings at load time, if necessary. ### `models` Models for entities or meshnodes. ### `textures`, `sounds`, `media` Media files (textures, sounds, whatever) that will be transferred to the client and will be available for use by the mod. Naming convention for registered textual names ---------------------------------------------- Registered names should generally be in this format: "modname:" ( 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. ### Aliases Aliases can be added by using `minetest.register_alias(name, convert_to)` or `minetest.register_alias_force(name, convert_to). This will make Minetest to convert things called name to things called `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 be also used for setting 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`. Textures -------- 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: * e.g. `foomod_foothing.png` * e.g. `foomod_foothing` Texture modifiers ----------------- There are various texture modifiers that can be used to generate textures on-the-fly. ### Texture overlaying Textures can be overlaid by putting a `^` between them. Example: default_dirt.png^default_grass_side.png `default_grass_side.png` is overlayed over `default_dirt.png`. The texture with the lower resolution will be automatically upscaled to the higher resolution texture. ### Texture grouping 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`. ### Escaping 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`. ### Advanced texture modifiers #### `[crack::

` * `` = animation frame count * `

` = current animation frame Draw a step of the crack animation on the texture. Example: default_cobble.png^[crack:10:1 #### `[combine:x:,=:,=:...` * `` = width * `` = height * `` = x position * `` = y position * `` = texture to combine Creates a texture of size `` times `` and blits the listed files to their specified coordinates. Example: [combine:16x32:0,0=default_cobble.png:0,16=default_wood.png #### `[resize:x` Resizes the texture to the given dimensions. Example: default_sandstone.png^[resize:16x16 #### `[opacity:` 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:` 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 #### `[brighten` Brightens the texture. Example: tnt_tnt_side.png^[brighten #### `[noalpha` Makes the texture completely opaque. Example: default_leaves.png^[noalpha #### `[makealpha:,,` Convert one color to transparency. Example: default_cobble.png^[makealpha:128,128,128 #### `[transform` * `` = transformation(s) to apply Rotates and/or flips the image. `` 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{{{` 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::` Blit the lower ``% part of `` on the texture. Example: base.png^[lowpart:25:overlay.png #### `[verticalframe::` * `` = animation frame count * `` = current animation frame Crops the texture to a frame of a vertical animation. Example: default_torch_animated.png^[verticalframe:16:8 #### `[mask:` Apply a mask to the base image. The mask is applied using binary AND. #### `[colorize::` Colorize the textures with the given color. `` is specified as a `ColorString`. `` 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 ``. If omitted, the alpha of `` will be used as the ratio. If it is the word "`alpha`", then each texture pixel will contain the RGB of `` and the alpha of `` multiplied by the alpha of the texture pixel. Sounds ------ 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 on all clients { gain = 1.0, -- default } -- Play locationless to one player { to_player = name, gain = 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 = , 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` * e.g. `""` * e.g. `"default_place_node"` * e.g. `{}` * e.g. `{name = "default_place_node"}` * e.g. `{name = "default_place_node", gain = 1.0}` Registered definitions of stuff ------------------------------- Anything added using certain `minetest.register_*` functions get added to the global `minetest.registered_*` tables. * `minetest.register_entity(name, prototype table)` * added to `minetest.registered_entities[name]` * `minetest.register_node(name, node definition)` * added to `minetest.registered_items[name]` * added to `minetest.registered_nodes[name]` * `minetest.register_tool(name, item definition)` * added to `minetest.registered_items[name]` * `minetest.register_craftitem(name, item definition)` * added to `minetest.registered_items[name]` * `minetest.unregister_item(name)` * Unregisters the item name from engine, and deletes the entry with key * `name` from `minetest.registered_items` and from the associated item * table according to its nature: minetest.registered_nodes[] etc * `minetest.register_biome(biome definition)` * returns an integer uniquely identifying the registered biome * added to `minetest.registered_biome` with the key of `biome.name` * if `biome.name` is nil, the key is the returned ID * `minetest.register_ore(ore definition)` * returns an integer uniquely identifying the registered ore * added to `minetest.registered_ores` with the key of `ore.name` * if `ore.name` is nil, the key is the returned ID * `minetest.register_decoration(decoration definition)` * returns an integer uniquely identifying the registered decoration * added to `minetest.registered_decorations` with the key of `decoration.name` * if `decoration.name` is nil, the key is the returned ID * `minetest.register_schematic(schematic definition)` * returns an integer uniquely identifying the registered schematic * added to `minetest.registered_schematic` with the key of `schematic.name` * if `schematic.name` is nil, the key is the returned ID * if the schematic is loaded from a file, schematic.name is set to the filename * if the function is called when loading the mod, and schematic.name is a relative path, then the current mod path will be prepended to the schematic filename * `minetest.clear_registered_biomes()` * clears all biomes currently registered * `minetest.clear_registered_ores()` * clears all ores currently registered * `minetest.clear_registered_decorations()` * clears all decorations currently registered * `minetest.clear_registered_schematics()` * clears all schematics currently registered 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 ----- 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. 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" paramtype2 == "degrotate" ^ The rotation of this node is stored in param2. Plants are rotated this way. Values range 0 - 179. The value stored in param2 is multiplied by two to get the actual rotation 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. collision_box = { type = "fixed", fixed = { {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5}, }, }, ^ defines list of collision boxes for the node. If empty, collision boxes will be the same as nodeboxes, in case of any other nodes will be full cube as in the example above. Nodes can also contain extra data. See "Node Metadata". Node drawtypes --------------- There are a bunch of different looking node types. Look for examples in `games/minimal` or `games/minetest_game`. * `normal` * `airlike` * `liquid` * `flowingliquid` * `glasslike` * `glasslike_framed` * `glasslike_framed_optional` * `allfaces` * `allfaces_optional` * `torchlike` * `signlike` * `plantlike` * `firelike` * `fencelike` * `raillike` * `nodebox` -- See below. (**Experimental!**) * `mesh` -- use models for nodes `*_optional` drawtypes need less rendering time if deactivated (always client side). Node boxes ----------- Node selection boxes are defined using "node boxes" The `nodebox` node drawtype allows defining visual of nodes consisting of arbitrary number of boxes. It allows defining stuff like stairs. Only the `fixed` and `leveled` box type is supported for these. Please note that this is still experimental, and may be incompatibly changed in the future. A nodebox is defined as any of: { -- A normal cube; the default in most things type = "regular" } { -- A fixed box (facedir param2 is used, if applicable) type = "fixed", 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, ...} } 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}, `type = "leveled"` is same as `type = "fixed"`, but `y2` will be automatically set to level from `param2`. Meshes ------ If drawtype `mesh` is used, tiles should hold model materials textures. Only static meshes are implemented. For supported model formats see Irrlicht engine documentation. Noise Parameters ---------------- Noise Parameters, or commonly called "`NoiseParams`", define the properties of perlin noise. ### `offset` Offset that the noise is translated by (i.e. added) after calculation. ### `scale` Factor that the noise is scaled by (i.e. multiplied) after calculation. ### `spread` Vector containing values by which each coordinate is divided by before calculation. Higher spread values result in larger noise features. A value of `{x=250, y=250, z=250}` is common. ### `seed` Random seed for the noise. Add the world seed to a seed offset for world-unique noise. In the case of `minetest.get_perlin()`, this value has the world seed automatically added. ### `octaves` Number of times the noise gradient is accumulated into the noise. Increase this number to increase the amount of detail in the resulting noise. A value of `6` is common. ### `persistence` Factor by which the effect of the noise gradient function changes with each successive octave. Values less than `1` make the details of successive octaves' noise diminish, while values greater than `1` make successive octaves stronger. A value of `0.6` is common. ### `lacunarity` Factor by which the noise feature sizes change with each successive octave. A value of `2.0` is common. ### `flags` Leave this field unset for no special handling. Currently supported are `defaults`, `eased` and `absvalue`. #### `defaults` Specify this if you would like to keep auto-selection of eased/not-eased while specifying some other flags. #### `eased` Maps noise gradient values onto a quintic S-curve before performing interpolation. This results in smooth, rolling noise. Disable this (`noeased`) for sharp-looking noise. If no flags are specified (or defaults is), 2D noise is eased and 3D noise is not eased. #### `absvalue` Accumulates the absolute value of each noise gradient result. Noise parameters format example 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" } ^ A single noise parameter table can be used to get 2D or 3D noise, when getting 2D noise spread.z is ignored. Ore types --------- These tell in what manner the ore is generated. All default ores are of the uniformly-distributed scatter type. ### `scatter` Randomly chooses a location and generates a cluster of ore. If `noise_params` is specified, the ore will be placed if the 3D perlin noise at that point is greater than the `noise_threshold`, giving the ability to create a non-equal distribution of ore. ### `sheet` Creates a sheet of ore in a blob shape according to the 2D perlin noise described by `noise_params` 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 eminates 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. ### `puff` Creates 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. ### `blob` Creates 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. ### `vein` Creates veins of ore varying in density by according to the intersection of two instances of 3d perlin noise with diffferent 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, flags = "eased", }, noise_threshold = 1.6 WARNING: Use this ore type *very* sparingly since it is ~200x more computationally expensive than any other ore. Ore attributes -------------- See section "Flag Specifier Format". Currently supported flags: `absheight` ### `absheight` Also produce this same ore between the height range of `-y_max` and `-y_min`. Useful for having ore in sky realms without having to duplicate ore entries. ### `puff_cliffs` If 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_composition` By 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`. Decoration types ---------------- The varying types of decorations that can be placed. ### `simple` Creates 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. ### `schematic` Copies 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. Schematic specifier -------------------- 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: * The `size` field is a 3D vector containing the dimensions of the provided schematic. (required) * The `yslice_prob` field is a table of {ypos, prob} which sets the `ypos`th vertical slice of the schematic to have a `prob / 256 * 100` chance of occuring. (default: 255) * The `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: * A probability value of `0` or `1` means that node will never appear (0% chance). * A probability value of `254` or `255` means the node will always appear (100% chance). * If the probability value `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. Schematic attributes -------------------- 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. 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. 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", ref=ObjectRef}` 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. Items ----- ### Item types There are three kinds of items: nodes, tools and craftitems. * Node (`register_node`): A node from the world. * Tool (`register_tool`): A tool/weapon that can dig and damage things according to `tool_capabilities`. * Craftitem (`register_craftitem`): A miscellaneous item. ### Item formats Items and item stacks can exist in three formats: Serializes, table format and `ItemStack`. #### Serialized This is called "stackstring" or "itemstring": * e.g. `'default:dirt 5'` * e.g. `'default:pick_wood 21323'` * e.g. `'default:apple'` #### Table format Examples: 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=""} #### `ItemStack` A 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. Groups ------ 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. ### Usage 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 Groups of items can define what kind of an item it is (e.g. wool). ### Groups of nodes 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. ### Groups of entities For entities, groups are, as of now, used only for calculating damage. The rating is the percentage of damage caused by tools with this damage group. See "Entity damage mechanism". object.get_armor_groups() --> a group-rating table (e.g. {fleshy=100}) object.set_armor_groups({fleshy=30, cracky=80}) ### Groups of tools Groups in tools define which groups of nodes and entities they are effective towards. ### Groups in crafting recipes 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'}, } ### Special groups * `immortal`: Disables the group damage system for an entity * `level`: Can be used to give an additional sense of progression in the game. * A larger level will cause e.g. a weapon of a lower level make much less damage, and get worn out much faster, or not be able to get drops from destroyed nodes. * `0` is something that is directly accessible at the start of gameplay * There is no upper limit * `dig_immediate`: (player can always pick up node without tool wear) * `2`: node is removed without tool wear after 0.5 seconds or so (rail, sign) * `3`: node is removed without tool wear immediately (torch) * `disable_jump`: Player (and possibly other things) cannot jump from node * `fall_damage_add_percent`: damage speed = `speed * (1 + value/100)` * `bouncy`: value is bounce speed in percent * `falling_node`: if there is no walkable block under the node it will fall * `attached_node`: if the node under it is not a walkable block the node will be dropped as an item. If the node is wallmounted the wallmounted direction is checked. * `soil`: saplings will grow on nodes in this group * `connect_to_raillike`: makes nodes of raillike drawtype with same group value connect to each other ### Known damage and digging time defining groups * `crumbly`: dirt, sand * `cracky`: tough but crackable stuff like stone. * `snappy`: something that can be cut using fine tools; e.g. leaves, small plants, wire, sheets of metal * `choppy`: something that can be cut using force; e.g. trees, wooden planks * `fleshy`: Living things like animals and the player. This could imply some blood effects when hitting. * `explody`: Especially prone to explosions * `oddly_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. ### Examples of custom groups 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 metal * `weapon`: any weapon * `heavy`: anything considerably heavy ### Digging time calculation specifics Groups 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 definition Tools define: * Full punch interval * Maximum drop level * For an arbitrary list of groups: * Uses (until the tool breaks) * Maximum level (usually `0`, `1`, `2` or `3`) * Digging times * Damage groups #### Full punch interval When used as a weapon, the tool will do full damage if this time is spent between punches. If e.g. half the time is spent, the tool will do half damage. #### Maximum drop level 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. #### Uses 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: 10 * `uses=10, leveldiff=1`: actual uses: 30 * `uses=10, leveldiff=2`: actual uses: 90 #### Maximum level Tells what is the maximum level of a node of this group that the tool will be able to dig. #### Digging times 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. #### Damage groups List of damage for groups of entities. See "Entity damage mechanism". #### Example definition of the capabilities of a tool tool_capabilities = { full_punch_interval=1.5, max_drop_level=1, groupcaps={ crumbly={maxlevel=2, uses=20, times={[1]=1.60, [2]=1.20, [3]=0.80}} } damage_groups = {fleshy=2}, } This makes the tool be able to dig nodes that fulfil both of these: * Have the `crumbly` group * Have a `level` group less or equal to `2` 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**: * At `crumbly==0`, the node is not diggable. * At `crumbly==3`, the level difference digging time divider kicks in and makes easy nodes to be quickly breakable. * At `level > 2`, the node is not diggable, because it's `level > maxlevel` Entity damage mechanism ----------------------- Damage 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) 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. To punch an entity/object in Lua, call: object:punch(puncher, time_from_last_punch, tool_capabilities, direction) * Return value is tool wear. * Parameters are equal to the above callback. * If `direction` equals `nil` and `puncher` does not equal `nil`, `direction` will be automatically filled in based on the location of `puncher`. Node Metadata ------------- 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`". Metadata contains two things: * A key-value store * An inventory 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 at Example 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" } }) Formspec -------- 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. ### 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[,,]` * Define the size of the menu in inventory slots * `fixed_size`: `true`/`false` (optional) * deprecated: `invsize[,;]` #### `container[,]` * 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[;;,;,;]` * Show an inventory list #### `list[;;,;,;]` * Show an inventory list #### `listring[;]` * 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[;]` for the last two inventory lists added by list[...] #### `listcolors[;]` * Sets background color of slots as `ColorString` * Sets background color of slots on mouse hovering #### `listcolors[;;]` * Sets background color of slots as `ColorString` * Sets background color of slots on mouse hovering * Sets color of slots border #### `listcolors[;;;;]` * 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[;;,]` * Adds tooltip for an element * `` tooltip background color as `ColorString` (optional) * `` tooltip font color as `ColorString` (optional) #### `image[,;,;]` * Show an image * Position and size units are inventory slots #### `item_image[,;,;]` * Show an inventory image of registered item/node * Position and size units are inventory slots #### `bgcolor[;]` * Sets background color of formspec as `ColorString` * If `true`, the background color is drawn fullscreen (does not effect the size of the formspec) #### `background[,;,;]` * 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[,;,;;]` * 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[,;,;;