297 lines
9.6 KiB
Lua
297 lines
9.6 KiB
Lua
-- Copyright (C) 2025 snoutie
|
|
-- Authors: snoutie (copyright@achtarmig.org)
|
|
-- This program is free software: you can redistribute it and/or modify
|
|
-- it under the terms of the GNU Affero General Public License as published
|
|
-- by the Free Software Foundation, either version 3 of the License, or
|
|
-- (at your option) any later version.
|
|
|
|
-- This program is distributed in the hope that it will be useful,
|
|
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
-- GNU Affero General Public License for more details.
|
|
|
|
-- You should have received a copy of the GNU Affero General Public License
|
|
-- along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
local internal_bucket = {}
|
|
|
|
local wear_levels = {}
|
|
wear_levels[1] = 65535
|
|
wear_levels[2] = 57337
|
|
wear_levels[3] = 49146
|
|
wear_levels[4] = 40955
|
|
wear_levels[5] = 32764
|
|
wear_levels[6] = 24573
|
|
wear_levels[7] = 16382
|
|
wear_levels[8] = 8191
|
|
wear_levels[9] = 0
|
|
|
|
local base_mcl_buckets = core.get_modpath("mcl_buckets")
|
|
local base_default = core.get_modpath("default")
|
|
|
|
local function check_protection(pos, name, text)
|
|
if core.is_protected(pos, name) then
|
|
core.log("action", (name ~= "" and name or "A mod")
|
|
.. " tried to " .. text
|
|
.. " at protected position "
|
|
.. core.pos_to_string(pos)
|
|
.. " with a bucket")
|
|
core.record_protection_violation(pos, name)
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function internal_bucket.get_wear(liquid_level)
|
|
return wear_levels[liquid_level + 1]
|
|
end
|
|
|
|
function internal_bucket.get_liquid_level(wear)
|
|
for i = 1, 9 do
|
|
if wear_levels[i] == wear then
|
|
return i - 1
|
|
end
|
|
end
|
|
end
|
|
|
|
local function set_bucket_item_liquid_level(item, liquid_level)
|
|
local meta = item:get_meta()
|
|
|
|
meta:set_string("description",
|
|
ItemStack(item:get_name()):get_description() .. " " .. liquid_level .. "/8")
|
|
|
|
item:set_wear(internal_bucket.get_wear(liquid_level))
|
|
end
|
|
|
|
local function mcl_get_pointed_thing(usr)
|
|
local start = usr:get_pos()
|
|
start.y = start.y + usr:get_properties().eye_height
|
|
local look_dir = usr:get_look_dir()
|
|
local _end = vector.add(start, vector.multiply(look_dir, 5))
|
|
|
|
local ray = core.raycast(start, _end, false, true)
|
|
for pointed_thing in ray do
|
|
local name = core.get_node(pointed_thing.under).name
|
|
local def = core.registered_nodes[name]
|
|
if not def or def.drawtype ~= "flowingliquid" then
|
|
return pointed_thing
|
|
end
|
|
end
|
|
end
|
|
|
|
local function get_bucket_name_empty()
|
|
if base_default then
|
|
return "bucket:bucket_empty"
|
|
elseif base_mcl_buckets then
|
|
return "mcl_buckets:bucket_empty"
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function get_bucket_name_filled(source_name)
|
|
if base_default then
|
|
return bucket.liquids[source_name].itemname
|
|
elseif base_mcl_buckets then
|
|
return mcl_buckets.liquids[source_name].bucketname
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function get_liquid_name(bucket_name)
|
|
if base_default then
|
|
for source, b in pairs(bucket.liquids) do
|
|
if b.itemname and b.itemname == bucket_name then
|
|
return b.source
|
|
end
|
|
end
|
|
elseif base_mcl_buckets then
|
|
return mcl_buckets.buckets[bucket_name].source_place
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
|
|
if pointed_thing.type == "object" then
|
|
pointed_thing.ref:punch(user, 1.0, { full_punch_interval = 1.0 }, nil)
|
|
return user:get_wielded_item()
|
|
elseif pointed_thing.type ~= "node" then
|
|
return
|
|
end
|
|
|
|
local liquid = liquid_physics.get_liquid_at(pointed_thing.under)
|
|
|
|
if liquid == nil then
|
|
return on_use_fallback(itemstack, user, pointed_thing)
|
|
end
|
|
|
|
local node = core.get_node(pointed_thing.under)
|
|
|
|
if check_protection(pointed_thing.under,
|
|
user:get_player_name(),
|
|
"take " .. node.name) then
|
|
return
|
|
end
|
|
|
|
local liquid_source = liquid_physics.get_liquid_node_names(liquid.liquid_id)[8]
|
|
local bucket_name = get_bucket_name_filled(liquid_source)
|
|
|
|
if bucket_name == nil then
|
|
return on_use_fallback(itemstack, user, pointed_thing)
|
|
end
|
|
|
|
-- Filled Bucket
|
|
local bucket_item = ItemStack(bucket_name)
|
|
set_bucket_item_liquid_level(bucket_item, liquid.liquid_level)
|
|
|
|
local return_item = bucket_item
|
|
|
|
local item_count = user:get_wielded_item():get_count()
|
|
|
|
if item_count > 1 then
|
|
local inv = user:get_inventory()
|
|
if inv:room_for_item("main", { name = bucket_name }) then
|
|
inv:add_item("main", bucket_item)
|
|
else
|
|
local pos = user:getpos()
|
|
pos.y = math.floor(pos.y + 0.5)
|
|
core.add_item(pos, bucket_item)
|
|
end
|
|
|
|
-- set to return empty buckets minus 1
|
|
return_item = ItemStack(get_bucket_name_empty() .. tostring(item_count - 1))
|
|
end
|
|
|
|
liquid_physics.set_liquid_at(pointed_thing.under, 0, 0)
|
|
|
|
return return_item
|
|
end
|
|
|
|
local function bucket_on_place(on_place_fallback, bucket_liquid_id, source_name, itemstack, user, pointed_thing)
|
|
-- Must be pointing to node
|
|
if pointed_thing.type ~= "node" then
|
|
return
|
|
end
|
|
|
|
local node = core.get_node(pointed_thing.under)
|
|
local node_def = core.registered_nodes[node.name]
|
|
|
|
if not node_def then
|
|
return itemstack
|
|
end
|
|
|
|
-- Call on_rightclick if the pointed node defines it
|
|
if node_def.on_rightclick and
|
|
not (user and user:is_player() and
|
|
user:get_player_control().sneak) then
|
|
return node_def.on_rightclick(
|
|
pointed_thing.under,
|
|
node, user,
|
|
itemstack)
|
|
end
|
|
|
|
-- Where to place the liquid at
|
|
local place_at_pos
|
|
|
|
if node_def.buildable_to then
|
|
place_at_pos = pointed_thing.under
|
|
else
|
|
place_at_pos = pointed_thing.above
|
|
|
|
node = core.get_node(place_at_pos)
|
|
|
|
local node_above_def = core.registered_nodes[node.name]
|
|
|
|
if not node_above_def or not node_above_def.buildable_to then
|
|
return itemstack
|
|
end
|
|
end
|
|
|
|
if check_protection(place_at_pos, user
|
|
and user:get_player_name()
|
|
or "", "place " .. source_name) then
|
|
return
|
|
end
|
|
|
|
local liquid_level = internal_bucket.get_liquid_level(itemstack:get_wear())
|
|
local liquid = liquid_physics.get_liquid_at(place_at_pos)
|
|
|
|
if liquid == nil then
|
|
if liquid_physics.set_liquid_at(place_at_pos, bucket_liquid_id, liquid_level) then
|
|
return ItemStack(get_bucket_name_empty())
|
|
end
|
|
return itemstack
|
|
end
|
|
|
|
if liquid.liquid_id == bucket_liquid_id then
|
|
local give_amount = math.min(8 - liquid.liquid_level, liquid_level)
|
|
if liquid_physics.set_liquid_at(place_at_pos, bucket_liquid_id, liquid.liquid_level + give_amount) then
|
|
if give_amount == liquid_level then
|
|
return ItemStack(get_bucket_name_empty())
|
|
end
|
|
set_bucket_item_liquid_level(itemstack, liquid_level - give_amount)
|
|
return itemstack
|
|
end
|
|
return itemstack
|
|
end
|
|
end
|
|
|
|
function internal_bucket.register_empty_bucket(bucket_name)
|
|
local bucket_tool = core.registered_items[bucket_name]
|
|
|
|
if base_default then
|
|
local on_use_fallback = bucket_tool.on_use
|
|
local on_use_wrapper = function(itemstack, user, pointed_thing)
|
|
return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
|
|
end
|
|
core.override_item(bucket_name, { on_use = on_use_wrapper }, nil)
|
|
elseif base_mcl_buckets then
|
|
local on_use_fallback = bucket_tool.on_place
|
|
local on_use_wrapper = function(itemstack, user, pointed_thing)
|
|
local use_select_box = core.settings:get_bool("mcl_buckets_use_select_box", false)
|
|
if use_select_box == false then
|
|
-- TODO: Understand why this is nil
|
|
if user.get_pos == nil then
|
|
return itemstack
|
|
end
|
|
pointed_thing = mcl_get_pointed_thing(user)
|
|
end
|
|
return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
|
|
end
|
|
core.override_item(bucket_name, { on_place = on_use_wrapper }, nil)
|
|
end
|
|
end
|
|
|
|
function internal_bucket.register_filled_bucket(name)
|
|
local bucket_tool = core.registered_items[name]
|
|
|
|
local source_name = get_liquid_name(name)
|
|
if source_name == nil then
|
|
error("Liquid Physics: Could not register bucket. Liquid for bucket " .. name .. " was not found")
|
|
end
|
|
local bucket_liquid_id = liquid_physics.get_liquid_id(source_name)
|
|
if bucket_liquid_id == nil then
|
|
error("Liquid Physics: Could not register bucket. Liquid " ..
|
|
source_name .. " was not registered with liquid physics.")
|
|
end
|
|
|
|
if base_default then
|
|
local on_place_fallback = bucket_tool.on_place
|
|
local on_place_wrapper = function(itemstack, user, pointed_thing)
|
|
return bucket_on_place(on_place_fallback, bucket_liquid_id, source_name, itemstack, user, pointed_thing)
|
|
end
|
|
core.override_item(name, {
|
|
on_place = on_place_wrapper
|
|
}, nil)
|
|
elseif base_mcl_buckets then
|
|
local on_place_fallback = bucket_tool.on_place
|
|
local on_place_wrapper = function(itemstack, user, pointed_thing)
|
|
return bucket_on_place(on_place_fallback, bucket_liquid_id, source_name, itemstack, user, pointed_thing)
|
|
end
|
|
core.override_item(name, {
|
|
on_place = on_place_wrapper
|
|
}, nil)
|
|
end
|
|
end
|
|
|
|
return internal_bucket
|