Inventory

-- SERVER SCRIPT:
local INVENTORY = script:FindAncestorByType("Inventory")
local DECAY_PERIOD = 5

function Tick()
    Task.Wait(DECAY_PERIOD)

    for _,item in pairs(INVENTORY:GetItems()) do
        local value, hasProperty = item:GetCustomProperty("Freshness")
        if hasProperty and value > 0 then
            item:SetCustomProperty("Freshness", value - 1)
        end
    end
end

-- CLIENT SCRIPT:
local INVENTORY = script:FindAncestorByType("Inventory")

function OnPropertyChanged(inventory, item, propertyName)
    local value = item:GetCustomProperty(propertyName)

    print("Item ".. item.name ..":".. propertyName .." = ".. tostring(value))

    if propertyName == "Freshness" then
        if value == 1 then
            print("One of your items is almost rotten!")

        elseif value == 0 then
            print(item.name .." is now rotten.")
        end
    end
end

INVENTORY.itemPropertyChangedEvent:Connect(OnPropertyChanged)

local INVENTORY_TEMPLATE = script:GetCustomProperty("Inventory")

function OnPlayerJoined(player)
    local inventory = World.SpawnAsset(INVENTORY_TEMPLATE)
    player.serverUserData.inventory = inventory

    inventory:Assign(player)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)

-- Add binding set action names as custom properties.
local SLOT1_ACTION = script:GetCustomProperty("Slot1Action")
local SLOT2_ACTION = script:GetCustomProperty("Slot2Action")

function DropItemFromSlot(player, slotNumber)
    local inventory = player:GetInventories()[1]
    if not inventory then return end

    local deltaZ = 100
    if player.isCrouching then
         deltaZ = 50
    end

    local params = {
        count = 1,
        position = player:GetWorldPosition() - Vector3.UP * deltaZ
    }

    if inventory:CanDropFromSlot(slotNumber, params) then
        inventory:DropFromSlot(slotNumber, params)
    end
end

function OnActionPressed(player, action)
    if action == SLOT1_ACTION then
        DropItemFromSlot(player, 1)
    elseif action == SLOT2_ACTION then
        DropItemFromSlot(player, 2)
    end
end

Input.actionPressedEvent:Connect(OnActionPressed)

function OnMove(player, fromSlot, toSlot)
    local inventory = player:GetInventories()[1]

    if inventory:CanMoveFromSlot(fromSlot, toSlot) then
        inventory:MoveFromSlot(fromSlot, toSlot)
    end
end

Events.ConnectForPlayer("MoveItemStack", OnMove)

local TRIGGER = script:GetCustomProperty("Trigger"):WaitForObject()

function PickUpItem(player, itemObject)
    local inventory = player:GetInventories()[1]
    if not inventory then return end

    local params = {all = true}

    if inventory:CanPickUpItem(itemObject, params) then
        inventory:PickUpItem(itemObject, params)
    end
end

function OnBeginOverlap(_, player)
    if player:IsA("Player") then
        local item = TRIGGER:FindAncestorByType("ItemObject")
        PickUpItem(player, item)
    end
end

TRIGGER.beginOverlapEvent:Connect(OnBeginOverlap)

local RESOURCE_NAME = script:GetCustomProperty("ScrapResourceName")

function Scrap(inventory, slotNumber)
    if inventory:CanRemoveFromSlot(slotNumber) then
        local item = inventory:GetItem(slotNumber)
        local resourceGain = item.count

        inventory:RemoveFromSlot(slotNumber)

        return resourceGain
    end
    return 0
end

function OnScrapItem(player, slotNumber)
    local inventory = player:GetInventories()[1]
    local resourceGain = Scrap(inventory, slotNumber)
    player:AddResource(RESOURCE_NAME, resourceGain)
end

Events.ConnectForPlayer("ScrapItem", OnScrapItem)

local function OnPlayerDied(player, _)
    for _,inventory in ipairs(player:GetInventories()) do
        inventory:ClearItems()
    end
end

local function OnPlayerJoined(player)
    player.diedEvent:Connect(OnPlayerDied)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)

function Compact(inventory)
    inventory:ConsolidateItems()
    inventory:SortItems()
end

function OnCompactInventories(player)
    for _,inventory in ipairs(player:GetInventories()) do
        Compact(inventory)
    end
end

Events.ConnectForPlayer("CompactInventories", OnCompactInventories)

local VERBOSE = false
local player = Game.GetLocalPlayer()
local currentInventory = nil

