389 lines
9.7 KiB
Lua
389 lines
9.7 KiB
Lua
-- Magicalities Wands
|
|
|
|
magicalities.wands = {}
|
|
|
|
local transform_recipes = {
|
|
["mg_table"] = {result = "magicalities:arcane_table", requirements = nil}
|
|
}
|
|
|
|
local wandcaps = {
|
|
full_punch_interval = 1.0,
|
|
max_drop_level = 0,
|
|
groupcaps = {},
|
|
damage_groups = {fleshy = 2},
|
|
}
|
|
|
|
local function align(len)
|
|
local str = ""
|
|
for i = 1, len do
|
|
str = str.."\t"
|
|
end
|
|
return str
|
|
end
|
|
|
|
function magicalities.wands.get_wand_focus(stack)
|
|
local meta = stack:get_meta()
|
|
if meta:get_string("focus") == "" then
|
|
return nil
|
|
end
|
|
|
|
local focus = meta:get_string("focus")
|
|
local itemdef = minetest.registered_items[focus]
|
|
if not itemdef then return nil end
|
|
|
|
return focus, itemdef
|
|
end
|
|
|
|
local function focus_requirements(stack, fdef)
|
|
if fdef["_wand_requirements"] then
|
|
return magicalities.wands.wand_has_contents(stack, fdef["_wand_requirements"])
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
local function focuses_formspec(available, focusname)
|
|
local x = 0
|
|
local fsp = ""
|
|
for focus in pairs(available) do
|
|
if x < 5 then
|
|
fsp = fsp .. "item_image_button["..x..",2.8;1,1;"..focus..";"..focus..";]"
|
|
x = x + 1
|
|
end
|
|
end
|
|
|
|
local current = ""
|
|
if not focusname then
|
|
current = "label[2,1;No Focus]"
|
|
else
|
|
current = "item_image_button[2,0.5;1,1;"..focusname..";remove;Remove]"..
|
|
"label[0,1.5;Current: "..minetest.registered_items[focusname].description.."]"
|
|
end
|
|
|
|
return "size[5,3.5]"..
|
|
default.gui_bg..
|
|
default.gui_bg_img..
|
|
"label[0,0;Wand Focuses]"..
|
|
current..
|
|
"label[0,2.4;Available]"..
|
|
fsp
|
|
end
|
|
|
|
-- Update wand's description
|
|
function magicalities.wands.update_wand_desc(stack)
|
|
local meta = stack:get_meta()
|
|
local data_table = minetest.deserialize(meta:get_string("contents"))
|
|
|
|
local wanddata = minetest.registered_items[stack:get_name()]
|
|
local description = wanddata.description
|
|
local capcontents = wanddata["_cap_max"] or 15
|
|
local strbld = description.."\n"
|
|
|
|
local longest_desc = 0
|
|
for _,data in pairs(magicalities.elements) do
|
|
if not data.inheritance then
|
|
local len = #data.description
|
|
if len > longest_desc then
|
|
longest_desc = len
|
|
end
|
|
end
|
|
end
|
|
|
|
local elems = {}
|
|
for elem, amount in pairs(data_table) do
|
|
local dataelem = magicalities.elements[elem]
|
|
if amount > 0 then
|
|
elems[#elems + 1] = minetest.colorize(dataelem.color, dataelem.description.." ")..
|
|
align(longest_desc * 2 - #dataelem.description)..
|
|
amount.."/"..capcontents
|
|
end
|
|
end
|
|
|
|
local focus, def = magicalities.wands.get_wand_focus(stack)
|
|
local focusstr = "No Wand Focus"
|
|
if focus then
|
|
focusstr = def.description
|
|
end
|
|
|
|
strbld = strbld .. focusstr
|
|
if #elems > 0 then
|
|
table.sort(elems)
|
|
strbld = strbld .. "\n" .. table.concat(elems, "\n")
|
|
end
|
|
|
|
meta:set_string("description", strbld)
|
|
end
|
|
|
|
-- Ensure wand has contents
|
|
function magicalities.wands.wand_has_contents(stack, requirements)
|
|
local meta = stack:get_meta()
|
|
local data_table = minetest.deserialize(meta:get_string("contents"))
|
|
|
|
if not data_table then return false end
|
|
|
|
for name, count in pairs(requirements) do
|
|
if not data_table[name] or data_table[name] < count then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-- Take wand contents
|
|
function magicalities.wands.wand_take_contents(stack, to_take)
|
|
local meta = stack:get_meta()
|
|
local data_table = minetest.deserialize(meta:get_string("contents"))
|
|
|
|
for name, count in pairs(to_take) do
|
|
if not data_table[name] or data_table[name] - count < 0 then
|
|
return nil
|
|
end
|
|
|
|
data_table[name] = data_table[name] - count
|
|
end
|
|
|
|
local data_res = minetest.serialize(data_table)
|
|
meta:set_string("contents", data_res)
|
|
|
|
return stack
|
|
end
|
|
|
|
-- Add wand contents
|
|
function magicalities.wands.wand_insert_contents(stack, to_put)
|
|
local meta = stack:get_meta()
|
|
local data_table = minetest.deserialize(meta:get_string("contents"))
|
|
local cap = minetest.registered_items[stack:get_name()]["_cap_max"]
|
|
local leftover = {}
|
|
|
|
for name, count in pairs(to_put) do
|
|
if data_table[name] then
|
|
if data_table[name] + count > cap then
|
|
data_table[name] = cap
|
|
leftover[name] = (data_table[name] + count) - cap
|
|
else
|
|
data_table[name] = data_table[name] + count
|
|
end
|
|
end
|
|
end
|
|
|
|
local data_res = minetest.serialize(data_table)
|
|
meta:set_string("contents", data_res)
|
|
|
|
return stack, leftover
|
|
end
|
|
|
|
-- Can add wand contents
|
|
function magicalities.wands.wand_insertable_contents(stack, to_put)
|
|
local meta = stack:get_meta()
|
|
local data_table = minetest.deserialize(meta:get_string("contents"))
|
|
local cap = minetest.registered_items[stack:get_name()]["_cap_max"]
|
|
local insertable = {}
|
|
|
|
for name, count in pairs(to_put) do
|
|
if data_table[name] then
|
|
if data_table[name] + count < cap + 1 then
|
|
insertable[name] = count
|
|
end
|
|
end
|
|
end
|
|
|
|
return insertable
|
|
end
|
|
|
|
-- Initialize wand metadata
|
|
local function initialize_wand(stack)
|
|
local data_table = {}
|
|
|
|
for name, data in pairs(magicalities.elements) do
|
|
if not data.inheritance then
|
|
data_table[name] = 0
|
|
end
|
|
end
|
|
|
|
local meta = stack:get_meta()
|
|
meta:set_string("contents", minetest.serialize(data_table))
|
|
end
|
|
|
|
local function wand_action(itemstack, placer, pointed_thing)
|
|
if not pointed_thing.type == "node" then return itemstack end
|
|
local node = minetest.get_node(pointed_thing.under)
|
|
local imeta = itemstack:get_meta()
|
|
|
|
-- Initialize wand metadata
|
|
if imeta:get_string("contents") == nil or imeta:get_string("contents") == "" then
|
|
initialize_wand(itemstack)
|
|
magicalities.wands.update_wand_desc(itemstack)
|
|
end
|
|
|
|
-- Replacement
|
|
local to_replace = nil
|
|
for grp, result in pairs(transform_recipes) do
|
|
if minetest.get_item_group(node.name, grp) > 0 then
|
|
to_replace = result
|
|
break
|
|
end
|
|
end
|
|
|
|
-- Call rightclick on the wand focus
|
|
local focus, fdef = magicalities.wands.get_wand_focus(itemstack)
|
|
if focus then
|
|
if fdef["_wand_node"] and focus_requirements(itemstack, fdef) then
|
|
itemstack = fdef["_wand_node"](pointed_thing.under, node, placer, itemstack, pointed_thing)
|
|
|
|
return itemstack
|
|
end
|
|
end
|
|
|
|
-- Call on_rightclick on the node instead if it cannot be replaced
|
|
if not to_replace then
|
|
local nodedef = minetest.registered_nodes[node.name]
|
|
|
|
if nodedef.on_rightclick then
|
|
itemstack = nodedef.on_rightclick(pointed_thing.under, node, placer, itemstack, pointed_thing)
|
|
end
|
|
|
|
return itemstack
|
|
end
|
|
|
|
if to_replace.requirements then
|
|
if not magicalities.wands.wand_has_contents(itemstack, to_replace.requirements) then return itemstack end
|
|
itemstack = magicalities.wands.wand_take_contents(itemstack, to_replace.requirements)
|
|
magicalities.wands.update_wand_desc(itemstack)
|
|
end
|
|
|
|
minetest.swap_node(pointed_thing.under, {name = to_replace.result, param1 = node.param1, param2 = node.param2})
|
|
|
|
local spec = minetest.registered_nodes[to_replace.result]
|
|
if spec.on_construct then
|
|
spec.on_construct(pointed_thing.under)
|
|
end
|
|
|
|
return itemstack
|
|
end
|
|
|
|
local function use_wand(itemstack, user, pointed_thing)
|
|
local imeta = itemstack:get_meta()
|
|
|
|
-- Initialize wand metadata
|
|
if imeta:get_string("contents") == nil or imeta:get_string("contents") == "" then
|
|
initialize_wand(itemstack)
|
|
magicalities.wands.update_wand_desc(itemstack)
|
|
end
|
|
|
|
-- Call use on the wand focus
|
|
local focus, fdef = magicalities.wands.get_wand_focus(itemstack)
|
|
if focus then
|
|
if fdef["_wand_use"] and focus_requirements(itemstack, fdef) then
|
|
itemstack = fdef["_wand_use"](itemstack, user, pointed_thing)
|
|
|
|
return itemstack
|
|
end
|
|
end
|
|
|
|
magicalities.wands.update_wand_desc(itemstack)
|
|
return itemstack
|
|
end
|
|
|
|
local function wand_focuses(itemstack, user, pointed_thing)
|
|
local focuses_found = {}
|
|
local inv = user:get_inventory()
|
|
local list = inv:get_list("main")
|
|
|
|
local focusname, focusdef = magicalities.wands.get_wand_focus(itemstack)
|
|
local meta = itemstack:get_meta()
|
|
|
|
for _, stack in pairs(list) do
|
|
if minetest.get_item_group(stack:get_name(), "wand_focus") > 0 then
|
|
focuses_found[stack:get_name()] = true
|
|
end
|
|
end
|
|
|
|
minetest.show_formspec(user:get_player_name(), "magicalities:wand_focuses", focuses_formspec(focuses_found, focusname))
|
|
minetest.register_on_player_receive_fields(function (player, formname, fields)
|
|
if formname ~= "magicalities:wand_focuses" then
|
|
return false
|
|
end
|
|
|
|
-- Make sure field is a valid item
|
|
local f = ""
|
|
if not fields["quit"] then
|
|
if fields["remove"] then
|
|
f = nil
|
|
else
|
|
for v in pairs(fields) do
|
|
if minetest.registered_items[v] then
|
|
f = v
|
|
break
|
|
end
|
|
end
|
|
end
|
|
else
|
|
return true
|
|
end
|
|
|
|
local was
|
|
|
|
was = meta:get_string("focus")
|
|
if was == "" and not f then
|
|
return true
|
|
elseif was ~= "" then
|
|
was = ItemStack(was)
|
|
if not inv:room_for_item("main", was) then
|
|
return true
|
|
end
|
|
end
|
|
|
|
minetest.close_formspec(player:get_player_name(), "magicalities:wand_focuses")
|
|
|
|
local removed_focus = false
|
|
local set = false
|
|
|
|
-- Update itemstack
|
|
for i, stack in pairs(list) do
|
|
if set and (removed_focus or not f) then break end
|
|
if not removed_focus and stack:get_name() == f then
|
|
inv:set_stack("main", i, ItemStack(nil))
|
|
removed_focus = true -- Make sure to only remove one
|
|
end
|
|
|
|
if stack:get_name() == itemstack:get_name() and stack:get_meta() == itemstack:get_meta() and not set then
|
|
if not f then
|
|
meta:set_string("focus", "")
|
|
magicalities.wands.update_wand_desc(itemstack)
|
|
elseif f ~= "" then
|
|
meta:set_string("focus", f)
|
|
magicalities.wands.update_wand_desc(itemstack)
|
|
end
|
|
|
|
inv:set_stack("main", i, itemstack)
|
|
set = true
|
|
end
|
|
end
|
|
|
|
-- Give the removed focus back
|
|
if was then
|
|
inv:add_item("main", was)
|
|
end
|
|
|
|
return true
|
|
end)
|
|
|
|
return itemstack
|
|
end
|
|
|
|
function magicalities.wands.register_wand(name, data)
|
|
local mod = minetest.get_current_modname()
|
|
minetest.register_tool(mod..":wand_"..name, {
|
|
description = data.description,
|
|
inventory_image = data.image,
|
|
tool_capabilities = wandcaps,
|
|
stack_max = 1,
|
|
_cap_max = data.wand_cap,
|
|
on_use = use_wand,
|
|
on_place = wand_action,
|
|
on_secondary_use = wand_focuses,
|
|
groups = {wand = 1}
|
|
})
|
|
end
|