Ultimate Inventory System

https://opsive.com/support/documentation/ultimate-inventory-system
Admin
The Ultimate Inventory System is a powerful, modular, and scalable framework for developers to...
Tokens:84,026
Snippets:705
Trust Score:8.3
Update:9 months ago
Show doc for...
Tokens:
Raw
### Example Interactable Behavior - C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/interaction-system

This C# code provides an example of how to create a custom Interactable Behavior. It demonstrates overriding methods for checking interaction possibility, handling selection/deselection events, and implementing the core interaction logic. It also shows how to cast the interactor to a specific type like IInteractorWithInventory to access inventory-related functionality.

```csharp
/// <summary>
/// Example Interactable Behavior.
/// </summary>
public class ExampleInteractableBehavior : InteractableBehavior
{
    /// <summary>
    /// can the interactor interact with this component.
    /// </summary>
    /// <param name="interactor">The interactor.</param>
    /// <returns>Returns true if it can interact.</returns>
    public override bool CanInteract(IInteractor interactor)
    {
        return base.CanInteract(interactor);
    }
    /// <summary>
    /// The event called when the interactable is selected by an interactor.
    /// </summary>
    /// <param name="interactor">The interactor.</param>
    public override void OnSelect(IInteractor interactor)
    {
        base.OnSelect(interactor);
        // Do something.
    }
    /// <summary>
    /// The event when the interactable is no longer selected.
    /// </summary>
    /// <param name="interactor">The interactor.</param>
    public override void OnDeselect(IInteractor interactor)
    {
        base.OnDeselect(interactor);
        // Do something.
    }
    
    /// <summary>
    /// On Interaction.
    /// </summary>
    /// <param name="interactor">The interactor.</param>
    protected override void OnInteractInternal(IInteractor interactor)
    {
        // If you require the interactor to be an inventory interactor.
        if (!(interactor is IInteractorWithInventory interactorWithInventory)) { return; }
        var inventory = interactorWithInventory.Inventory;
        // Do something.
    }
}
```

--------------------------------

### Get Item Attributes by Type and Name (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/attributes

Demonstrates how to retrieve attribute values from an item using its type and name. This includes getting specific typed attributes like 'Attack' and generic attributes like 'Icon'. It also shows how to count and access attributes by index.

```csharp
// Retrieves an attack attribute value by getting its attribute.
var attackAttribute = item.GetAttribute<Attribute<int>>("Attack");
if (attackAttribute != null) {
    // The real attack value.
    var myAttack = attackAttribute.GetValue();
    // The override attack value.
    var myAttackOverride = attackAttribute.OverrideValue;
    // The inherited attack value.
    var myAttackInherited = attackAttribute.GetInheritedValue();
}

// Retrieves an icon attribute value.
if (item.TryGetAttributeValue("Icon", out Sprite myIcon)) {
    // myIcon exists.
}

// Loops through the Item attributes.
var indludeItemDefinitionAttributes = true;
var includeItemCategoryAttributes = true;
var attributeCount = item.GetAttributeCount(indludeItemDefinitionAttributes,includeItemCategoryAttributes);
for (int i = 0; i < attributeCount; i++) {
    var attribute = item.GetAttributeAt(i, indludeItemDefinitionAttributes,includeItemCategoryAttributes);
    // We don't know the type of the attributes but we can get their values as objects.
    Debug.Log(attribute.GetValueAsObject());
}
```

--------------------------------

### Custom Item View Drop Action Example (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/item-view-slots-container/move-items-drag-drop

Shows how to create a custom drop action by inheriting from the 'ItemViewDropAction' abstract class. The 'Drop' method is overridden to implement the desired action when an item is dropped.

```csharp
// Action.
[Serializable]
public class ItemViewDropMoveIndexAction : ItemViewDropAction
{
    public override void Drop(ItemViewDropHandler itemViewDropHandler)
    {
        itemViewDropHandler.SourceContainer.MoveItem(itemViewDropHandler.StreamData.SourceIndex, itemViewDropHandler.StreamData.DestinationIndex);
    }
}
```

--------------------------------

### Accessing and Using Display Panel Manager (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/display-panel-manager

Demonstrates how to retrieve the Display Panel Manager, its Panel Owner, and individual panels by name. It also shows how to open and close panels, get the currently selected panel/menu, and register for panel open/close events.

```csharp
// Get the Display Panel Manager by ID from the Inventory System Manager singleton.
var displayPanelManager = InventorySystemManager.GetDisplayPanelManager(ID);

// Get the Panel Owner. It is a GameObject, usually the character GameObject with the Inventory component.
// The panel owner also receives events about panels opening/closing and more.
var panelOwner = displayPanelManager.PanelOwner;

// Get a panel by the panel name.
var panel = displayPanelManager.GetPanel(panelName);

// Open a panel from the panel managers, this uses the current selected panel as the previous panel.
displayPanelManager.OpenPanel(panel);

// Get the selected panel.
var selectedPanel = displayPanelManager.SelectedDisplayPanel;

// Get the selected menu.
var selectedMenu = displayPanelManager.SelectedDisplayMenu;

// Close the selected panel.
displayPanelManager.CloseSelectedPanel();

// Register to the event for opening/closing panels, (All events can be found in EventNames.cs)
```

--------------------------------

### Assign and Use Items in Hotbar

Source: https://opsive.com/support/documentation/ultimate-inventory-system/editor-window/item-hotbar

These C# code examples demonstrate how to assign an item to a specific slot in the hotbar and how to use an item from a hotbar slot. This functionality is crucial for interactive inventory systems.

```csharp
hotbar.AssignItemToSlot(itemInfo, itemSlotIndex);

hotbar.UseItem(itemSlotIndex);
```

--------------------------------

### Custom Item View Drop Condition Example (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/item-view-slots-container/move-items-drag-drop

Demonstrates how to create a custom drop condition by inheriting from the 'ItemViewDropCondition' abstract class. The 'CanDrop' method is overridden to implement the specific condition logic.

