X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=mods%2Fdefault%2Ffunctions.lua;h=f9ff77cc455de0472a32e9dafa43def5b11cfb27;hb=84da00acd45023f7af6f09bd6d404a495b66f860;hp=7f4492cbc58e2f14999a460bc322de1c7282fe67;hpb=9fdbc1f4072dcf2296af9bcce6ec92bfa75972ca;p=oweals%2Fminetest_game.git diff --git a/mods/default/functions.lua b/mods/default/functions.lua index 7f4492cb..f9ff77cc 100644 --- a/mods/default/functions.lua +++ b/mods/default/functions.lua @@ -1,5 +1,3 @@ --- mods/default/functions.lua - -- -- Sounds -- @@ -7,20 +5,20 @@ function default.node_sound_defaults(table) table = table or {} table.footstep = table.footstep or - {name="", gain=1.0} + {name = "", gain = 1.0} table.dug = table.dug or - {name="default_dug_node", gain=0.25} + {name = "default_dug_node", gain = 0.25} table.place = table.place or - {name="default_place_node_hard", gain=1.0} + {name = "default_place_node_hard", gain = 1.0} return table end function default.node_sound_stone_defaults(table) table = table or {} table.footstep = table.footstep or - {name="default_hard_footstep", gain=0.5} + {name = "default_hard_footstep", gain = 0.3} table.dug = table.dug or - {name="default_hard_footstep", gain=1.0} + {name = "default_hard_footstep", gain = 1.0} default.node_sound_defaults(table) return table end @@ -28,11 +26,11 @@ end function default.node_sound_dirt_defaults(table) table = table or {} table.footstep = table.footstep or - {name="default_dirt_footstep", gain=1.0} + {name = "default_dirt_footstep", gain = 0.4} table.dug = table.dug or - {name="default_dirt_footstep", gain=1.5} + {name = "default_dirt_footstep", gain = 1.0} table.place = table.place or - {name="default_place_node", gain=1.0} + {name = "default_place_node", gain = 1.0} default.node_sound_defaults(table) return table end @@ -40,11 +38,23 @@ end function default.node_sound_sand_defaults(table) table = table or {} table.footstep = table.footstep or - {name="default_sand_footstep", gain=0.5} + {name = "default_sand_footstep", gain = 0.12} table.dug = table.dug or - {name="default_sand_footstep", gain=1.0} + {name = "default_sand_footstep", gain = 0.24} table.place = table.place or - {name="default_place_node", gain=1.0} + {name = "default_place_node", gain = 1.0} + default.node_sound_defaults(table) + return table +end + +function default.node_sound_gravel_defaults(table) + table = table or {} + table.footstep = table.footstep or + {name = "default_gravel_footstep", gain = 0.4} + table.dug = table.dug or + {name = "default_gravel_footstep", gain = 1.0} + table.place = table.place or + {name = "default_place_node", gain = 1.0} default.node_sound_defaults(table) return table end @@ -52,9 +62,9 @@ end function default.node_sound_wood_defaults(table) table = table or {} table.footstep = table.footstep or - {name="default_wood_footstep", gain=0.5} + {name = "default_wood_footstep", gain = 0.3} table.dug = table.dug or - {name="default_wood_footstep", gain=1.0} + {name = "default_wood_footstep", gain = 1.0} default.node_sound_defaults(table) return table end @@ -62,13 +72,11 @@ end function default.node_sound_leaves_defaults(table) table = table or {} table.footstep = table.footstep or - {name="default_grass_footstep", gain=0.35} + {name = "default_grass_footstep", gain = 0.45} table.dug = table.dug or - {name="default_grass_footstep", gain=0.85} - table.dig = table.dig or - {name="default_dig_crumbly", gain=0.4} + {name = "default_grass_footstep", gain = 0.7} table.place = table.place or - {name="default_place_node", gain=1.0} + {name = "default_place_node", gain = 1.0} default.node_sound_defaults(table) return table end @@ -76,283 +84,594 @@ end function default.node_sound_glass_defaults(table) table = table or {} table.footstep = table.footstep or - {name="default_glass_footstep", gain=0.5} + {name = "default_glass_footstep", gain = 0.3} + table.dig = table.dig or + {name = "default_glass_footstep", gain = 0.5} table.dug = table.dug or - {name="default_break_glass", gain=1.0} + {name = "default_break_glass", gain = 1.0} default.node_sound_defaults(table) return table end --- --- Legacy --- +function default.node_sound_metal_defaults(table) + table = table or {} + table.footstep = table.footstep or + {name = "default_metal_footstep", gain = 0.4} + table.dig = table.dig or + {name = "default_dig_metal", gain = 0.5} + table.dug = table.dug or + {name = "default_dug_metal", gain = 0.5} + table.place = table.place or + {name = "default_place_node_metal", gain = 0.5} + default.node_sound_defaults(table) + return table +end -function default.spawn_falling_node(p, nodename) - spawn_falling_node(p, nodename) +function default.node_sound_water_defaults(table) + table = table or {} + table.footstep = table.footstep or + {name = "default_water_footstep", gain = 0.2} + default.node_sound_defaults(table) + return table end --- Horrible crap to support old code --- Don't use this and never do what this does, it's completely wrong! --- (More specifically, the client and the C++ code doesn't get the group) -function default.register_falling_node(nodename, texture) - minetest.log("error", debug.traceback()) - minetest.log('error', "WARNING: default.register_falling_node is deprecated") - if minetest.registered_nodes[nodename] then - minetest.registered_nodes[nodename].groups.falling_node = 1 - end +function default.node_sound_snow_defaults(table) + table = table or {} + table.footstep = table.footstep or + {name = "default_snow_footstep", gain = 0.2} + table.dig = table.dig or + {name = "default_snow_footstep", gain = 0.3} + table.dug = table.dug or + {name = "default_snow_footstep", gain = 0.3} + table.place = table.place or + {name = "default_place_node", gain = 1.0} + default.node_sound_defaults(table) + return table end + -- --- Global callbacks +-- Lavacooling -- --- Global environment step function -function on_step(dtime) - -- print("on_step") +default.cool_lava = function(pos, node) + if node.name == "default:lava_source" then + minetest.set_node(pos, {name = "default:obsidian"}) + else -- Lava flowing + minetest.set_node(pos, {name = "default:stone"}) + end + minetest.sound_play("default_cool_lava", + {pos = pos, max_hear_distance = 16, gain = 0.25}, true) end -minetest.register_globalstep(on_step) -function on_placenode(p, node) - --print("on_placenode") +if minetest.settings:get_bool("enable_lavacooling") ~= false then + minetest.register_abm({ + label = "Lava cooling", + nodenames = {"default:lava_source", "default:lava_flowing"}, + neighbors = {"group:cools_lava", "group:water"}, + interval = 2, + chance = 2, + catch_up = false, + action = function(...) + default.cool_lava(...) + end, + }) end -minetest.register_on_placenode(on_placenode) -function on_dignode(p, node) - --print("on_dignode") -end -minetest.register_on_dignode(on_dignode) -function on_punchnode(p, node) +-- +-- Optimized helper to put all items in an inventory into a drops list +-- + +function default.get_inventory_drops(pos, inventory, drops) + local inv = minetest.get_meta(pos):get_inventory() + local n = #drops + for i = 1, inv:get_size(inventory) do + local stack = inv:get_stack(inventory, i) + if stack:get_count() > 0 then + drops[n+1] = stack:to_table() + n = n + 1 + end + end end -minetest.register_on_punchnode(on_punchnode) -- --- Grow trees +-- Papyrus and cactus growing -- +-- Wrapping the functions in ABM action is necessary to make overriding them possible + +function default.grow_cactus(pos, node) + if node.param2 >= 4 then + return + end + pos.y = pos.y - 1 + if minetest.get_item_group(minetest.get_node(pos).name, "sand") == 0 then + return + end + pos.y = pos.y + 1 + local height = 0 + while node.name == "default:cactus" and height < 4 do + height = height + 1 + pos.y = pos.y + 1 + node = minetest.get_node(pos) + end + if height == 4 or node.name ~= "air" then + return + end + if minetest.get_node_light(pos) < 13 then + return + end + minetest.set_node(pos, {name = "default:cactus"}) + return true +end + +function default.grow_papyrus(pos, node) + pos.y = pos.y - 1 + local name = minetest.get_node(pos).name + if name ~= "default:dirt_with_grass" and name ~= "default:dirt" then + return + end + if not minetest.find_node_near(pos, 3, {"group:water"}) then + return + end + pos.y = pos.y + 1 + local height = 0 + while node.name == "default:papyrus" and height < 4 do + height = height + 1 + pos.y = pos.y + 1 + node = minetest.get_node(pos) + end + if height == 4 or node.name ~= "air" then + return + end + if minetest.get_node_light(pos) < 13 then + return + end + minetest.set_node(pos, {name = "default:papyrus"}) + return true +end + minetest.register_abm({ - nodenames = {"default:sapling"}, - interval = 10, - chance = 50, - action = function(pos, node) - local is_soil = minetest.registered_nodes[minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name].groups.soil - if is_soil == nil or is_soil == 0 then return end - print("A sapling grows into a tree at "..minetest.pos_to_string(pos)) - local vm = minetest.get_voxel_manip() - local minp, maxp = vm:read_from_map({x=pos.x-16, y=pos.y, z=pos.z-16}, {x=pos.x+16, y=pos.y+16, z=pos.z+16}) - local a = VoxelArea:new{MinEdge=minp, MaxEdge=maxp} - local data = vm:get_data() - default.grow_tree(data, a, pos, math.random(1, 4) == 1, math.random(1,100000)) - vm:set_data(data) - vm:write_to_map(data) - vm:update_map() - end + label = "Grow cactus", + nodenames = {"default:cactus"}, + neighbors = {"group:sand"}, + interval = 12, + chance = 83, + action = function(...) + default.grow_cactus(...) + end }) minetest.register_abm({ - nodenames = {"default:junglesapling"}, - interval = 10, - chance = 50, - action = function(pos, node) - local is_soil = minetest.registered_nodes[minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name].groups.soil - if is_soil == nil or is_soil == 0 then return end - print("A jungle sapling grows into a tree at "..minetest.pos_to_string(pos)) - local vm = minetest.get_voxel_manip() - local minp, maxp = vm:read_from_map({x=pos.x-16, y=pos.y-1, z=pos.z-16}, {x=pos.x+16, y=pos.y+16, z=pos.z+16}) - local a = VoxelArea:new{MinEdge=minp, MaxEdge=maxp} - local data = vm:get_data() - default.grow_jungletree(data, a, pos, math.random(1,100000)) - vm:set_data(data) - vm:write_to_map(data) - vm:update_map() - end + label = "Grow papyrus", + nodenames = {"default:papyrus"}, + neighbors = {"default:dirt", "default:dirt_with_grass"}, + interval = 14, + chance = 71, + action = function(...) + default.grow_papyrus(...) + end }) + -- --- Lavacooling +-- Dig upwards -- -default.cool_lava_source = function(pos) - minetest.set_node(pos, {name="default:obsidian"}) - minetest.sound_play("default_cool_lava", {pos = pos, gain = 0.25}) +function default.dig_up(pos, node, digger) + if digger == nil then return end + local np = {x = pos.x, y = pos.y + 1, z = pos.z} + local nn = minetest.get_node(np) + if nn.name == node.name then + minetest.node_dig(np, nn, digger) + end end -default.cool_lava_flowing = function(pos) - minetest.set_node(pos, {name="default:stone"}) - minetest.sound_play("default_cool_lava", {pos = pos, gain = 0.25}) + +-- +-- Fence registration helper +-- +local fence_collision_extra = minetest.settings:get_bool("enable_fence_tall") and 3/8 or 0 + +function default.register_fence(name, def) + minetest.register_craft({ + output = name .. " 4", + recipe = { + { def.material, 'group:stick', def.material }, + { def.material, 'group:stick', def.material }, + } + }) + + local fence_texture = "default_fence_overlay.png^" .. def.texture .. + "^default_fence_overlay.png^[makealpha:255,126,126" + -- Allow almost everything to be overridden + local default_fields = { + paramtype = "light", + drawtype = "nodebox", + node_box = { + type = "connected", + fixed = {-1/8, -1/2, -1/8, 1/8, 1/2, 1/8}, + -- connect_top = + -- connect_bottom = + connect_front = {{-1/16, 3/16, -1/2, 1/16, 5/16, -1/8 }, + {-1/16, -5/16, -1/2, 1/16, -3/16, -1/8 }}, + connect_left = {{-1/2, 3/16, -1/16, -1/8, 5/16, 1/16}, + {-1/2, -5/16, -1/16, -1/8, -3/16, 1/16}}, + connect_back = {{-1/16, 3/16, 1/8, 1/16, 5/16, 1/2 }, + {-1/16, -5/16, 1/8, 1/16, -3/16, 1/2 }}, + connect_right = {{ 1/8, 3/16, -1/16, 1/2, 5/16, 1/16}, + { 1/8, -5/16, -1/16, 1/2, -3/16, 1/16}} + }, + collision_box = { + type = "connected", + fixed = {-1/8, -1/2, -1/8, 1/8, 1/2 + fence_collision_extra, 1/8}, + -- connect_top = + -- connect_bottom = + connect_front = {-1/8, -1/2, -1/2, 1/8, 1/2 + fence_collision_extra, -1/8}, + connect_left = {-1/2, -1/2, -1/8, -1/8, 1/2 + fence_collision_extra, 1/8}, + connect_back = {-1/8, -1/2, 1/8, 1/8, 1/2 + fence_collision_extra, 1/2}, + connect_right = { 1/8, -1/2, -1/8, 1/2, 1/2 + fence_collision_extra, 1/8} + }, + connects_to = {"group:fence", "group:wood", "group:tree", "group:wall"}, + inventory_image = fence_texture, + wield_image = fence_texture, + tiles = {def.texture}, + sunlight_propagates = true, + is_ground_content = false, + groups = {}, + } + for k, v in pairs(default_fields) do + if def[k] == nil then + def[k] = v + end + end + + -- Always add to the fence group, even if no group provided + def.groups.fence = 1 + + def.texture = nil + def.material = nil + + minetest.register_node(name, def) end -minetest.register_abm({ - nodenames = {"default:lava_flowing"}, - neighbors = {"group:water"}, - interval = 1, - chance = 1, - action = function(pos, node, active_object_count, active_object_count_wider) - default.cool_lava_flowing(pos, node, active_object_count, active_object_count_wider) - end, -}) -minetest.register_abm({ - nodenames = {"default:lava_source"}, - neighbors = {"group:water"}, - interval = 1, - chance = 1, - action = function(pos, node, active_object_count, active_object_count_wider) - default.cool_lava_source(pos, node, active_object_count, active_object_count_wider) - end, -}) +-- +-- Fence rail registration helper +-- + +function default.register_fence_rail(name, def) + minetest.register_craft({ + output = name .. " 16", + recipe = { + { def.material, def.material }, + { "", ""}, + { def.material, def.material }, + } + }) + + local fence_rail_texture = "default_fence_rail_overlay.png^" .. def.texture .. + "^default_fence_rail_overlay.png^[makealpha:255,126,126" + -- Allow almost everything to be overridden + local default_fields = { + paramtype = "light", + drawtype = "nodebox", + node_box = { + type = "connected", + fixed = {{-1/16, 3/16, -1/16, 1/16, 5/16, 1/16}, + {-1/16, -3/16, -1/16, 1/16, -5/16, 1/16}}, + -- connect_top = + -- connect_bottom = + connect_front = {{-1/16, 3/16, -1/2, 1/16, 5/16, -1/16}, + {-1/16, -5/16, -1/2, 1/16, -3/16, -1/16}}, + connect_left = {{-1/2, 3/16, -1/16, -1/16, 5/16, 1/16}, + {-1/2, -5/16, -1/16, -1/16, -3/16, 1/16}}, + connect_back = {{-1/16, 3/16, 1/16, 1/16, 5/16, 1/2 }, + {-1/16, -5/16, 1/16, 1/16, -3/16, 1/2 }}, + connect_right = {{ 1/16, 3/16, -1/16, 1/2, 5/16, 1/16}, + { 1/16, -5/16, -1/16, 1/2, -3/16, 1/16}} + }, + collision_box = { + type = "connected", + fixed = {-1/8, -1/2, -1/8, 1/8, 1/2 + fence_collision_extra, 1/8}, + -- connect_top = + -- connect_bottom = + connect_front = {-1/8, -1/2, -1/2, 1/8, 1/2 + fence_collision_extra, -1/8}, + connect_left = {-1/2, -1/2, -1/8, -1/8, 1/2 + fence_collision_extra, 1/8}, + connect_back = {-1/8, -1/2, 1/8, 1/8, 1/2 + fence_collision_extra, 1/2}, + connect_right = { 1/8, -1/2, -1/8, 1/2, 1/2 + fence_collision_extra, 1/8} + }, + connects_to = {"group:fence", "group:wall"}, + inventory_image = fence_rail_texture, + wield_image = fence_rail_texture, + tiles = {def.texture}, + sunlight_propagates = true, + is_ground_content = false, + groups = {}, + } + for k, v in pairs(default_fields) do + if def[k] == nil then + def[k] = v + end + end + + -- Always add to the fence group, even if no group provided + def.groups.fence = 1 + + def.texture = nil + def.material = nil + + minetest.register_node(name, def) +end + -- --- Papyrus and cactus growing +-- Leafdecay +-- + +-- Prevent decay of placed leaves + +default.after_place_leaves = function(pos, placer, itemstack, pointed_thing) + if placer and placer:is_player() then + local node = minetest.get_node(pos) + node.param2 = 1 + minetest.set_node(pos, node) + end +end + +-- Leafdecay +local function leafdecay_after_destruct(pos, oldnode, def) + for _, v in pairs(minetest.find_nodes_in_area(vector.subtract(pos, def.radius), + vector.add(pos, def.radius), def.leaves)) do + local node = minetest.get_node(v) + local timer = minetest.get_node_timer(v) + if node.param2 ~= 1 and not timer:is_started() then + timer:start(math.random(20, 120) / 10) + end + end +end + +local movement_gravity = tonumber( + minetest.settings:get("movement_gravity")) or 9.81 + +local function leafdecay_on_timer(pos, def) + if minetest.find_node_near(pos, def.radius, def.trunks) then + return false + end + + local node = minetest.get_node(pos) + local drops = minetest.get_node_drops(node.name) + for _, item in ipairs(drops) do + local is_leaf + for _, v in pairs(def.leaves) do + if v == item then + is_leaf = true + end + end + if minetest.get_item_group(item, "leafdecay_drop") ~= 0 or + not is_leaf then + minetest.add_item({ + x = pos.x - 0.5 + math.random(), + y = pos.y - 0.5 + math.random(), + z = pos.z - 0.5 + math.random(), + }, item) + end + end + + minetest.remove_node(pos) + minetest.check_for_falling(pos) + + -- spawn a few particles for the removed node + minetest.add_particlespawner({ + amount = 8, + time = 0.001, + minpos = vector.subtract(pos, {x=0.5, y=0.5, z=0.5}), + maxpos = vector.add(pos, {x=0.5, y=0.5, z=0.5}), + minvel = vector.new(-0.5, -1, -0.5), + maxvel = vector.new(0.5, 0, 0.5), + minacc = vector.new(0, -movement_gravity, 0), + maxacc = vector.new(0, -movement_gravity, 0), + minsize = 0, + maxsize = 0, + node = node, + }) +end + +function default.register_leafdecay(def) + assert(def.leaves) + assert(def.trunks) + assert(def.radius) + for _, v in pairs(def.trunks) do + minetest.override_item(v, { + after_destruct = function(pos, oldnode) + leafdecay_after_destruct(pos, oldnode, def) + end, + }) + end + for _, v in pairs(def.leaves) do + minetest.override_item(v, { + on_timer = function(pos) + leafdecay_on_timer(pos, def) + end, + }) + end +end + + +-- +-- Convert dirt to something that fits the environment -- minetest.register_abm({ - nodenames = {"default:cactus"}, - neighbors = {"group:sand"}, - interval = 50, - chance = 20, + label = "Grass spread", + nodenames = {"default:dirt"}, + neighbors = { + "air", + "group:grass", + "default:snow", + }, + interval = 6, + chance = 50, + catch_up = false, action = function(pos, node) - pos.y = pos.y-1 - local name = minetest.get_node(pos).name - if minetest.get_item_group(name, "sand") ~= 0 then - pos.y = pos.y+1 - local height = 0 - while minetest.get_node(pos).name == "default:cactus" and height < 4 do - height = height+1 - pos.y = pos.y+1 - end - if height < 4 then - if minetest.get_node(pos).name == "air" then - minetest.set_node(pos, {name="default:cactus"}) - end - end + -- Check for darkness: night, shadow or under a light-blocking node + -- Returns if ignore above + local above = {x = pos.x, y = pos.y + 1, z = pos.z} + if (minetest.get_node_light(above) or 0) < 13 then + return + end + + -- Look for spreading dirt-type neighbours + local p2 = minetest.find_node_near(pos, 1, "group:spreading_dirt_type") + if p2 then + local n3 = minetest.get_node(p2) + minetest.set_node(pos, {name = n3.name}) + return + end + + -- Else, any seeding nodes on top? + local name = minetest.get_node(above).name + -- Snow check is cheapest, so comes first + if name == "default:snow" then + minetest.set_node(pos, {name = "default:dirt_with_snow"}) + elseif minetest.get_item_group(name, "grass") ~= 0 then + minetest.set_node(pos, {name = "default:dirt_with_grass"}) end - end, + end }) + +-- +-- Grass and dry grass removed in darkness +-- + minetest.register_abm({ - nodenames = {"default:papyrus"}, - neighbors = {"default:dirt", "default:dirt_with_grass"}, - interval = 50, - chance = 20, + label = "Grass covered", + nodenames = {"group:spreading_dirt_type", "default:dry_dirt_with_dry_grass"}, + interval = 8, + chance = 50, + catch_up = false, action = function(pos, node) - pos.y = pos.y-1 - local name = minetest.get_node(pos).name - if name == "default:dirt" or name == "default:dirt_with_grass" then - if minetest.find_node_near(pos, 3, {"group:water"}) == nil then - return - end - pos.y = pos.y+1 - local height = 0 - while minetest.get_node(pos).name == "default:papyrus" and height < 4 do - height = height+1 - pos.y = pos.y+1 - end - if height < 4 then - if minetest.get_node(pos).name == "air" then - minetest.set_node(pos, {name="default:papyrus"}) - end + local above = {x = pos.x, y = pos.y + 1, z = pos.z} + local name = minetest.get_node(above).name + local nodedef = minetest.registered_nodes[name] + if name ~= "ignore" and nodedef and not ((nodedef.sunlight_propagates or + nodedef.paramtype == "light") and + nodedef.liquidtype == "none") then + if node.name == "default:dry_dirt_with_dry_grass" then + minetest.set_node(pos, {name = "default:dry_dirt"}) + else + minetest.set_node(pos, {name = "default:dirt"}) end end - end, + end }) + -- --- Leafdecay +-- Moss growth on cobble near water -- --- To enable leaf decay for a node, add it to the "leafdecay" group. --- --- The rating of the group determines how far from a node in the group "tree" --- the node can be without decaying. +local moss_correspondences = { + ["default:cobble"] = "default:mossycobble", + ["stairs:slab_cobble"] = "stairs:slab_mossycobble", + ["stairs:stair_cobble"] = "stairs:stair_mossycobble", + ["stairs:stair_inner_cobble"] = "stairs:stair_inner_mossycobble", + ["stairs:stair_outer_cobble"] = "stairs:stair_outer_mossycobble", + ["walls:cobble"] = "walls:mossycobble", +} +minetest.register_abm({ + label = "Moss growth", + nodenames = {"default:cobble", "stairs:slab_cobble", "stairs:stair_cobble", + "stairs:stair_inner_cobble", "stairs:stair_outer_cobble", + "walls:cobble"}, + neighbors = {"group:water"}, + interval = 16, + chance = 200, + catch_up = false, + action = function(pos, node) + node.name = moss_correspondences[node.name] + if node.name then + minetest.set_node(pos, node) + end + end +}) + -- --- If param2 of the node is ~= 0, the node will always be preserved. Thus, if --- the player places a node of that kind, you will want to set param2=1 or so. +-- Register a craft to copy the metadata of items -- --- If the node is in the leafdecay_drop group then the it will always be dropped --- as an item -default.leafdecay_trunk_cache = {} -default.leafdecay_enable_cache = true --- Spread the load of finding trunks -default.leafdecay_trunk_find_allow_accumulator = 0 +function default.register_craft_metadata_copy(ingredient, result) + minetest.register_craft({ + type = "shapeless", + output = result, + recipe = {ingredient, result} + }) -minetest.register_globalstep(function(dtime) - local finds_per_second = 5000 - default.leafdecay_trunk_find_allow_accumulator = - math.floor(dtime * finds_per_second) -end) - -minetest.register_abm({ - nodenames = {"group:leafdecay"}, - neighbors = {"air", "group:liquid"}, - -- A low interval and a high inverse chance spreads the load - interval = 2, - chance = 5, - - action = function(p0, node, _, _) - --print("leafdecay ABM at "..p0.x..", "..p0.y..", "..p0.z..")") - local do_preserve = false - local d = minetest.registered_nodes[node.name].groups.leafdecay - if not d or d == 0 then - --print("not groups.leafdecay") + minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv) + if itemstack:get_name() ~= result then return end - local n0 = minetest.get_node(p0) - if n0.param2 ~= 0 then - --print("param2 ~= 0") - return - end - local p0_hash = nil - if default.leafdecay_enable_cache then - p0_hash = minetest.hash_node_position(p0) - local trunkp = default.leafdecay_trunk_cache[p0_hash] - if trunkp then - local n = minetest.get_node(trunkp) - local reg = minetest.registered_nodes[n.name] - -- Assume ignore is a trunk, to make the thing work at the border of the active area - if n.name == "ignore" or (reg and reg.groups.tree and reg.groups.tree ~= 0) then - --print("cached trunk still exists") - return - end - --print("cached trunk is invalid") - -- Cache is invalid - table.remove(default.leafdecay_trunk_cache, p0_hash) + + local original + local index + for i = 1, #old_craft_grid do + if old_craft_grid[i]:get_name() == result then + original = old_craft_grid[i] + index = i end end - if default.leafdecay_trunk_find_allow_accumulator <= 0 then + if not original then return end - default.leafdecay_trunk_find_allow_accumulator = - default.leafdecay_trunk_find_allow_accumulator - 1 - -- Assume ignore is a trunk, to make the thing work at the border of the active area - local p1 = minetest.find_node_near(p0, d, {"ignore", "group:tree"}) - if p1 then - do_preserve = true - if default.leafdecay_enable_cache then - --print("caching trunk") - -- Cache the trunk - default.leafdecay_trunk_cache[p0_hash] = p1 - end + local copymeta = original:get_meta():to_table() + itemstack:get_meta():from_table(copymeta) + -- put the book with metadata back in the craft grid + craft_inv:set_stack("craft", index, original) + end) +end + + +-- +-- NOTICE: This method is not an official part of the API yet. +-- This method may change in future. +-- + +function default.can_interact_with_node(player, pos) + if player and player:is_player() then + if minetest.check_player_privs(player, "protection_bypass") then + return true end - if not do_preserve then - -- Drop stuff other than the node itself - itemstacks = minetest.get_node_drops(n0.name) - for _, itemname in ipairs(itemstacks) do - if minetest.get_item_group(n0.name, "leafdecay_drop") ~= 0 or - itemname ~= n0.name then - local p_drop = { - x = p0.x - 0.5 + math.random(), - y = p0.y - 0.5 + math.random(), - z = p0.z - 0.5 + math.random(), - } - minetest.add_item(p_drop, itemname) - end + else + return false + end + + local meta = minetest.get_meta(pos) + local owner = meta:get_string("owner") + + if not owner or owner == "" or owner == player:get_player_name() then + return true + end + + -- Is player wielding the right key? + local item = player:get_wielded_item() + if minetest.get_item_group(item:get_name(), "key") == 1 then + local key_meta = item:get_meta() + + if key_meta:get_string("secret") == "" then + local key_oldmeta = item:get_metadata() + if key_oldmeta == "" or not minetest.parse_json(key_oldmeta) then + return false end - -- Remove node - minetest.remove_node(p0) - nodeupdate(p0) + + key_meta:set_string("secret", minetest.parse_json(key_oldmeta).secret) + item:set_metadata("") end + + return meta:get_string("key_lock_secret") == key_meta:get_string("secret") end -}) + + return false +end