400 lines
14 KiB
Lua
400 lines
14 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
|
|
}
|
|
|
|
-- 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
|
|
|
|
-- Show notification to player
|
|
local function showNotification(message)
|
|
-- Try different methods to show a message to the player
|
|
debugPrint(message)
|
|
|
|
-- Method 1: Print to console (always works)
|
|
print("[" .. MOD_NAME .. "] " .. message)
|
|
|
|
-- Method 2: Try to use GUIMessageBox if available
|
|
pcall(function()
|
|
if GUI and GUI.AddMessage then
|
|
GUI.AddMessage(message, GUI.Font.Default)
|
|
end
|
|
end)
|
|
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)")
|
|
|
|
-- Only try to find matching items to stack with
|
|
local foundMatchingItem = false
|
|
|
|
-- Check if the container has any matching items first
|
|
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
|
|
foundMatchingItem = true
|
|
debugPrint("Found matching item in container: " .. containerItem.Name)
|
|
break
|
|
end
|
|
end
|
|
if foundMatchingItem then break 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
|
|
|
|
-- Try to stack with existing items
|
|
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
|
|
-- Try to stack with existing item
|
|
debugPrint("Trying to stack " .. item.Name .. " with existing item")
|
|
if containerInv.TryPutItem(item, slotIndex, true, false, nil) then
|
|
debugPrint("Successfully stacked " .. item.Name)
|
|
return true
|
|
else
|
|
debugPrint("Failed to stack " .. item.Name .. " - TryPutItem failed")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- We don't try to place in empty slots anymore, only stack with existing items
|
|
debugPrint("Failed to stack with existing items")
|
|
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
|
|
-- 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
|
|
|
|
return containers
|
|
end
|
|
|
|
-- Find the currently open container
|
|
local function getOpenContainer()
|
|
debugPrint("Attempting to find open container...")
|
|
|
|
-- Method 1: Check if Inventory.OpenState is accessible and has an open container
|
|
pcall(function()
|
|
if Character.Controlled and Character.Controlled.SelectedCharacter then
|
|
local selectedChar = Character.Controlled.SelectedCharacter
|
|
if selectedChar.Inventory then
|
|
debugPrint("Checking selected character's inventory")
|
|
-- This is likely the container the player is interacting with
|
|
return selectedChar
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- Method 2: Inspect GUI components to find inventory GUI components
|
|
pcall(function()
|
|
if GUI and GUI.Components then
|
|
for _, component in pairs(GUI.Components) do
|
|
-- Look for UI components related to inventory
|
|
if component.RectTransform and component.RectTransform.GUIComponent and
|
|
component.RectTransform.GUIComponent.UserData and
|
|
component.RectTransform.GUIComponent.UserData.Item then
|
|
local item = component.RectTransform.GUIComponent.UserData.Item
|
|
if item.OwnInventory then
|
|
debugPrint("Found open container via GUI component: " .. item.Name)
|
|
return item
|
|
end
|
|
end
|
|
end
|
|
end
|
|
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 then
|
|
debugPrint("Found open container via current interaction: " .. selectedItem.InteractingWith.Name)
|
|
return selectedItem.InteractingWith
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- Method 4: Try to use Inventory.DraggingInventory (if it exists)
|
|
pcall(function()
|
|
if Inventory and Inventory.DraggingInventory and
|
|
Inventory.DraggingInventory.Owner and
|
|
Inventory.DraggingInventory.Owner ~= Character.Controlled then
|
|
debugPrint("Found open container via DraggingInventory: " .. Inventory.DraggingInventory.Owner.Name)
|
|
return Inventory.DraggingInventory.Owner
|
|
end
|
|
end)
|
|
|
|
-- Method 5: Check all items in the game with open inventories
|
|
for item in Item.ItemList do
|
|
if item and item.OwnInventory then
|
|
local isOpened = false
|
|
-- Try different ways to detect if an inventory is opened
|
|
|
|
-- Method 5.1: Check IsOpenedByPlayer if available
|
|
pcall(function()
|
|
if item.OwnInventory.IsOpenedByPlayer then
|
|
isOpened = item.OwnInventory.IsOpenedByPlayer
|
|
end
|
|
end)
|
|
|
|
-- Method 5.2: Check if inventory has visualSlots created
|
|
pcall(function()
|
|
if item.OwnInventory.visualSlots and #item.OwnInventory.visualSlots > 0 then
|
|
isOpened = true
|
|
end
|
|
end)
|
|
|
|
-- Method 5.3: Check if OpenState > 0
|
|
pcall(function()
|
|
if item.OwnInventory.OpenState and item.OwnInventory.OpenState > 0 then
|
|
isOpened = true
|
|
end
|
|
end)
|
|
|
|
if isOpened then
|
|
debugPrint("Found open container: " .. item.Name)
|
|
return item
|
|
end
|
|
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
|
|
|
|
-- 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]
|
|
|
|
-- Skip container items
|
|
if item.OwnInventory then
|
|
debugPrint("Skipping container item: " .. item.Name)
|
|
goto nextItem
|
|
end
|
|
|
|
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
|
|
|
|
::nextItem::
|
|
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
|
|
|
|
-- Find all containers in player inventory, including nested ones
|
|
local containers = findAllContainers(inventory, {})
|
|
|
|
debugPrint("Found " .. #containers .. " containers" .. (CONFIG.NESTED_CONTAINERS and " (including nested)" or ""))
|
|
if #containers == 0 then
|
|
debugPrint("No containers with inventory found!")
|
|
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
|
|
|
|
-- Process inventory slots
|
|
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]
|
|
|
|
-- Skip container items
|
|
if item.OwnInventory then
|
|
debugPrint("Skipping container item: " .. item.Name)
|
|
goto nextItem
|
|
end
|
|
|
|
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
|
|
|
|
::nextItem::
|
|
end
|
|
|
|
::continueSlot::
|
|
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")
|
|
pcall(function()
|
|
Game.PlaySound("hit")
|
|
end)
|
|
showNotification("Stacked " .. itemsMoved .. " items")
|
|
else
|
|
debugPrint("No matching items to stack")
|
|
showNotification("No matching items to stack")
|
|
end
|
|
end
|
|
|
|
-- Show a small message to the user when the mod loads
|
|
Hook.Add("think", "quickStackInitMessage", function()
|
|
-- Use a safer method to show a message
|
|
showNotification(MOD_NAME .. " loaded! Press F to stack items.")
|
|
Hook.Remove("think", "quickStackInitMessage")
|
|
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)
|