```csharp
// Condition.
[Serializable]
public class ItemViewDropSameContainerCondition : ItemViewDropCondition{
    public override bool CanDrop(ItemViewDropHandler itemViewDropHandler)
    {
        return itemViewDropHandler.SourceContainer == itemViewDropHandler.DestinationContainer;
    }
}
```

--------------------------------

### Get Item Infos from Collection with Filters - C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory/item-collections

Retrieves a list of item information from the item collection, allowing for filtering and sorting. This example demonstrates filtering by item category and emphasizes the use of pooled arrays for performance and memory management, requiring the pooled array to be returned after use.

```csharp
//You can get multiple items from your item collection.
//You'll need an array to store your item infos.
var array = new ItemInfo[0];
//You can use a pooled array instead of creating a new array each time.
IMPORTANT: make sure to return the pooled array once you finished using it.
var pooledArray = GenericObjectPool.Get<ItemInfo[]>();

//Set your filter and sort parameters, for this example we'll filter by category.
var filterParameter = InventorySystemManager.GetItemCategory("MyCategory");

//Item info list slice will have all the itemInfos in the inventory that contain inherits the category.
//You can set whatever filter parameter you want.
var itemInfoListSlice = itemCollection.GetItemInfos(ref pooledArray, filterParameter,
    //Specify your filter.
    (candidateItemInfo, category) => { return category.InherentlyContains(candidateItemInfo.Item); });

//IMPORTANT: Don't forget to return the pooled array once you finished using the array.
GenericObjectPool.Return(pooledArray);
```

--------------------------------

### Getting Inventory Components with Inventory System Manager

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory-system-manager

Shows how to retrieve various management and data components associated with the inventory system using the InventorySystemManager.Get methods. This includes accessing display panel managers, inventory identifiers, cursors, and specific inventory containers like hotbars and grids.

```csharp
// Get a Display Panel Manager
var panelManager = InventorySystemManager.GetDisplayPanelManager(id);

// Get an Inventory Identifier by ID (a component which sits next to an Inventory)
var inventoryIdentifier = InventorySystemManager.GetInventoryIdentifier(id);
var inventory = inventoryIdentifier.Inventory;

// Get an Item View Slot Cursor Manager, which is used for drag & drop
var itemViewSlotCursorManager = InventorySystemManager.GetItemViewSlotCursorManager(id);

// Get Item View Slot Containers using their panel names and the panel manager id
var itemHotbar = InventorySystemManager.GetItemViewSlotContainer<ItemHotbar>(id, "Item Hotbar");
var inventoryGrid = InventorySystemManager.GetItemViewSlotContainer<InventoryGrid>(id,"Inventory Grid");
```

--------------------------------

### Unregistering Panel Events (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/display-panel-manager

Provides an example of how to unregister from panel open/close events using the EventHandler. This is important for managing event subscriptions and preventing memory leaks.

```csharp
EventHandler.UnregisterEvent<PanelEventData>(m_PanelOwner, EventNames.c_GameObject_OnPanelOpenClose_PanelEventData, PanelOpenedOrClosed);
```

--------------------------------

### Get Currency and Create Currency Amount (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/currency

This snippet demonstrates how to retrieve a currency object by its name and create a currency amount with a specified value and currency. It also shows a shorthand syntax for creating currency amounts.

```csharp
var dollars = InventorySystemManager.GetCurrency("Dollars");

var fiftyDollars1 = new CurrencyAmount(50, dollars);

var fiftyDollars2 = (50, dollars);
```

--------------------------------

### Interact with SaveSystemManager API in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/save-system

This C# code demonstrates how to use the SaveSystemManager API for common save file operations. It includes examples for saving, loading, and deleting save files using a specified slot index. It also shows how to retrieve the current save data information and specific cached serialized data.

```csharp
// Save in file 0
SaveSystemManager.Save(0);

// Load in file 0
SaveSystemManager.Load(0);

// Delete save at file 0
SaveSystemManager.DeleteSave(0);

// Get the current state of the cached save data
var saveData = SaveSystemManager.GetCurrentSaveDataInfo();

// Get the cached serialized data of a specific Saver component
var saveData = SaveSystemManager.TryGetSaveData("The Saver Key", out var serializedData);
```

--------------------------------

### Get All Items in Inventory

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory

Retrieves all item information from the inventory, excluding specified collections like 'Hide' and 'Loadout'. This is useful for displaying a comprehensive list of all items a character possesses.

```csharp
// Get all the items in the inventory (includes all the item collections except the ignored ones 'Hide' and 'Loadout')
var allItems = inventory.AllItemInfos;
```

--------------------------------

### Set Item Attribute Values at Runtime (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/attributes

Illustrates how to set attribute values on an item at runtime, provided the item is mutable. This includes changing variant types, setting override values, and defining modify expressions for attributes. It also provides an example for handling complex attribute types like 'Slots' which require careful management of inherited values.

```csharp
if (!item.IsMutable) {
    // Immutable items cannot have their attribute set.
}

// Retrieves an attack attribute.
var attackAttribute = item.GetAttribute<Attribute<int>>("Attack");
if (attackAttribute != null) {
    // The variant type can be changed.
    attackAttribute.SetVariantType(VariantType.Inherit);
    // Sets a new attack of 10. This will automatically set the Variant Type to Override.
    attackAttribute.SetOverrideValue(10);
    // Sets a new modify expression. This will automatically set the Variant Type to Modify and mark it as pre-evaluated.
    attackAttribute.SetModifyExpression("<Inherited> + 5",true);
}

// Be careful when using classes.
var itemSlotsAttribute = item.GetAttribute<Attribute<ItemAmounts>>("Slots");
if (itemSlotsAttribute != null) {
    var itemSlots = itemSlotsAttribute.GetValue();
    // Do not change the itemSlots directly as it might be inherited!
    // The overriding value should be checked first.
    if (itemSlots == itemSlotsAttribute.OverrideValue) {
        // The itemSlots can be modified.
        itemSlots.Add(newItem);
    } else {
        // The itemSlots is inherited form another object. The content should first be copied.
        itemSlots = new ItemAmounts(itemSlots);
        itemSlots.Add(newItem); 
        // Do not forget to set the new itemSlots value to the attribute.
        itemSlotsAttribute.SetOverrideValue(itemSlots);
    }
}
```

