Try Removing Error Message

api.lua

@@ -105,61 +105,103 @@ function liquid_physics.register_liquid(namespace, source_name, flowing_name)
     end
 
     --Overwrite source
-    source_liquid_def.liquid_range = 0
+    -- source_liquid_def.liquid_range = 0
     source_liquid_def.groups.liquid_physics = 1
 
-    core.register_node(":" .. source_liquid_name, source_liquid_def)
+    -- core.register_node(":" .. source_liquid_name, {
+    --     description                = source_liquid_def.description,
+    --     paramtype2                 = "flowingliquid",
+
+    --     drawtype                   = "flowingliquid",         -- Used by drawtype = "flowingliquid"
+    --     liquidtype                 = "",                      -- Flowing not needed here since condition is already met?
+
+    --     tiles                      = source_liquid_def.tiles, -- As needed by drawtype - copy from water
+    --     special_tiles              = source_liquid_def.tiles,
+    --     use_texture_alpha          = true,
+
+    --     liquid_renewable           = false, -- Disallow any kind of spreading
+    --     liquid_range               = 2,
+
+    --     buildable_to               = true,               -- For liquid_alternative_source = "test_water:test",
+
+    --     liquid_alternative_flowing = source_liquid_name, -- As requested in documentation
+
+    --     liquid_move_physics        = true,
+    --     walkable                   = false,
+
+    -- })
+
+    core.override_item(source_liquid_name, {
+        paramtype2 = "flowingliquid",
+        drawtype = "flowingliquid",
+        liquidtype = "",
+        liquid_renewable = false,
+        liquid_range = 2,
+        liquid_alternative_source = "",
+        liquid_alternative_flowing = source_liquid_name,
+        liquid_move_physics = true,
+        special_tiles = source_liquid_def.tiles,
+        groups = source_liquid_def.groups,
+        pointable = true,
+    }, nil)
+
+    -- core.register_node(":" .. source_liquid_name, source_liquid_def)
     liquid_physics._liquid_ids[source_liquid_name] = id
 
     local liquids = {}
     table.insert(liquids, "air")
 
     for i = 1, 7 do
-        local node_name = "liquid_physics:" .. namespace .. "_" .. source_name .. "_level_" .. i
+        liquid_physics._liquid_ids[source_liquid_name] = id
-
+        table.insert(liquids, source_liquid_name)
-        local level_def = {
-            name = node_name,
-            description = source_liquid_def.description .. " Level " .. i,
-            tiles = source_liquid_def.tiles,
-            use_texture_alpha = source_liquid_def.use_texture_alpha,
-            paramtype = source_liquid_def.paramtype,
-            walkable = source_liquid_def.walkable,
-            pointable = source_liquid_def.pointable,
-            diggable = source_liquid_def.diggable,
-            buildable_to = source_liquid_def.buildable_to,
-            is_ground_content = source_liquid_def.is_ground_content,
-            drawtype = "nodebox",
-            drop = source_liquid_def.drop,
-            drowning = source_liquid_def.drowning,
-            liquidtype = "source",
-            liquid_alternative_flowing = node_name,
-            liquid_alternative_source = node_name,
-            liquid_range = 0,
-            liquid_viscosity = source_liquid_def.liquid_viscosity,
-            liquid_renewable = false,
-            waving = source_liquid_def.waving,
-            color = source_liquid_def.color,
-            node_box = {
-                type = "fixed",
-                fixed = {
-                    { -0.5, -0.5, -0.5, 0.5, -0.375 + (0.125 * (i - 1)), 0.5 },
-                },
-            },
-            collision_box = {
-                type = "fixed",
-                fixed = { { -0.5, -0.5, -0.5, 0.5, -0.375 + (0.125 * (i - 1)), 0.5 }, },
-            },
-            post_effect_color = source_liquid_def.post_effect_color,
-            groups = source_liquid_def.groups,
-            sounds = source_liquid_def.sounds,
-        }
-
-        core.register_node(":" .. node_name, level_def)
-        liquid_physics._liquid_ids[node_name] = id
-
-        table.insert(liquids, node_name)
     end
 
