diff --git a/fungal_tree.lua b/fungal_tree.lua index 436243b..e97cd40 100644 --- a/fungal_tree.lua +++ b/fungal_tree.lua @@ -159,23 +159,7 @@ minetest.register_craft({ replacements = { {'bucket:bucket_water', 'bucket:bucket_water'}, {'bucket:bucket_river_water', 'bucket:bucket_river_water'}, - }, -}) - -minetest.register_craftitem("fun_caves:wooden_bowl", { - description = "Wooden Bowl", - drawtype = "plantlike", - paramtype = "light", - tiles = {"fun_caves_wooden_bowl.png"}, - inventory_image = "fun_caves_wooden_bowl.png", - groups = {bowl = 1, dig_immediate = 3}, -}) - -minetest.register_craft({ - output = 'fun_caves:wooden_bowl 20', - recipe = { - {'', '', ''}, - {'group:wood', '', 'group:wood'}, - {'', 'group:wood', ''}, + {'fun_caves:bucket_wood_water', 'fun_caves:bucket_wood_water'}, + {'fun_caves:bucket_wood_river_water', 'fun_caves:bucket_wood_river_water'}, }, }) diff --git a/init.lua b/init.lua index ede0562..72e649e 100644 --- a/init.lua +++ b/init.lua @@ -169,6 +169,7 @@ dofile(fun_caves.path .. "/deco.lua") dofile(fun_caves.path .. "/fungal_tree.lua") dofile(fun_caves.path .. "/wallhammer.lua") dofile(fun_caves.path .. "/mapgen.lua") +dofile(fun_caves.path .. "/wooden_buckets.lua") dofile(fun_caves.path .. "/spec_bomb.lua") dofile(fun_caves.path .. "/elixir.lua") -- must go after all items are registered dofile(fun_caves.path .. "/chat.lua") diff --git a/mobs.lua b/mobs.lua index 4f8b99c..86112e6 100644 --- a/mobs.lua +++ b/mobs.lua @@ -696,6 +696,7 @@ end if minetest.registered_entities["dmobs:elephant"] then local m = minetest.registered_entities["dmobs:elephant"] m.type = "monster" + m.water_damage = 0 end if minetest.registered_entities["mobs_bat:bat"] then diff --git a/nodes.lua b/nodes.lua index 641e339..36f76fc 100644 --- a/nodes.lua +++ b/nodes.lua @@ -428,3 +428,21 @@ for i = 3, 5 do }, }) end + +minetest.register_craftitem("fun_caves:wooden_bowl", { + description = "Wooden Bowl", + drawtype = "plantlike", + paramtype = "light", + tiles = {"fun_caves_wooden_bowl.png"}, + inventory_image = "fun_caves_wooden_bowl.png", + groups = {bowl = 1, dig_immediate = 3}, +}) + +minetest.register_craft({ + output = 'fun_caves:wooden_bowl 20', + recipe = { + {'group:wood', '', 'group:wood'}, + {'group:wood', '', 'group:wood'}, + {'', 'group:wood', ''}, + }, +}) diff --git a/spec_bomb.lua b/spec_bomb.lua index e06de2d..c259f51 100644 --- a/spec_bomb.lua +++ b/spec_bomb.lua @@ -177,153 +177,171 @@ for _, node in pairs(nodes) do end -local mass_nodes = {'fun_caves:tree', 'default:tree', 'default:jungletree', 'default:acacia_tree', 'default:aspen_tree', 'default:stone', 'default:sandstone', 'default:desert_stone', 'fun_caves:stone_with_algae', 'fun_caves:stone_with_moss', 'fun_caves:stone_with_lichen'} -local mass_tools_list = {'default:axe_bronze', 'default:axe_diamond', 'default:axe_mese', 'default:pick_bronze', 'default:pick_diamond', 'default:pick_mese'} -local mass_tools = {} -for _, tool in pairs(mass_tools_list) do - mass_tools[tool] = true -end -local mass_minerals_list = {'default:gravel'} -local mass_minerals = {} -for _, min in pairs(mass_minerals_list) do - mass_minerals[min] = true -end -for name, _ in pairs(minetest.registered_nodes) do - if name:find('stone_with') then - mass_minerals[name] = true +-- incompatible with buckets +if false then + local mass_nodes = {'fun_caves:tree', 'default:tree', 'default:jungletree', 'default:acacia_tree', 'default:aspen_tree', 'default:stone', 'default:sandstone', 'default:desert_stone', 'fun_caves:stone_with_algae', 'fun_caves:stone_with_moss', 'fun_caves:stone_with_lichen'} + local mass_tools_list = {'default:axe_bronze', 'default:axe_diamond', 'default:axe_mese', 'default:pick_bronze', 'default:pick_diamond', 'default:pick_mese'} + local mass_tools = {} + for _, tool in pairs(mass_tools_list) do + mass_tools[tool] = true end -end -local function default_rightclick(pos, node, clicker, itemstack, pointed_thing) - if itemstack:get_definition().type == "node" then - return minetest.item_place_node(itemstack, clicker, pointed_thing) + local mass_minerals_list = {'default:gravel'} + local mass_minerals = {} + for _, min in pairs(mass_minerals_list) do + mass_minerals[min] = true end - return itemstack -end - -for _, node in pairs(mass_nodes) do - if not minetest.registered_items[node] then - break - end - - minetest.override_item(node, {on_rightclick = function(pos, node, clicker, itemstack, pointed_thing) - local tool = itemstack:get_name() - if not mass_tools[tool] then - return default_rightclick(pos, node, clicker, itemstack, pointed_thing) + for name, _ in pairs(minetest.registered_nodes) do + if name:find('stone_with') then + mass_minerals[name] = true end - local tool_type, maxr - if tool:find('axe') then - if minetest.get_item_group(node.name, "tree") == 0 then + end + local function default_rightclick(pos, node, clicker, itemstack, pointed_thing) + if itemstack:get_definition().type == "node" then + return minetest.item_place_node(itemstack, clicker, pointed_thing) + end + return itemstack + end + + for _, node in pairs(mass_nodes) do + if not minetest.registered_items[node] then + break + end + + local node_def = minetest.registered_items[node] + if node_def.on_rightclick then + print(node) + node_def.fun_caves_default_rightclick = node.on_rightclick + print(dump(node_def)) + end + + minetest.override_item(node, {on_rightclick = function(pos, node, clicker, itemstack, pointed_thing) + local tool = itemstack:get_name() + if not mass_tools[tool] then + print('* return default') + if node then + local node_def = minetest.registered_items[node.name] + print(dump(node_def)) + if node_def and node_def.fun_caves_default_rightclick then + return node_def.fun_caves_default_rightclick(pos, node, clicker, itemstack, pointed_thing) + end + end return default_rightclick(pos, node, clicker, itemstack, pointed_thing) end - tool_type = 'axe' - maxr = {x = 2, y = 20, z = 2} - elseif tool:find('pick') then - if node.name ~= 'default:sandstone' and minetest.get_item_group(node.name, "stone") == 0 then + local tool_type, maxr + if tool:find('axe') then + if minetest.get_item_group(node.name, "tree") == 0 then + return default_rightclick(pos, node, clicker, itemstack, pointed_thing) + end + tool_type = 'axe' + maxr = {x = 2, y = 20, z = 2} + elseif tool:find('pick') then + if node.name ~= 'default:sandstone' and minetest.get_item_group(node.name, "stone") == 0 then + return default_rightclick(pos, node, clicker, itemstack, pointed_thing) + end + tool_type = 'pick' + maxr = {x = 2, y = 4, z = 2} + else return default_rightclick(pos, node, clicker, itemstack, pointed_thing) end - tool_type = 'pick' - maxr = {x = 2, y = 4, z = 2} - else - return default_rightclick(pos, node, clicker, itemstack, pointed_thing) - end - local player_pos = vector.round(clicker:getpos()) - local player_name = clicker:get_player_name() - local inv = clicker:get_inventory() - if not (player_pos and player_name and inv) then - return default_rightclick(pos, node, clicker, itemstack, pointed_thing) - end - pos = vector.round(pos) - local max_nodes = 60 - local minp = vector.subtract(pos, 2) - local maxp = vector.add(pos, maxr) - if pos.y >= player_pos.y then - minp.y = player_pos.y - if pos.y - player_pos.y < 3 then - maxp.y = player_pos.y + 3 + local player_pos = vector.round(clicker:getpos()) + local player_name = clicker:get_player_name() + local inv = clicker:get_inventory() + if not (player_pos and player_name and inv) then + return default_rightclick(pos, node, clicker, itemstack, pointed_thing) end - end - - local air = minetest.get_content_id('air') - local vm = minetest.get_voxel_manip() - local emin, emax = vm:read_from_map(minp, maxp) - local area = VoxelArea:new({MinEdge = emin, MaxEdge = emax}) - local data = vm:get_data() - local drops = {} - local names = {} - local diggable = {} - local tree_like = {} - local leaf_like = {} - local stone_like = {} - local count = 0 - local p = {} - for y = minp.y, maxp.y do - p.y = y - for z = minp.z, maxp.z do - p.z = z - local ivm = area:index(minp.x, y, z) - for x = minp.x, maxp.x do - p.x = x - if not names[data[ivm]] then - names[data[ivm]] = minetest.get_name_from_content_id(data[ivm]) - end - - if not diggable[data[ivm]] then - if tool_type == 'axe' then - diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'choppy') or 0 - diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'snappy') or 0 - diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'fleshy') or 0 - elseif tool_type == 'pick' then - diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'cracky') or 0 - end - end - - if not stone_like[data[ivm]] then - stone_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'stone') or 0 - stone_like[data[ivm]] = stone_like[data[ivm]] + (names[data[ivm]] == 'default:sandstone' and 1 or 0) - end - - if not tree_like[data[ivm]] then - tree_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'tree') or 0 - end - - if not leaf_like[data[ivm]] then - leaf_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'leafdecay') or 0 - end - - local dig_it - if tool_type == 'axe' then - dig_it = tree_like[data[ivm]] > 0 or leaf_like[data[ivm]] > 0 - elseif tool_type == 'pick' then - dig_it = stone_like[data[ivm]] > 0 or mass_minerals[names[data[ivm]]] - end - - if count < max_nodes and diggable[data[ivm]] > 0 and dig_it and not minetest.is_protected(p, player_name) then - drops[data[ivm]] = (drops[data[ivm]] or 0) + 1 - data[ivm] = air - count = count + 1 - end - ivm = ivm + 1 + pos = vector.round(pos) + local max_nodes = 60 + local minp = vector.subtract(pos, 2) + local maxp = vector.add(pos, maxr) + if pos.y >= player_pos.y then + minp.y = player_pos.y + if pos.y - player_pos.y < 3 then + maxp.y = player_pos.y + 3 end end - end - vm:set_data(data) - vm:write_to_map() - vm:update_map() - for id, number in pairs(drops) do - for i = 1, number do - local drops = minetest.get_node_drops(names[id], tool) - minetest.handle_node_drops(pos, drops, clicker) + local air = minetest.get_content_id('air') + local vm = minetest.get_voxel_manip() + local emin, emax = vm:read_from_map(minp, maxp) + local area = VoxelArea:new({MinEdge = emin, MaxEdge = emax}) + local data = vm:get_data() + local drops = {} + local names = {} + local diggable = {} + local tree_like = {} + local leaf_like = {} + local stone_like = {} + local count = 0 + local p = {} + for y = minp.y, maxp.y do + p.y = y + for z = minp.z, maxp.z do + p.z = z + local ivm = area:index(minp.x, y, z) + for x = minp.x, maxp.x do + p.x = x + if not names[data[ivm]] then + names[data[ivm]] = minetest.get_name_from_content_id(data[ivm]) + end + + if not diggable[data[ivm]] then + if tool_type == 'axe' then + diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'choppy') or 0 + diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'snappy') or 0 + diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'fleshy') or 0 + elseif tool_type == 'pick' then + diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'cracky') or 0 + end + end + + if not stone_like[data[ivm]] then + stone_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'stone') or 0 + stone_like[data[ivm]] = stone_like[data[ivm]] + (names[data[ivm]] == 'default:sandstone' and 1 or 0) + end + + if not tree_like[data[ivm]] then + tree_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'tree') or 0 + end + + if not leaf_like[data[ivm]] then + leaf_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'leafdecay') or 0 + end + + local dig_it + if tool_type == 'axe' then + dig_it = tree_like[data[ivm]] > 0 or leaf_like[data[ivm]] > 0 + elseif tool_type == 'pick' then + dig_it = stone_like[data[ivm]] > 0 or mass_minerals[names[data[ivm]]] + end + + if count < max_nodes and diggable[data[ivm]] > 0 and dig_it and not minetest.is_protected(p, player_name) then + drops[data[ivm]] = (drops[data[ivm]] or 0) + 1 + data[ivm] = air + count = count + 1 + end + ivm = ivm + 1 + end + end + end + vm:set_data(data) + vm:write_to_map() + vm:update_map() + + for id, number in pairs(drops) do + for i = 1, number do + local drops = minetest.get_node_drops(names[id], tool) + minetest.handle_node_drops(pos, drops, clicker) + end + + local tp = itemstack:get_tool_capabilities() + local def = ItemStack({name=names[id]}):get_definition() + local dp = minetest.get_dig_params(def.groups, tp) + --print(names[id], dp.wear, number) + itemstack:add_wear(dp.wear * number) end - local tp = itemstack:get_tool_capabilities() - local def = ItemStack({name=names[id]}):get_definition() - local dp = minetest.get_dig_params(def.groups, tp) - --print(names[id], dp.wear, number) - itemstack:add_wear(dp.wear * number) - end - - return itemstack - end, }) + return itemstack + end, }) + end end diff --git a/treegen.lua b/treegen.lua index 2e4cea5..d6dd890 100644 --- a/treegen.lua +++ b/treegen.lua @@ -146,7 +146,7 @@ bucket.register_liquid( "fun_caves:bucket_sap", "fun_caves_bucket_sap.png", "Bucket of Sap", - {} + {sap_bucket = 1} ) minetest.register_node("fun_caves:amber", { @@ -188,7 +188,7 @@ minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv local index for i = 1, player:get_inventory():get_size("craft") do if (old_craft_grid[i]:get_name()):find('^fun_caves:bucket') then - bucket = old_craft_grid[i] + bucket = old_craft_grid[i]:get_name() index = i end end @@ -196,7 +196,8 @@ minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv return end - craft_inv:set_stack("craft", index, 'bucket:bucket_empty') + bucket = bucket:gsub('sap', 'empty') + craft_inv:set_stack("craft", index, bucket) end) newnode = fun_caves.clone_node("default:tree") @@ -264,9 +265,12 @@ minetest.register_craft({ type = "shapeless", recipe = { 'vessels:glass_bottle', - 'fun_caves:bucket_sap', + 'group:sap_bucket', + }, + replacements = { + {'fun_caves:bucket_sap', 'bucket:bucket_empty'}, + {'fun_caves:bucket_wood_sap', 'bucket:bucket_wood_empty'}, }, - replacements = {{'fun_caves:bucket_sap', 'bucket:bucket_empty'},}, }) minetest.register_craft({ diff --git a/wooden_buckets.lua b/wooden_buckets.lua new file mode 100644 index 0000000..218c703 --- /dev/null +++ b/wooden_buckets.lua @@ -0,0 +1,127 @@ +local function register_liquid_wood(source, itemname, inventory_image, name, groups) + if itemname ~= nil then + minetest.register_craftitem(itemname, { + description = name, + inventory_image = inventory_image, + stack_max = 1, + liquids_pointable = true, + groups = groups, + + on_place = function(itemstack, user, pointed_thing) + -- Must be pointing to node + if pointed_thing.type ~= "node" then + return + end + + local node = minetest.get_node_or_nil(pointed_thing.under) + local ndef = node and minetest.registered_nodes[node.name] + + -- Call on_rightclick if the pointed node defines it + if ndef and ndef.on_rightclick and + user and not user:get_player_control().sneak then + return ndef.on_rightclick( + pointed_thing.under, + node, user, + itemstack) + end + + local lpos + + -- Check if pointing to a buildable node + if ndef and ndef.buildable_to then + -- buildable; replace the node + lpos = pointed_thing.under + else + -- not buildable to; place the liquid above + -- check if the node above can be replaced + lpos = pointed_thing.above + local node = minetest.get_node_or_nil(lpos) + local above_ndef = node and minetest.registered_nodes[node.name] + + if not above_ndef or not above_ndef.buildable_to then + -- do not remove the bucket with the liquid + return itemstack + end + end + + if minetest.is_protected(lpos, user and user:get_player_name() or "") then + return + end + + minetest.set_node(lpos, {name = source}) + return ItemStack("fun_caves:bucket_wood_empty") + end + }) + end +end + +for fluid, def in pairs(bucket.liquids) do + if not fluid:find('flowing') and not fluid:find('lava') and not fluid:find('molten') and not fluid:find('weightless') then + local item_name = def.itemname:gsub('[^:]+:bucket', 'fun_caves:bucket_wood') + local original = minetest.registered_items[def.itemname] + if original and item_name and item_name ~= def.itemname then + local new_name = original.description:gsub('Bucket', 'Wooden Bucket') + local new_image = original.inventory_image + register_liquid_wood(fluid, item_name, new_image, new_name, original.groups) + end + end +end + + +minetest.register_craft({ + output = 'fun_caves:bucket_wood_empty 1', + recipe = { + {'group:wood', '', 'group:wood'}, + {'', 'group:wood', ''}, + } +}) + +minetest.register_craftitem("fun_caves:bucket_wood_empty", { + description = "Empty Wooden Bucket", + inventory_image = "bucket.png", + stack_max = 99, + liquids_pointable = true, + on_use = function(itemstack, user, pointed_thing) + -- Must be pointing to node + if pointed_thing.type ~= "node" then + return + end + -- Check if pointing to a liquid source + local node = minetest.get_node(pointed_thing.under) + local liquiddef = bucket.liquids[node.name] + if node.name ~= liquiddef.source then + return + end + + if minetest.is_protected(pointed_thing.under, user:get_player_name()) then + return + end + + local item_count = user:get_wielded_item():get_count() + + -- default set to return filled bucket + local giving_back = liquiddef.itemname:gsub('^[^:]+:bucket', 'fun_caves:bucket_wood') + + -- check if holding more than 1 empty bucket + if item_count > 1 then + + -- if space in inventory add filled bucket, otherwise drop as item + local inv = user:get_inventory() + if inv:room_for_item("main", {name=giving_back}) then + inv:add_item("main", giving_back) + else + local pos = user:getpos() + pos.y = math.floor(pos.y + 0.5) + minetest.add_item(pos, giving_back) + end + + -- set to return empty buckets minus 1 + giving_back = "fun_caves:bucket_wood_empty "..tostring(item_count-1) + + end + + minetest.add_node(pointed_thing.under, {name="air"}) + + return ItemStack(giving_back) + end, +})