--------------------------------

### Manage Items in Slots (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/item-view-slots-container

Provides C# examples for directly manipulating items within the Item View Slots Container. This includes adding, removing, and moving items between specific slots, as well as retrieving item information or views from a slot.

```csharp
// Get the list of Item View Slots.
var itemViewSlots = m_ItemViewSlotContainer.ItemViewSlots;

// Add, Remove or Move items to specific slots.
m_ItemViewSlotContainer.AddItem(itemInfo, slotIndex);
m_ItemViewSlotContainer.RemoveItem(itemInfo, slotIndex);
m_ItemViewSlotContainer.MoveItem(sourceIndex, destinationIndex);

// Get the item in a slot.
var itemViewSlot = m_ItemViewSlotContainer.GetItemViewSlot(slotIndex);
var itemView = m_ItemViewSlotContainer.GetItemView(slotIndex);
var itemInfo = m_ItemViewSlotContainer.GetItemAt(slotIndex);
```

--------------------------------

### Get Item Info by Item Reference (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory

Retrieves the first item stack in the inventory that matches a given item reference. If no matching item stack is found, the result will indicate its absence. This is useful for locating specific items before performing actions like removal.

```csharp
//You can get the first matching item stack to an item.
var retrievedItemInfo = inventory.GetItemInfo(myItem);
if (retrievedItemInfo.HasValue == false) {
    //No item stack with that description was found in the inventory.
}
```

--------------------------------

### Trigger Dropper Component in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item-objects/item-and-currency-droppers

This C# code shows how to manually trigger a Dropper component to drop items or currency. You can get a reference to the specific dropper component (e.g., ItemDropper, CurrencyDropper) and call its 'Drop()' method. It also illustrates dropping specific items or inventories.

```csharp
using Opsive.UltimateInventorySystem.Core;
using Opsive.UltimateInventorySystem.Core.InventoryHelpers;
using Opsive.UltimateInventorySystem.ItemDrop;
using Opsive.UltimateInventorySystem.Items;
using UnityEngine;

public class DropperTriggerExample : MonoBehaviour
{
    public ItemDropper itemDropper;
    public CurrencyDropper currencyDropper;
    public RandomItemDropper randomItemDropper;
    public RandomCurrencyDropper randomCurrencyDropper;

    // Example of dropping all items from the ItemDropper
    public void DropAllItems() {
        if (itemDropper != null) {
            itemDropper.Drop();
        }
    }

    // Example of dropping a specific item pickup
    public void DropSpecificItem(ItemPickup itemPickup) {
        if (itemDropper != null) {
            itemDropper.DropItemPickup(itemPickup);
        }
    }

    // Example of dropping an inventory of items
    public void DropInventory(Inventory inventory) {
        if (itemDropper != null) {
            // Assuming itemList is a List<Item> from the inventory
            // itemDropper.DropInventoryPickup(inventory.GetAllItems()); 
        }
    }

    // Other dropper types can be triggered similarly using their respective Drop() methods.
}
```

--------------------------------

### Manually Call Drop Item Action in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item-actions

This C# code snippet demonstrates how to directly call an item action, specifically the 'DropItemAction'. It requires obtaining the ItemInfo, the ItemAction itself, and the ItemUser. The code handles retrieving item information, adjusting the amount, getting the item user, creating and initializing the action, and finally invoking it. It also shows how to optionally check if the action can be invoked and access any extra data returned by the action.

```csharp
public void ManuallyCallDropItemAction()
{
    //To call an item action directly in code you will need 3 things
    //1) The ItemInfo
    //2) The ItemAction
    //3) The ItemUser

    //First get the item you want. Here we'll get the first stack of apples we find.
    var result = m_Inventory.GetItemInfo(InventorySystemManager.GetItemDefinition("Apple"));
    
    //if the result does not have a value we do no have Apples in the inventory
    if(result.HasValue == false){ return; }
    //We have the apple ItemInfo now.
    var appleItemInfo = result.Value;
    
    //Lets trim to 2 apples maximum
    appleItemInfo = new ItemInfo(Mathf.Max(2, appleItemInfo.Amount), appleItemInfo);
    
    //Lets get the ItemUser. This is usually placed of the same gameobject as the Inventory, but not always
    var itemUser = m_Inventory.GetComponent<ItemUser>();
    
    //now lets create the drop item action, You can cache this object and reuse it if you which for more performance.
    var dropItemAction = new DropItemAction();
    
    //You must initialize the item action before using it. This can be only once
    dropItemAction.Initialize(false);
    
    //OPTIONAL: check if you are allowed to invoke the action (it will do this anyways internally)
    var canInvoke = dropItemAction.CanInvoke(appleItemInfo, itemUser);
    
    //Invoke the action
    dropItemAction.InvokeAction(appleItemInfo, itemUser);
    
    //For some actions you'll even have extra data you can use
    //For example drop action keeps track of the last dropped pickup object
    var droppedPickup = dropItemAction.PickUpGameObject;
}

```

--------------------------------

### Accessing and Interacting with Item Slot Collection (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory/item-collections/item-slot-collection

Demonstrates how to retrieve an Item Slot Collection from the inventory and perform common operations like adding, getting, and removing items. It shows usage with both slot indices and slot names, and how to find item slot locations.

