4.3 KiB
Executable File
RUNES' API
(as accurate as possible)
1. How it does work
Every rune registered uses the same method to work and access its environment. Runes are first registered using a specific function.
Their datas are stored somewhere in a namespace (see below). You can use multiple values to indicate the needed amount of mana, the type of the rune, its texture(s), etc. Then, once a rune is registered (as an item, for minetest), the most important thing is to connect its handler(s). Another specific function is used to this, where you pass as an argument the reference to a function receiving the parameters of the item/node's callback (eg. on_punch, on_dig, on_use, etc). The handler can choose to return "true" in order to manage the use of mana by itself instead of letting the item's code in minetest.registered_items[]. do it.
Functions
runes.register_rune(parameters)
The most important function. This is the function you use to declare your rune and its specifications to minetest itself.
It takes one argument, a table. This table can have the following articles :
- name
is mandatory, it's the rune's name (which will be used to craft its itemstring : runes:rune__)
- desc
is the item's description
- img
is another table :
- ["minor"] = <texture_file>
- ["medium"] = <texture_file>
- ["major"] = <texture_file>
None of these parameters are mandatory. Runes can have 1 or 2 or 3 levels (ok, not implemented yet, but it's coming).
You can use a single value like img = <texture_file>
and the texture will be applied for all levels
- type
is the type of rune. At the moment, three types are available :
- "craftitem" will register a craftitem
- "cube" will register a node
- "plate" will register a little slab 0.1 node thin
- needed_mana
is yet another table with different levels :
- ["minor"] =
- ["medium"] =
- ["major"] =
When using this rune at level "major", the ["major"] value of mana will be taken by default if the player has enough mana,
or it will be forbidden for him to use the rune if he doesn't have enough mana.
You don't have to indicate that parameter and just let the handler manage the mana.
runes.functions.connect(itemname, callback, handler)
This function will connect a registered rune's callback to its handler. It takes three mandatory arguments :
- itemname
is the rune's identification name (aka. name
for earlier). The same handler is used for every level
of a rune, so it has to determine what level he will handle (it's actually passed to it)
- callback
is a code identifying the callback. It can be :
- use
for on_use
- place
for after_place_node
- dig
for after_dig_node
(actually commented due to bugs in this section)
- can_dig
for can_dig
(true logic)
- punch
for on_punch
(rather logic too)
- handler
is the function handling the callback. See below for details.
Do not hesitate to consult lua_api.txt in order to see which callbacks are handled by what type of runes (craftitems, and nodes).
runes.functions.register_amulet(name, desc, maxcount, manadiff)
Amulets are special items able to increase the maximum of mana you can stock. Here are the arguments expected to register an amulet :
- name
is its name, used to create its itemstring : 'runes:_amulet'
Don't feel forced to use '_amulet' in an amulet name, it's completly useless.
- desc
is the item description.
- maxcount
represents the maximum amount of this amulet you can have per stack (aka stack_max
, see lua_api.txt for this).
- manadiff
is the amount of space you will get to stock more mana in your inventory. A global_step loop is charged with the task
of regulary looking into everyone's rune inventory to calculate every player's max_mana. If you loose amulets, your mana_max
will dicrease (and mana may be lost with it).
runes.functions.register_detached_inventory(player)
This function is only important for rune's inners. It registers a detached inventory to contain runes. Do not bother using it, there is no actual use of it out of runes' core.
runes.functions.save_detached_inventory(player)
Saves player's rune inventory on hard drive (in minetest.get_worldpath() .. "/runes/" .. player:get_player_name() .. "_rune.inv").