zenonseth/logistica-cd2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add better bucket registration support and support some bucket mods

Browse Source
This commit is contained in:
Zenon Seth 2024-06-06 21:00:03 +01:00
parent ff04a3a9ce
commit 4ca9e59285
16 changed files with 274 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
api/lava_furnace.lua
View File

@ -7,10 +7,6 @@ local META_LAVA_USED = "ufuel"
local get_meta = minetest.get_meta
local itemstrings = logistica.itemstrings
local BUCKET_LAVA = itemstrings.lava_bucket
local BUCKET_EMPTY = itemstrings.empty_bucket
local LAVA_UNIT = "logistica:lava_unit"
local INV_FUEL = "fuel"
@ -22,14 +18,15 @@ local GUIDE_BTN = "guide"
local UPDATE_INTERVAL = 1.0
local function is_lava_bucket(itemstackName)
return logistica.reservoir_get_full_buckets_for_liquid(logistica.liquids.lava)[itemstackName] ~= nil
end
local function fill_lava_tank_from_fuel(pos, meta, inv)
local itemstackName = inv:get_stack(INV_FUEL, 1):get_name()
if itemstackName ~= BUCKET_LAVA and itemstackName ~= LAVA_UNIT then return end
if not is_lava_bucket(itemstackName) and itemstackName ~= LAVA_UNIT then return end
local returnStack = ItemStack("")
if itemstackName == BUCKET_LAVA then
returnStack = ItemStack(BUCKET_EMPTY)
end
local returnStack = logistica.reservoir_get_empty_bucket_for_full_bucket(itemstackName) or ItemStack("")
local currLevel = meta:get_int(META_LAVA_IN_TANK)
local cap = logistica.lava_furnace_get_lava_capacity(pos)
if cap - currLevel < 1000 then return end
@ -288,10 +285,11 @@ end
local function lava_furnace_allow_metadata_inv_put(pos, listname, index, stack, player)
if minetest.is_protected(pos, player:get_player_name()) then return 0 end
local stackName = stack:get_name()
if listname == INV_INPT or listname == INV_ADDI then
return stack:get_count()
elseif listname == INV_FUEL
and (stack:get_name() == BUCKET_LAVA or stack:get_name() == LAVA_UNIT) then
and (is_lava_bucket(stackName) or stackName == LAVA_UNIT) then
return 1
else
return 0

10
api/reservoir.lua
View File