```csharp
// Get the Item Slot Collection within the inventory using Get Item Collection and cast it to its type.
var equipmentItemCollection = m_Inventory.GetItemCollection(m_EquipmentItemCollectionID) as ItemSlotCollection;

//Use the slot Index to add, get and remove.
var itemAdded = equipmentItemCollection.AddItem(itemInfo, slotIndex);
var itemInSlot = equipmentItemCollection.GetItemInfoAtSlot(slotIndex);
var itemRemoved = equipmentItemCollection.RemoveItem(slotIndex, amountToRemove);

//Or use the slot name.
itemAdded = equipmentItemCollection.AddItem(itemInfo, slotName);
itemInSlot = equipmentItemCollection.GetItemInfoAtSlot(slotName);
itemRemoved = equipmentItemCollection.RemoveItemInSlot(slotName, amountToRemove);

var item = equipmentItemCollection.GetAllItemStacks()[0];

//Might not be equal to.
var otherItem = equipmentItemCollection.GetItemInfoAtSlot(0);
Item myItem = InventorySystemManager.CreateItem("myItem");

//Gets the slot where the item actually is.
var realSlotIndex = equipmentItemCollection.GetItemSlotIndex(myItem);

//Get the index where the item could potentially fit if it was added.
var potentialSlotIndex = equipmentItemCollection.GetTargetSlotIndex(myItem);
```

--------------------------------

### Custom Multi Filter Sorter Implementation (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/item-info-filter-sorters

An example implementation of a custom multi-filter sorter that inherits from ItemInfoFilterSorterBase. It applies a sequence of filters and sorters to a list of ItemInfo objects, processing them in the order they are provided. The CanContain method checks if an ItemInfo satisfies all combined filters.

```csharp
public class ItemInfoMultiFilterSorter : ItemInfoFilterSorterBase
{
    [SerializeField] internal List<ItemInfoFilterSorterBase> m_GridFilters;
    public List<ItemInfoFilterSorterBase> GridFilters => m_GridFilters;
    
    public override ListSlice<ItemInfo> Filter(ListSlice<ItemInfo> input, ref ItemInfo[] outputPooledArray)
    {
        var list = input;
        for (int i = 0; i < m_GridFilters.Count; i++) {
            list = m_GridFilters[i].Filter(list, ref outputPooledArray);
        }
        return list;
    }
    public override bool CanContain(ItemInfo input)
    {
        for (int i = 0; i < m_GridFilters.Count; i++) {
            if (m_GridFilters[i].CanContain(input)) { continue; }
            return false;
        }
        return true;
    }
}
```

--------------------------------

### Create Custom Amount Item View Module (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/views/item-view

Demonstrates how to create a custom Item View Module in C# by inheriting from the 'ItemViewModule' base class. This example specifically creates an 'AmountItemView' to display the item's amount, with an option to hide it if the amount is 1 or less. It utilizes Unity's 'SerializeField' for UI element assignment and 'Tooltip' for editor hints.

```csharp
/// <summary>
/// An item box component to display an amount.
/// </summary>
public class AmountItemView : ItemViewModule
{
    [Tooltip("The amount text.")]
    [SerializeField] protected Text m_AmountText;
    [Tooltip("Do not show amount if it is 1 or lower.")]
    [SerializeField] protected bool m_HideAmountIfSingle;

    /// <summary>
    /// Set the value.
    /// </summary>
    /// <param name="info">The item info.</param>
    public override void SetValue(ItemInfo info)
    {
        if (m_HideAmountIfSingle && info.Amount <= 1) {
            m_AmountText.text = "";
        } else {
            m_AmountText.text = $"x {info.Amount}";
        }
    }

    /// <summary>
    /// Clear the value.
    /// </summary>
    public override void Clear()
    {
        m_AmountText.text = "";
    }
}
```

--------------------------------

### Currency Owner Management in C# - Ultimate Inventory System

Source: https://opsive.com/support/documentation/ultimate-inventory-system/currency

Demonstrates how to interact with the Currency Owner component to manage in-game currency. This includes retrieving currency owners, accessing currency collections, and performing operations like adding, getting, removing, and setting currency amounts. It utilizes the InventorySystemManager and CurrencyOwner classes.

```csharp
var inventory = InventorySystemManager.GetInventoryIdentifier(0).Inventory;

// Get the currencyOwner from an Inventory
var currencyOwner = inventory.GetCurrencyComponent<CurrencyCollection>() as CurrencyOwner;
// Or get it directly from the Inventory Identifier.
currencyOwner = InventorySystemManager.GetInventoryIdentifier(0).CurrencyOwner;

// Get the Currency Collection from the owner.
var ownerCurrencyCollection = currencyOwner.CurrencyAmount;

// Get currency from the Inventory System Manager.
var gold = InventorySystemManager.GetCurrency("Gold");
var silver = InventorySystemManager.GetCurrency("Silver");

// Create currency Collections anywhere you need them.
CurrencyCollection otherCurrencyCollection = new CurrencyCollection();
otherCurrencyCollection.AddCurrency(new CurrencyAmount[] {(10, silver), (10, gold)});

// Add Currency.
ownerCurrencyCollection.AddCurrency(gold, 10);
ownerCurrencyCollection.AddCurrency(new CurrencyAmount[] { (10 ,silver), (10 ,gold)});
ownerCurrencyCollection.AddCurrency(otherCurrencyCollection);

// Get Currency.
ownerCurrencyCollection.GetAmountOf(gold); // returns only gold amount
ownerCurrencyCollection.GetAmountOf(silver); // returns only silver amount
// GetFullAmountAsRootCurrency returns the sum of currencies that share the same root
// Example 30 gold, 30 silver, 0 bronze (1 gold == 100 silver, 1 silver == 100 bronze)
// The function will return 30*10000+30*100+0 => 303000 
ownerCurrencyCollection.GetFullAmountAsRootCurrency(gold); 

// Remove Currency
ownerCurrencyCollection.RemoveCurrency(gold, 10);
ownerCurrencyCollection.RemoveCurrency(new CurrencyAmount[] { (10 ,silver), (10 ,gold)});
ownerCurrencyCollection.RemoveCurrency(otherCurrencyCollection);

// Set Currency
ownerCurrencyCollection.SetCurrency(new CurrencyAmount[] { (10 ,silver), (10 ,gold)});
ownerCurrencyCollection.SetCurrency(otherCurrencyCollection);

// Remove All
ownerCurrencyCollection.RemoveAll();
```