function RefreshInventoryUI()
    print("\nInventory:")

    for i = 1, currentInventory.slotCount do
        local item = currentInventory:GetItem(i)
        if item then
            print(item.name .." x"..item.count)

            if VERBOSE then
                print("  itemAssetId: "..item.itemAssetId)
                print("  itemTemplateId: "..item.itemTemplateId)
                print("  maxStackCount: "..item.maximumStackCount)
                print("  inventory: "..item.inventory.name)
                print("  slot: "..item.slot)
            end
        end
    end
end

while currentInventory == nil do
    currentInventory = player:GetInventories()[1]
    if currentInventory then
        currentInventory.changedEvent:Connect(RefreshInventoryUI)
        RefreshInventoryUI()
    else
        Task.Wait()
    end
end

function Tick()
    for _,player in ipairs(Game.GetPlayers()) do
        local inventories = player:GetInventories()
        local totalItems = 0
        for _,inventory in ipairs(inventories) do
            totalItems = totalItems + ComputeItemCount(inventory)
        end
        print(player.name.." has "..totalItems.." items across "..#inventories .." inventories.")
    end
    Task.Wait(3)
end

function ComputeItemCount(inventory)
    if inventory.occupiedSlotCount == 0 then return 0 end
    local total = 0
    for i = 1, inventory.occupiedSlotCount do
        local item = inventory:GetItem(i)
        if item then
            total = total + item.count
        end
    end
    return total
end

local INVENTORY_TEMPLATE = script:GetCustomProperty("InventoryWithPickup")

function OnPlayerDied(player, dmg)
    -- The player's inventory is dropped upon death
    local inventory = player.serverUserData.inventory
    player.serverUserData.inventory = nil
    inventory:Unassign()
    inventory:SetWorldPosition(player:GetWorldPosition())
end

function OnInteracted(trigger, player)
    -- Dead players cannot pickup an inventory
    if player.isDead then return end

    local inventory = trigger.parent
    if player.serverUserData.inventory == nil then
        -- The player picks up the inventory
        inventory:Assign(player)
        player.serverUserData.inventory = inventory

    elseif inventory.slotCount >= 1 then
        -- They already have an inventory. Transfer the items
        local targetInventory = player.serverUserData.inventory
        for i = 1,inventory.slotCount do
            if inventory:CanGiveSlot(i, targetInventory) then
                inventory:GiveSlot(i, targetInventory)
            end
        end
    end
end

function OnOwnerChanged(inventory)
    if Object.IsValid(inventory.owner) then
        -- Hide the inventory
        inventory.serverUserData.trigger.isInteractable = false
        inventory.visibility = Visibility.FORCE_OFF
    else
        -- Show the inventory
        inventory.serverUserData.trigger.isInteractable = true
        inventory.visibility = Visibility.INHERIT
    end
end

function OnPlayerJoined(player)
    -- Spawn inventory object
    local inventory = World.SpawnAsset(INVENTORY_TEMPLATE)
    -- Find the trigger
    local trigger = inventory:FindDescendantByType("Trigger")
    inventory.serverUserData.trigger = trigger
    -- Connect events
    player.diedEvent:Connect(OnPlayerDied)
    inventory.ownerChangedEvent:Connect(OnOwnerChanged)
    trigger.interactedEvent:Connect(OnInteracted)
    -- Assign to player
    player.serverUserData.inventory = inventory
    inventory:Assign(player)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)

local INVENTORY_TEMPLATE = script:GetCustomProperty("Inventory")

function SaveInventory(player, inventory)
    -- Serialize
    local inventoryData = {}
    for i,item in pairs(inventory:GetItems()) do
        inventoryData[item.itemAssetId] = item.count
    end
    -- Save to storage
    local data = Storage.GetPlayerData(player)
    data.inventory = inventoryData
    data.inventorySize = inventory.slotCount
    Storage.SetPlayerData(player, data)
end

function LoadInventory(player)
    local inventory = World.SpawnAsset(INVENTORY_TEMPLATE)
    -- Load from storage
    local data = Storage.GetPlayerData(player)
    -- Parse
    if data.inventorySize and data.inventory then
        inventory:Resize(data.inventorySize)
        for assetId,itemCount in pairs(data.inventory) do
            inventory:AddItem(assetId, {count = itemCount})
        end
    end
    return inventory
end

function OnPlayerJoined(player)
    local inventory = LoadInventory(player)
    player.serverUserData.inventory = inventory

    inventory:Assign(player)
end

function OnPlayerLeft(player)
    local inventory = player.serverUserData.inventory
    SaveInventory(player, inventory)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)
Game.playerLeftEvent:Connect(OnPlayerLeft)