Clean up and improve chainsaw

ShadowNinja

2014-06-26 9019ebe496c868589e7eeed4450e0903953a0906

Clean up and improve chainsaw

 technic/tools/chainsaw.lua

@@ -1,24 +1,29 @@
-- 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

-- The default stuff
local timber_nodenames={["default:jungletree"] = true,
                        ["default:papyrus"]    = true,
                        ["default:cactus"]     = true,
                        ["default:tree"]       = true,
                        ["default:apple"]      = true
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

-- The default trees
local timber_nodenames = {
    ["default:jungletree"] = true,
    ["default:papyrus"]    = true,
    ["default:cactus"]     = true,
    ["default:tree"]       = true,
    ["default:apple"]      = true,
}

if chainsaw_leaves == true then
if chainsaw_leaves then
    timber_nodenames["default:leaves"] = true
    timber_nodenames["default:jungleleaves"] = true
end

-- technic_worldgen defines rubber trees if moretrees isn't installed
if minetest.get_modpath("technic_worldgen") or
   minetest.get_modpath("moretrees") then
        minetest.get_modpath("moretrees") then
    timber_nodenames["moretrees:rubber_tree_trunk_empty"] = true
    timber_nodenames["moretrees:rubber_tree_trunk"]       = true
    if chainsaw_leaves then
@@ -27,7 +32,7 @@
end

-- Support moretrees if it is there
if( minetest.get_modpath("moretrees") ~= nil ) then
if minetest.get_modpath("moretrees") then
    timber_nodenames["moretrees:apple_tree_trunk"]                 = true
    timber_nodenames["moretrees:apple_tree_trunk_sideways"]        = true
    timber_nodenames["moretrees:beech_trunk"]                      = true
@@ -72,8 +77,8 @@
    end
end

-- Support growing_trees if it is there
if( minetest.get_modpath("growing_trees") ~= nil ) then
-- Support growing_trees
if minetest.get_modpath("growing_trees") then
    timber_nodenames["growing_trees:trunk"]         = true
    timber_nodenames["growing_trees:medium_trunk"]  = true
    timber_nodenames["growing_trees:big_trunk"]     = true
@@ -88,13 +93,13 @@
    timber_nodenames["growing_trees:branch_zz"]     = true
    timber_nodenames["growing_trees:branch_xx"]     = true

    if chainsaw_leaves == true then
    if chainsaw_leaves then
        timber_nodenames["growing_trees:leaves"] = true
    end
end

-- Support growing_cactus if it is there
if( minetest.get_modpath("growing_cactus") ~= nil ) then
-- Support growing_cactus
if minetest.get_modpath("growing_cactus") then
    timber_nodenames["growing_cactus:sprout"]                       = true
    timber_nodenames["growing_cactus:branch_sprout_vertical"]       = true
    timber_nodenames["growing_cactus:branch_sprout_vertical_fixed"] = true
@@ -113,9 +118,9 @@
    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
-- Support farming_plus
if minetest.get_modpath("farming_plus") then
    if chainsaw_leaves then
        timber_nodenames["farming_plus:cocoa_leaves"] = true
    end
end
@@ -126,80 +131,82 @@
technic.register_power_tool("technic:chainsaw", chainsaw_max_charge)

-- Table for saving what was sawed down
local produced = nil
local produced = {}

-- 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
local function chainsaw_handle_node_drops(pos, drops, digger)
    -- Add dropped items to list of collected nodes
    for _, dropped_item in ipairs(drops) do
        if produced[dropped_item] == nil then
            produced[dropped_item] = 1
-- 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
            produced[dropped_item] = produced[dropped_item] + 1
            p:set_count(p:get_count() + stack:get_count())
        end
    end
end

--- Iterator over positions to try to saw around a sawed node.
-- This returns nodes in a 3x2x3 area. It does not return lower (y) positions
-- to prevent the chainsaw from cutting down nodes below the cutting position.
-- @param pos Reference to sawing position.  Note that this is overridden.
local function iterSawTries(pos)
    -- Shift the position down on the x and z axes
    pos.x, pos.z = pos.x - 1, pos.z - 1
    -- Save our starting position for reseting it later
    local startx, startz = pos.x, pos.z
    -- We will move out by one in every direction except -y
    local endx, endy, endz = pos.x + 2, pos.y + 1, pos.z + 2
    -- Adjust for initial increment
    pos.x = pos.x - 1

    return function()
        if pos.x < endx then
            pos.x = pos.x + 1
        else
            pos.x = startx
            if pos.z < endz then
                pos.z = pos.z + 1
            else
                pos.z = startz
                if pos.y < endy then
                    pos.y = pos.y + 1
                else
                    return nil
                end
            end
        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.
local function recursive_dig(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)

        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

        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

        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
local function recursive_dig(pos, remaining_charge)
    if remaining_charge < chainsaw_charge_per_node then
        return remaining_charge
    end
    -- Nothing sawed down
    local node = minetest.get_node(pos)

    if not timber_nodenames[node.name] then
        return 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

    -- Check surroundings and run recursively if any charge left
    for pos in iterSawTries(pos) do
        if remaining_charge < chainsaw_charge_per_node then
            break
        end
        if timber_nodenames[minetest.get_node(pos).name] then
            remaining_charge = recursive_dig(pos, remaining_charge)
        end
    end
    return remaining_charge
end

@@ -224,6 +231,10 @@
                -- 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
@@ -233,43 +244,30 @@
    return pos
end

-- Saw down trees entry point
local function chainsaw_dig_it(pos, player,current_charge)
    if minetest.is_protected(pos, player:get_player_name()) then
        minetest.record_protection_violation(pos, player:get_player_name())
        return current_charge
    end
        local remaining_charge=current_charge
-- 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})

        -- 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 = get_drop_pos(pos)
                while number > 99 do
                        minetest.env:add_item(p, produced_item .. " 99")
                        p = get_drop_pos(pos)
                        number = number - 99
                end
                minetest.env:add_item(p, produced_item .. " " .. number)
    -- 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
        return remaining_charge
        stack:set_count(count)
        minetest.add_item(get_drop_pos(pos), stack)
    end

    -- Clean up
    produced = {}

    return remaining_charge
end


@@ -283,17 +281,23 @@
        if pointed_thing.type ~= "node" then
            return itemstack
        end

        local meta = minetest.deserialize(itemstack:get_metadata())
        if not meta or not meta.charge then
            return
        end
        -- Send current charge to digging function so that the chainsaw will stop after digging a number of nodes.
        if meta.charge < chainsaw_charge_per_node then
        if not meta or not meta.charge or
                meta.charge < chainsaw_charge_per_node then
            return
        end

        local pos = minetest.get_pointed_thing_position(pointed_thing, above)
        meta.charge = chainsaw_dig_it(pos, user, meta.charge)
        local name = user:get_player_name()
        if minetest.is_protected(pos, name) then
            minetest.record_protection_violation(pos, name)
            return current_charge
        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)

        technic.set_RE_wear(itemstack, meta.charge, chainsaw_max_charge)
        itemstack:set_metadata(minetest.serialize(meta))
        return itemstack
@@ -301,10 +305,11 @@
})

minetest.register_craft({
    output = 'technic:chainsaw',
    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'},
        {"technic:stainless_steel_ingot", "technic:stainless_steel_ingot", "technic:battery"},
        {"technic:stainless_steel_ingot", "technic:motor",                 "technic:battery"},
        {"",                              "",                              "default:copper_ingot"},
    }
})