--------------------------------

### Item Binding Property Example (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item-objects/item-binding

Demonstrates how to define a C# property for use with the Item Binding component. It highlights the difference between a serialized field and a public property, which is necessary for the binding to function correctly. The property ensures that changes to the attribute value are reflected in the component.

```csharp
// This is a field.
[SerializeField] protected int m_BulletsPerFire;

// This is a property.
public int BulletsPerFire
{
    get => m_BulletsPerFire;
    set => m_BulletsPerFire = value;
}
```

--------------------------------

### Item Attribute API

Source: https://opsive.com/support/documentation/ultimate-inventory-system/attributes

This section details how to get and set attribute values for items. Attributes can be found in Item Categories, Item Definitions, and Items. The methods for getting and setting attribute values are similar across these object types.

```APIDOC
## Item Attribute API

### Description
This API allows you to retrieve and modify attribute values associated with inventory items. Attributes are fundamental properties that define an item's characteristics, such as attack power, icon, or slot capacity. You can access attributes directly, check for their existence, iterate through them, and retrieve their values in various formats.

### Method
This documentation covers methods for both retrieving and setting attributes. Specific HTTP methods are not applicable as this describes runtime code execution within the inventory system.

### Endpoint
N/A (Runtime code execution)

### Parameters

#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```csharp
// Retrieves an attack attribute value by getting its attribute.
var attackAttribute = item.GetAttribute<Attribute<int>>("Attack");
if (attackAttribute != null) {
    // The real attack value.
    var myAttack = attackAttribute.GetValue();
    // The override attack value.
    var myAttackOverride = attackAttribute.OverrideValue;
    // The inherited attack value.
    var myAttackInherited = attackAttribute.GetInheritedValue();
}

// Retrieves an icon attribute value.
if (item.TryGetAttributeValue("Icon", out Sprite myIcon)) {
    // myIcon exists.
}

// Loops through the Item attributes.
var indludeItemDefinitionAttributes = true;
var includeItemCategoryAttributes = true;
var attributeCount = item.GetAttributeCount(indludeItemDefinitionAttributes,includeItemCategoryAttributes);
for (int i = 0; i < attributeCount; i++) {
    var attribute = item.GetAttributeAt(i, indludeItemDefinitionAttributes,includeItemCategoryAttributes);
    // We don't know the type of the attributes but we can get their values as objects.
    Debug.Log(attribute.GetValueAsObject());
}
```

### Response

#### Success Response (200)
Attribute values are returned directly or through methods like `GetValue()`, `OverrideValue`, and `GetInheritedValue()`.

#### Response Example
```csharp
// Example of retrieving an integer attribute value
int attackValue = attackAttribute.GetValue(); 

// Example of checking if an attribute exists
bool iconExists = item.TryGetAttributeValue("Icon", out Sprite myIcon);

// Example of retrieving an attribute as an object
object attributeValue = attribute.GetValueAsObject();
```

### Setting Attribute Values

**Important:** Attribute values can only be set at runtime if the item is mutable. An item's mutability is determined by its Item Category.

```csharp
if (!item.IsMutable) {
    // Immutable items cannot have their attribute set.
    Debug.LogError("Item is not mutable. Cannot set attribute values.");
    return;
}

// Retrieves an attack attribute.
var attackAttribute = item.GetAttribute<Attribute<int>>("Attack");
if (attackAttribute != null) {
    // The variant type can be changed.
    attackAttribute.SetVariantType(VariantType.Inherit);
    // Sets a new attack of 10. This will automatically set the Variant Type to Override.
    attackAttribute.SetOverrideValue(10);
    // Sets a new modify expression. This will automatically set the Variant Type to Modify and mark it as pre-evaluated.
    attackAttribute.SetModifyExpression("<Inherited> + 5",true);
}

// Be careful when using classes.
var itemSlotsAttribute = item.GetAttribute<Attribute<ItemAmounts>>("Slots");
if (itemSlotsAttribute != null) {
    var itemSlots = itemSlotsAttribute.GetValue();
    // Do not change the itemSlots directly as it might be inherited!
    // The overriding value should be checked first.
    if (itemSlots == itemSlotsAttribute.OverrideValue) {
        // The itemSlots can be modified.
        itemSlots.Add(newItem);
    } else {
        // The itemSlots is inherited form another object. The content should first be copied.
        itemSlots = new ItemAmounts(itemSlots); // Create a new instance from the inherited value
        itemSlots.Add(newItem);
        // Do not forget to set the new itemSlots value to the attribute.
        itemSlotsAttribute.SetOverrideValue(itemSlots);
    }
}
```
```

--------------------------------

### Buy and Sell Items from Shop (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/editor-window/shop

Provides methods for buying and selling items from a shop. It requires the buyer's/seller's inventory, currency owner, the item, and the amount. The process can fail and return false.

```csharp
/// <summary>
/// Buy an item from the shop.
/// </summary>
/// <param name="buyerInventory">The inventory of the buyer.</param>
/// <param name="currencyOwnerBase">The currency owner of the buyer.</param>
/// <param name="item">The item to buy.</param>
/// <param name="amount">The amount to buy.</param>
/// <returns>The process can fail returning false.</returns>        
BuyItem(Inventory buyerInventory, ICurrencyOwner currencyOwnerBase, Item item, int amount)

/// <summary>
/// Sell an item to the shop.
/// </summary>
/// <param name="sellerInventory">The inventory of the seller.</param>
/// <param name="currencyOwnerBase">The currency owner of the seller.</param>
/// <param name="item">The item being sold.</param>
/// <param name="amount">The amount being sold.</param>
/// <returns>The process can fail returning false.</returns>
SellItem(Inventory sellerInventory, ICurrencyOwner currencyOwnerBase, Item item, int amount)
```

