Inventory and containers

Inventory

Inventory is what the player carries: the items in their inventory, worn and in hand included, as the game's save counts them. What's in a bag isn't in it. A bag's contents are kept in the bag (see Containers).

foreach (InventoryItem item in Inventory.Items())
    context.Log($"{item.Name} x{item.Stack}{(item.IsEquipped ? " (worn)" : "")}");

Inventory.Add("wine", stack: 2);                                   // one of the game's items
Inventory.Add<MyBlade>(setup: blade => blade.Durability = 50);     // a mod's weapon, half worn
int taken = Inventory.Remove("wine", 1);

Names are those of Items.Give: one of the game's items by its o_inv_ object's name less o_inv_ ("wine"), or a weapon or armour by its name. quality is an ItemQuality: Rolled (as loot is, the default), Common, Enchanted, Magical or Cursed.

Inventory events

Inventory.OnAdded(context, item => context.Log($"Picked up {item.Name} x{item.Stack}"));
Inventory.OnRemoved(context, item => context.Log($"Lost {item.Name}"));
Inventory.OnEquipped(context, (item, on) => context.Log($"{item.Name} {(on ? "on" : "off")}"));

The inventory is compared once a frame, after the game's done with it, so every way an item comes or goes counts. A game loaded starts afresh.

Items: InventoryItem

An InventoryItem is one item, as a slot: one the player carries, or one in an open container. It's kept by id, so it can be kept between frames; check Exists first.

Each item has its own data, kept with it wherever it goes (a chest, the ground, a save):

if (Inventory.Add<MyBlade>() is { } blade)
{
    blade.Durability = 50;
    blade.ModData(context)["kills"] = 0;
}

Combat.OnHit(context, attack =>
{
    if (attack.Killed && Inventory.Items().FirstOrDefault(i => i.IsEquipped && i.Name == "My Blade") is { Exists: true } worn)
    {
        var mine = worn.ModData(context);
        mine["kills"] = mine["kills"].AsInt + 1;
    }
});

Every Add takes a setup that sets an item's values as it's made: Inventory.Add("wine", setup: wine => wine.ModData(context)["gift"] = true).

Containers

Containers are the chests, barrels, tombs and the like in the world, and the player's bags (a backpack, a casket, a quiver). A container holds its items three ways, as the game keeps them:

• Never opened (a container in the world): nothing yet. Its loot is rolled as it's first opened, from a seed of its place, from its loot table. HasBeenOpened tells.
• Open: a window whose items are ordinary item slots, as the inventory's are: an OpenContainer.
• Closed: saved in it, one entry an item, in the game's own save format (ContentsJson).

Containers.AddItem and RemoveItem work in all three:

// A bottle of wine in the chest, open or closed.
Containers.AddItem(chest, "wine");
Containers.AddItem<MyBlade>(chest, setup: blade => blade.Durability = 50);
int taken = Containers.RemoveItem(chest, "wine", 1);

An item put in a closed one is saved in it as the game's save does, and goes in its first free cell as it opens. A never-opened one stays unopened: its loot is rolled as it's first opened, and the item joins it then.

Container events

Containers.OnOpened(context, open => context.Log($"{open.Items().Count} items inside"));
Containers.OnClosed(context, chest => context.Log($"Closed: {Containers.ContentsJson(chest)}"));
Containers.OnItemAdded(context, (open, item) => context.Log($"Put {item.Name} in"));