+    -- for i = 1, 7 do
+    --     local node_name = "liquid_physics:" .. namespace .. "_" .. source_name .. "_level_" .. i
+
+    --     local level_def = {
+    --         name = node_name,
+    --         description = source_liquid_def.description .. " Level " .. i,
+    --         tiles = source_liquid_def.tiles,
+    --         use_texture_alpha = source_liquid_def.use_texture_alpha,
+    --         paramtype = source_liquid_def.paramtype,
+    --         walkable = source_liquid_def.walkable,
+    --         pointable = source_liquid_def.pointable,
+    --         diggable = source_liquid_def.diggable,
+    --         buildable_to = source_liquid_def.buildable_to,
+    --         is_ground_content = source_liquid_def.is_ground_content,
+    --         drawtype = "nodebox",
+    --         drop = source_liquid_def.drop,
+    --         drowning = source_liquid_def.drowning,
+    --         liquidtype = "source",
+    --         liquid_alternative_flowing = node_name,
+    --         liquid_alternative_source = node_name,
+    --         liquid_range = 0,
+    --         liquid_viscosity = source_liquid_def.liquid_viscosity,
+    --         liquid_renewable = false,
+    --         waving = source_liquid_def.waving,
+    --         color = source_liquid_def.color,
+    --         node_box = {
+    --             type = "fixed",
+    --             fixed = {
+    --                 { -0.5, -0.5, -0.5, 0.5, -0.375 + (0.125 * (i - 1)), 0.5 },
+    --             },
+    --         },
+    --         collision_box = {
+    --             type = "fixed",
+    --             fixed = { { -0.5, -0.5, -0.5, 0.5, -0.375 + (0.125 * (i - 1)), 0.5 }, },
+    --         },
+    --         post_effect_color = source_liquid_def.post_effect_color,
+    --         groups = source_liquid_def.groups,
+    --         sounds = source_liquid_def.sounds,
+    --     }
+
+    --     core.register_node(":" .. node_name, level_def)
+    --     liquid_physics._liquid_ids[node_name] = id
+
+    --     table.insert(liquids, node_name)
+    -- end
+
     table.insert(liquids, source_liquid_name)
 
     -- Finally, stop flowing
@@ -167,7 +209,9 @@ function liquid_physics.register_liquid(namespace, source_name, flowing_name)
     core.override_item(flowing_liquid_name, {
         liquid_range = 0,
         liquid_renewable = false,
-        groups = flowing_liquid_def.groups
+        liquid_alternative_source = "",
+        liquid_alternative_flowing = "",
+        groups = flowing_liquid_def.groups,
     }, nil)
     liquid_physics._liquid_ids[flowing_liquid_name] = id
 

bucket.lua

@@ -105,7 +105,8 @@ local function get_liquid_name(bucket_name)
             end
         end
     elseif base_mcl_buckets then
-        return mcl_buckets.buckets[bucket_name].source_place
+        -- TODO: How Should I handle this then...
+        return mcl_buckets.buckets[bucket_name].source_take[1]
     end
     return nil
 end
@@ -118,12 +119,33 @@ local function bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
         return
     end
 
+    local held_bucket_name = itemstack:get_name()
+
+    local is_bucket_filled = held_bucket_name ~= get_bucket_name_empty()
+    local bucket_contents = is_bucket_filled and get_liquid_name(held_bucket_name)
+    local bucket_fill_level = internal_bucket.get_liquid_level(itemstack:get_wear())
+
     local liquid = liquid_physics.get_liquid_at(pointed_thing.under)
 
+    -- Bucket is filled and pointed at liquid is not registered
+    -- -> Don't scoop
+    if bucket_contents and liquid == nil then
+        return itemstack
+    end
+
+    -- Pointed at liquid is not registered
+    -- -> Scoop via fallback
     if liquid == nil then
         return on_use_fallback(itemstack, user, pointed_thing)
     end
 