--------------------------------

### Creating Items at Runtime with Inventory System Manager

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory-system-manager

Illustrates the various ways to create items at runtime using the InventorySystemManager.CreateItem method. This includes creating items by name, using an Item Definition, specifying an ID, or creating a copy of an existing item.

```csharp
// Create an item using its name
InventorySystemManager.CreateItem("ItemName");

// Create an item with its Item Definition
InventorySystemManager.CreateItem(itemDefinition);

// Specify the ID you wish your item should have (useful when saving or using a server/client)
InventorySystemManager.CreateItem(itemDefinition, itemID);

// Create a copy of an Item
InventorySystemManager.CreateItem(item);
```

--------------------------------

### Get or Set Item Attribute Value - C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item

Retrieves a specific attribute from an Item and allows for getting or setting its value. This is crucial for modifying item properties at runtime, but setting override values is restricted to mutable items.

```csharp
// Change an attribute value on the sword item
var attackAttribute = sword.GetAttribute<Attribute<int>>("Attack");
// Get the attribute value
var attack = attackAttribute.GetValue();
// Setting the override value at runtime is only allowed on Mutable Items.
attackAttribute.SetOverrideValue(attack + 5);
```

--------------------------------

### Get Item View Slot and Item Slot from Collection View - C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/item-view-slots-container/item-slot-collection-view-equipment

Demonstrates how to retrieve an Item View Slot by its name and subsequently get the associated Item Slot from the Item Slot Collection View. This is useful for accessing specific equipment slots.

```csharp
var headItemViewSlot = m_ItemSlotCollectionView.GetItemViewSlot("Head");
var headItemSlot = m_ItemSlotCollectionView.GetItemSlot(headItemViewSlot );
```

--------------------------------

### ItemInfo Constructors in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item/item-info

Demonstrates various ways to instantiate the ItemInfo struct using different combinations of item, amount, item stack, and item collection data. These constructors allow for both explicit and implicit creation of ItemInfo objects.

```csharp
new ItemInfo(itemAmount, itemCollection, itemStack);
new ItemInfo("MyItem", 1);
new ItemInfo(item, amount);
new ItemInfo(itemAmount);
new ItemInfo(itemStack);
new ItemInfo(itemAmount, otherItemInfo);
new ItemInfo(amount, otherItemInfo);
new ItemInfo(itemDefinition, amount);
new ItemInfo(otherItemInfo, amount);
new ItemInfo(amount, item);
```

--------------------------------

### Access Inventory and Display Panel Managers - C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/getting-started/version-1-1-update-guide

This C# code demonstrates how to access the Inventory System Manager singleton to retrieve inventory data and control display panels. It requires the Inventory System to be initialized.

```csharp
var inventory = InventorySystemManager.GetInventoryIdentifier(1).Inventory;

// Add Items by name.
inventory.AddItem("potion", 3);

// Get the panel manager.
var displayPanelManager = InventorySystemManager.GetDisplayPanelManager(1);

// Open a Display Panel by name.
displayPanelManager.OpenPanel("Main Menu");
```

--------------------------------

### Custom Item Collection Filter Example (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/item-view-slots-container/item-info-filter-sorters

An example of a custom filter that shows or hides items based on their ItemCollection. It uses two arrays, m_ShowItemCollections and m_HideItemCollections, to define the filtering criteria. If m_ShowItemCollections is empty, all items are initially considered showable.

```csharp
using Opsive.UltimateInventorySystem.Core.Data.State;
using Opsive.UltimateInventorySystem.ItemFilterSorters;
using UnityEngine;

public class ItemInfoItemCollectionFilter : ItemInfoFilterBase
{
    [Tooltip("The item collections to show, Show all if null.")]
    [SerializeField]    protected ItemCollectionID[] m_ShowItemCollections;
    [Tooltip("The item collections that should not be drawn.")]
    [SerializeField]    protected ItemCollectionID[] m_HideItemCollections =
        { ItemCollectionPurpose.Loadout, ItemCollectionPurpose.Hide };

    // Return true to show the item, false to hide it.
    public override bool Filter(ItemInfo itemInfo)
    {
        var show = m_ShowItemCollections.Length == 0;
                for (int i = 0; i < m_ShowItemCollections.Length; i++) {
            if (!m_ShowItemCollections[i].Compare(itemInfo.ItemCollection)) { continue; }
            show = true;
            break;
        }
        if (show == false) { return false;}
                for (int i = 0; i < m_HideItemCollections.Length; i++) {
            if (m_HideItemCollections[i].Compare(itemInfo.ItemCollection)) { return false; }
        }
        return true;
    }
}
```

--------------------------------

### Buy and Sell Items using Shop

Source: https://opsive.com/support/documentation/ultimate-inventory-system/currency/shop

Functions to buy and sell items from the shop. These functions interact with inventory and currency systems to process transactions. They can fail and return false if the transaction cannot be completed.

```csharp
/// <summary>
/// Buy an item from the shop.
/// </summary>
/// <param name="buyerInventory">The inventory of the buyer.</param>
/// <param name="currencyOwnerBase">The currency owner of the buyer.</param>
/// <param name="item">The item to buy.</param>
/// <param name="amount">The amount to buy.</param>
/// <returns>The process can fail returning false.</returns>        	
BuyItem(Inventory buyerInventory, ICurrencyOwner currencyOwnerBase, Item item, int amount)

/// <summary>
/// Sell an item to the shop.
/// </summary>
/// <param name="sellerInventory">The inventory of the seller.</param>
/// <param name="currencyOwnerBase">The currency owner of the seller.</param>
/// <param name="item">The item being sold.</param>
/// <param name="amount">The amount being sold.</param>
/// <returns>The process can fail returning false.</returns>
SellItem(Inventory sellerInventory, ICurrencyOwner currencyOwnerBase, Item item, int amount)
```