@ -213,11 +213,13 @@ function logistica.register_reservoir(liquidName, liquidDesc, bucketItemName, li
def.light_source = optLight
def.inventory_image = make_inv_image(variantName, liquidTexture)
minetest.register_node(nodeName, def)
logistica.register_non_pushable(nodeName)
logistica.GROUPS.reservoirs.register(nodeName)
if not minetest.registered_nodes[nodeName] then
minetest.register_node(nodeName, def)
logistica.register_non_pushable(nodeName)
logistica.GROUPS.reservoirs.register(nodeName)
minetest.register_node(nodeName.."_disabled", get_disabled_def(def))
minetest.register_node(nodeName.."_disabled", get_disabled_def(def))
end
logistica.reservoir_register_names(lname, bucketItemName, optEmptyBucketName, liquidDesc, liquidTexture, sourceNodeName)
end

6
logic/bucket_emptier.lua
View File

@ -30,10 +30,10 @@ function logistica.emptier_timer(pos, elapsed)
repeat
local stack = inv:get_stack(INV_INPUT, currSlot)
local stackName = stack:get_name()
local liquidName = logistica.reservoir_get_liquid_name_for_bucket(stackName)
local liquidName = logistica.reservoir_get_liquid_name_for_filled_bucket(stackName)
if liquidName then
local emptyBucket = logistica.reservoir_get_empty_bucket_for_liquid(liquidName)
if inv:room_for_item(INV_MAIN, ItemStack(emptyBucket)) then
local emptyBucket = logistica.reservoir_get_empty_bucket_for_full_bucket(stackName)
if emptyBucket and inv:room_for_item(INV_MAIN, ItemStack(emptyBucket)) then
local newStack = logistica.empty_bucket_into_network(network, stack)
if newStack then
success = true

11
logic/bucket_filler.lua
View File

@ -9,7 +9,7 @@ local buckets_to_names = nil
local function get_all_buckets_to_names_list()
if not buckets_to_names then
buckets_to_names = logistica.table_to_list_indexed(
logistica.reservoir_get_all_buckets_to_names_map(),
logistica.reservoir_get_all_filled_buckets_to_names_map(),
function (bucketName, liquidName)
return { bucketName = bucketName, liquidName = liquidName }
end
@ -59,15 +59,18 @@ function logistica.take_item_from_bucket_filler(pos, stackToTake, network, colle
local originalRequestedBuckets = stackToTake:get_count()
local stackToTakeName = stackToTake:get_name()
local liquidName = logistica.reservoir_get_liquid_name_for_bucket(stackToTakeName)
local liquidName = logistica.reservoir_get_liquid_name_for_filled_bucket(stackToTakeName)
if not liquidName then return { remaining = stackToTake:get_count(), error = S("Unknown liquid: ")..liquidName } end
local liquidInfo = logistica.get_liquid_info_in_network(pos, liquidName)
local remainingRequest = math.min(liquidInfo.curr, originalRequestedBuckets)
local unfillableBuckets = originalRequestedBuckets - remainingRequest
local filledBucketName = logistica.reservoir_get_full_bucket_for_liquid(liquidName)
local emptyBucketName = logistica.reservoir_get_empty_bucket_for_liquid(liquidName)
local filledBuckets = logistica.reservoir_get_full_buckets_for_liquid(liquidName)
if not filledBuckets[stackToTakeName] then return { remaining = stackToTake:get_count(), error = S("Unknown filled bucket requested: ")..stackToTakeName } end
local filledBucketName = stackToTakeName
local emptyBucketName = logistica.reservoir_get_empty_bucket_for_full_bucket(stackToTakeName)
if not emptyBucketName then return { remaining = stackToTake:get_count(), error = S("Unknown full bucket: ")..stackToTakeName } end
-- first try to get the empty bucket from our internal inventory
local inv = minetest.get_meta(pos):get_inventory()

2
logic/lava_furnace_fueler.lua
View File

@ -4,7 +4,7 @@ local META_TARGET_LAVA = "tarlava"
local META_LAVA_IN_TANK = "lavam"
local EMPTY_BUCKET = logistica.itemstrings.empty_bucket
local LAVA_LIQUID_NAME = "lava"
local LAVA_LIQUID_NAME = logistica.liquids.lava
local function get_lava_furnace_lava_in_tank(meta)
return meta:get_int(META_LAVA_IN_TANK)

2
logic/network_storage.lua
View File

@ -48,7 +48,7 @@ function logistica.empty_bucket_into_network(network, bucketItemStack, dryRun)
if not logistica.reservoir_is_full_bucket(bucketItemStack:get_name()) then return nil end
local bucketName = bucketItemStack:get_name()
local liquidName = logistica.reservoir_get_liquid_name_for_bucket(bucketName)
local liquidName = logistica.reservoir_get_liquid_name_for_filled_bucket(bucketName)
local highestReservoirPos = nil
local emptyReservoirPos = nil

12
logic/pump.lua
View File

@ -1,3 +1,5 @@
local EMPTY_BUCKET = logistica.itemstrings.empty_bucket -- sort of weird, but we move liquids around in buckets, so we need some known "empty" bucket
local PUMP_MAX_RANGE = logistica.settings.pump_max_range
local PUMP_MAX_DEPTH = logistica.settings.pump_max_depth
@ -89,8 +91,12 @@ local function get_valid_source(targetPosition, ownerName)
local nodeDef = minetest.registered_nodes[node.name]
if nodeDef.liquidtype ~= "source" then return nil end
local bucketName = logistica.reservoir_get_full_bucket_for_liquid(liquidName)
if not bucketName then return nil end
local bucketsName = logistica.reservoir_get_full_buckets_for_liquid(liquidName)
local bucketName = nil
for potentialBucket, _ in pairs(bucketsName) do
-- basically, try to pick the EMPTY_BUCKET, but if not present for some weird reason, pick any valid filled bucket
if bucketName ~= EMPTY_BUCKET then bucketName = potentialBucket end
end
-- otherwise its valid
local isRenewable = nodeDef.liquid_renewable ; if isRenewable == nil then isRenewable = true end -- default value is true, per api docs
@ -126,7 +132,7 @@ end
-- returns true if succeeded, false if not
local function put_liquid_in_network_reservoirs(pumpPosition, bucketItemStack, network)
if not network then return false end
local liquidName = logistica.reservoir_get_liquid_name_for_bucket(bucketItemStack:get_name())
local liquidName = logistica.reservoir_get_liquid_name_for_filled_bucket(bucketItemStack:get_name())
if not liquidName then return false end
local amountInNetwork = logistica.get_liquid_info_in_network(pumpPosition, liquidName)
local maxAmount = get_max_level(minetest.get_meta(pumpPosition))

125
logic/reservoir.lua
View File

@ -1,12 +1,14 @@
local S = logistica.TRANSLATOR
local BUCKET_TO_NAME = {}
local NAME_TO_BUCKET = {}
local NAME_TO_EMPTY_BUCKET = {}
local NAME_TO_DESC = {}
local NAME_TO_TEXTURE = {}
local NAME_TO_SOURCE = {}
local SOURCE_TO_NAME = {}
local FILLED_BUCKET_TO_NAME = {} -- { full_bucket_name = liquidName }
local NAME_TO_FILLED_BUCKETS = {} -- { liquidName = { full_bucket_name = true, ... } }
local FILLED_TO_EMPTY = {} -- { full_bucket_name = empty_bucket_name }
local EMPTY_TO_FILLED = {} -- { empty_bucket_name = { liquidName = full_bucket_name } }
local NAME_TO_EMPTY_BUCKETS = {} -- { liquidName = { emptyBucket = true, ... } }
local NAME_TO_DESC = {} -- { liquidName = "Description of liquid" }
local NAME_TO_TEXTURE = {} -- { liquidName = "texture_of_liquid" }
local NAME_TO_SOURCE = {} -- { liquidName = source_node_name }
local SOURCE_TO_NAME = {} -- { source_node_name = liquid_name }
local EMPTY_BUCKET = logistica.itemstrings.empty_bucket
local EMPTY_SUFFIX = "_empty"
@ -28,15 +30,29 @@ local function ends_with(str, ending)
return ending == "" or string.sub(str, -#ending) == ending
end
local function get_empty_bucket_needed_for(liquidName)
local savedBucket = NAME_TO_EMPTY_BUCKET[liquidName]
if savedBucket then return savedBucket
else return EMPTY_BUCKET end
local function get_empty_buckets_that_can_accept(liquidName)
local savedBuckets = NAME_TO_EMPTY_BUCKETS[liquidName]
if savedBuckets then return savedBuckets
else return {} end
end
local function get_full_bucket_needed_for(liquidName)
if liquidName == LIQUID_NONE then return BUCKET_ANY end
return NAME_TO_BUCKET[liquidName]
local function does_full_bucket_match_liquid(fullBucketName, liquidName)
if liquidName == LIQUID_NONE then
return FILLED_BUCKET_TO_NAME[fullBucketName] ~= nil
end
local filledBuckets = NAME_TO_FILLED_BUCKETS[liquidName]
if not filledBuckets then return false end
return filledBuckets[fullBucketName] ~= nil
end
-- returns full bucket itemstack name, or nil if there isn't one (because empty can't hold liquid)
local function get_filled_bucket_for_empty_and_liquid(emptyBucketName, liquidName)
local emptyBucketsForLiquid = NAME_TO_EMPTY_BUCKETS[liquidName]
if not emptyBucketsForLiquid then return nil end
if not emptyBucketsForLiquid[emptyBucketName] then return nil end
local potentialFilledBuckets = EMPTY_TO_FILLED[emptyBucketName]
if not potentialFilledBuckets then return nil end
return potentialFilledBuckets[liquidName]
end
local function get_empty_reservoir_name(nodeName, liquidName)
@ -79,11 +95,21 @@ function logistica.reservoir_get_description(currBuckets, maxBuckets, liquidName
end
function logistica.reservoir_register_names(liquidName, bucketName, emptyBucketName, liquidDesc, liquidTexture, sourceNodeName)
BUCKET_TO_NAME[bucketName] = liquidName
NAME_TO_BUCKET[liquidName] = bucketName
if emptyBucketName then
NAME_TO_EMPTY_BUCKET[liquidName] = emptyBucketName
end
if not emptyBucketName then emptyBucketName = EMPTY_BUCKET end
FILLED_BUCKET_TO_NAME[bucketName] = liquidName
if not NAME_TO_FILLED_BUCKETS[liquidName] then NAME_TO_FILLED_BUCKETS[liquidName] = {} end
NAME_TO_FILLED_BUCKETS[liquidName][bucketName] = true
FILLED_TO_EMPTY[bucketName] = emptyBucketName
if not EMPTY_TO_FILLED[emptyBucketName] then EMPTY_TO_FILLED[emptyBucketName] = {} end
EMPTY_TO_FILLED[emptyBucketName][liquidName] = bucketName
if not NAME_TO_EMPTY_BUCKETS[liquidName] then NAME_TO_EMPTY_BUCKETS[liquidName] = {} end
NAME_TO_EMPTY_BUCKETS[liquidName][emptyBucketName] = true
NAME_TO_DESC[liquidName] = liquidDesc
NAME_TO_TEXTURE[liquidName] = liquidTexture
if sourceNodeName then
@ -106,15 +132,25 @@ function logistica.reservoir_use_item_on(pos, itemstack, optNode, dryRun)
local maxBuckets = nodeDef.logistica.maxBuckets
local liquidDesc = logistica.reservoir_get_description_of_liquid(liquidName)
local emptyBucket = get_empty_bucket_needed_for(liquidName)
local fullBucket = get_full_bucket_needed_for(liquidName)
local isReservoirFull = liquidName ~= LIQUID_NONE
if itemStackName == emptyBucket then
local tryToFillBucket = false
local tryToEmptyBucket = false
if isReservoirFull then
local emptyBucketsForLiquid = get_empty_buckets_that_can_accept(liquidName)
if emptyBucketsForLiquid[itemStackName] then tryToFillBucket = true end
end
if not tryToFillBucket then
tryToEmptyBucket = does_full_bucket_match_liquid(itemStackName, liquidName)
end
if tryToFillBucket then
if nodeLiquidLevel == 0 then
-- make sure we swap this for the empty reservoir
logistica.swap_node(pos, get_empty_reservoir_name(node.name, liquidName))
return nil
end
local fullBucket = get_filled_bucket_for_empty_and_liquid(itemStackName, liquidName)
if not fullBucket then return nil end
nodeLiquidLevel = nodeLiquidLevel - 1
@ -135,10 +171,10 @@ function logistica.reservoir_use_item_on(pos, itemstack, optNode, dryRun)
end
return ItemStack(fullBucket)
elseif fullBucket == BUCKET_ANY or itemStackName == fullBucket then
local newLiquidName = BUCKET_TO_NAME[itemStackName]
elseif tryToEmptyBucket then
local newLiquidName = FILLED_BUCKET_TO_NAME[itemStackName]
if not newLiquidName then return nil end -- wasn't a bucket we can use
local newEmptyBucket = get_empty_bucket_needed_for(newLiquidName)
local newEmptyBucket = FILLED_TO_EMPTY[itemStackName]
if not newEmptyBucket then return nil end
nodeLiquidLevel = nodeLiquidLevel + 1
@ -182,16 +218,11 @@ function logistica.reservoir_get_liquid_level(pos)
end
function logistica.reservoir_is_empty_bucket(bucketName)
if bucketName == EMPTY_BUCKET then return true end
for _, bucket in pairs(NAME_TO_EMPTY_BUCKET) do
if bucket == bucketName then return true end
end
return false
return EMPTY_TO_FILLED[bucketName] ~= nil
end
function logistica.reservoir_is_full_bucket(bucketName)
if BUCKET_TO_NAME[bucketName] ~= nil then return true end
return false
return FILLED_BUCKET_TO_NAME[bucketName] ~= nil
end
-- returns true if the itemname is a known empty or filled bucket that can be used in a reservoir
@ -199,23 +230,35 @@ function logistica.reservoir_is_known_bucket(bucketName)
return logistica.reservoir_is_empty_bucket(bucketName) or logistica.reservoir_is_full_bucket(bucketName)
end
-- return the liquid name for the given bucket name, or nil if there's none registered
function logistica.reservoir_get_liquid_name_for_bucket(bucketName)
return BUCKET_TO_NAME[bucketName]
-- return the liquid name for the given filled bucket name, or nil if there's none registered
function logistica.reservoir_get_liquid_name_for_filled_bucket(bucketName)
return FILLED_BUCKET_TO_NAME[bucketName]
end
function logistica.reservoir_get_all_buckets_to_names_map()
return table.copy(BUCKET_TO_NAME)
function logistica.reservoir_get_all_filled_buckets_to_names_map()
return table.copy(FILLED_BUCKET_TO_NAME)
end
function logistica.reservoir_get_all_sources_to_names_map()
return table.copy(SOURCE_TO_NAME)
end
function logistica.reservoir_get_empty_bucket_for_liquid(liquidName)
return get_empty_bucket_needed_for(liquidName)
-- returns a list of empty buckets that can accept this liquid
function logistica.reservoir_get_empty_buckets_that_can_accept(liquidName)
local emptyBuckets = NAME_TO_EMPTY_BUCKETS[liquidName]
if not emptyBuckets then return {} end
return table.copy(emptyBuckets)
end
function logistica.reservoir_get_full_bucket_for_liquid(liquidName)
return get_full_bucket_needed_for(liquidName)
-- returns the empty bucket name corresponding to the filled bucket - or nil if the given filledBucketName isn't a full bucket
function logistica.reservoir_get_empty_bucket_for_full_bucket(filledBucketName)
return FILLED_TO_EMPTY[filledBucketName]
end
-- returns a table {filledBucket = true, ...} of the filled buckets that can hold this liquid
-- or empty table if there are none
function logistica.reservoir_get_full_buckets_for_liquid(liquidName)
local filledBuckets = NAME_TO_FILLED_BUCKETS[liquidName]
if not filledBuckets then return {} end
return table.copy(filledBuckets)
end

2
mod.conf
View File

@ -1,5 +1,5 @@
name = logistica
optional_depends = default, bucket, i3, mcl_core, mcl_buckets, unified_inventory, mcl_mobitems, animalia, ethereal, mesecons_mvps
optional_depends = default, bucket, i3, mcl_core, mcl_buckets, unified_inventory, mcl_mobitems, animalia, ethereal, mesecons_mvps, bucket_wooden
min_minetest_version = 5.4.0
author = ZenonSeth
description = On-demand Item Transportation + Powerful Item and Liquid Storage

15
registration/item_recipes.lua
View File

@ -91,11 +91,16 @@ minetest.register_craft({
}
})
minetest.register_craft({
output = itemstrings.lava_bucket,
type = "shapeless",
recipe = { L("lava_unit"), "bucket:bucket_empty" }
})
for filledBucket, _ in pairs(logistica.reservoir_get_full_buckets_for_liquid(logistica.liquids.lava)) do
local emptyBucket = logistica.reservoir_get_empty_bucket_for_full_bucket(filledBucket)
if minetest.registered_items[filledBucket] and minetest.registered_items[emptyBucket] then
minetest.register_craft({
output = filledBucket,
type = "shapeless",
recipe = { L("lava_unit"), emptyBucket }
})
end
end
minetest.register_craft({
output = L("cobblegen_upgrade"),

31
registration/machines_api_reg.lua
View File

@ -259,36 +259,7 @@ logistica.register_requester("Bulk Request Inserter\nInserts up to 64 items at a
-- Reservoirs
--------------------------------
local mcla = minetest.get_game_info().id == "mineclonia"
local mcl2 = minetest.get_game_info().id == "mineclone2"
local lava_texture = "default_lava.png"
local water_texture = "default_water.png"
local river_water_texture = "default_river_water.png"
if mcla then
lava_texture = "default_lava_source_animated.png^[sheet:1x16:0,0"
water_texture = "default_water_source_animated.png^[sheet:1x16:0,0"
river_water_texture = "default_river_water_source_animated.png^[sheet:1x16:0,0"
elseif mcl2 then
lava_texture = "mcl_core_lava_source_animation.png^[sheet:1x16:0,0"
water_texture = "mcl_core_water_source_animation.png^[sheet:1x16:0,0^[multiply:#3F76E4"
river_water_texture = "mcl_core_water_source_animation.png^[sheet:1x16:0,0^[multiply:#0084FF"
end
logistica.register_reservoir("lava", "Lava", itemstrings.lava_bucket, lava_texture, itemstrings.lava_source, 8)
logistica.register_reservoir("water", "Water", itemstrings.water_bucket, water_texture, itemstrings.water_source)
logistica.register_reservoir("river_water", "River Water", itemstrings.river_water_bucket, river_water_texture, itemstrings.river_water_source)
-- milk buckets
if minetest.registered_items["mcl_mobitems:milk_bucket"] then
logistica.register_reservoir("milk", "Milk", "mcl_mobitems:milk_bucket", "logistica_milk_liquid.png")
end
if minetest.registered_items["animalia:bucket_milk"] then
logistica.register_reservoir("milk", "Milk", "animalia:bucket_milk", "logistica_milk_liquid.png")
end
if minetest.registered_items["ethereal:bucket_cactus"] then
logistica.register_reservoir("cactus_pulp", "Cactus Pulp", "ethereal:bucket_cactus", "logistica_milk_liquid.png^[colorize:#697600:227")
end
logistica.compat_bucket_register_buckets()
--------------------------------
-- Passive Supply Chest

2
registration/registration.lua
View File

@ -1,8 +1,8 @@
local path = logistica.MODPATH .. "/registration"
-- once again, order is important
dofile(path.."/node_recipes.lua")
dofile(path.."/item_recipes.lua")
dofile(path.."/machines_api_reg.lua")
dofile(path.."/item_recipes.lua")
dofile(path.."/lava_furnace_recipes.lua")
dofile(path.."/misc.lua")
dofile(path.."/compat_unified_inv.lua")

1
util/common.lua
View File

@ -1,7 +1,6 @@
logistica.TRANSLATOR = minetest.get_translator(logistica.MODNAME)
local META_ON_OFF_KEY = "logonoff"
local charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

91
util/compat_bucket.lua Normal file
View File

@ -0,0 +1,91 @@
-- Provide compatiblity with:
-- 1. The bucket_lite mod and its many buckets
-- 2. The wooden bucket mod (there's 2 of them but only 1 seems functional with latest minetest - the bucket_wooden)
local liquids = logistica.liquids
local des = liquids.name_to_description
local tex = liquids.name_to_texture
local src = liquids.name_to_source_block
local lit = liquids.name_to_light
--[[ table entry format:
[empty_bucket_name] = {
[liquid_name] = filled_bucket_name
}
--]]
local buckets_to_register = {}
-- default buckets
--[[
logistica.register_reservoir(
liq.lava, des[liq.lava], itemstrings.lava_bucket, tex[liq.lava], src[liq.lava], lit[liq.lava])
logistica.register_reservoir(
liq.water, des[liq.water], itemstrings.water_bucket, tex[liq.water], src[liq.water], lit[liq.water])
logistica.register_reservoir(
liq.river_water, des[liq.river_water], itemstrings.river_water_bucket, tex[liq.river_water], src[liq.river_water], lit[liq.river_water])
]]
buckets_to_register[logistica.itemstrings.empty_bucket] = {
[liquids.water] = logistica.itemstrings.water_bucket,
[liquids.river_water] = logistica.itemstrings.river_water_bucket,
[liquids.lava] = logistica.itemstrings.lava_bucket,
}
-- bucket_lite
local function liteEmptyBucket(type) return "bucket:bucket_empty_"..type end
local function liteWaterBucket(type) return "bucket:bucket_water_uni_"..type end
local function liteRiverBucket(type) return "bucket:bucket_water_river_"..type end
local function liteLavaBucket(type) return "bucket:bucket_lava_uni_"..type end
local bucket_lite_types = { "bronze", "diamond", "gold", "mese", "steel", "stone", "wood" }
for _, type in ipairs(bucket_lite_types) do
local emptyBucket = liteEmptyBucket(type)
if minetest.registered_items[emptyBucket] then
buckets_to_register[emptyBucket] = {
[liquids.water] = liteWaterBucket(type),
[liquids.river_water] = liteRiverBucket(type),
[liquids.lava] = liteLavaBucket(type),
}
end
end
-- bucket_wooden
if minetest.registered_items["bucket_wooden:bucket_empty"] then
buckets_to_register["bucket_wooden:bucket_empty"] = {
[liquids.water] = "bucket_wooden:bucket_water",
[liquids.river_water] = "bucket_wooden:bucket_river_water",
}
end
--
----------------------------------------------------------------
-- global funcs and registration
----------------------------------------------------------------
function logistica.compat_bucket_register_buckets()
for emptyBucket, data in pairs(buckets_to_register) do
for liquidName, fullBucket in pairs(data) do
if minetest.registered_items[fullBucket] then
logistica.register_reservoir(
liquidName, des[liquidName], fullBucket, tex[liquidName], src[liquidName], lit[liquidName], emptyBucket
)
end
end
end
-- unique buckets with unique liquids
if minetest.registered_items["mcl_mobitems:milk_bucket"] then
logistica.register_reservoir("milk", "Milk", "mcl_mobitems:milk_bucket", "logistica_milk_liquid.png")
end
if minetest.registered_items["animalia:bucket_milk"] then
logistica.register_reservoir("milk", "Milk", "animalia:bucket_milk", "logistica_milk_liquid.png")
end
if minetest.registered_items["ethereal:bucket_cactus"] then
logistica.register_reservoir("cactus_pulp", "Cactus Pulp", "ethereal:bucket_cactus", "logistica_milk_liquid.png^[colorize:#697600:227")
end
end

49
util/liquids.lua Normal file
View File

@ -0,0 +1,49 @@
local S = logistica.TRANSLATOR
local itemstrings = logistica.itemstrings
logistica.liquids = {}
local liq = logistica.liquids
liq.lava = "lava"
liq.water = "water"
liq.river_water = "river_water"
liq.name_to_description = {
[liq.lava] = S("Lava"),
[liq.water] = S("Water"),
[liq.river_water] = S("River Water"),
}
local lava_texture = "default_lava.png"
local water_texture = "default_water.png"
local river_water_texture = "default_river_water.png"
local mcla = minetest.get_game_info().id == "mineclonia"
local mcl2 = minetest.get_game_info().id == "mineclone2"
if mcla then
lava_texture = "default_lava_source_animated.png^[sheet:1x16:0,0"
water_texture = "default_water_source_animated.png^[sheet:1x16:0,0"
river_water_texture = "default_river_water_source_animated.png^[sheet:1x16:0,0"
elseif mcl2 then
lava_texture = "mcl_core_lava_source_animation.png^[sheet:1x16:0,0"
water_texture = "mcl_core_water_source_animation.png^[sheet:1x16:0,0^[multiply:#3F76E4"
river_water_texture = "mcl_core_water_source_animation.png^[sheet:1x16:0,0^[multiply:#0084FF"
end
liq.name_to_texture = {
[liq.lava] = lava_texture,
[liq.water] = water_texture,
[liq.river_water] = river_water_texture,
}
liq.name_to_source_block = {
[liq.lava] = itemstrings.lava_source,
[liq.water] = itemstrings.water_source,
[liq.river_water] = itemstrings.river_water_source,
}
liq.name_to_light = {
[liq.lava] = 8,
[liq.water] = 0,
[liq.river_water] = 0,
}

2
util/util.lua
View File

@ -4,6 +4,7 @@ dofile(path.."/compat_mcl.lua")
dofile(path.."/compat_mesecons.lua")
dofile(path.."/settings.lua")
dofile(path.."/common.lua")
dofile(path.."/liquids.lua")
dofile(path.."/rotations.lua")
dofile(path.."/hud.lua")
dofile(path.."/ui_logic.lua")
@ -11,6 +12,7 @@ dofile(path.."/ui.lua")
dofile(path.."/sound.lua")
dofile(path.."/inv_list_sorting.lua")
dofile(path.."/inv_list_filtering.lua")
dofile(path.."/compat_bucket.lua")
-- bad debug
local d = {}