452 lines
27 KiB
Plaintext
452 lines
27 KiB
Plaintext
Complete and Total Lua-Only Inventory Rewrite [lua_inv]
|
|
Modding API Reference
|
|
=============================================
|
|
|
|
|
|
|
|
[MetaData]
|
|
|
|
A table of data attached to various objects, to allow for extra custom data to be added, which can be controlled via its own callbacks.
|
|
|
|
### Constructors:
|
|
|
|
* lua_inv.metadata(parent) - Create a new metadata object. The "parent" should be the object that owns this. See MetaDataParent below.
|
|
|
|
### Fields [Read-Only]:
|
|
|
|
* data - The table where the metadata's key/value pairs are actually stored.
|
|
* parent - A reference to the owner of the MetaData. If there is none, this will instead contain {orphaned = true}
|
|
|
|
### Functions:
|
|
|
|
* :allow_change(key, value) - Check if setting the key/value pair is allowed. Returns a boolean indicating permission.
|
|
* :on_change(key, value) - Simulate effects of setting the key/value pair. Returns the final value.
|
|
* :contains(key) - Returns true if the value that they key contains is anything other than nil.
|
|
* :get(key) - Returns the exact value that this key contains, or nil if it doesn't exist.
|
|
* :remove(key) - Sets the value at the given key to nil.
|
|
* :set_string(key, value) - Sets the given value, converting to a string if necessary. Returns the final value or false if it failed.
|
|
* :get_string(key) - Gets the value at the given key as a string. If it doesn't exist, "" is returned.
|
|
* :set_int(key, value) - Sets the given value, converting to a whole number if necessary. Returns the final value or false if it failed.
|
|
* :get_int(key) - Gets the value at the given key as a whole number. If it doesn't exist or isn't a number, 0 is returned.
|
|
* :set_float(key, value) - Sets the given value, converting to a number if necessary. Returns the final value or false if it failed.
|
|
* :get_float(key) - Gets the value at the given key as a number. If it doesn't exist or isn't a number, 0 is returned.
|
|
* :to_table() - Returns a writable copy of this MetaData's data table.
|
|
* :from_table(table) - Clears all of the previous data and adds every key/value pair within the provided table. Returns self.
|
|
* :equals(MetaData) - Returns true if the provided MetaData has all the same key/value pairs as this one. Callbacks aren't considered for this.
|
|
* :serialize() - Returns a JSON string representing all the key/value pairs in the data table.
|
|
|
|
### Global Callbacks (Use with caution):
|
|
|
|
* lua_inv.register_metadata_allow_change(function(MetaData, key value)) - Create a permission function that applies to all MetaData objects.
|
|
* lua_inv.register_metadata_on_change(function(MetaData, key value)) - Create an on-change modifier function for all MetaData objects.
|
|
|
|
### Operators:
|
|
|
|
* MetaData == MetaData - An alternate way to check if two MetaData objects have all the same key/value data.
|
|
|
|
|
|
|
|
[MetaDataParent]
|
|
|
|
Any object can be considered if set as a MetaData's parent. They gain special functionality for possessing the following functions:
|
|
|
|
* metadata_allow_change(Parent, MetaData, k, v) - Apply a special permission function to the owned MetaData that it wouldn't normally have.
|
|
* metadata_on_change(Parent, MetaData, k, v) - Apply a special transformation function to the owned MetaData that it wouldn't normally have.
|
|
|
|
|
|
|
|
[ItemStack]
|
|
|
|
A reference to a slot that can hold an item. Unlike the normal kind, these are most often accessed directly via reference.
|
|
When you make a change to one, there is usually no need to "commit" the change by using set_stack in the inventory.
|
|
|
|
### Constructors:
|
|
|
|
* lua_inv.itemstack(name, count, wear, meta, parent) - The normal way to create a new ItemStack.
|
|
-- name: The name of the item, usually in the format of modname:itemname. Defaults to ""
|
|
-- count: How many of this object you wish to create. Defaults to 1.
|
|
-- wear: Number/100 for how close this item is to breaking. If the count is higher than 1, only the stack's top item will have the wear. Defaults to 0.
|
|
-- meta: A key/value table that will be supplied to this item's MetaData. Defaults to an empty table. Can't accept an entire MetaData object; use :to_table() instead.
|
|
-- parent: The object that owns this ItemStack, usually expected to be an inventory. See ItemStackInInventoryParent below.
|
|
|
|
* lua_inv.itemstack_from_string(String) - Create an ItemStack based on a provided ItemString.
|
|
|
|
* lua_inv.itemstack_from_userdata(UserData) - Port a UserData-type ItemStack into a lua_inv-type one.
|
|
|
|
* lua_inv.itemstack_to_userdata(ItemStack) - The opposite of the above. Export an ItemStack back into a regular UserData item.
|
|
|
|
### Fields [Read-Only]:
|
|
|
|
* parent - A reference to the owner of the ItemStack. If there is none, this will instead contain {orphaned = true}
|
|
|
|
### Special MetaData Fields
|
|
|
|
* description - If present, this will be shown as the description of the item.
|
|
* inventory_image - If present, this filename will be used for the item's sprite.
|
|
* frames - If present, overrides the amount of frames in an item's animation.
|
|
* speed - If present, overrides the animation speed of the item.
|
|
* frame_template - If present, this will be used to grab the next frame's image, by formatting it with the current frame number.
|
|
-- If both frames and frame_template are in the MetaData, you can animate an itemstack even if its definition lacks the _lua_inv_animation function.
|
|
|
|
### Functions:
|
|
|
|
* :allow_change(key, value) - Check if setting the key/value pair is allowed. Returns a boolean indicating permission.
|
|
* :on_change(key, value) - Simulate effects of setting the key/value pair. Returns the final value.
|
|
* :after_change(key, init, final) - Simulate effects after successfully setting the key's value from init to final. Returns nothing.
|
|
* :metadata_allow_change(MetaData, key, value) - Apply a special permission function to the owned MetaData that it wouldn't normally have.
|
|
* :metadata_on_change(MetaData, key, value) - Apply a special transformation function to the owned MetaData that it wouldn't normally have.
|
|
* :is_empty() - Returns true if this doesn't contain anything.
|
|
* :is_full() - Returns true only if the stack's count is equal to its max count.
|
|
* :get_name() - Returns the internal name of the item that this contains.
|
|
* :set_name(name) - Change the name of the contained item. Setting "" will instead erase it. Returns the final name.
|
|
* :get_count() - Returns the amount of items this stack contains.
|
|
* :set_count(count) - Set the amount of items that this stack contains. Setting 0 will instead empty it. Returns the final number.
|
|
* :get_wear() - Returns how worn out the top item is, from 0 to 100.
|
|
* :set_wear(wear) - Set this object's wear. If it's over 100, the count will be decremented. Returns the final wear.
|
|
* :get_meta() - Returns the MetaData of this stack.
|
|
* :get_total_size() - Returns the count, except the last item is counted as a partial item according to how worn the stack is.
|
|
* :get_description() - Returns the description of this item, or a custom description if the MetaData contains it.
|
|
* :get_inventory_image() - Attempts to create an inventory image for this item. If it doesn't exist, it attempt to make a cube formspec element.
|
|
* :get_animation(frame) - Returns ItemStackAnimation if defined in the registration or MetaData. Returns nil otherwise.
|
|
* :get_wear_visual() - Returns a colored bar for a formspec or HUD, representing how worn the item is.
|
|
* :to_string() - Returns an itemstring that represents this item.
|
|
* :get_stack_max() - Returns the maximum count that this item can have. Defaults to 99 for unknown items.
|
|
* :get_free_space() - Returns the amount of items that this can gain before it reaches the stack_max.
|
|
* :is_known() - Returns true if this item has an existing definition.
|
|
* :get_definition() - Returns this item's entry in minetest.registered_items if it exists.
|
|
* :has_custom_tool_capabilities() - Returns true if tool_capabilities were set for this item.
|
|
* :get_tool_capabilities() - Returns custom tool capabilities if set, its definition's capabilites if defined, or the hand's capabilities.
|
|
* :set_tool_capabilities(table) - Set a table of custom tool capabilities to apply to this item. Returns nothing.
|
|
* :add_wear(wear) - Add an amount of wear to this item. Works the same as set_wear.
|
|
* :is_similar(ItemStack) - By default, returns true if this item's name and MetaData match the provided ItemStack. Custom conditions may be set.
|
|
* :add_item(ItemStack) - Attempt to put ItemStack into this stack. ItemStack will contain the leftovers, if any. Returns self.
|
|
* :item_fits(ItemStack) - Return true if ItemStack is similar to this, and there is enough free space to fit all of ItemStack.
|
|
* :take_item(count) - Take the desired amount of items from this stack and return it.
|
|
* :peek_item(count) - Copy the desired amount of items from this stack and return it.
|
|
* :serialize() - Returns a JSON string representing the contents of this ItemStack.
|
|
|
|
### Global Callbacks (Use with caution):
|
|
|
|
* lua_inv.register_itemstack_allow_change(function(ItemStack, key, value)) - Create a permission function to apply to all ItemStacks.
|
|
* lua_inv.register_itemstack_on_change(function(ItemStack, key, value)) - Create an on_change function to apply to all ItemStack.
|
|
* lua_inv.register_itemstack_after_change(function(ItemStack, key, init, final)) - Create a function to apply after all changes to ItemStacks.
|
|
|
|
### Definition Entries for minetest.register_item:
|
|
|
|
* _lua_inv_allow_change(self, key, value) - Set a restriction for how this item can be changed. Return a boolean to indicate permission.
|
|
* _lua_inv_on_change(self, key, value) - Do something whenever this item is changed. Return a value to change it.
|
|
* _lua_inv_after_change(self, key, init, final) - Do something after this item is changed.
|
|
* _lua_inv_metadata_allow_change(self, meta, key, value) - Set a restriction for how this item's MetaData can be changed. Return false to prevent it.
|
|
* _lua_inv_metadata_on_change(self, meta, key, value) - Do something whenever the MetaData of this item is changed.
|
|
* _lua_inv_is_similar(self, other) - Set a custom condition when checking if this item should be considered similar to another.
|
|
* _lua_inv_add(self, other) - Specify custom behavior for adding other into self.
|
|
* _lua_inv_on_use(self, user, pointed_thing) - Like on_use, but this one supports lua_inv itemstacks and will NOT replace default behavior.
|
|
* _lua_inv_on_place(self, placer, pointed_thing) - Like on_place, but this provides a lua_inv itemstack instead.
|
|
* _lua_inv_on_secondary_use(self, placer, pointed_thing) - Like on_secondary_use, but this provides a lua_inv itemstack instead.
|
|
* _lua_inv_animation(self, frame) - If used, this should return an ItemStackAnimation.
|
|
|
|
### Operators:
|
|
|
|
* ItemStack + ItemStack - Attempt to add the second ItemStack into the first, like in the ItemStack:add_item function.
|
|
* ItemStack == ItemStack - Returns true if both ItemStacks have the same name, count, wear, and MetaData contents.
|
|
* ItemStack < ItemStack - Returns true if the total size of the first ItemStack is less than the second.
|
|
* ItemStack <= ItemStack - Returns true if the total size of the first ItemStack is less than or equal to the second.
|
|
|
|
|
|
|
|
[ItemStackInInventoryParent]
|
|
|
|
When an Inventory is the parent of an ItemStack, it has the following fields:
|
|
|
|
* inv - The actual Inventory object that the ItemStack belongs to.
|
|
* list - The name of the Inventory list that the ItemStack is in.
|
|
* index - The specific index within the Inventory's list that the ItemStack is in.
|
|
|
|
|
|
|
|
[ItemStackAnimation]
|
|
|
|
A mini-definition table used to specify how an object should be animated. It uses the fields in the list below.
|
|
|
|
Note that when used, the item's inventory_image should provide a vertical animation strip so the animation works in formspecs.
|
|
|
|
* frames - The amount of frames in the animation.
|
|
* speed - The time (in milliseconds) that each frame is shown. Optional; default is (1000 / frames)
|
|
* frame_template - The name of the file of each individual frame. Use %d in place of a specific frame number, so that string.format will work with it.
|
|
|
|
|
|
|
|
[Inventory]
|
|
|
|
A reference to a table of lists of itemstacks. Once a list is set, it sticks with the same set of ItemStacks for as long as it possibly can.
|
|
Every slot is set via reference, and items are added and removed simply by directly changing the contents of contained ItemStacks.
|
|
|
|
### Constructors:
|
|
|
|
* lua_inv.inventory(parent, allow_change, on_change, after_change) - Create a new inventory with many optional values.
|
|
-- parent: The object that owns this. If there is none, it will instead be {orphaned = true}
|
|
-- allow_change(self, InventoryChange): A function used to allow or disallow items from being moved or changed. See InventoryChange below.
|
|
-- on_change(self, InventoryChange): A function called when a change would occur in the Inventory. See InventoryChange below.
|
|
-- after_change(self, InventoryChange): A function called after a change occurs in the Inventory. See InventoryChange below.
|
|
|
|
* lua_inv.inventory_from_serialized_string(serial, new_inv) - Load the given inventory with deserialized data.
|
|
-- serial: Data from a past use of Inventory:serialize(). Must manually prepend it with "return " including the space.
|
|
-- new_inv: The inventory reference to put the data in. Must already exist, typically from the same lua_inv.inventory call that created the serialzed inventory.
|
|
|
|
### Fields [Read-Only]:
|
|
|
|
* data - The table of lists that this inventory contains, indexed by listname.
|
|
* width - The table of widths for each list, indexed by listname.
|
|
* callbacks - A table of the functions that were provided to the constructor, indexed by function names.
|
|
* parent - A reference to the owner of the Inventory. If there is none, this will instead contain {orphaned = true}
|
|
|
|
### Functions:
|
|
|
|
* :get_allow_change() - Return the allow_change function that was passed to the Constructor. Defaults to a function that always returns true.
|
|
* :get_on_change() - Return the on_change function that was passed to the Constructor. Defaults to an empty function.
|
|
* :get_after_chagne() - Return the after_change function that was passed to the Constructor. Defaults to an empty function.
|
|
* :allow_change(self, InventoryChange) - Returns true or false if a given change is allowed in this inventory.
|
|
* :on_change(self, InventoryChange) - Applies callbacks when a change would be set in this inventory.
|
|
* :after_change(self, InventoryChange) - Applies callbacks after a change is set in this inventory.
|
|
* :is_empty(listname) - Returns true if every ItemStack in every list in this inventory is empty. If listname is provided, only that list is checked for emptiness.
|
|
* :get_size(listname) - Returns the amount of ItemStacks in a given list.
|
|
* :set_size(listname, size) - Change the size of a given list. If it's shortened, ItemStacks will be deleted. If size is 0, the whole list is deleted.
|
|
* :get_width(listname) - Returns the given width of a list, usually only relavent for crafting. Defaults to 1.
|
|
* :set_width(listname, width) - Sets the Inventory's width. Returns the width if successful, or false otherwise.
|
|
* :get_stack(listname, index) - Returns the ItemStack from the given list's index.
|
|
* :set_stack(listname, index, ItemStack)- Swap the provided ItemStack into the ItemSlot found in the given listname and index.
|
|
* :get_list(listname) - Returns a read-only table based on the provided list name.
|
|
* :set_list(listname, list) - Swap the contents of an entire list with those of the provided list.
|
|
* :get_lists() - Get the read-only table that this Inventory contains.
|
|
* :set_lists(listname, lists) - Completely overwrite the contents of an Inventory with the provided lists.
|
|
* :add_item(listname, ItemStack) - Add the ItemStack into the inventory. It will try to find a similar slot to fill, before trying an empty slot.
|
|
* :room_for_item(listname, ItemStack) - Return true if there is at least one slot in the list that can fit the provided ItemStack.
|
|
* :contains_item(listname, ItemStack, match_meta) -Check if the list already contains the provided ItemStack. May optionally check MetaData too.
|
|
* :remove_item(listname, ItemStack, match_meta) -Remove the requested item from the list and return said item. May optional check MetaData too.
|
|
* :serialize() - Returns a JSON string representing the contents of this Inventory.
|
|
|
|
### Global Callbacks (Use with caution):
|
|
|
|
* lua_inv.register_inventory_allow_change(function(Inventory, InventoryChange)) - Create a permission function to apply to all Inventories.
|
|
* lua_inv.register_inventory_on_change(function(Inventory, InventoryChange)) - Create an on_change function to apply to all Inventories.
|
|
* lua_inv.register_inventory_after_change(function(Inventory, InventoryChange)) - Create a function to apply after all changes to Inventories.
|
|
|
|
### Definition Entries for minetest.register_node:
|
|
|
|
* _lua_inv_inventory(pos) - Overrides behavior for creating an inventory at the given position. Usually useful for setting list sizes right away.
|
|
|
|
|
|
|
|
[InventoryChange]
|
|
|
|
This has a couple variations, depending on the type of change that occurs in an inventory.
|
|
|
|
* ItemStack :set_name, :set_count, :set_wear
|
|
{
|
|
type = "set",
|
|
stack = ItemStack,
|
|
key = key,
|
|
val = value, --Only when allow_change and on_change sends the callback
|
|
init_val = initial_value, --Only when after_change sends the callback
|
|
final_val = final_value, --Only when after_change sends the callback
|
|
}
|
|
|
|
* Inventory:set_stack
|
|
{
|
|
type = "swap",
|
|
stack1 = ItemStack, --The one that could have been retrieved by ItemStack:get_stack() before the swap
|
|
stack2 = ItemStack, --The one that was inputted into Inventory:set_stack to trigger the swap.
|
|
}
|
|
|
|
|
|
|
|
[FormspecElement]
|
|
|
|
A Lua Table representation of a line in a Formspec. As a table, it can easily have dynamic behaviors upon being converted into a Formspec String.
|
|
|
|
### Constructors:
|
|
|
|
* lua_inv.formspec_element(name, arguments, to_string) - The usual way to create an element for a Dyanamic Formspec.
|
|
name: The name of the element. You will usually want this to match one of Minetest's Formspec Element types, unless you set to_string.
|
|
arguments: A table of arguments. See below for examples.
|
|
to_string: A function to define custom behavior for turning this into a Formspec string. See below for details.
|
|
|
|
* lua_inv.default_formspec_element_to_string(FormspecElement) - The default for to_string. Turns a FormspecElement table into a formspec string.
|
|
|
|
* lua_inv.formspec_element_from_string(String) - This function will interpret a formspec string and create a FormspecElement table based off of it.
|
|
|
|
### Arguments:
|
|
|
|
A regular Formspec Element will separate values by either a semi-colon or a comma.
|
|
A semi-colon separates two entire arguments.
|
|
A comma separates sub-arguments, which would then go into their own specific table.
|
|
|
|
For example: list[current_player;main;0,5;8,4;]
|
|
|
|
The arguments for the above "list" Formspec Element would be represented as such:
|
|
{
|
|
[1] = "current_player",
|
|
[2] = "main",
|
|
[3] = {[1] = 0, [2] = 5},
|
|
[4] = {[1] = 8, [2] = 4},
|
|
}
|
|
|
|
### :to_string(self, player, formname, fields)
|
|
|
|
* self - The FormspecElement table that this function belongs to.
|
|
* player - The Player that this is being shown to.
|
|
* formname - The name of the form that will be sent to the player when the final formspec is shown.
|
|
* fields - Optional. Will be present if the player did something that would require feedback and a new formspec to be formed. Works like regular Minetest.
|
|
|
|
### Subclasses:
|
|
|
|
* lua_inv.dynamic_list(inv_location, listname, x, y, w, h, start_index, slot_bg)- Like a list[], except it's a grid of buttons to form a lua_inv-compatible UI.
|
|
* lua_inv.stack_mode_selector(x, y) - Meant to be paired with dynamic_list to offer more options for moving around ItemStacks.
|
|
* lua_inv.drop_item_button(x, y) - Provides a way for formspecs with dynamic lists to drop items onto the ground.
|
|
* lua_inv.active_indicator(x, y, w, y, base_img, cover_img, var)- Like an image[], except var% of cover_img will be drawn over base_img.
|
|
|
|
|
|
|
|
[DynamicFormspec]
|
|
|
|
This is essentially a formspec that is built to use FormspecElement as defined above.
|
|
It can be set up to use a page structure pretty easily, just by using the related page functions.
|
|
Every Dynamic Formspec requires at least one page to do anything. The first added page will have have an index of 1.
|
|
|
|
### Constructors:
|
|
|
|
lua_inv.dynamic_formspec() - The standard method for creating a DynamicFormspec. Note that at least one page must always be created for it to be usable.
|
|
|
|
lua_inv.dynamic_formspec_from_string(formspec) - This is a way to automatically interpret and convert an existing formspec string into a DynamicFormspec.
|
|
|
|
### Fields [Read-Only]:
|
|
|
|
* elems - A table of all the pages of FormspecElements.
|
|
* pageTitles - A table of each page's title.
|
|
* meta - The primary MetaData object that belongs to the formspec, typically used by each FormspecElement for communication.
|
|
* temp_meta - A secondary MetaData object, which is cleared after each time the formspec is changed or closed.
|
|
* size_w - The width of this formspec, which applies to all pages.
|
|
* size_h - The height of this formspec, which applies to all pages.
|
|
* tabs_hidden - If true, the tabheader[] element will no longer be shown if the formspec has multiple pages.
|
|
|
|
### Functions
|
|
|
|
* :get_fs_size() - Returns (width, height) that will be applied to all pages in this formspec.
|
|
* :set_fs_size(w, h) - Set the width and height of all pages in this formspec to the given numbers.
|
|
* :set_tabs_hidden(bool) - Set to true to disable the tabheader[] shown when there is more than 1 page. Useful for making your own navigation.
|
|
* :size(n) - Returns the number of FormspecElements in the given page. N defaults to 1.
|
|
* :get(index, n) - Returns Page n's FormspecElement at the given index. N defaults to 1.
|
|
* :set(index, FormspecElement, n) - Replace Page n's FormspecElement at the given index with a new one, or deletes it if the second argument is nil. N defaults to 1.
|
|
* :add(FormspecElement, n) - Add the given FormspecElement to Page n the end of the list. N defaults to 1.
|
|
* :del(index, n) - Remove the FormspecElement of Page n at the given index. N defaults to 1.
|
|
* :page_add(title) - Add a new page with the given title. Returns the page's index to allow formspec elements to be added to it.
|
|
* :page_count() - Returns the total number of pages.
|
|
* :page_get(n) - Returns the page at the specified index, if it exists.
|
|
* :page_title(n) - Returns the name given to the page at the specified index.
|
|
* :page_del(n) - Deletes the page at the given index. Any pages that were after it will be pushed back in the list to fill the space.
|
|
* :page_current() - Returns the currently displayed page.
|
|
* :page_switch(n) - Switches the formspec to instead show the given page. If n is a number but out of bounds, it will wrap around.
|
|
* :form(Player, formname, fields) - Build a presentable formspec string out of all existing FormspecElements according to their to_string method.
|
|
|
|
### Global Callbacks (Use with caution):
|
|
|
|
* lua_inv.register_on_formspec_open(function(player, formname, DynamicFormspec))
|
|
-- The given function will be called whenever any formspec is shown to a player or updated.
|
|
|
|
* lua_inv.register_on_formspec_close(function(player, formname, DynamicFormspec, fields))
|
|
-- The given function will be called whenever any formspec is properly closed.
|
|
|
|
|
|
|
|
[Manager]
|
|
|
|
An internal manager is used to keep track of DynamicFormspec states. Also comes with helpful functions.
|
|
|
|
* lua_inv.get_df_meta(Player) - Returns two MetaData objects tied to the Player's open DynamicFormspec. It's important as it allows FormspecElements to communicate.
|
|
-- meta: For more persistent variables that are kept even after the DynamicFormspec is closed.
|
|
-- temp_meta: For less persistent variables that get deleted when the DynamicFormspec is closed or updated. Occasionally needed to fix cases of looping or other oddities in formspecs.
|
|
|
|
* lua_inv.show_formspec(Player, formname, DynamicFormspec) - The official method to showing a DynamicFormspec in a way that indicates lua_inv compatability.
|
|
|
|
|
|
|
|
[SurvivalInventory]
|
|
|
|
A subclass of a DynamicFormspec that is given to all players. It's a lua_inv compatible recreation of a basic survival inventory formspec.
|
|
|
|
### Methods:
|
|
|
|
* lua_inv.survival_inventory.form() - Builds the DynamicFormspec to be shown to the player. It has a custom element to show a 2D image or 3D model on the owner based of their properties.
|
|
* lua_inv.survival_inventory.ref(Player) - Builds the Player's Inventory, with the Player as its parent, with allow_change and after_change callbacks.
|
|
|
|
|
|
|
|
[PlayerInventory]
|
|
|
|
Although mainly for internal use, it comes with a few tools that may be useful in various cases.
|
|
|
|
### Fields:
|
|
|
|
* lua_inv.player_inventory - A table, indexed by player names, which can be used to access a player's inventory or inventory formspec.
|
|
-- inv: A link to the player's Inventory.
|
|
-- form: A link to the DynamicFormspec shown to the player to let them interact with their inventory.
|
|
|
|
### Methods:
|
|
|
|
* lua_inv.get_player_wielded_item(player) - Get the ItemStack that the player is wielding.
|
|
* lua_inv.set_player_wielded_item(player, itemstack) - Set the ItemStack that the playee is wielding. A Userdata item may be sent instead, and will automaticall be converted.
|
|
* lua_inv.update_held_item_data(player) - Update internal information about the wielded item's tool_capabilities. Automatically called for most use cases.
|
|
|
|
|
|
|
|
[NodeInventory]
|
|
|
|
A separate table of these is maintained to keep track of node inventories and ensure that they are readily accessible.
|
|
|
|
### Constructor:
|
|
|
|
lua_inv.fetch_node_inventory(pos, keep_nil) - Returns a node inventory for the given position, and creates one if it didn't already exist.
|
|
-- keep_nil: Optional. If true, this function will return nil instead of creating a new inventory.
|
|
|
|
|
|
|
|
[DetachedInventory]
|
|
|
|
A table of these is maintained to allow them to appear in formspecs.
|
|
|
|
Note that unlike other inventory types, these are NOT saved automatically. For these, you should implement persistence yourself, if necessary.
|
|
|
|
### Constructor:
|
|
|
|
lua_inv.create_detached_inventory(name, input_parent, allow_change_func, on_change_func, after_change_func) - Returns a new detached inventory.
|
|
-- name: The name of the detached inventory, used to fetch it later.
|
|
-- The other arguments work the same as lua_inv.inventory()
|
|
-- Note that you are not allowed to create a detached inventory using the name of one that already exists. This will cause an error.
|
|
|
|
### Method:
|
|
|
|
lua_inv.get_detached_inventory(name) - Returns a detached inventory indexed by the given name, if it exists.
|
|
|
|
|
|
|
|
[Misc. Functions]
|
|
|
|
* lua_inv.change_involves_list(inv, change, listname) - If the change table has an involved stack in the given inv and listname, return the stack.
|
|
* lua_inv.set_list_take_only(inv, change, listname) - Use in an allow_change callback to prevent players from placing items in the given listname.
|
|
* lua_inv.tiles_to_cube_textures({tiles}) - Converts a table of tiles from an object's properties into a table of textures for an entity.
|
|
* lua_inv.update_hotbar(player) - Update the player's hotbar visuals in the event of a change. Automatically called for most use cases.
|
|
|
|
|
|
|
|
[Default Support Functions]
|
|
|
|
* lua_inv.default.chest_override(name) - Overrides the named chest so its behaviors properly use lua_inv.
|
|
|
|
* lua_inv.default.furnace_override(name) - Overrides the named furnace so its behaviors properly use lua_inv.
|
|
|
|
* lua_inv.default.shelf_override(name, groupname, listname, slot_bg) - Overrides the named shelf to work with lua_inv.
|
|
-- groupname: Only items with this groupname will be allowed on the shelf.
|
|
-- listname: The name of the shelf's inventory's main list.
|
|
-- slot_bg: The name of the image that will be shown in the shelf's slots to indicate the type of item it can accept.
|
|
|