The character controller is seamlessly integrated with the Ultimate Inventory System allowing you to use the Ultimate Inventory System inventory rather than the inventory included with the character controller. The integration includes the Ultimate Inventory System Bridge component which is responsible for the communication between the two assets. This integration can be downloaded from one of the pages listed below.

A great way to get familiar with the integration is by playing around in the integration demo scene which can be found in:

The integration includes two databases: IntegrationDemoInventorySystem and EmptyCharacterInventoryDatabase. The IntegrationDemoInventorySystem database is used within the Ultimate Character Controller demo scene. To get started within a fresh database you can use the EmptyDatabase which contains the minimum for the Ultimate Character Controller integration. This database can be duplicated from the Ultimate Inventory System’s Setup Manager:


The Ultimate Inventory System allows for flexibility in how you setup your inventory but the integration does require some high level setup in order to be able to work with the character controller.


The following categories are required:

  • Equippable: The Equippable category specifies the items that can be equipped, such as an assault rifle or a sword. While this high level category is required, the Ultimate Inventory System allows you to nest categories so you can have any category structure beneath this.
  • Consumable: The Consumable category specifies the objects that can be consumed by items, such as assault rifle bullets or mana. Inventory objects that are not used by the item system, such as a potion.

If your character can equip multiple of the same item, such as dual pistols, then the following category is required:

  • Multi Item: Parented to the Equippable category, the Multi Item category is an optional category which specifies that the same item can be equipped in multiple slots. Examples include dual pistols or the grenade which can be equipped in the left or right hand. Any item which satisfies this requirement must inherit the Multi Item category. Items which can be dual wielded but are not of the same item type, such as a sword and shield, do not need to be parented to the Multi Item category.

The integration uses a variety of attributes in order to perform different functionality. The following Item Category attribute is used:

  • ExposedItemSet: A boolean which indicates if the category should be exposed to the Item Set Manager.
  • CanEquipFromMenu: A boolean which indicates if the category within the Item Set Manager should be able to be equipped from the menu. In the demo scene this is used by the Right and Left Hand Grenade categories to prevent that Item Set from being equipped when the grenade is equipped from the menu.

The following Item Definition attributes are used:

  • Prefab: A GameObject which is used by items which are not in the Muti Item category. This attribute specifies the prefab that should be spawned. This prefab should be a runtime pickup prefab.
  • Prefabs: A GameObject[] which is used by items which are in the Multi Item category. This attribute specifies the set of prefabs that should be spawned. Each element within the array corresponds to the slot that the item is spawned.
  • ExclusiveEquip: A bool which specifies if the Multi Item is equipped separately from itself. In the case of dual pistols, Exclusive Equip would be false because multiple pistols can be equipped at the same time. In the case of a grenade which can be equipped in either hand the Exclusive Equip value should be true since only one item can be equipped at a time.

The following Item attributes are used:

  • IsEquipped: Defined on the Equipped Item Category, specifies if the item is currently equipped. This is used by the inventory UI to show if the item is equipped.


Ultimate Character Controller
First Person Controller
Third Person Controller
UFPS: Ultimate First Person Shooter
UTPS: Ultimate Third Person Shooter
UFPM: Ultimate First Person Melee
UFPM: Ultimate Third Person Melee


  1. Install the integration from above.
  2. Duplicate the EmptyCharacterInventoryDatabase from the Inventory Manager.
  3. Open the Integrations Manager from Tools -> Opsive -> Ultimate Character Controller -> Integrations Manager. Select the Integration Inspectors tab.
  4. Drag your character into the Object field. This character must first be setup with the Character Manager. Select Setup Character.
  5. Ensure you have setup your inventory according to the structure described within the Setup section.
  6. Ensure the Equippable, Consumable, and Multi Item categories within the Ultimate Inventory System Bridge have been set. The Multi Item category is optional.
  7. Create a new Item Definition for the item that you’d like to add. Ensure it is parented to the Single Item or Multi Item category.
  8. Create your Item prefab using the Runtime Item Pickup steps. Item Types from the Ultimate Character Controller do not need to be created as you should instead use the Item Definitions.
  9. Assign the the runtime pickup prefab to the Prefab attribute on the created Item Definition.


