1 Minetest Lua Modding API Reference 0.4.dev
2 ==========================================
6 If you have any difficulty in understanding this, please read:
7 http://www.lua.org/pil/
11 dump2(obj, name="_", dumped={})
12 ^ Return object serialized as a string, handles reference loops
14 ^ Return object serialized as a string
19 $path_share/games/gameid/mods/
20 $path_share/mods/gameid/
21 $path_user/games/gameid/mods/
22 $path_user/mods/gameid/ <-- User-installed mods
25 In a run-in-place version (eg. the distributed windows version):
26 minetest-0.4.x/games/gameid/mods/
27 minetest-0.4.x/mods/gameid/ <-- User-installed mods
28 minetest-0.4.x/worlds/worldname/worldmods/
30 On an installed version on linux:
31 /usr/share/minetest/games/gameid/mods/
32 ~/.minetest/mods/gameid/ <-- User-installed mods
33 ~/.minetest/worlds/worldname/worldmods
35 Naming convention for registered textual names
36 ----------------------------------------------
37 "modname:<whatever>" (<whatever> can have characters a-zA-Z0-9_)
39 This is to prevent conflicting names from corrupting maps and is
40 enforced by the mod loader.
42 Example: mod "experimental", ideal item/node/entity name "tnt":
43 -> the name should be "experimental:tnt".
45 Enforcement can be overridden by prefixing the name with ":". This can
46 be used for overriding the registrations of some other mod.
48 Example: Any mod can redefine experimental:tnt by using the name
49 ":experimental:tnt" when registering it.
50 (also that mod is required to have "experimental" as a dependency)
52 The ":" prefix can be used for maintaining backwards compatibility.
56 Aliases can be added by using minetest.register_alias(name, convert_to)
58 This can be used for maintaining backwards compatibility.
60 This can be also used for setting quick access names for things, eg. if
61 you have an item called epiclylongmodname:stuff, you could do
62 minetest.register_alias("stuff", "epiclylongmodname:stuff")
63 and be able to use "/giveme stuff".
67 Mods should generally prefix their textures with modname_, eg. given
68 the mod name "foomod", a texture could be called
71 Representations of simple things
72 --------------------------------
73 MapNode representation:
74 {name="name", param1=num, param2=num}
76 MapNodes do not directly have any other data associated with them.
77 If you want to access the definition of the node, you access
78 minetest.registered_nodes[node.name]
80 param1 and param2 are 8 bit and 4 bit integers, respectively. They
81 are reserved for certain automated functions. If you don't use these
82 functions, you can use them to store arbitrary values.
84 param1 is reserved for the engine when:
86 param2 is reserved for the engine when any of these are used:
87 liquidtype == "flowing"
88 drawtype == "flowingliquid"
89 drawtype == "torchlike"
90 drawtype == "signlike"
94 Currently the API does not provide any helper functions for addition,
95 subtraction and whatever; you can define those that you need yourself.
97 stackstring/itemstring: A stack of items in serialized format.
98 eg. 'node "default:dirt" 5'
99 eg. 'tool "default:pick_wood" 21323'
100 eg. 'craft "default:apple" 2'
102 item: A stack of items in Lua table format.
103 eg. {name="default:dirt", count=1, wear=0, metadata=""}
105 eg. {name="default:pick_wood", count=1, wear=21323, metadata=""}
106 ^ a wooden pick about 1/3 weared out
107 eg. {name="default:apple", count=1, wear=0, metadata=""}
110 Any time an item must be passed to a function, it can be an
111 ItemStack (see below), an itemstring or a table in the above format.
115 Node (register_node):
116 A node from the world
117 Tool (register_tool):
118 A tool/weapon that can dig and damage things according to tool_capabilities
119 Craftitem (register_craftitem):
124 In a number of places, there is a group table. Groups define the
125 properties of a thing (item, node, armor of entity, capabilities of
126 tool) in such a way that the engine and other mods can can interact with
127 the thing without actually knowing what the thing is.
130 - Groups are stored in a table, having the group names with keys and the
131 group ratings as values. For example:
132 groups = {crumbly=3, soil=1}
133 ^ Default dirt (soil group actually currently not defined; TODO)
134 groups = {crumbly=2, soil=1, level=2, outerspace=1}
135 ^ A more special dirt-kind of thing
136 - Groups always have a rating associated with them. If there is no
137 useful meaning for a rating for an enabled group, it shall be 1.
138 - When not defined, the rating of a group defaults to 0. Thus when you
139 read groups, you must interpret nil and 0 as the same value, 0.
143 Groups of items can define what kind of an item it is (eg. wool).
147 In addition to the general item things, whether a node is diggable and how
148 long it takes is defined by using groups.
152 For entities, groups are, as of now, used only for calculating damage.
154 object.get_armor_groups() -> a group-rating table (eg. {fleshy=3})
155 object.set_armor_groups({level=2, fleshy=2, cracky=2})
159 Groups in tools define which groups of nodes and entities they are
162 Groups in crafting recipes
163 ---------------------------
164 - Not implemented yet. (TODO)
165 - Will probably look like this:
167 output = 'food:meat_soup_raw',
173 preserve = {'group:bowl'},
178 - immortal: Disables the group damage system for an entity
179 - level: Can be used to give an additional sense of progression in the game.
180 - A larger level will cause eg. a weapon of a lower level make much less
181 damage, and get weared out much faster, or not be able to get drops
182 from destroyed nodes.
183 - 0 is something that is directly accessible at the start of gameplay
184 - dig_immediate: (player can always pick up node without tool wear)
185 - 2: node is removed without tool wear after 0.5 seconds or so
187 - 3: node is removed without tool wear immediately (torch)
189 Known damage and digging time defining groups
190 ----------------------------------------------
191 - crumbly: dirt, sand
192 - cracky: tough but crackable stuff like stone.
193 - snappy: something that can be cut using fine tools; eg. leaves, small
194 plants, wire, sheets of metal
195 - choppy: something that can be cut using force; eg. trees, wooden planks
196 - fleshy: Living things like animals and the player. This could imply
197 some blood effects when hitting.
198 - explody: Especially prone to explosions
199 - oddly_breakable_by_hand:
200 Can be added to nodes that shouldn't logically be breakable by the
201 hand but are. Somewhat similar to dig_immediate, but times are more
202 like {[1]=3.50,[2]=2.00,[3]=0.70} and this does not override the
203 speed of a tool if the tool can dig at a larger speed than this
204 suggests for the hand.
206 Examples of custom groups
207 --------------------------
208 Item groups are often used for defining, well, //groups of items//.
209 - meat: any meat-kind of a thing (rating might define the size or healing
210 ability or be irrelevant - it is not defined as of yet)
211 - eatable: anything that can be eaten. Rating might define HP gain in half
213 - flammable: can be set on fire. Rating might define the intensity of the
214 fire, affecting eg. the speed of the spreading of an open fire.
215 - wool: any wool (any origin, any color)
218 - heavy: anything considerably heavy
220 Digging time calculation specifics
221 -----------------------------------
222 Groups such as **crumbly**, **cracky** and **snappy** are used for this
223 purpose. Rating is 1, 2 or 3. A higher rating for such a group implies
226 Also, the **level** group is used.
228 Tools define their properties by a list of parameters for groups. They
229 cannot dig other groups; thus it is important to use a standard bunch of
230 groups to enable interaction with tools.
232 **Example definition of the digging capabilities of a tool:**
233 tool_capabilities = {
234 full_punch_interval=1.5,
237 crumbly={maxwear=0.01, maxlevel=2, times={[1]=0.80, [2]=0.60, [3]=0.40}}
242 * Full punch interval Maximum drop level For an arbitrary list of groups:
243 * Maximum level (usually 0, 1, 2 or 3) Maximum wear (0...1) Digging times
245 **Full punch interval**: When used as a weapon, the tool will do full
246 damage if this time is spent between punches. If eg. half the time is
247 spent, the tool will do half damage.
249 **Maximum drop level** suggests the maximum level of node, when dug with
250 the tool, that will drop it's useful item. (eg. iron ore to drop a lump of
253 **Maximum level** tells what is the maximum level of a node of this group
254 that the tool will be able to dig.
256 **Maximum wear** determines how much the tool wears out when it is used for
257 digging a node, of this group, of the maximum level. For lower leveled
258 tools, the wear is divided by //4// to the exponent //level difference//.
259 This means for a maximum wear of 0.1, a level difference 1 will result in
260 wear=0.1/4=0.025, and a level difference of 2 will result in
261 wear=0.1/(4*4)=0.00625.
263 **Digging times** is basically a list of digging times for different
264 ratings of the group. It also determines the damage done to entities, based
265 on their "armor groups".
266 * For example, as a lua table, ''times={2=2.00, 3=0.70}''. This would
267 * result the tool to be able to dig nodes that have a rating of 2 or 3
268 * for this group, and unable to dig the rating 1, which is the toughest.
269 * Unless there is a matching group that enables digging otherwise. For
270 * entities, damage equals the amount of nodes dug in the time spent
271 * between hits, with a maximum of ''full_punch_interval''.
273 Entity damage mechanism
274 ------------------------
275 Client predicts damage based on damage groups. Because of this, it is able to
276 give an immediate response when an entity is damaged or dies; the response is
277 pre-defined somehow (eg. by defining a sprite animation) (not implemented;
280 The group **immortal** will completely disable normal damage.
282 Entities can define a special armor group, which is **punch_operable**. This
283 group will disable the regular damage mechanism for players punching it by hand
286 On the Lua side, every punch calls ''entity:on_punch(puncher,
287 time_from_last_punch, tool_capabilities, direction)''. This should never be
288 called directly, because damage is usually not handled by the entity itself.
289 * ''puncher'' is the object performing the punch. Can be nil. Should never be
290 accessed unless absolutely required.
291 * ''time_from_last_punch'' is time from last punch (by puncher) or nil.
292 * ''tool_capabilities'' can be nil.
293 * ''direction'' is a unit vector, pointing from the source of the punch to
296 To punch an entity/object in Lua, call ''object:punch(puncher, time_from_last_punch, tool_capabilities, direction)''.
297 * Return value is tool wear.
298 * Parameters are equal to the above callback.
299 * If ''direction'' is nil and ''puncher'' is not nil, ''direction'' will be
300 automatically filled in based on the location of ''puncher''.
302 minetest namespace reference
303 -----------------------------
304 minetest.register_entity(name, prototype table)
305 minetest.register_abm(abm definition)
306 minetest.register_node(name, node definition)
307 minetest.register_tool(name, item definition)
308 minetest.register_craftitem(name, item definition)
309 minetest.register_alias(name, convert_to)
310 minetest.register_craft(recipe)
311 minetest.register_globalstep(func(dtime))
312 minetest.register_on_placenode(func(pos, newnode, placer))
313 minetest.register_on_dignode(func(pos, oldnode, digger))
314 minetest.register_on_punchnode(func(pos, node, puncher))
315 minetest.register_on_generated(func(minp, maxp))
316 minetest.register_on_newplayer(func(ObjectRef))
317 minetest.register_on_dieplayer(func(ObjectRef))
318 minetest.register_on_respawnplayer(func(ObjectRef))
319 ^ return true in func to disable regular player placement
320 ^ currently called _before_ repositioning of player occurs
321 minetest.register_on_chat_message(func(name, message))
322 minetest.add_to_creative_inventory(itemstring)
323 minetest.setting_get(name) -> string or nil
324 minetest.setting_getbool(name) -> boolean value or nil
325 minetest.chat_send_all(text)
326 minetest.chat_send_player(name, text)
327 minetest.get_player_privs(name) -> set of privs
328 minetest.get_inventory(location) -> InvRef
329 ^ location = eg. {type="player", name="celeron55"}
330 {type="node", pos={x=, y=, z=}}
331 minetest.get_current_modname() -> string
332 minetest.get_modpath(modname) -> eg. "/home/user/.minetest/usermods/modname"
333 ^ Useful for loading additional .lua modules or static data from mod
334 minetest.get_worldpath(modname) -> eg. "/home/user/.minetest/world"
335 ^ Useful for storing custom data
340 minetest.log(loglevel, line)
341 ^ loglevel one of "error", "action", "info", "verbose"
344 minetest.env - environment reference
347 minetest.registered_items
348 ^ List of registered items, indexed by name
349 minetest.registered_nodes
350 ^ List of registered node definitions, indexed by name
351 minetest.registered_craftitems
352 ^ List of registered craft item definitions, indexed by name
353 minetest.registered_tools
354 ^ List of registered tool definitions, indexed by name
355 minetest.registered_entities
356 ^ List of registered entity prototypes, indexed by name
358 ^ List of object references, indexed by active object id
360 ^ List of lua entities, indexed by active object id
362 Deprecated but defined for backwards compatibility:
363 minetest.digprop_constanttime(time)
364 minetest.digprop_stonelike(toughness)
365 minetest.digprop_dirtlike(toughness)
366 minetest.digprop_gravellike(toughness)
367 minetest.digprop_woodlike(toughness)
368 minetest.digprop_leaveslike(toughness)
369 minetest.digprop_glasslike(toughness)
373 EnvRef: basically ServerEnvironment and ServerMap combined.
375 - add_node(pos, node)
378 ^ Returns {name="ignore", ...} for unloaded area
379 - get_node_or_nil(pos)
380 ^ Returns nil for unloaded area
381 - get_node_light(pos, timeofday) -> 0...15 or nil
382 ^ timeofday: nil = current time, 0 = night, 0.5 = day
383 - add_entity(pos, name): Returns ObjectRef or nil if failed
384 - add_item(pos, itemstring)
387 - get_meta(pos) -- Get a NodeMetaRef at that position
388 - get_player_by_name(name) -- Get an ObjectRef to a player
389 - get_objects_inside_radius(pos, radius)
390 - set_timeofday(val): val: 0...1; 0 = midnight, 0.5 = midday
393 NodeMetaRef (this stuff is subject to change in a future version)
396 - allows_text_input()
397 - set_text(text) -- eg. set the text of a sign
401 Generic node metadata specific:
402 - set_infotext(infotext)
403 - get_inventory() -> InvRef
404 - set_inventory_draw_spec(string)
405 - set_allow_text_input(bool)
406 - set_allow_removal(bool)
407 - set_enforce_owner(bool)
408 - is_inventory_modified()
409 - reset_inventory_modified()
411 - reset_text_modified()
412 - set_string(name, value)
415 ObjectRef: Moving things in the game are generally these
416 (basically reference to a C++ ServerActiveObject)
418 - remove(): remove object (after returning from Lua)
419 - getpos() -> {x=num, y=num, z=num}
420 - setpos(pos); pos={x=num, y=num, z=num}
421 - moveto(pos, continuous=false): interpolated move
422 - punch(puncher, time_from_last_punch, tool_capabilities, direction)
423 ^ puncher = an another ObjectRef,
424 ^ time_from_last_punch = time since last punch action of the puncher
425 - right_click(clicker); clicker = an another ObjectRef
426 - get_hp(): returns number of hitpoints (2 * number of hearts)
427 - set_hp(hp): set number of hitpoints (2 * number of hearts)
428 - get_inventory() -> InvRef
429 - get_wield_list(): returns the name of the inventory list the wielded item is in
430 - get_wield_index(): returns the index of the wielded item
431 - get_wielded_item() -> ItemStack
432 - set_wielded_item(item): replaces the wielded item, returns true if successful
433 LuaEntitySAO-only: (no-op for other objects)
434 - setvelocity({x=num, y=num, z=num})
435 - getvelocity() -> {x=num, y=num, z=num}
436 - setacceleration({x=num, y=num, z=num})
437 - getacceleration() -> {x=num, y=num, z=num}
439 - getyaw() -> radians
441 - setsprite(p={x=0,y=0}, num_frames=1, framelength=0.2,
442 - select_horiz_by_yawpitch=false)
443 - ^ Select sprite from spritesheet with optional animation and DM-style
444 - texture selection based on yaw relative to camera
445 - set_armor_groups({group1=rating, group2=rating, ...})
446 - get_entity_name() (DEPRECATED: Will be removed in a future version)
448 Player-only: (no-op for other objects)
449 - get_player_name(): will return nil if is not a player
450 - get_look_dir(): get camera direction as a unit vector
451 - get_look_pitch(): pitch in radians
452 - get_look_yaw(): yaw in radians (wraps around pretty randomly as of now)
454 InvRef: Reference to an inventory
456 - get_size(listname): get size of a list
457 - set_size(listname, size): set size of a list
458 - get_stack(listname, i): get a copy of stack index i in list
459 - set_stack(listname, i, stack): copy stack to index i in list
460 - get_list(listname): return full list
461 - set_list(listname, list): set full list (size will not change)
462 - add_item(listname, stack): add item somewhere in list, returns leftover ItemStack
463 - room_for_item(listname, stack): returns true if the stack of items
464 can be fully added to the list
465 - contains_item(listname, stack): returns true if the stack of items
466 can be fully taken from the list
467 remove_item(listname, stack): take as many items as specified from the list,
468 returns the items that were actually removed (as an ItemStack)
470 ItemStack: A stack of items.
472 - is_empty(): return true if stack is empty
473 - get_name(): returns item name (e.g. "default:stone")
474 - get_count(): returns number of items on the stack
475 - get_wear(): returns tool wear (0-65535), 0 for non-tools
476 - get_metadata(): returns metadata (a string attached to an item stack)
477 - clear(): removes all items from the stack, making it empty
478 - replace(item): replace the contents of this stack (item can also
479 be an itemstring or table)
480 - to_string(): returns the stack in itemstring form
481 - to_table(): returns the stack in Lua table form
482 - get_stack_max(): returns the maximum size of the stack (depends on the item)
483 - get_free_space(): returns get_stack_max() - get_count()
484 - is_known(): returns true if the item name refers to a defined item type
485 - get_definition(): returns the item definition table
486 - get_tool_capabilities(): returns the digging properties of the item,
487 ^ or those of the hand if none are defined for this item type
488 - add_wear(amount): increases wear by amount if the item is a tool
489 - add_item(item): put some item or stack onto this stack,
490 ^ returns leftover ItemStack
491 - item_fits(item): returns true if item or stack can be fully added to this one
492 - take_item(n): take (and remove) up to n items from this stack
493 ^ returns taken ItemStack
494 ^ if n is omitted, n=1 is used
495 - peek_item(n): copy (don't remove) up to n items from this stack
496 ^ returns copied ItemStack
497 ^ if n is omitted, n=1 is used
501 - Functions receive a "luaentity" as self:
502 - It has the member .name, which is the registered name ("mod:thing")
503 - It has the member .object, which is an ObjectRef pointing to the object
504 - The original prototype stuff is visible directly via a metatable
506 - on_activate(self, staticdata)
507 ^ Called when the object is instantiated.
508 - on_step(self, dtime)
509 ^ Called on every server tick (dtime is usually 0.05 seconds)
510 - on_punch(self, puncher, time_from_last_punch, tool_capabilities, dir)
511 ^ Called when somebody punches the object.
512 ^ Note that you probably want to handle most punches using the
513 automatic armor group system.
514 ^ puncher: ObjectRef (can be nil)
515 ^ time_from_last_punch: Meant for disallowing spamming of clicks (can be nil)
516 ^ tool_capabilities: capability table of used tool (can be nil)
517 ^ dir: unit vector of direction of punch. Always defined. Points from
518 the puncher to the punched.
519 - on_rightclick(self, clicker)
520 - get_staticdata(self)
521 ^ Should return a string that will be passed to on_activate when
522 the object is instantiated the next time.
527 Entity definition (register_entity)
530 collisionbox = {-0.5,-0.5,-0.5, 0.5,0.5,0.5},
531 visual = "cube"/"sprite",
532 visual_size = {x=1, y=1},
533 textures = {texture,texture,texture,texture,texture,texture},
534 spritediv = {x=1, y=1},
535 initial_sprite_basepos = {x=0, y=0},
536 on_activate = function(self, staticdata),
537 on_step = function(self, dtime),
538 on_punch = function(self, hitter),
539 on_rightclick = function(self, clicker),
540 get_staticdata = function(self),
541 # Also you can define arbitrary member variables here
542 myvariable = whatever,
545 ABM (ActiveBlockModifier) definition (register_abm)
547 nodenames = {"default:lava_source"},
548 neighbors = {"default:water_source", "default:water_flowing"}, -- (any of these)
549 ^ If left out or empty, any neighbor will do
550 interval = 1.0, -- (operation interval)
551 chance = 1, -- (chance of trigger is 1.0/this)
552 action = func(pos, node, active_object_count, active_object_count_wider),
555 Item definition (register_node, register_craftitem, register_tool)
557 description = "Steel Axe",
558 groups = {}, -- key=name, value=rating; rating=1..3.
559 if rating not applicable, use 1.
560 eg. {wool=1, fluffy=3}
561 {soil=2, outerspace=1, crumbly=1}
563 {hard=1, metal=1, spikes=1}
564 inventory_image = "default_tool_steelaxe.png",
566 wield_scale = {x=1,y=1,z=1},
568 liquids_pointable = false,
569 tool_capabilities = {
570 full_punch_interval = 1.0,
574 fleshy={times={[2]=0.80, [3]=0.40}, maxwear=0.05, maxlevel=1},
575 snappy={times={[2]=0.80, [3]=0.40}, maxwear=0.05, maxlevel=1},
576 choppy={times={[3]=0.90}, maxwear=0.05, maxlevel=0}
579 on_drop = func(item, dropper, pos),
580 on_place = func(item, placer, pointed_thing),
581 on_use = func(item, user, pointed_thing),
584 Node definition (register_node)
586 <all fields allowed in item definitions>,
590 tile_images = {"default_unknown_block.png"},
591 special_materials = {
592 {image="", backface_culling=true},
593 {image="", backface_culling=true},
596 post_effect_color = {a=0, r=0, g=0, b=0},
599 is_ground_content = false,
600 sunlight_propagates = false,
605 buildable_to = false,
607 -- alternatively drop = { max_items = ..., items = { ... } }
610 liquid_alternative_flowing = "",
611 liquid_alternative_source = "",
612 liquid_viscosity = 0,
614 damage_per_second = 0,
615 selection_box = {type="regular"},
616 legacy_facedir_simple = false, -- Support maps made in and before January 2012
617 legacy_wallmounted = false, -- Support maps made in and before January 2012
620 Recipe: (register_craft)
622 output = 'default:pick_stone',
624 {'default:cobble', 'default:cobble', 'default:cobble'},
625 {'', 'default:stick', ''},
626 {'', 'default:stick', ''},
628 replacements = <optional list of item pairs,
629 replace one input item with another item on crafting>
635 output = 'mushrooms:mushroom_stew',
638 "mushrooms:mushroom_brown",
639 "mushrooms:mushroom_red",
641 replacements = <optional list of item pairs,
642 replace one input item with another item on crafting>
645 Recipe (tool repair):
648 additional_wear = -0.02,
654 output = "default:glass",
655 recipe = "default:sand",
659 Recipe (furnace fuel):
662 recipe = "default:leaves",