729 lines
29 KiB
Lua
729 lines
29 KiB
Lua
if SERVER then return end
|
|
|
|
-- Register necessary types and make fields accessible
|
|
LuaUserData.RegisterType("Barotrauma.Items.Components.ItemContainer+SlotRestrictions")
|
|
LuaUserData.RegisterType(
|
|
'System.Collections.Immutable.ImmutableArray`1[[Barotrauma.Items.Components.ItemContainer+SlotRestrictions, Barotrauma]]')
|
|
LuaUserData.MakeFieldAccessible(Descriptors['Barotrauma.Items.Components.ItemContainer'], 'slotRestrictions')
|
|
LuaUserData.MakeFieldAccessible(Descriptors['Barotrauma.ItemInventory'], 'slots')
|
|
LuaUserData.MakeFieldAccessible(Descriptors["Barotrauma.CharacterInventory"], "slots")
|
|
|
|
-- Simple configuration
|
|
local CONFIG = {
|
|
TRIGGER_KEY = Keys.F, -- Key to press for quick stacking
|
|
NESTED_CONTAINERS = true, -- Whether to include nested containers
|
|
DEBUG_MODE = true, -- Print debug messages
|
|
HAND_SLOTS = { 6, 7 }, -- Slot numbers for hands (typically slots 6 and 7)
|
|
PRIORITY_CONTAINERS = { "toolbelt", "backpack", "pouch" }, -- Priority order for containers
|
|
EXCLUDE_TOOLS = true, -- Exclude tools from container list
|
|
TOOL_IDENTIFIERS = { "welding", "gun", "weapon", "revolver", "smg", "rifle", "shotgun",
|
|
"diving", "oxygen", "scanner", "card", "id", "fuel", "rod", "battery",
|
|
"fabricator", "deconstructor" }, -- Common tool identifiers to exclude
|
|
ALWAYS_INCLUDE = { "toolbelt", "backpack", "pouch" } -- Always include these items even if they match tool criteria
|
|
}
|
|
|
|
-- MOD INFO
|
|
local MOD_NAME = "Quick Stack To Containers"
|
|
local MOD_VERSION = "1.1.0"
|
|
|
|
print(MOD_NAME .. " v" .. MOD_VERSION .. " loaded!")
|
|
|
|
-- Debugging helper function
|
|
local function debugPrint(message)
|
|
if CONFIG.DEBUG_MODE then
|
|
print("[" .. MOD_NAME .. "] " .. message)
|
|
end
|
|
end
|
|
|
|
---@param table table
|
|
---@param depth number?
|
|
function DumpTable(table, depth)
|
|
if depth == nil then
|
|
depth = 0
|
|
end
|
|
if (depth > 200) then
|
|
print("Error: Depth > 200 in dumpTable()")
|
|
return
|
|
end
|
|
for k, v in pairs(table) do
|
|
if (type(v) == "table") then
|
|
print(string.rep(" ", depth) .. k .. ":")
|
|
DumpTable(v, depth + 1)
|
|
else
|
|
print(string.rep(" ", depth) .. k .. ": ", v)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Show notification to player
|
|
-- Helper function to check if an item is a tool rather than a container
|
|
local function isTool(item)
|
|
if not item or not item.Prefab or not item.Prefab.Identifier then return false end
|
|
|
|
-- Never exclude priority containers
|
|
local identifier = item.Prefab.Identifier.Value:lower()
|
|
for _, alwaysInclude in ipairs(CONFIG.ALWAYS_INCLUDE) do
|
|
if identifier:find(alwaysInclude) then
|
|
debugPrint("Always including high priority container: " .. item.Name)
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- Check tags first - most reliable method
|
|
local hasTags = false
|
|
pcall(function()
|
|
if item.Tags and item.Tags ~= "" then
|
|
hasTags = true
|
|
local tags = item.Tags:lower()
|
|
|
|
-- If item has explicit container tag, it's a container
|
|
if tags:find("container") then
|
|
debugPrint("Item has container tag: " .. item.Name)
|
|
return false
|
|
end
|
|
|
|
-- If item has tool or weapon tag, it's a tool
|
|
if tags:find("tool") or tags:find("weapon") then
|
|
debugPrint("Item has tool/weapon tag: " .. item.Name)
|
|
return true
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- If we found tags and made a decision based on them, return the result
|
|
if hasTags then
|
|
-- If we got here, the tags didn't conclusively identify this as a tool
|
|
-- For items with tags but no tool/weapon tag, check the number of slots
|
|
if item.OwnInventory and item.OwnInventory.slots and #item.OwnInventory.slots > 1 then
|
|
-- Items with multiple slots are likely containers
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- Fall back to identifier checks
|
|
for _, toolId in ipairs(CONFIG.TOOL_IDENTIFIERS) do
|
|
if identifier:find(toolId) then
|
|
-- Skip known exceptions
|
|
if toolId == "tool" and identifier:find("toolbox") or identifier:find("toolbelt") then
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
end
|
|
|
|
-- Final check based on slots - tools typically have 1 slot, containers have multiple
|
|
if item.OwnInventory and item.OwnInventory.slots then
|
|
-- Consider items with more than 2 slots as containers
|
|
if #item.OwnInventory.slots > 2 then
|
|
return false
|
|
elseif #item.OwnInventory.slots == 1 then
|
|
-- Most single-slot inventories are tools, but check for exceptions
|
|
-- Some special container items might have 1 slot but still be containers
|
|
if identifier:find("container") or identifier:find("box") or identifier:find("crate") then
|
|
return false
|
|
end
|
|
-- Otherwise likely a tool
|
|
return true
|
|
end
|
|
end
|
|
|
|
-- When in doubt, don't classify as a tool
|
|
return false
|
|
end
|
|
|
|
-- Helper function to move an item to a container, but only if matching items exist
|
|
local function moveItemToContainer(item, containerInv)
|
|
if not item or not containerInv then return false end
|
|
|
|
debugPrint("Attempting to stack with existing items in container (" .. #containerInv.slots .. " slots)")
|
|
|
|
-- Get max stack size for this item (default to 1 if we can't determine)
|
|
local maxStackSize = 60
|
|
pcall(function()
|
|
print(item.Prefab.MaxStackSize)
|
|
if item.Prefab and item.Prefab.MaxStackSize then
|
|
maxStackSize = item.Prefab.MaxStackSize
|
|
end
|
|
end)
|
|
|
|
-- Get current condition/quality of item (for proper stacking)
|
|
local itemCondition = 100
|
|
pcall(function()
|
|
if item.Condition then
|
|
itemCondition = item.Condition
|
|
end
|
|
end)
|
|
|
|
-- Check if the container has any matching items first
|
|
local foundMatchingItem = false
|
|
local matchingSlots = {}
|
|
|
|
-- First pass: find all matching slots
|
|
for slotIndex = 0, #containerInv.slots - 1 do
|
|
for _, containerItem in ipairs(containerInv.slots[slotIndex + 1].items) do
|
|
if containerItem.Prefab.Identifier.Equals(item.Prefab.Identifier) then
|
|
-- Check similar condition/quality (within 10%)
|
|
local containerItemCondition = 100
|
|
pcall(function()
|
|
if containerItem.Condition then
|
|
containerItemCondition = containerItem.Condition
|
|
end
|
|
end)
|
|
|
|
-- Only consider similar quality items
|
|
if math.abs(containerItemCondition - itemCondition) <= 10 then
|
|
foundMatchingItem = true
|
|
table.insert(matchingSlots, {
|
|
slotIndex = slotIndex,
|
|
currentSize = #containerInv.slots[slotIndex + 1].items,
|
|
remainingSpace = maxStackSize - #containerInv.slots[slotIndex + 1].items
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- If no matching items exist in the container, don't move the item
|
|
if not foundMatchingItem then
|
|
debugPrint("No matching items in container, skipping " .. item.Name)
|
|
return false
|
|
end
|
|
|
|
-- Sort slots by most available space first
|
|
table.sort(matchingSlots, function(a, b)
|
|
return a.remainingSpace > b.remainingSpace
|
|
end)
|
|
|
|
-- Try to stack with existing items that have space
|
|
for _, matchingSlot in ipairs(matchingSlots) do
|
|
-- Only try to put in slots that have space
|
|
if matchingSlot.remainingSpace > 0 then
|
|
debugPrint("Trying to stack " ..
|
|
item.Name .. " with existing items (slot has " .. matchingSlot.remainingSpace .. " space)")
|
|
|
|
-- Try to move the full item
|
|
if containerInv.TryPutItem(item, matchingSlot.slotIndex, true, false, nil) then
|
|
debugPrint("Successfully stacked " .. item.Name)
|
|
return true
|
|
else
|
|
debugPrint("Failed full stack, likely due to size limits")
|
|
|
|
-- If full stack failed, try to split and move part of it (if possible)
|
|
pcall(function()
|
|
-- Check if we can split stacks and if the item is a stack
|
|
if item.SplitStack and maxStackSize > 1 then
|
|
local currentStackSize = 1
|
|
-- Try to determine current stack size
|
|
pcall(function()
|
|
if item.Count then currentStackSize = item.Count end
|
|
end)
|
|
|
|
-- If current stack is larger than 1, try to split it
|
|
if currentStackSize > 1 then
|
|
-- Calculate how much we can move
|
|
local amountToMove = math.min(matchingSlot.remainingSpace, currentStackSize - 1)
|
|
|
|
if amountToMove > 0 then
|
|
debugPrint("Attempting to split stack and move " .. amountToMove .. " items")
|
|
|
|
-- Try to split the stack
|
|
local splitItem = item:SplitStack(amountToMove)
|
|
if splitItem then
|
|
-- Try to put the split item into the slot
|
|
if containerInv.TryPutItem(splitItem, matchingSlot.slotIndex, true, false, nil) then
|
|
debugPrint("Successfully moved partial stack of " .. splitItem.Name)
|
|
return true
|
|
else
|
|
debugPrint("Failed to move split stack")
|
|
-- If it fails, try to recombine the original stack
|
|
pcall(function()
|
|
item:AddItem(splitItem)
|
|
end)
|
|
end
|
|
else
|
|
debugPrint("Failed to split stack")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- If we couldn't stack with existing partial stacks, look for empty slots
|
|
-- But only if we're still stacking by finding matching items
|
|
debugPrint("Failed to stack with existing items, checking for empty slots")
|
|
|
|
-- Find empty slots
|
|
local emptySlots = {}
|
|
for slotIndex = 0, #containerInv.slots - 1 do
|
|
if #containerInv.slots[slotIndex + 1].items == 0 then
|
|
table.insert(emptySlots, slotIndex)
|
|
end
|
|
end
|
|
|
|
-- If there are empty slots, try to put the item there
|
|
for _, slotIndex in ipairs(emptySlots) do
|
|
debugPrint("Trying to put " .. item.Name .. " in empty slot " .. slotIndex)
|
|
if containerInv.TryPutItem(item, slotIndex, false, false, nil) then
|
|
debugPrint("Successfully put " .. item.Name .. " in empty slot")
|
|
return true
|
|
end
|
|
end
|
|
|
|
debugPrint("Failed to stack with existing items or find empty slots")
|
|
return false
|
|
end
|
|
|
|
-- Sort containers by priority
|
|
local function sortContainersByPriority(containers)
|
|
table.sort(containers, function(a, b)
|
|
local aPriority = -1
|
|
local bPriority = -1
|
|
|
|
-- Check priority for first container
|
|
for i, identifier in ipairs(CONFIG.PRIORITY_CONTAINERS) do
|
|
if a.Prefab.Identifier.Value:find(identifier) then
|
|
aPriority = i
|
|
break
|
|
end
|
|
end
|
|
|
|
-- Check priority for second container
|
|
for i, identifier in ipairs(CONFIG.PRIORITY_CONTAINERS) do
|
|
if b.Prefab.Identifier.Value:find(identifier) then
|
|
bPriority = i
|
|
break
|
|
end
|
|
end
|
|
|
|
return aPriority < bPriority
|
|
end)
|
|
|
|
return containers
|
|
end
|
|
|
|
-- Recursively find all containers in the player's inventory, including nested ones
|
|
local function findAllContainers(inventory, containers)
|
|
if not inventory or not inventory.slots then return containers end
|
|
|
|
containers = containers or {}
|
|
|
|
for _, slot in ipairs(inventory.slots) do
|
|
for _, item in ipairs(slot.items) do
|
|
if item.OwnInventory then
|
|
-- Skip tools if configured to do so
|
|
if CONFIG.EXCLUDE_TOOLS and isTool(item) then
|
|
debugPrint("Skipping tool: " .. item.Name .. " (" .. item.Prefab.Identifier.Value .. ")")
|
|
else
|
|
-- Add this container
|
|
debugPrint("Found container: " .. item.Name .. " (" .. item.Prefab.Identifier.Value .. ")")
|
|
table.insert(containers, item)
|
|
|
|
-- Recursively search inside this container if enabled
|
|
if CONFIG.NESTED_CONTAINERS then
|
|
debugPrint("Searching inside " .. item.Name .. " for nested containers")
|
|
findAllContainers(item.OwnInventory, containers)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return containers
|
|
end
|
|
|
|
---@class ItemLocation
|
|
---@field inventory Barotrauma.ItemInventory
|
|
---@field slotIndex number
|
|
---@field maxFits number
|
|
|
|
-- The resulting item tree is a table where the key is an ID of an item
|
|
-- And the value is an object that represents where that item is located
|
|
-- In our inventory
|
|
-- Special case are empty slots where any item fits
|
|
---@param inventory Barotrauma.ItemInventory
|
|
---@param itemTree table<string, ItemLocation[]>
|
|
---@return table
|
|
local function buildItemTree(inventory, itemTree, iter)
|
|
iter = iter or 0
|
|
itemTree = itemTree or {}
|
|
if not inventory or not inventory.slots then
|
|
debugPrint("Inventory is nil or has no slots, returning empty itemTree")
|
|
return itemTree
|
|
end
|
|
|
|
-- One slot can have one item but multiple of it
|
|
-- The number of an item in a slot is #slot.items
|
|
for slotIndex, slot in ipairs(inventory.slots) do
|
|
-- This iteration is done only to skip the player inventory as a potential destination
|
|
-- Since it will always be 0th iteration and there's no point stacking
|
|
-- Items from the player inventory to itself
|
|
debugPrint("Building item tree for inventory at iteration: " .. iter .. ", slot index: " .. slotIndex)
|
|
debugPrint("Slot " .. slotIndex .. " has " .. #slot.items .. " items")
|
|
if iter > 0 then
|
|
if #slot.items == 0 then
|
|
debugPrint("Slot " .. slotIndex .. " is empty, adding to itemTree as 'empty'")
|
|
itemTree['empty'] = itemTree['empty'] or {}
|
|
itemTree['empty'][#itemTree['empty'] + 1] = {
|
|
inventory = inventory,
|
|
slotIndex = slotIndex,
|
|
maxFits = 60
|
|
}
|
|
debugPrint("Added empty slot to itemTree at index: " .. slotIndex)
|
|
else
|
|
---@type Barotrauma.Item
|
|
local item = slot.items[1]
|
|
local identifier = item.Prefab.Identifier.Value
|
|
debugPrint("Found item: " ..
|
|
item.Name .. " with identifier: " .. identifier .. ", max stack size: " .. maxStackSize)
|
|
itemTree[identifier] = itemTree[identifier] or {}
|
|
-- We DO want even slots with maxFits = 0
|
|
-- Because that indicates that we DO HAVE the item
|
|
-- At all
|
|
-- And based on that we decide to move it
|
|
itemTree[identifier][#itemTree[identifier] + 1] = {
|
|
inventory = inventory,
|
|
slotIndex = slotIndex,
|
|
maxFits = slot.HowManyCanBePut(item.Prefab)
|
|
}
|
|
debugPrint("Added item to itemTree under identifier: " ..
|
|
identifier .. ", available fits: " .. (maxStackSize - #slot.items))
|
|
end
|
|
end
|
|
|
|
|
|
if #slot.items > 0 then
|
|
---@type Barotrauma.Item
|
|
local item = slot.items[1]
|
|
local tags = item.Prefab.Tags
|
|
local shouldSuss = false
|
|
for tag in tags do
|
|
if tag.value:find("container") then
|
|
shouldSuss = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if shouldSuss then
|
|
debugPrint("Searching inside " .. item.Name .. " for nested containers")
|
|
buildItemTree(item.OwnInventory, itemTree, iter + 1)
|
|
end
|
|
end
|
|
end
|
|
|
|
debugPrint("Completed building item tree for current inventory iteration: " .. iter)
|
|
return itemTree
|
|
end
|
|
|
|
-- Find the currently open container - improved version
|
|
local function getOpenContainer()
|
|
debugPrint("Attempting to find open container...")
|
|
|
|
local openContainer = nil
|
|
local hasVisibleInventory = false
|
|
|
|
-- Method 1: Try to use Inventory.CurrentInventory or similar properties
|
|
pcall(function()
|
|
if Inventory and Inventory.CurrentContainer and Inventory.CurrentContainer.Owner then
|
|
openContainer = Inventory.CurrentContainer.Owner
|
|
hasVisibleInventory = true
|
|
debugPrint("Found open container via CurrentContainer: " .. openContainer.Name)
|
|
end
|
|
end)
|
|
|
|
if hasVisibleInventory and openContainer then return openContainer end
|
|
|
|
-- Method 2: Check if Inventory.OpenInventories exists and has entries
|
|
pcall(function()
|
|
if Inventory and Inventory.OpenInventories and #Inventory.OpenInventories > 0 then
|
|
-- Get the last opened inventory
|
|
for _, inv in ipairs(Inventory.OpenInventories) do
|
|
if inv and inv.Owner and inv.Owner ~= Character.Controlled then
|
|
openContainer = inv.Owner
|
|
hasVisibleInventory = true
|
|
debugPrint("Found open container via OpenInventories: " .. openContainer.Name)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
if hasVisibleInventory and openContainer then return openContainer end
|
|
|
|
-- Method 3: Check if currently selected item is interacting with a container
|
|
pcall(function()
|
|
if Character.Controlled and Character.Controlled.SelectedItem then
|
|
local selectedItem = Character.Controlled.SelectedItem
|
|
-- Check if selected item is interacting with something
|
|
if selectedItem.InteractingWith and selectedItem.InteractingWith.OwnInventory and
|
|
selectedItem.InteractingWith ~= Character.Controlled then
|
|
openContainer = selectedItem.InteractingWith
|
|
hasVisibleInventory = true
|
|
debugPrint("Found open container via current interaction: " .. openContainer.Name)
|
|
end
|
|
end
|
|
end)
|
|
|
|
if hasVisibleInventory and openContainer then return openContainer end
|
|
|
|
-- For safety, add a visual check - only return a container if it has a visible UI element
|
|
if openContainer then
|
|
-- Verify this container actually has a visible UI
|
|
local isVisible = false
|
|
|
|
pcall(function()
|
|
-- Common method to check if inventory is visible - look for visual components
|
|
if openContainer.OwnInventory and openContainer.OwnInventory.visualSlots and
|
|
#openContainer.OwnInventory.visualSlots > 0 then
|
|
isVisible = true
|
|
end
|
|
end)
|
|
|
|
if not isVisible then
|
|
debugPrint("Container found but not visibly open in UI: " .. openContainer.Name)
|
|
return nil
|
|
end
|
|
end
|
|
|
|
debugPrint("No open container found")
|
|
return nil
|
|
end
|
|
|
|
-- Function to stack from open container to player containers
|
|
local function stackFromOpenContainer(character, playerContainers, openContainer)
|
|
if not character or not openContainer or not openContainer.OwnInventory then return 0 end
|
|
|
|
debugPrint("Stacking from open container: " .. openContainer.Name)
|
|
|
|
local itemsMoved = 0
|
|
local openContainerInv = openContainer.OwnInventory
|
|
|
|
-- Create a cache of processable items to avoid redundant checks
|
|
local itemsToProcess = {}
|
|
local processedIdentifiers = {}
|
|
|
|
-- Process each slot in the open container
|
|
for slotIndex = 0, #openContainerInv.slots - 1 do
|
|
local slot = openContainerInv.slots[slotIndex + 1]
|
|
|
|
-- Process items in the slot
|
|
for i = #slot.items, 1, -1 do
|
|
local item = slot.items[i]
|
|
local identifierValue = item.Prefab.Identifier.Value
|
|
|
|
-- Skip container items
|
|
if item.OwnInventory then
|
|
debugPrint("Skipping container item: " .. item.Name)
|
|
goto nextItem
|
|
end
|
|
|
|
-- Skip if we've already processed an item of this type
|
|
if processedIdentifiers[identifierValue] then
|
|
debugPrint("Already processed items of type: " .. identifierValue .. " from open container")
|
|
goto nextItem
|
|
end
|
|
|
|
table.insert(itemsToProcess, {
|
|
item = item,
|
|
slotIndex = slotIndex
|
|
})
|
|
|
|
-- Mark identifier as scheduled for processing
|
|
processedIdentifiers[identifierValue] = true
|
|
|
|
::nextItem::
|
|
end
|
|
end
|
|
|
|
-- Now process the collected items - this greatly reduces redundant container checks
|
|
for _, itemData in ipairs(itemsToProcess) do
|
|
local item = itemData.item
|
|
|
|
debugPrint("Processing item from container: " .. item.Name)
|
|
|
|
-- Try to move the item to each player container
|
|
for _, container in ipairs(playerContainers) do
|
|
debugPrint("Trying to stack " .. item.Name .. " into " .. container.Name)
|
|
if moveItemToContainer(item, container.OwnInventory) then
|
|
debugPrint("Stacked " .. item.Name .. " from open container into " .. container.Name)
|
|
itemsMoved = itemsMoved + 1
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
return itemsMoved
|
|
end
|
|
|
|
-- Function to quickly stack items from inventory to containers
|
|
local function quickStackItems(character)
|
|
if not character then
|
|
debugPrint("No character found")
|
|
return
|
|
end
|
|
|
|
debugPrint("Quick stack function called")
|
|
|
|
local inventory = character.Inventory
|
|
if not inventory or not inventory.slots then
|
|
debugPrint("Character has no inventory")
|
|
return
|
|
end
|
|
|
|
local itemTree = buildItemTree(inventory, {})
|
|
DumpTable(itemTree)
|
|
|
|
-- Find all containers in player inventory, including nested ones
|
|
-- local containers = findAllContainers(inventory, {})
|
|
|
|
-- -- Fallback: If no containers found, try a direct search for known container types
|
|
-- if #containers == 0 then
|
|
-- debugPrint("No containers found with standard method, trying fallback method...")
|
|
|
|
-- -- Direct slot search for common container types
|
|
-- for _, slot in ipairs(inventory.slots) do
|
|
-- for _, item in ipairs(slot.items) do
|
|
-- if item.OwnInventory then
|
|
-- local identifier = item.Prefab.Identifier.Value:lower()
|
|
-- -- Force include specific items that we know should be containers
|
|
-- if identifier:find("toolbelt") or identifier:find("backpack") or
|
|
-- identifier:find("pouch") or identifier:find("container") or
|
|
-- identifier:find("box") or identifier:find("crate") or
|
|
-- item.Name:find("Container") or item.Name:find("Box") then
|
|
|
|
-- debugPrint("Fallback: Force including known container: " .. item.Name)
|
|
-- table.insert(containers, item)
|
|
|
|
-- -- Also check container slots
|
|
-- if CONFIG.NESTED_CONTAINERS and #item.OwnInventory.slots > 2 then
|
|
-- for _, containerSlot in ipairs(item.OwnInventory.slots) do
|
|
-- for _, containerItem in ipairs(containerSlot.items) do
|
|
-- if containerItem.OwnInventory and
|
|
-- (containerItem.Prefab.Identifier.Value:lower():find("container") or
|
|
-- containerItem.Name:find("Container")) then
|
|
|
|
-- debugPrint("Fallback: Found nested container: " .. containerItem.Name)
|
|
-- table.insert(containers, containerItem)
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
|
|
-- debugPrint("Found " .. #containers .. " containers" .. (CONFIG.NESTED_CONTAINERS and " (including nested)" or ""))
|
|
-- if #containers == 0 then
|
|
-- debugPrint("No containers with inventory found!")
|
|
-- showNotification("No containers found! Make sure you have a backpack, toolbelt, or storage box.")
|
|
-- return
|
|
-- end
|
|
|
|
-- -- Sort containers by priority
|
|
-- containers = sortContainersByPriority(containers)
|
|
-- for i, container in ipairs(containers) do
|
|
-- debugPrint(i .. ": " .. container.Name .. " - priority container: " ..
|
|
-- tostring(container.Prefab.Identifier.Value:find(CONFIG.PRIORITY_CONTAINERS[1]) ~= nil))
|
|
-- end
|
|
|
|
-- local itemsMoved = 0
|
|
|
|
-- -- Create a cache of processable items to avoid redundant checks
|
|
-- local itemsToProcess = {}
|
|
-- local processedIdentifiers = {}
|
|
|
|
-- -- First collect all items we might want to stack
|
|
-- for slotIndex, slot in ipairs(inventory.slots) do
|
|
-- -- Skip hand slots
|
|
-- local isHandSlot = false
|
|
-- for _, handSlot in ipairs(CONFIG.HAND_SLOTS) do
|
|
-- if slotIndex == handSlot then
|
|
-- isHandSlot = true
|
|
-- break
|
|
-- end
|
|
-- end
|
|
-- if isHandSlot then
|
|
-- debugPrint("Skipping hand slot: " .. slotIndex)
|
|
-- goto continueSlot
|
|
-- end
|
|
|
|
-- -- Process items in the slot
|
|
-- for i = #slot.items, 1, -1 do
|
|
-- local item = slot.items[i]
|
|
-- local identifierValue = item.Prefab.Identifier.Value
|
|
|
|
-- -- Skip container items
|
|
-- if item.OwnInventory then
|
|
-- debugPrint("Skipping container item: " .. item.Name)
|
|
-- goto nextItem
|
|
-- end
|
|
|
|
-- -- Skip if we've already processed an item of this type
|
|
-- if processedIdentifiers[identifierValue] then
|
|
-- debugPrint("Already processed items of type: " .. identifierValue)
|
|
-- goto nextItem
|
|
-- end
|
|
|
|
-- debugPrint("Adding to process list: " .. item.Name)
|
|
-- table.insert(itemsToProcess, {
|
|
-- item = item,
|
|
-- slotIndex = slotIndex
|
|
-- })
|
|
|
|
-- -- Mark identifier as scheduled for processing
|
|
-- processedIdentifiers[identifierValue] = true
|
|
|
|
-- ::nextItem::
|
|
-- end
|
|
|
|
-- ::continueSlot::
|
|
-- end
|
|
|
|
-- -- Now process the collected items - this greatly reduces redundant container checks
|
|
-- for _, itemData in ipairs(itemsToProcess) do
|
|
-- local item = itemData.item
|
|
|
|
-- debugPrint("Processing inventory item: " .. item.Name .. " (" .. item.Prefab.Identifier.Value .. ")")
|
|
|
|
-- -- Try to move the item to each container
|
|
-- for _, container in ipairs(containers) do
|
|
-- debugPrint("Trying container: " .. container.Name)
|
|
-- if moveItemToContainer(item, container.OwnInventory) then
|
|
-- debugPrint("Stacked " .. item.Name .. " into " .. container.Name)
|
|
-- itemsMoved = itemsMoved + 1
|
|
-- break
|
|
-- end
|
|
-- end
|
|
-- end
|
|
|
|
-- -- Check if there's an open container to stack from
|
|
-- local openContainer = getOpenContainer()
|
|
-- if openContainer then
|
|
-- debugPrint("Found open container to stack from: " .. openContainer.Name)
|
|
-- local openContainerItemsMoved = stackFromOpenContainer(character, containers, openContainer)
|
|
-- itemsMoved = itemsMoved + openContainerItemsMoved
|
|
-- else
|
|
-- debugPrint("No open container found to stack from")
|
|
-- end
|
|
|
|
-- if itemsMoved > 0 then
|
|
-- debugPrint("Stacked " .. itemsMoved .. " items into containers")
|
|
-- else
|
|
-- debugPrint("No matching items to stack")
|
|
-- end
|
|
end
|
|
|
|
-- Hook into player control to listen for key press
|
|
Hook.Patch("Barotrauma.Character", "ControlLocalPlayer", function(instance, ptable)
|
|
if not PlayerInput.KeyHit(CONFIG.TRIGGER_KEY) then return end
|
|
|
|
local character = instance
|
|
if not character then return end
|
|
|
|
quickStackItems(character)
|
|
end, Hook.HookMethodType.After)
|