+    -- Bucket is filled and pointed at liquid is of different kind
+    -- -> Don't scoop
+    local liquid_source_name = liquid_physics.get_liquid_node_names(liquid.liquid_id)[8]
+    if bucket_contents and bucket_contents ~= liquid_source_name then
+        return itemstack
+    end
+
     local node = core.get_node(pointed_thing.under)
 
     if check_protection(pointed_thing.under,
@@ -132,38 +154,43 @@ local function bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
         return
     end
 
-    local liquid_source = liquid_physics.get_liquid_node_names(liquid.liquid_id)[8]
+    local bucket_name_filled = get_bucket_name_filled(liquid_source_name)
-    local bucket_name = get_bucket_name_filled(liquid_source)
 
-    if bucket_name == nil then
+    -- Don't know how to handle
+    -- -> Fallback
+    if bucket_name_filled == nil then
         return on_use_fallback(itemstack, user, pointed_thing)
     end
 
-    -- Filled Bucket
+    local item_bucket = ItemStack(bucket_name_filled)
-    local bucket_item = ItemStack(bucket_name)
+    if not is_bucket_filled then
-    set_bucket_item_liquid_level(bucket_item, liquid.liquid_level)
+        set_bucket_item_liquid_level(item_bucket, 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_filled }) then
+                inv:add_item("main", item_bucket)
+            else
+                local pos = user:getpos()
+                pos.y = math.floor(pos.y + 0.5)
+                core.add_item(pos, item_bucket)
+            end
 
-    local item_count = user:get_wielded_item():get_count()
+            -- set to return empty buckets minus 1
-
+            item_bucket = ItemStack(get_bucket_name_empty() .. tostring(item_count - 1))
-    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
+        liquid_physics.set_liquid_at(pointed_thing.under, 0, 0)
-        return_item = ItemStack(get_bucket_name_empty() .. tostring(item_count - 1))
+        return item_bucket
+    else
+        local give_amount = math.min(8 - bucket_fill_level, liquid.liquid_level)
+
+        set_bucket_item_liquid_level(item_bucket, bucket_fill_level + give_amount)
+        liquid_physics.set_liquid_at(pointed_thing.under, liquid.liquid_id, liquid.liquid_level - give_amount)
+
+        return item_bucket
     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)
@@ -240,24 +267,33 @@ function internal_bucket.register_empty_bucket(bucket_name)
 
     if base_default then
         local on_use_fallback = bucket_tool.on_use
-        local on_use_wrapper = function(itemstack, user, pointed_thing)
+        core.override_item(bucket_name, {
-            return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
+            on_use = function(itemstack, user, pointed_thing)
-        end
+                return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
-        core.override_item(bucket_name, { on_use = on_use_wrapper }, nil)
+            end
+        }, nil)
     elseif base_mcl_buckets then
         local on_use_fallback = bucket_tool.on_place
-        local on_use_wrapper = function(itemstack, user, pointed_thing)
+        if core.settings:get_bool("liquid_physics_voxelibre_enable_scooping_via_use", true) then
-            local use_select_box = core.settings:get_bool("mcl_buckets_use_select_box", false)
+            core.override_item(bucket_name, {
-            if use_select_box == false then
+                on_use = function(itemstack, user, pointed_thing)
-                -- TODO: Understand why this is nil
+                    return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
-                if user.get_pos == nil then
-                    return itemstack
                 end
-                pointed_thing = mcl_get_pointed_thing(user)
+            }, nil)
-            end
-            return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
         end
-        core.override_item(bucket_name, { on_place = on_use_wrapper }, nil)
+        core.override_item(bucket_name, {
+            on_place = 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
+        }, nil)
     end
 end
 
@@ -276,20 +312,50 @@ function internal_bucket.register_filled_bucket(name)
 
     if base_default then
         local on_place_fallback = bucket_tool.on_place
-        local on_place_wrapper = function(itemstack, user, pointed_thing)
+        local on_use_fallback = bucket_tool.on_place
-            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
+            on_use     = function(itemstack, user, pointed_thing)
+                return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
+            end,
+            on_place   = function(itemstack, user, pointed_thing)
+                return bucket_on_place(on_place_fallback, bucket_liquid_id, source_name, itemstack, user, pointed_thing)
+            end,
+            wear_color = {
+                blend = "linear",
+                color_stops = {
+                    [0.0] = "#ff0000",
+                    [0.5] = "slateblue",
+                    [1.0] = { r = 0, g = 255, b = 0, a = 150 },
+                }
+            },
         }, nil)
+
+        core.register_tool(":" .. name, core.registered_items[name])
     elseif base_mcl_buckets then
         local on_place_fallback = bucket_tool.on_place