--------------------------------

### Control Display Panel - Ultimate Inventory System

Source: https://opsive.com/support/documentation/ultimate-inventory-system/ui/display-panel-manager

Demonstrates how to interact with Display Panels using the Panel Manager. Includes methods for opening and closing panels, accessing panel state, and retrieving related objects like the previous panel or selectable.

```csharp
// Open the panel using the Panel Manager which uses the currently selected panel.
panel.SmartOpen();
panel.SmartClose();

// Get references to the objects and the state of the panel.
DisplayPanel previousPanel = panel.PreviousePanel;
Selectable previousSelectable = panel.PreviousSelectable;
bool isOpen = panel.IsOpen;
var panelManager = panel.Manager;
string panelName = panel.UniqueName;
List<DisplayPanelBinding> panelBindings = panel.Bindings;

// Open the panel specifying the previous panel and selectable.
panel.Open(previousPanel, previousSelectable)

// Close the panel where the parameter selectPrevious is a bool which true will open the previous panel once this one is closed.
panel.Close( true )
```

--------------------------------

### Getting an Item from an Item Collection

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item

Explains how to retrieve an ItemInfo object for a given item from an item collection. Returns a nullable ItemInfo if the item is found.

```APIDOC
## Getting an Item from an Item Collection

### Description
Retrieve information about an item currently present in an item collection. The method returns a nullable ItemInfo structure containing the amount and a reference to the item stack.

### Method
`ItemCollection.GetItemInfo(Item item)`

### Endpoint
N/A (These are class methods)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Assume itemCollection is an initialized ItemCollection object
var swordItem = InventorySystemManager.CreateItem("Sword");

// Get an item from the item collection, it returns a nullable Item Info.
var itemInfoResult = itemCollection.GetItemInfo(swordItem);

// If the item does not exist in the item collection the result will be null.
if (itemInfoResult.HasValue == false) {
    // The item does not exist.
} else {
    // The item was found in the Item Collection.
    var swordItemInfo = itemInfoResult.Value;
    // The Item Info has the amount and reference to the item stack.
}
```

### Response
#### Success Response (200)
- **Nullable<ItemInfo>** - A nullable structure containing `ItemInfo` if the item exists in the collection, otherwise null.
  - **ItemInfo.Value** (ItemInfo object) - Contains the amount and reference to the item stack.

#### Response Example
```json
{
  "hasValue": true,
  "value": {
    "item": {
      "itemName": "Sword",
      "id": 54321
    },
    "amount": 1
  }
}
```
```

--------------------------------

### Create Item from Definition

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory/item-collections

Demonstrates how to create an item instance from a predefined item definition. This can be done either by first retrieving the ItemDefinition object or by directly using the item definition's name.

```csharp
var myItemDefinition = InventorySystemManager.GetItemDefinition("MyItemDefinition");
var myItem = InventorySystemManager.CreateItem(myItemDefinition);

var myOtherItem = InventorySystemManager.CreateItem("MyOtherItemDefinition");
```

--------------------------------

### Spawn Items with Item Object Spawner in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item-objects/item-and-currency-droppers

This code demonstrates how to use the Item Object Spawner component to spawn items at runtime. It requires an ID for the spawner and an ItemInfo object, along with a spawn position. Options for delays and auto-destruction are also available.

```csharp
using Opsive.UltimateInventorySystem.Core;
using Opsive.UltimateInventorySystem.Core.InventoryHelpers;
using Opsive.UltimateInventorySystem.UI.Item.ItemPickUp;
using UnityEngine;

public class ItemSpawnerExample : MonoBehaviour
{
    public int itemObjectSpawnerID = 1;

    public void SpawnItem(ItemInfo itemInfo, Vector3 spawnPosition)
    {
        // Get the Item Object Spawner anywhere in your code.
        var itemObjectSpawner = InventorySystemManager.GetGlobal<ItemObjectSpawner>(itemObjectSpawnerID);

        // Spawn an Item using an item Info and a position.
        itemObjectSpawner.Spawn(itemInfo, spawnPosition);

        // There are options to spawn with a delay, an auto destroy or even both.
        // itemObjectSpawner.SpawnWithDelay(itemInfo, spawnPosition, delay);
        // itemObjectSpawner.SpawnWithAutoDestroy(itemInfo, spawnPosition, autoDestroyTimer);
        // itemObjectSpawner.Spawn(itemInfo, spawnPosition, delay, autoDestroyTimer);
    }
}
```

--------------------------------

### Get Item from Item Collection - C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item

Retrieves an ItemInfo object for a specific item from an Item Collection. The method returns a nullable ItemInfo, which will be null if the item is not found within the collection.

```csharp
// Get an item from the item collection, it returns a nullable Item Info.
var itemInfoResult = itemCollection.GetItemInfo(sword);
// If the item does not exist in the item collection the result will be null.
if (itemInfoResult.HasValue == false) {
    // The item does not exist.
} else {
    // The item was found in the Item Collection.
    var swordItemInfo = itemInfoResult.Value;
    // The Item Info has the amount and reference to the item stack.
}
```

--------------------------------

### Get Item Collection by Name (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory

Retrieves an item collection from the inventory using its unique name. If the collection is of a specific type, it can be cast accordingly. This is useful for accessing and manipulating groups of items.

```csharp
// Get an Item Collection by name.
var itemCollection = m_Inventory.GetItemCollection("Item Collection Name");
// if your item collection is of a specific type simply cast it
var itemSlotCollection = m_Inventory.GetItemCollection("Equipment") as ItemSlotCollection;
```

--------------------------------

### Accessing Inventory Data with Inventory System Manager

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory-system-manager

Demonstrates how to retrieve specific inventory data like item categories, definitions, and currency using the InventorySystemManager.Get methods. These methods allow direct access to organized data within the inventory system.

```csharp
InventorySystemManager.GetItemCategory("Weapons");
InventorySystemManager.GetItemDefinition("Big Potion");
InventorySystemManager.GetCurrency("Gold");
```

--------------------------------

### Get Item Object from Item in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item-objects

Retrieves the Item Object associated with an item, or iterates through multiple Item Objects if the item is not unique. It also provides a method to check if an item is currently bound to a specific Item Object.

```csharp
//If your Item is Unique you may get the Item Object from the Item
var itemObject = newItem.GetLastItemObject();

