From 718a5beda197cd0a775fd41aedfb5b1bbd5d1d8b Mon Sep 17 00:00:00 2001 From: ZettaScript <contact@zettascript.org> Date: Thu, 20 Oct 2022 17:56:10 +0200 Subject: [PATCH] Supply converter: demany only the needed power (#577) --- technic/tools/chainsaw.lua | 659 ++++++++++++++++++++++++++++++++++++++--------------------- 1 files changed, 418 insertions(+), 241 deletions(-) diff --git a/technic/tools/chainsaw.lua b/technic/tools/chainsaw.lua index 891f4e4..99beb52 100644 --- a/technic/tools/chainsaw.lua +++ b/technic/tools/chainsaw.lua @@ -1,269 +1,446 @@ -- Configuration -local chainsaw_max_charge = 30000 -- 30000 - Maximum charge of the saw -local chainsaw_charge_per_node = 12 -- 12 - Gives 2500 nodes on a single charge (about 50 complete normal trees) -local chainsaw_leaves = true -- true - Cut down entire trees, leaves and all -technic.register_power_tool ("technic:chainsaw",chainsaw_max_charge) +local chainsaw_max_charge = 30000 -- Maximum charge of the saw +-- Gives 2500 nodes on a single charge (about 50 complete normal trees) +local chainsaw_charge_per_node = 12 +-- Cut down tree leaves. Leaf decay may cause slowness on large trees +-- if this is disabled. +local chainsaw_leaves = true -minetest.register_tool("technic:chainsaw", { - description = "Chainsaw", - inventory_image = "technic_chainsaw.png", - stack_max = 1, - on_use = function(itemstack, user, pointed_thing) - if pointed_thing.type=="node" then - item=itemstack:to_table() - local meta=get_item_meta(item["metadata"]) - if meta==nil then return end --tool not charged - if meta["charge"]==nil then return end - -- Send current charge to digging function so that the chainsaw will stop after digging a number of nodes. - local charge=meta["charge"] - if charge < chainsaw_charge_per_node then return end -- only cut if charged +-- First value is node name; second is whether the node is considered even if chainsaw_leaves is false. +local nodes = { + -- The default trees + {"default:acacia_tree", true}, + {"default:aspen_tree", true}, + {"default:jungletree", true}, + {"default:papyrus", true}, + {"default:cactus", true}, + {"default:tree", true}, + {"default:apple", true}, + {"default:pine_tree", true}, + {"default:acacia_leaves", false}, + {"default:aspen_leaves", false}, + {"default:leaves", false}, + {"default:jungleleaves", false}, + {"default:pine_needles", false}, - charge=chainsaw_dig_it(minetest.get_pointed_thing_position(pointed_thing, above),user,charge) - technic.set_RE_wear(item,charge,chainsaw_max_charge) - meta["charge"]=charge - item["metadata"]=set_item_meta(meta) - itemstack:replace(item) - return itemstack - end - end, -}) + -- The default bushes + {"default:acacia_bush_stem", true}, + {"default:bush_stem", true}, + {"default:pine_bush_stem", true}, + {"default:acacia_bush_leaves", false}, + {"default:blueberry_bush_leaves", false}, + {"default:blueberry_bush_leaves_with_berries", false}, + {"default:bush_leaves", false}, + {"default:pine_bush_needles", false}, -minetest.register_craft({ - output = 'technic:chainsaw', - recipe = { - {'technic:stainless_steel_ingot', 'technic:stainless_steel_ingot', 'technic:battery'}, - {'technic:stainless_steel_ingot', 'technic:motor', 'technic:battery'}, - {'', '', 'default:copper_ingot'}, - } -}) + -- Rubber trees from moretrees or technic_worldgen if moretrees isn't installed + {"moretrees:rubber_tree_trunk_empty", true}, + {"moretrees:rubber_tree_trunk", true}, + {"moretrees:rubber_tree_leaves", false}, --- The default stuff -local timber_nodenames={["default:jungletree"] = true, - ["default:papyrus"] = true, - ["default:cactus"] = true, - ["default:tree"] = true, - ["default:apple"] = true + -- Support moretrees (trunk) + {"moretrees:acacia_trunk", true}, + {"moretrees:apple_tree_trunk", true}, + {"moretrees:beech_trunk", true}, + {"moretrees:birch_trunk", true}, + {"moretrees:cedar_trunk", true}, + {"moretrees:date_palm_ffruit_trunk", true}, + {"moretrees:date_palm_fruit_trunk", true}, + {"moretrees:date_palm_mfruit_trunk", true}, + {"moretrees:date_palm_trunk", true}, + {"moretrees:fir_trunk", true}, + {"moretrees:jungletree_trunk", true}, + {"moretrees:oak_trunk", true}, + {"moretrees:palm_trunk", true}, + {"moretrees:palm_fruit_trunk", true}, + {"moretrees:palm_fruit_trunk_gen", true}, + {"moretrees:pine_trunk", true}, + {"moretrees:poplar_trunk", true}, + {"moretrees:sequoia_trunk", true}, + {"moretrees:spruce_trunk", true}, + {"moretrees:willow_trunk", true}, + -- Support moretrees (leaves) + {"moretrees:acacia_leaves", false}, + {"moretrees:apple_tree_leaves", false}, + {"moretrees:beech_leaves", false}, + {"moretrees:birch_leaves", false}, + {"moretrees:cedar_leaves", false}, + {"moretrees:date_palm_leaves", false}, + {"moretrees:fir_leaves", false}, + {"moretrees:fir_leaves_bright", false}, + {"moretrees:jungletree_leaves_green", false}, + {"moretrees:jungletree_leaves_yellow", false}, + {"moretrees:jungletree_leaves_red", false}, + {"moretrees:oak_leaves", false}, + {"moretrees:palm_leaves", false}, + {"moretrees:poplar_leaves", false}, + {"moretrees:pine_leaves", false}, + {"moretrees:sequoia_leaves", false}, + {"moretrees:spruce_leaves", false}, + {"moretrees:willow_leaves", false}, + -- Support moretrees (fruit) + {"moretrees:acorn", false}, + {"moretrees:apple_blossoms", false}, + {"moretrees:cedar_cone", false}, + {"moretrees:coconut", false}, + {"moretrees:coconut_0", false}, + {"moretrees:coconut_1", false}, + {"moretrees:coconut_2", false}, + {"moretrees:coconut_3", false}, + {"moretrees:dates_f0", false}, + {"moretrees:dates_f1", false}, + {"moretrees:dates_f2", false}, + {"moretrees:dates_f3", false}, + {"moretrees:dates_f4", false}, + {"moretrees:dates_fn", false}, + {"moretrees:dates_m0", false}, + {"moretrees:dates_n", false}, + {"moretrees:fir_cone", false}, + {"moretrees:pine_cone", false}, + {"moretrees:spruce_cone", false}, + + -- Support growing_trees + {"growing_trees:trunk", true}, + {"growing_trees:medium_trunk", true}, + {"growing_trees:big_trunk", true}, + {"growing_trees:trunk_top", true}, + {"growing_trees:trunk_sprout", true}, + {"growing_trees:branch_sprout", true}, + {"growing_trees:branch", true}, + {"growing_trees:branch_xmzm", true}, + {"growing_trees:branch_xpzm", true}, + {"growing_trees:branch_xmzp", true}, + {"growing_trees:branch_xpzp", true}, + {"growing_trees:branch_zz", true}, + {"growing_trees:branch_xx", true}, + {"growing_trees:leaves", false}, + + -- Support cool_trees + {"bamboo:trunk", true}, + {"bamboo:leaves", false}, + {"birch:trunk", true}, + {"birch:leaves", false}, + {"cherrytree:trunk", true}, + {"cherrytree:blossom_leaves", false}, + {"cherrytree:leaves", false}, + {"chestnuttree:trunk", true}, + {"chestnuttree:leaves", false}, + {"clementinetree:trunk", true}, + {"clementinetree:leaves", false}, + {"ebony:trunk", true}, + {"ebony:creeper", false}, + {"ebony:creeper_leaves", false}, + {"ebony:leaves", false}, + {"jacaranda:trunk", true}, + {"jacaranda:blossom_leaves", false}, + {"larch:trunk", true}, + {"larch:leaves", false}, + {"lemontree:trunk", true}, + {"lemontree:leaves", false}, + {"mahogany:trunk", true}, + {"mahogany:leaves", false}, + {"palm:trunk", true}, + {"palm:leaves", false}, + + -- Support growing_cactus + {"growing_cactus:sprout", true}, + {"growing_cactus:branch_sprout_vertical", true}, + {"growing_cactus:branch_sprout_vertical_fixed", true}, + {"growing_cactus:branch_sprout_xp", true}, + {"growing_cactus:branch_sprout_xm", true}, + {"growing_cactus:branch_sprout_zp", true}, + {"growing_cactus:branch_sprout_zm", true}, + {"growing_cactus:trunk", true}, + {"growing_cactus:branch_trunk", true}, + {"growing_cactus:branch", true}, + {"growing_cactus:branch_xp", true}, + {"growing_cactus:branch_xm", true}, + {"growing_cactus:branch_zp", true}, + {"growing_cactus:branch_zm", true}, + {"growing_cactus:branch_zz", true}, + {"growing_cactus:branch_xx", true}, + + -- Support farming_plus + {"farming_plus:banana_leaves", false}, + {"farming_plus:banana", false}, + {"farming_plus:cocoa_leaves", false}, + {"farming_plus:cocoa", false}, + + -- Support nature + {"nature:blossom", false}, + + -- Support snow + {"snow:needles", false}, + {"snow:needles_decorated", false}, + {"snow:star", false}, + + -- Support vines (also generated by moretrees if available) + {"vines:vines", false}, + + {"trunks:moss", false}, + {"trunks:moss_fungus", false}, + {"trunks:treeroot", false}, + + -- Support ethereal + {"ethereal:bamboo", true}, + {"ethereal:bamboo_leaves", false}, + {"ethereal:banana_trunk", true}, + {"ethereal:bananaleaves", false}, + {"ethereal:banana", false}, + {"ethereal:birch_trunk", true}, + {"ethereal:birch_leaves", false}, + {"ethereal:frost_tree", true}, + {"ethereal:frost_leaves", false}, + {"ethereal:mushroom_trunk", true}, + {"ethereal:mushroom", false}, + {"ethereal:mushroom_pore", true}, + {"ethereal:orangeleaves", false}, + {"ethereal:orange", false}, + {"ethereal:palm_trunk", true}, + {"ethereal:palmleaves", false}, + {"ethereal:coconut", false}, + {"ethereal:redwood_trunk", true}, + {"ethereal:redwood_leaves", false}, + {"ethereal:sakura_trunk", true}, + {"ethereal:sakura_leaves", false}, + {"ethereal:sakura_leaves2", false}, + {"ethereal:scorched_tree", true}, + {"ethereal:willow_trunk", true}, + {"ethereal:willow_twig", false}, + {"ethereal:yellow_trunk", true}, + {"ethereal:yellowleaves", false}, + {"ethereal:golden_apple", false}, } -if chainsaw_leaves == true then - timber_nodenames["default:leaves"] = true +local timber_nodenames = {} +for _, node in pairs(nodes) do + if chainsaw_leaves or node[2] then + timber_nodenames[node[1]] = true + end end --- Support moretrees if it is there -if( minetest.get_modpath("moretrees") ~= nil ) then - timber_nodenames["moretrees:apple_tree_trunk"] = true - timber_nodenames["moretrees:apple_tree_trunk_sideways"] = true - timber_nodenames["moretrees:beech_trunk"] = true - timber_nodenames["moretrees:beech_trunk_sideways"] = true - timber_nodenames["moretrees:birch_trunk"] = true - timber_nodenames["moretrees:birch_trunk_sideways"] = true - timber_nodenames["moretrees:fir_trunk"] = true - timber_nodenames["moretrees:fir_trunk_sideways"] = true - timber_nodenames["moretrees:oak_trunk"] = true - timber_nodenames["moretrees:oak_trunk_sideways"] = true - timber_nodenames["moretrees:palm_trunk"] = true - timber_nodenames["moretrees:palm_trunk_sideways"] = true - timber_nodenames["moretrees:pine_trunk"] = true - timber_nodenames["moretrees:pine_trunk_sideways"] = true - timber_nodenames["moretrees:rubber_tree_trunk"] = true - timber_nodenames["moretrees:rubber_tree_trunk_sideways"] = true - timber_nodenames["moretrees:rubber_tree_trunk_empty"] = true - timber_nodenames["moretrees:rubber_tree_trunk_sideways_empty"] = true - timber_nodenames["moretrees:sequoia_trunk"] = true - timber_nodenames["moretrees:sequoia_trunk_sideways"] = true - timber_nodenames["moretrees:spruce_trunk"] = true - timber_nodenames["moretrees:spruce_trunk_sideways"] = true - timber_nodenames["moretrees:willow_trunk"] = true - timber_nodenames["moretrees:willow_trunk_sideways"] = true - timber_nodenames["moretrees:jungletree_trunk"] = true - timber_nodenames["moretrees:jungletree_trunk_sideways"] = true +local S = technic.getter - if chainsaw_leaves == true then - timber_nodenames["moretrees:apple_tree_leaves"] = true - timber_nodenames["moretrees:oak_leaves"] = true - timber_nodenames["moretrees:sequoia_leaves"] = true - timber_nodenames["moretrees:birch_leaves"] = true - timber_nodenames["moretrees:birch_leaves"] = true - timber_nodenames["moretrees:palm_leaves"] = true - timber_nodenames["moretrees:spruce_leaves"] = true - timber_nodenames["moretrees:spruce_leaves"] = true - timber_nodenames["moretrees:pine_leaves"] = true - timber_nodenames["moretrees:willow_leaves"] = true - timber_nodenames["moretrees:rubber_tree_leaves"] = true - timber_nodenames["moretrees:jungletree_leaves_green"] = true - timber_nodenames["moretrees:jungletree_leaves_yellow"] = true - timber_nodenames["moretrees:jungletree_leaves_red"] = true - end -end +technic.register_power_tool("technic:chainsaw", chainsaw_max_charge) --- Support growing_trees if it is there -if( minetest.get_modpath("growing_trees") ~= nil ) then - timber_nodenames["growing_trees:trunk"] = true - timber_nodenames["growing_trees:medium_trunk"] = true - timber_nodenames["growing_trees:big_trunk"] = true - timber_nodenames["growing_trees:trunk_top"] = true - timber_nodenames["growing_trees:trunk_sprout"] = true - timber_nodenames["growing_trees:branch_sprout"] = true - timber_nodenames["growing_trees:branch"] = true - timber_nodenames["growing_trees:branch_xmzm"] = true - timber_nodenames["growing_trees:branch_xpzm"] = true - timber_nodenames["growing_trees:branch_xmzp"] = true - timber_nodenames["growing_trees:branch_xpzp"] = true - timber_nodenames["growing_trees:branch_zz"] = true - timber_nodenames["growing_trees:branch_xx"] = true +-- This function checks if the specified node should be sawed +local function check_if_node_sawed(pos) + local node_name = minetest.get_node(pos).name + if timber_nodenames[node_name] + or (chainsaw_leaves and minetest.get_item_group(node_name, "leaves") ~= 0) + or minetest.get_item_group(node_name, "tree") ~= 0 then + return true + end - if chainsaw_leaves == true then - timber_nodenames["growing_trees:leaves"] = true - end -end - --- Support growing_cactus if it is there -if( minetest.get_modpath("growing_cactus") ~= nil ) then - timber_nodenames["growing_cactus:sprout"] = true - timber_nodenames["growing_cactus:branch_sprout_vertical"] = true - timber_nodenames["growing_cactus:branch_sprout_vertical_fixed"] = true - timber_nodenames["growing_cactus:branch_sprout_xp"] = true - timber_nodenames["growing_cactus:branch_sprout_xm"] = true - timber_nodenames["growing_cactus:branch_sprout_zp"] = true - timber_nodenames["growing_cactus:branch_sprout_zm"] = true - timber_nodenames["growing_cactus:trunk"] = true - timber_nodenames["growing_cactus:branch_trunk"] = true - timber_nodenames["growing_cactus:branch"] = true - timber_nodenames["growing_cactus:branch_xp"] = true - timber_nodenames["growing_cactus:branch_xm"] = true - timber_nodenames["growing_cactus:branch_zp"] = true - timber_nodenames["growing_cactus:branch_zm"] = true - timber_nodenames["growing_cactus:branch_zz"] = true - timber_nodenames["growing_cactus:branch_xx"] = true -end - --- Support farming_plus if it is there -if( minetest.get_modpath("farming_plus") ~= nil ) then - if chainsaw_leaves == true then - timber_nodenames["farming_plus:cocoa_leaves"] = true - end + return false end -- Table for saving what was sawed down -local produced +local produced = {} --- Saw down trees entry point -chainsaw_dig_it = function(pos, player,current_charge) - local remaining_charge=current_charge - - -- Save the currently installed dropping mechanism so we can restore it. - local original_handle_node_drops = minetest.handle_node_drops - - -- A bit of trickery here: use a different node drop callback - -- and restore the original afterwards. - minetest.handle_node_drops = chainsaw_handle_node_drops - - -- clear result and start sawing things down - produced = {} - remaining_charge = recursive_dig(pos, remaining_charge, player) - minetest.sound_play("chainsaw", {pos = pos, gain = 1.0, max_hear_distance = 10,}) - - -- Restore the original noder drop handler - minetest.handle_node_drops = original_handle_node_drops - - -- Now drop items for the player - local number, produced_item, p - for produced_item,number in pairs(produced) do - --print("ADDING ITEM: " .. produced_item .. " " .. number) - -- Drop stacks of 99 or less - p = { - x = pos.x + math.random()*4, - y = pos.y, - z = pos.z + math.random()*4 - } - while number > 99 do - minetest.env:add_item(p, produced_item .. " 99") - p = { - x = pos.x + math.random()*4, - y = pos.y, - z = pos.z + math.random()*4 - } - number = number - 99 - end - minetest.env:add_item(p, produced_item .. " " .. number) - end - return remaining_charge +-- Save the items sawed down so that we can drop them in a nice single stack +local function handle_drops(drops) + for _, item in ipairs(drops) do + local stack = ItemStack(item) + local name = stack:get_name() + local p = produced[name] + if not p then + produced[name] = stack + else + p:set_count(p:get_count() + stack:get_count()) + end + end end --- Override the default handling routine to be able to count up the --- items sawed down so that we can drop them i an nice single stack -chainsaw_handle_node_drops = function(pos, drops, digger) - -- Add dropped items to list of collected nodes - local _, dropped_item - for _, dropped_item in ipairs(drops) do - if produced[dropped_item] == nil then - produced[dropped_item] = 1 - else - produced[dropped_item] = produced[dropped_item] + 1 - end - end +--- Iterator over positions to try to saw around a sawed node. +-- This returns positions in a 3x1x3 area around the position, plus the +-- position above it. This does not return the bottom position to prevent +-- the chainsaw from cutting down nodes below the cutting position. +-- @param pos Sawing position. +local function iterSawTries(pos) + -- Copy position to prevent mangling it + local pos = vector.new(pos) + local i = 0 + + return function() + i = i + 1 + -- Given a (top view) area like so (where 5 is the starting position): + -- X --> + -- Z 123 + -- | 456 + -- V 789 + -- This will return positions 1, 4, 7, 2, 8 (skip 5), 3, 6, 9, + -- and the position above 5. + if i == 1 then + -- Move to starting position + pos.x = pos.x - 1 + pos.z = pos.z - 1 + elseif i == 4 or i == 7 then + -- Move to next X and back to start of Z when we reach + -- the end of a Z line. + pos.x = pos.x + 1 + pos.z = pos.z - 2 + elseif i == 5 then + -- Skip the middle position (we've already run on it) + -- and double-increment the counter. + pos.z = pos.z + 2 + i = i + 1 + elseif i <= 9 then + -- Go to next Z. + pos.z = pos.z + 1 + elseif i == 10 then + -- Move back to center and up. + -- The Y+ position must be last so that we don't dig + -- straight upward and not come down (since the Y- + -- position isn't checked). + pos.x = pos.x - 1 + pos.z = pos.z - 1 + pos.y = pos.y + 1 + else + return nil + end + return pos + end end -- This function does all the hard work. Recursively we dig the node at hand -- if it is in the table and then search the surroundings for more stuff to dig. -recursive_dig = function(pos, remaining_charge, player) - local node=minetest.env:get_node(pos) - local i=1 - -- Lookup node name in timber table: - if timber_nodenames[node.name] ~= nil then - -- Return if we are out of power - if remaining_charge < chainsaw_charge_per_node then - return 0 - end - local np - -- wood found - cut it. - minetest.env:dig_node(pos) +local function recursive_dig(pos, remaining_charge) + if remaining_charge < chainsaw_charge_per_node then + return remaining_charge + end + local node = minetest.get_node(pos) - remaining_charge=remaining_charge-chainsaw_charge_per_node - -- check surroundings and run recursively if any charge left - np={x=pos.x+1, y=pos.y, z=pos.z} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - np={x=pos.x+1, y=pos.y, z=pos.z+1} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - np={x=pos.x+1, y=pos.y, z=pos.z-1} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end + if not check_if_node_sawed(pos) then + return remaining_charge + end - np={x=pos.x-1, y=pos.y, z=pos.z} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - np={x=pos.x-1, y=pos.y, z=pos.z+1} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - np={x=pos.x-1, y=pos.y, z=pos.z-1} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end + -- Wood found - cut it + handle_drops(minetest.get_node_drops(node.name, "")) + minetest.remove_node(pos) + remaining_charge = remaining_charge - chainsaw_charge_per_node - np={x=pos.x, y=pos.y+1, z=pos.z} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - - np={x=pos.x, y=pos.y, z=pos.z+1} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - np={x=pos.x, y=pos.y, z=pos.z-1} - if timber_nodenames[minetest.env:get_node(np).name] ~= nil then - remaining_charge = recursive_dig(np, remaining_charge) - end - return remaining_charge - end - -- Nothing sawed down - return remaining_charge + -- Check surroundings and run recursively if any charge left + for npos in iterSawTries(pos) do + if remaining_charge < chainsaw_charge_per_node then + break + end + if check_if_node_sawed(npos) then + remaining_charge = recursive_dig(npos, remaining_charge) + else + minetest.check_for_falling(npos) + end + end + return remaining_charge end +-- Function to randomize positions for new node drops +local function get_drop_pos(pos) + local drop_pos = {} + + for i = 0, 8 do + -- Randomize position for a new drop + drop_pos.x = pos.x + math.random(-3, 3) + drop_pos.y = pos.y - 1 + drop_pos.z = pos.z + math.random(-3, 3) + + -- Move the randomized position upwards until + -- the node is air or unloaded. + for y = drop_pos.y, drop_pos.y + 5 do + drop_pos.y = y + local node = minetest.get_node_or_nil(drop_pos) + + if not node then + -- If the node is not loaded yet simply drop + -- the item at the original digging position. + return pos + elseif node.name == "air" then + -- Add variation to the entity drop position, + -- but don't let drops get too close to the edge + drop_pos.x = drop_pos.x + (math.random() * 0.8) - 0.5 + drop_pos.z = drop_pos.z + (math.random() * 0.8) - 0.5 + return drop_pos + end + end + end + + -- Return the original position if this takes too long + return pos +end + +-- Chainsaw entry point +local function chainsaw_dig(pos, current_charge) + -- Start sawing things down + local remaining_charge = recursive_dig(pos, current_charge) + minetest.sound_play("chainsaw", {pos = pos, gain = 1.0, + max_hear_distance = 10}) + + -- Now drop items for the player + for name, stack in pairs(produced) do + -- Drop stacks of stack max or less + local count, max = stack:get_count(), stack:get_stack_max() + stack:set_count(max) + while count > max do + minetest.add_item(get_drop_pos(pos), stack) + count = count - max + end + stack:set_count(count) + minetest.add_item(get_drop_pos(pos), stack) + end + + -- Clean up + produced = {} + + return remaining_charge +end + + +minetest.register_tool("technic:chainsaw", { + description = S("Chainsaw"), + inventory_image = "technic_chainsaw.png", + stack_max = 1, + wear_represents = "technic_RE_charge", + on_refill = technic.refill_RE_charge, + on_use = function(itemstack, user, pointed_thing) + if pointed_thing.type ~= "node" then + return itemstack + end + + local meta = minetest.deserialize(itemstack:get_metadata()) + if not meta or not meta.charge or + meta.charge < chainsaw_charge_per_node then + return + end + + local name = user:get_player_name() + if minetest.is_protected(pointed_thing.under, name) then + minetest.record_protection_violation(pointed_thing.under, name) + return + end + + -- Send current charge to digging function so that the + -- chainsaw will stop after digging a number of nodes + meta.charge = chainsaw_dig(pointed_thing.under, meta.charge) + if not technic.creative_mode then + technic.set_RE_wear(itemstack, meta.charge, chainsaw_max_charge) + itemstack:set_metadata(minetest.serialize(meta)) + end + return itemstack + end, +}) + +local mesecons_button = minetest.get_modpath("mesecons_button") +local trigger = mesecons_button and "mesecons_button:button_off" or "default:mese_crystal_fragment" + +minetest.register_craft({ + output = "technic:chainsaw", + recipe = { + {"technic:stainless_steel_ingot", trigger, "technic:battery"}, + {"basic_materials:copper_wire", "basic_materials:motor", "technic:battery"}, + {"", "", "technic:stainless_steel_ingot"}, + }, + replacements = { {"basic_materials:copper_wire", "basic_materials:empty_spool"}, }, + +}) + -- Gitblit v1.8.0