-        local on_place_wrapper = function(itemstack, user, pointed_thing)
+        if core.settings:get_bool("liquid_physics_voxelibre_enable_scooping_via_use", true) then
-            return bucket_on_place(on_place_fallback, bucket_liquid_id, source_name, itemstack, user, pointed_thing)
+            local on_use_fallback = bucket_tool.on_use
+            core.override_item(name, {
+                on_use = function(itemstack, user, pointed_thing)
+                    return bucket_on_use(on_use_fallback, itemstack, user, pointed_thing)
+                end
+            }, nil)
         end
         core.override_item(name, {
-            on_place = on_place_wrapper
+            on_place = function(itemstack, user, pointed_thing)
+                return bucket_on_place(on_place_fallback, bucket_liquid_id, source_name, itemstack, user, pointed_thing)
+            end,
+            wear_color = {
+                blend = "linear",
+                color_stops = {
+                    [0.0] = "#ff0000",
+                    [0.5] = "slateblue",
+                    [1.0] = { r = 0, g = 255, b = 0, a = 150 },
+                }
+            },
         }, nil)
+
+        core.register_tool(":" .. name, core.registered_items[name])
     end
 end
 

game/default.lua

@@ -20,11 +20,11 @@ internal_bucket.register_empty_bucket("bucket:bucket_empty")
 
 -- Settings
 
-if core.settings:get_bool("liquid_physics_enable_water_physics", false) then
+if core.settings:get_bool("liquid_physics_enable_water_physics", true) then
     liquid_physics.register_liquid("default", "water_source", "water_flowing")
     internal_bucket.register_filled_bucket("bucket:bucket_water")
 end
-if core.settings:get_bool("liquid_physics_enable_lava_physics", false) then
+if core.settings:get_bool("liquid_physics_enable_lava_physics", true) then
     liquid_physics.register_liquid("default", "lava_source", "lava_flowing")
     internal_bucket.register_filled_bucket("bucket:bucket_lava")
 end

game/voxelibre.lua

@@ -20,11 +20,11 @@ internal_bucket.register_empty_bucket("mcl_buckets:bucket_empty")
 
 -- Settings
 
-if core.settings:get_bool("liquid_physics_enable_water_physics", false) then
+if core.settings:get_bool("liquid_physics_enable_water_physics", true) then
     liquid_physics.register_liquid("mcl_core", "water_source", "water_flowing")
     internal_bucket.register_filled_bucket("mcl_buckets:bucket_water")
 end
-if core.settings:get_bool("liquid_physics_enable_lava_physics", false) then
+if core.settings:get_bool("liquid_physics_enable_lava_physics", true) then
     liquid_physics.register_liquid("mcl_core", "lava_source", "lava_flowing")
     internal_bucket.register_filled_bucket("mcl_buckets:bucket_lava")
 end

internal.lua

@@ -74,7 +74,13 @@ function internal.new_lpn(hash, pos)
     local liquid_id = internal.get_liquid_id(node.name)
     local liquid_level = -1
     if liquid_id then
-        liquid_level = internal.get_liquid_level(liquid_id, node.name)
+        local node_level = core.get_node_level(pos)
+        if liquid_id == 0 then
+            node_level = 0
+        elseif node_level == 0 and node.name == liquid_physics.get_liquid_node_names(liquid_id)[8] then
+            node_level = 8
+        end
+        liquid_level = node_level --internal.get_liquid_level(liquid_id, node.name)
     end
     return {
         hash = hash,
@@ -100,6 +106,7 @@ end
 -- @param lpn table Liquid Physics Node
 function internal.set_node(lpn)
     core.set_node(lpn.pos, { name = internal.get_liquid_node_name(lpn.liquid_id, lpn.liquid_level) })
+    core.set_node_level(lpn.pos, lpn.liquid_level)
 end
 
 -- This node will be checked in the next cycle

physics.lua

@@ -224,6 +224,7 @@ core.register_on_mapblocks_changed(function(modified_blocks, modified_blocks_cou
     end
     -- Update only changed nodes from buffer
     for _, lpn in pairs(b) do
+        --core.chat_send_all(dump(lpn))
         if lpn.init_liquid_level ~= lpn.liquid_level then
             internal.set_node(lpn)
         end

settingtypes.txt

@@ -1,2 +1,3 @@
-liquid_physics_enable_water_physics (Enable physics for water) bool true
+liquid_physics_enable_water_physics (Enable Physics For Water) bool true
-liquid_physics_enable_lava_physics (Enable physics for lava) bool true
+liquid_physics_enable_lava_physics (Enable Physics For Lava) bool true
+liquid_physics_voxelibre_enable_scooping_via_use (VoxeLibre: Enable Scooping Via Use/Punch) bool true