Converting Existing UCC items

If you have an existing project using the character controller and wish to convert the items on your character to work with the Ultimate Inventory System you must follow the steps below

  1. Create a new item by following the video above.
  2. Copy the Item and ItemAction components (Shootable Weapon, Melee Weapon, Throwable Item, Magic Item) from your existing item to the new item that was just created.
  3. Set the Item Definition field on the Item component to your Ultimate Inventory System Item Definition
  4. Delete the item from your character using the Item Manager.

In addition make sure to read the runtime pickup section. The bottom Object Identifier section is especially useful for specifying the locations of GameObjects that exist on the character.


using Opsive.Shared.Events;
using Opsive.UltimateCharacterController.Integrations.UltimateInventorySystem;
using Opsive.UltimateCharacterController.Items;
using Opsive.UltimateInventorySystem.Core.DataStructures;
using Opsive.UltimateInventorySystem.Core.InventoryCollections;
using UnityEngine;

public class ExamplesForDocumentation : MonoBehaviour
    [Tooltip("The UIS Inventory Component")]
    [SerializeField] protected Inventory m_UISInventory;
    [Tooltip("The Inventory System Bridge.")]
    [SerializeField] protected UltimateInventorySystemBridge m_InventorySystemBridge;

    /// <summary>
    /// Get the item equipped in slot 0 the UCC way.
    /// </summary>
    [ContextMenu("Get Right Hand Item UCC")]
    public void GetItemInSlotUCCway()
        //Get the item at slot 0 (Right Hand)
        var item = m_InventorySystemBridge.GetActiveItem(0);
        Debug.Log("UCC: "+item);
        Debug.Log("Converted to UIS: "+ConvertUCCItemToUISItem(item));
    /// <summary>
    /// Get the item equipped in slot 0 the UIS way.
    /// </summary>
    [ContextMenu("Get Right Hand Item UIS")]
    public void GetItemInSlotUISway()
        //Get the equipment item collection as an ItemSlotCollection
        var itemSlotCollection = m_UISInventory.GetItemCollection("Equipped") as ItemSlotCollection;

        //Get the ItemInfo using the ItemSlot name.
        var itemInRightHand = itemSlotCollection.GetItemInfoAtSlot("RightHand");
        Debug.Log("UIS: "+itemInRightHand);
        Debug.Log("Converted to UCC: "+ConvertUISItemToUCCItem(itemInRightHand.Item));

    /// <summary>
    /// Convert a UIS Item to a UCC Item.
    /// </summary>
    /// <param name="uisItem">The UIS item.</param>
    /// <returns>The UCC Item.</returns>
    public Item ConvertUISItemToUCCItem(Opsive.UltimateInventorySystem.Core.Item uisItem)
        return m_InventorySystemBridge.GetItem(uisItem, 0);
    /// <summary>
    /// Convert the UCC Item to a UIS Item.
    /// </summary>
    /// <param name="uccItem">The UCC Item.</param>
    /// <returns>THe UIS Item.</returns>
    public Opsive.UltimateInventorySystem.Core.Item ConvertUCCItemToUISItem(Item uccItem)
        return uccItem?.ItemIdentifier as Opsive.UltimateInventorySystem.Core.Item;

    /// <summary>
    /// Equip an Item.
    /// </summary>
    /// <param name="itemInfo">The item to equip.</param>
    /// <param name="equip">Equip or Unequip?</param>
    public void EquipItem(ItemInfo itemInfo, bool equip)
        EventHandler.ExecuteEvent<ItemInfo, bool>(m_InventorySystemBridge.gameObject, "OnItemActionEquipUnequip", itemInfo, equip);
    /// <summary>
    /// Drop an Item.
    /// </summary>
    /// <param name="itemInfo">The item to drop.</param>
    public void DropItem(ItemInfo itemInfo)
        EventHandler.ExecuteEvent<ItemInfo>(m_InventorySystemBridge.gameObject, "OnItemActionDrop", itemInfo);