// You may easily check if an item is bound to an Item Object.
if(newItem.IsBoundToItemObject(itemObject)){
	//The item is bound to that item object.
}

// If it is not unique the item may have multiple Item Objects:
// Loop over all the item object
var count = newItem.GetItemObjectCount();
for(int i =0; i < count; i++){
	var itemObjectAtIndex = newItem.GetItemObjectAt(i);
}
```

--------------------------------

### Create Custom Search Filter Preset in C#

Source: https://opsive.com/support/documentation/ultimate-inventory-system/editor-window

Demonstrates how to create a custom search filter preset by inheriting from SearchableListFilterPreset and overriding the IsValid function. This allows for advanced filtering logic beyond simple string matching. The provided code defines the base class with properties for search string and sort option index.

```csharp
/// <summary>
/// An object used to create filter and sort presets for the searchable list visual element.
/// </summary>
public class SearchableListFilterPreset : ScriptableObject
{
    [Tooltip("The default search string.")]
    [SerializeField] protected string m_SearchString;
    [Tooltip("The default Sort option, indicated by index.")]
    [SerializeField] protected int m_SortOptionIndex;
    
    public string SearchString { get => m_SearchString; set => m_SearchString = value; }
    public int SortOptionIndex { get => m_SortOptionIndex; set => m_SortOptionIndex = value; }
    /// <summary>
    /// Returns whether the object is valid (the string search is done separately).
    /// This function can be overwritten to make custom searchable list filters with more advanced properties.
    /// </summary>
    /// <param name="obj">The object to check if valid.</param>
    /// <returns>True if the object is valid.</returns>
    public virtual bool IsValid(object obj)
    {
        return true;
    }
}
```

--------------------------------

### Managing Global Objects with Inventory System Manager

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory-system-manager

Demonstrates how to register and retrieve global objects using the InventorySystemManager.SetGlobal and InventorySystemManager.GetGlobal methods. This allows for the storage and retrieval of various object types, such as Transforms and custom classes like ItemObjectSpawner, using a unique ID.

```csharp
// Get & Set whatever objects you want using their types and an ID as key.
InventorySystemManager.SetGlobal<Transform>(myTransform, id);
var transform = InventorySystemManager.GetGlobal<Transform>(id);

var itemObjectSpawner = InventorySystemManager.GetGlobal<ItemObjectSpawner>(id);
```

--------------------------------

### Get All System Items, Definitions, and Categories

Source: https://opsive.com/support/documentation/ultimate-inventory-system/item

Retrieves all available item categories, item definitions, and individual items currently registered within the inventory system. This is useful for system-wide queries, data aggregation, and UI population.

```csharp
// Get all ItemCategories, Item Definitions and Items in the game.
var allItemCategories = InventorySystemManager.ItemCategoryRegister.GetAll();
var allItemDefinitions = InventorySystemManager.ItemDefinitionRegister.GetAll();
var allItems = InventorySystemManager.ItemRegister.GetAll();
```

--------------------------------

### Load Managers in New Scene (C#)

Source: https://opsive.com/support/documentation/ultimate-inventory-system/scene-transitions

This C# script demonstrates the 'Smart Managers Load Component' strategy for loading managers when transitioning to a new scene. It checks if managers are already loaded and instantiates a prefab or loads an additive scene if they are not. Ensure the execution order of this component is set to -500.

```csharp
using UnityEngine;
using UnityEngine.SceneManagement;

public class SceneLoaderManagerExample : MonoBehaviour
{
    [SerializeField] protected GameObject m_ManagerPrefab;
    [SerializeField] protected int m_ManagerSceneBuildIndex = -1;

    private void Awake()
    {
        if (!InventorySystemManager.IsNull) {
            //This gameobject is only needed to load the managers remove it once it is done.
            Destroy(gameObject);
            return;
        }

        // Instantiate a prefab of managers (Make sure to DontDestroyOnLoad).
        if (m_ManagerPrefab != null) {
            var managers = Instantiate(m_ManagerPrefab);
            //Optional don't destroy on load here instead of within the manager components
            //DontDestroyOnLoad(managers);
        }

        //Instead of a prefab load an additive scene with the manager (Make sure to DontDestroyOnLoad).
        if (m_ManagerSceneBuildIndex >= 0) {
            SceneManager.LoadScene(m_ManagerSceneBuildIndex, LoadSceneMode.Additive);
        }

        //This gameobject is only needed to load the managers remove it once it is done.
        Destroy(gameObject);
    }
}
```

--------------------------------

### Get Item Amount from Collection

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory/item-collections

Demonstrates how to obtain the total amount of a specific item within a collection. The `GetItemAmount` method can count across multiple stacks for a matching description. An optional boolean parameter allows for checking inherently.

```csharp
var amount = itemCollection.GetItemAmount(myItem);
var amountDefinition = itemCollection.GetItemAmount(myItemDefinition,true);
```

--------------------------------

### Get Item Info from Collection

Source: https://opsive.com/support/documentation/ultimate-inventory-system/inventory/item-collections

Shows how to retrieve an ItemInfo object for a specific item from the collection. The `GetItemInfo` method searches for the first matching item stack. If no item stack with the specified description is found, it returns a null value.

```csharp
var retrievedItemInfo = itemCollection.GetItemInfo(myItem);
if (retrievedItemInfo.HasValue == false) { //No item stack with that description was found in the inventory. }
```
Tokens:
Raw