Inventory

Read more about the Inventory system in Hiro here.

Initializing the inventory system #

The inventory system relies on the Nakama System and an ILogger, both must be passed in as dependencies via the constructor.

1
2
var inventorySystem = new InventorySystem(logger, nakamaSystem);
systems.Add(inventorySystem);

Subscribing to changes in the inventory system #

You can listen for changes in the inventory system so that you can respond appropriately, such as updating the UI, by implementing the IObserver pattern, or use the SystemObserver<T> type which handles it for you.

1
2
3
4
5
var disposer = SystemObserver<InventorySystem>.Create(inventorySystem, system => {
    Instance.Logger.Info($"System updated.");

    // Update UI elements etc as necessary here...
});

Refreshing the inventory system #

To ensure the inventory system has the latest information from Nakama you can refresh it.

1
await inventorySystem.RefreshAsync();

Listing the available items #

You can list the available items in the inventory system.

1
2
3
4
5
6
var items = await inventorySystem.GetItemCodexAsync();

foreach (var item in items)
{
    Debug.Log($"Item {item.Id}: {item.Name} - {item.Description}");
}

You can optionally retrieve a filtered list of items by category.

1
2
var category = "<category1>";
var items = await inventorySystem.GetItemCodexAsync(category)

Listing the user’s inventory #

You can list a user’s inventory.

1
2
3
4
foreach (var item in inventorySystem.Items)
{
    Debug.Log($"Item {item.Id}: {item.Name} - {item.Description}");
}

Granting inventory items #

Grant one or more inventory items to the player.

1
2
3
4
5
6
7
var items = new Dictionary<string, long>
{
    { "<itemId1>", 1 },
    { "<itemId2>", 10 }
};

await inventorySystem.GrantItemsAsync(items);

Removing inventory items #

To remove items from a user’s inventory, without consuming them, use a negative grant value.

1
2
3
4
5
6
7
var items = new Dictionary<string, long>
{
    { "<itemId1>", -1 },
    { "<itemId2>", -10 }
};

await inventorySystem.GrantItemsAsync(items);

Deleting item instances #

Delete a specific item instance by its instance ID, rather than reducing its stacked count. Use this for non-stackable items, or items whose instance carries state that a count can’t represent.

1
await inventorySystem.DeleteItemsAsync(new[] { "<instanceId>" });

See Removing items for when to choose this over a negative grant.

Consuming items #

You can consume items or item instances for a user that have the consumable flag. You can specify whether or not the user is allowed to overconsume (use more than they have).

Setting overconsume to true can be useful when handling multiple device scenarios. This allows consumption of the item, even if the local device’s resource data is out of sync. However, once the item reaches zero, further consumption is prevented, irrespective of the overconsume setting. This provides developers flexibility in managing inventory inconsistencies across devices.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var itemsToConsume = new Dictionary<string, long>
{
    {"<consumableId1>", 2},
    {"<consumableId2>", 1}
};
var instancesToConsume = new Dictionary<string, long>
{
    {"<instanceId1>", 1},
    {"<instanceId2>", 1}
};

var overconsume = false;

await inventorySystem.ConsumeItemsAsync(itemsToConsume, instancesToConsume, overconsume);

Updating item properties #

You can update the properties on an item instance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
var updates = new Dictionary<string, UpdateInventoryItemProperties>
{
    {
        "itemId1",
        new UpdateInventoryItemProperties
        (
            // String Properties
            new Dictionary<string, string>
            {
                { "crafted_by", "username" }
            },
            // Numeric Properties
            new Dictionary<string, double>
            {
                { "rank",  5 }
            }
        )
    }
};

await inventorySystem.UpdateItemsAsync(updates);

Heroic Cloud