-- Configuration
|
|
local chainsaw_max_charge = 30000 -- Maximum charge of the saw
|
-- Cut down tree leaves. Leaf decay may cause slowness on large trees
|
-- if this is disabled.
|
local chainsaw_leaves = true
|
|
local chainsaw_efficiency = 0.95 -- Drops less items
|
|
-- Maximal dimensions of the tree to cut
|
local tree_max_radius = 10
|
local tree_max_height = 70
|
|
local S = technic.getter
|
|
--[[
|
Format: [node_name] = dig_cost
|
|
This table is filled automatically afterwards to support mods such as:
|
|
cool_trees
|
ethereal
|
moretrees
|
]]
|
local tree_nodes = {
|
-- For the sake of maintenance, keep this sorted alphabetically!
|
["default:acacia_bush_stem"] = -1,
|
["default:bush_stem"] = -1,
|
["default:pine_bush_stem"] = -1,
|
|
["default:cactus"] = -1,
|
["default:papyrus"] = -1,
|
|
["ethereal:bamboo"] = -1,
|
}
|
|
-- Function to decide whether or not to cut a certain node (and at which energy cost)
|
local function populate_costs(name, def)
|
repeat
|
if tree_nodes[name] == -1 then
|
tree_nodes[name] = nil
|
break -- Manually added, but need updating
|
end
|
if (def.groups.tree or 0) > 0 then
|
break -- Tree node
|
end
|
if (def.groups.leaves or 0) > 0 and chainsaw_leaves then
|
break -- Leaves
|
end
|
if (def.groups.leafdecay_drop or 0) > 0 then
|
break -- Food
|
end
|
return -- Abort function: do not dig this node
|
|
-- luacheck: push ignore 511
|
until 1
|
-- luacheck: pop
|
|
-- Function did not return! --> add content ID to the digging table
|
local content_id = minetest.get_content_id(name)
|
|
-- Get 12 in average
|
local cost = 0
|
if def.groups.choppy then
|
cost = def.groups.choppy * 5 -- trunks (usually 3 * 5)
|
elseif def.groups.snappy then
|
cost = def.groups.snappy * 2 -- leaves
|
end
|
tree_nodes[content_id] = math.max(4, cost)
|
end
|
|
minetest.register_on_mods_loaded(function()
|
local ndefs = minetest.registered_nodes
|
-- Populate hardcoded nodes
|
for name in pairs(tree_nodes) do
|
local ndef = ndefs[name]
|
if ndef and ndef.groups then
|
populate_costs(name, ndef)
|
end
|
end
|
|
-- Find all trees and leaves
|
for name, def in pairs(ndefs) do
|
if def.groups then
|
populate_costs(name, def)
|
end
|
end
|
end)
|
|
|
technic.register_power_tool("technic:chainsaw", chainsaw_max_charge)
|
|
local pos9dir = {
|
{ 1, 0, 0},
|
{-1, 0, 0},
|
{ 0, 0, 1},
|
{ 0, 0, -1},
|
{ 1, 0, 1},
|
{-1, 0, -1},
|
{ 1, 0, -1},
|
{-1, 0, 1},
|
{ 0, 1, 0}, -- up
|
}
|
|
local cutter = {
|
-- See function cut_tree()
|
}
|
|
local c_air = minetest.get_content_id("air")
|
local function dig_recursive(x, y, z)
|
local i = cutter.area:index(x, y, z)
|
if cutter.seen[i] then
|
return
|
end
|
cutter.seen[i] = 1 -- Mark as visited
|
|
if cutter.param2[i] ~= 0 then
|
-- Do not dig manually placed nodes
|
return
|
end
|
|
local c_id = cutter.data[i]
|
local cost = tree_nodes[c_id]
|
if not cost or cost > cutter.charge then
|
return -- Cannot dig this node
|
end
|
|
-- Count dug nodes
|
cutter.drops[c_id] = (cutter.drops[c_id] or 0) + 1
|
cutter.seen[i] = 2 -- Mark as dug (for callbacks)
|
cutter.data[i] = c_air
|
cutter.charge = cutter.charge - cost
|
|
-- Expand maximal bounds for area protection check
|
if x < cutter.minp.x then cutter.minp.x = x end
|
if y < cutter.minp.y then cutter.minp.y = y end
|
if z < cutter.minp.z then cutter.minp.z = z end
|
if x > cutter.maxp.x then cutter.maxp.x = x end
|
if y > cutter.maxp.y then cutter.maxp.y = y end
|
if z > cutter.maxp.z then cutter.maxp.z = z end
|
|
-- Traverse neighbors
|
local xn, yn, zn
|
for _, offset in ipairs(pos9dir) do
|
xn, yn, zn = x + offset[1], y + offset[2], z + offset[3]
|
if cutter.area:contains(xn, yn, zn) then
|
dig_recursive(xn, yn, zn)
|
end
|
end
|
end
|
|
local handle_drops
|
|
local function chainsaw_dig(player, pos, remaining_charge)
|
local minp = {
|
x = pos.x - (tree_max_radius + 1),
|
y = pos.y,
|
z = pos.z - (tree_max_radius + 1)
|
}
|
local maxp = {
|
x = pos.x + (tree_max_radius + 1),
|
y = pos.y + tree_max_height,
|
z = pos.z + (tree_max_radius + 1)
|
}
|
|
local vm = minetest.get_voxel_manip()
|
local emin, emax = vm:read_from_map(minp, maxp)
|
|
cutter = {
|
area = VoxelArea:new{MinEdge=emin, MaxEdge=emax},
|
data = vm:get_data(),
|
param2 = vm:get_param2_data(),
|
seen = {},
|
drops = {}, -- [content_id] = count
|
minp = vector.copy(pos),
|
maxp = vector.copy(pos),
|
charge = remaining_charge
|
}
|
|
dig_recursive(pos.x, pos.y, pos.z)
|
|
-- Check protection
|
local player_name = player:get_player_name()
|
if minetest.is_area_protected(cutter.minp, cutter.maxp, player_name, 6) then
|
minetest.chat_send_player(player_name, "The chainsaw cannot cut this tree. The cuboid " ..
|
minetest.pos_to_string(cutter.minp) .. ", " .. minetest.pos_to_string(cutter.maxp) ..
|
" contains protected nodes.")
|
minetest.record_protection_violation(pos, player_name)
|
return
|
end
|
|
minetest.sound_play("chainsaw", {
|
pos = pos,
|
gain = 1.0,
|
max_hear_distance = 20
|
})
|
|
handle_drops(pos)
|
|
vm:set_data(cutter.data)
|
vm:write_to_map(true)
|
vm:update_map()
|
|
-- Update falling nodes
|
for i, status in pairs(cutter.seen) do
|
if status == 2 then -- actually dug
|
minetest.check_for_falling(cutter.area:position(i))
|
end
|
end
|
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
|
|
local drop_inv = minetest.create_detached_inventory("technic:chainsaw_drops", {}, ":technic")
|
handle_drops = function(pos)
|
local n_slots = 100
|
drop_inv:set_size("main", n_slots)
|
drop_inv:set_list("main", {})
|
|
-- Put all dropped items into the detached inventory
|
for c_id, count in pairs(cutter.drops) do
|
local name = minetest.get_name_from_content_id(c_id)
|
|
-- Add drops in bulk -> keep some randomness
|
while count > 0 do
|
local drops = minetest.get_node_drops(name, "")
|
-- higher numbers are faster but return uneven sapling counts
|
local decrement = math.ceil(count * 0.3)
|
decrement = math.min(count, math.max(5, decrement))
|
|
for _, stack in ipairs(drops) do
|
stack = ItemStack(stack)
|
local total = math.ceil(stack:get_count() * decrement * chainsaw_efficiency)
|
local stack_max = stack:get_stack_max()
|
|
-- Split into full stacks
|
while total > 0 do
|
local size = math.min(total, stack_max)
|
stack:set_count(size)
|
drop_inv:add_item("main", stack)
|
total = total - size
|
end
|
end
|
count = count - decrement
|
end
|
end
|
|
-- Drop in random places
|
for i = 1, n_slots do
|
local stack = drop_inv:get_stack("main", i)
|
if stack:is_empty() then
|
break
|
end
|
minetest.add_item(get_drop_pos(pos), stack)
|
end
|
|
drop_inv:set_size("main", 0) -- free RAM
|
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 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
|
chainsaw_dig(user, pointed_thing.under, meta.charge)
|
meta.charge = cutter.charge
|
|
cutter = {} -- Free RAM
|
|
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"}, },
|
|
})
|
