Item Definition
Defines a Steam Inventory Item
Like what your seeing?
Support us as a GitHub Sponsor and get instant access to all our assets, exclusive tools and assets, escalated support and issue tracking and our gratitude. These articles are made possible by our GitHub Sponsors ... become a sponsor today!
Introduction
public class ItemDefinitionObject : ScriptableObject
Represents a Steam Inventory Item of any type. This object contains all the schema data for any possible item. The specifics of each field are defined in Steam's Inventory Schema documentaiton.
When importing items from Steam API note that Valve omits the bundle node from Items of type 'Generator' thus anytime you import items from Valve the "Items" field on generator type items will be empty and must be set manually before you can export them again.
This is a deliberate decision from Valve and has been confirmed it is not a bug it is by design. If you (like us) would like it changed then please submit a support ticket to Valve letting them know that this decision adversly impacts you.
Fields and Attributes
Id
public SteamItemDef_t Id => get;
Returns the item defintion ID.
Details
public List<ItemDetail> Details => get;
Returns a list of all the known item details the local user owns of this item type.
TotalQuantity
public long TotalQuantity => get;
Returns the quantity of this item the user owns, this is the sum of all quanity in each detail.
DisplayName
public string DisplayName => get;
This can only be used if you have called LoadItemDefintions from the Inventory API. It returns the localized name of the item if any.
HasPrice
public bool HasPrice => get;
Indicates rather or not this item has a price ... this will always return false until after the system has fully initalized. Initalization occures on initalization of the API and can take a few seconds.
CurrencyCode
public Currency.Code CurrencyCode => get;
Returns the currency code used by the local user's currency in Steam. e.g. USD, GBP, EUR, etc.
CurrencySymbol
public string CurrencySymbol => get;
Returns the sting symbol used by the local user's currency.
CurrentPrice
public ulong CurrentPrice => get;
The price of the item as a whole number e.g. 1 represents the smallest denominator in the user's currency so 100 would represent 100 cents or 1 dolar in USD ... this will always return false until after the system has fully initalized. Initalization occures on initalization of the API and can take a few seconds.
No price found if this returns 0.
BasePrice
public ulong BasePrice => get;
The base price of the item as a whole number e.g. 1 represents the smallest denominator in the user's currency so 100 would represent 100 cents or 1 dolar in USD ... this will always return false until after the system has fully initalized. Initalization occures on initalization of the API and can take a few seconds.
No price found if this returns 0.
Type
public InventoryItemType Type => get;
This indicates the type of item this definition represents.
Name
public string Name => get;
Gets the simple name of the item as defined in your schema. If you need the language based name see DisplayName.
Description
public string Description => get;
Gets the simple description as defined in your schema. If you need the langauge based name you will need to fetch item defintions and get the description property.
DisplayType
public string DisplayType => get;
Gets the simple display type as defined in your schema. If you need the langauge based name you will need to fetch item defintions and get the description property.
Bundle
public Bundle.Entry[] Bundle => get;
Gets the array of Bundle.Entry objects defining the contents of this bundle if any
PromoRuleOwns
public AppId_t[] PromoRuleOwns => get;
Returns the list of app ids that the user must own for this item to be droped as a promo item.
PromoRuleAchievements
public string[] PromoRuleAchievemets => get;
Returns the list of achievment IDs that the user must have achieved for this item to be droped as a promo item.
PromoRulePlayed
public PromoRule.PlayedEntry[] PromoRulePlayed => get;
Returns the list of player entries ... indicates the app ID and length of time in min that the player must have played before this item can be droped as a promo.
DropStartTime
public string DropStartTime => get;
The item drop start time if this is a promo item.
Recipies
public ExchangeRecipe[] Recipies => get;
Returns the array of exchange recipies for this item if any
BackgroundColor
public Color BackgroundColor => get;
The background color used in the Steam Store and marketplace entries if any
NameColor
public Color NameColor => get;
The name color used in the Steam Store and marketplace entries if any
IconUrl
public string IconUrl => get;
The icon URL for this item if any, this is used by the Steam Store and marketplace entries.
IconUrlLarge
public string IconUrlLarge => get;
The icon URL for this item if any, this is used by the Steam Store and marketplace entries.
Marketable
public bool Marketable => get;
Can this item be sold by players on the Steam marketplace.
Tradable
public bool Tradable => get;
Can this item be traded between players via the Steam Inventory system.
Tags
public ItemTag[] Tags;=> get
The set of tags related to this item.
TagGenerators
public ItemDefinition[] TagGenerators => get;
The array of items used as tag generators related to this item
TagGeneratorValueArray
public TagGeneratorValue[] TagGeneratorvalueArray => get;
The array of values that can be generated for this item
StoreTags
public string[] StoreTags => get;
Returns the array of store tags assigned to this item
StoreImages
public string[] StoreImages => get;
Returns the array of store images assigned to this item
Hidden
public bool Hidden => get;
Is this item hidden from the user's inventory
StoreHidden
public bool StoreHidden => get;
Is this item hidden from the store
Methods
Add Promo Item
public bool AddPromoItem(callback);
Grants the item in a one-time promotional to the local user
Get Consume Orders
public ConsumeOrder[] GetConsumeOrders(quantity);
Creates ConsumeOrders which can be used with the Consume method to consume instances of this item if available. This is only needed when consuming more than 1 instance at a time.
Consume
public bool Consume(callback);
public bool Consume(order, callback);
Consume 1 or many instances of this item if the player owns them
Can Exchange
This method checks if a user can exchange for this item using a specific recipie. You can get the list of available recipies from the ItemDefinition.item_exchange or you can create the recipie manually if you know the items needed.
public bool CanExchange(ExchangeRecipe, out List<ExchangeEntry>);
Get Exchange Entry
public bool GetExchangeEntry(quantity, out entries);
Gets a set of ExchangeEntry objects that match the quantity provided if the player's owns them. This can be used with Exchange to "craft" 1 item by exchanging a set of other items.
Exchange
Exchanges a collection of ExchangeEntry for this item. The Valve backend will validate and insure that this set of ExchangeEntries satisifies one of the configured excahnge recipies for this item.
public void Exchange(IEnumerable<ExchangeEntry>, callback);
Exchanges a set of ExchangeEntry objects to create a new instance of this item.
Generate Item
Can only be used by developers for development testing
public void GenerateItem(callback);
Only available to developers, this simply creates a new instance of this item
Start Purchase
public void StartPurchase(callback);
If the item is confugred correctly for store purchases this will open the store loading the cart with the indicated number of items to be purcahsed.
CurrentPriceString
public string CurrentPriceString();
This reurnts the culture formated string for the currency assuming it is base 100. This works well for curencies such as USD, EUR, GBP or anything with a "cent" concept but will not work well for currencies that always use whole numbers such as the Yen.
BasePriceString
public string BasePriceString();
This reurnts the culture formated string for the currency assuming it is base 100. This works well for curencies such as USD, EUR, GBP or anything with a "cent" concept but will not work well for currencies that always use whole numbers such as the Yen.
Trigger Drop
public void TriggerDrop(callback);
Triggers a play time drop assuming the player has played long enough and the item is a playtime generator item.
How To
Check Ownership
Once your happy that the local state is fresh enough for your purposes you can check for ownership of an item by simply checking its TotalQuantity
if(item.TotalQuantity > 0)
Debug.Log("The user owns " + item.TotalQuanity + " of this item.");
else
Debug.Log("The user does not own any of this item.");
Refresh Inventory
You can refresh the local state of items at any time, keep in mind Valve may rate limit this and simply return the most recent cashe value.
To refresh the full inventory
API.Inventory.Client.GetAllItems(callback);
The callback is optional and can be used to know when the results comeback. The Heathen SteamSettings object will update the state of all known ItemDefinition objects so its not nessisary to process the resulting InventoryResults object unless you want to check for something specific.
You can also choose to refresh a specific set of item instances
API.Inventory.Client.GetItemsByID(instances, callback);
As with GetAllItems the callback is optional and can be used to check the specifics of the resullting data or simply to know when the request has been completed.
Add Promo Item
Short cut to the Add Promo Item of the API.Inventory interface.
item.AddPromoItem(callback);
Consume
You can use the Item Definition to consume 1 or more instances of the item with simple method calls.
Consume a single instance
This is the simplest and most common approch, it assumes you are consuming a single instance of the item.
item.Consume(callback);
Consume multiple
When consuming multiple instnaces we need to first get a set of orders.
var orders = item.GetConsumeOrders(quantity);
foreach(var order in orders)
{
item.Consume(order, callback);
}
Exchange
To exchange some items for another item, the item you wish to exchange for must define the recipie of items in its Item Definition as upoloaded to Steam's portal.
The item recipie is how this is able to run client side, since the item definition defines what exchanges are valid, and the Steam backend controls what items the player owns then Steam can assuradly confirm that a recipie is valid.
An exchange, exchanges some set of items for some other item. Its most simple to think of this as crafting, you provide some set of ingrediants and the result is some single item. When you call Exchange on an item you provide a set of items and if the process is succesfult you will recieve evidence of a new instnace of this item in the player's inventory.
To start the proces you must first identify the specifc item instnaces to be consumed. How you generate ExchangeEntry objects for an item depends on the specific needs of the recipie. In most cases a recipie will require a number of a specific item type, in this case you can simply call GetExchangeEntry
on the specific item.
if(itemToExchange.GetExchangeEntry(quantity, out entries))
{
// Enough where found
}
else
{
// Not enough of this item available
}
Once you have the collection of ExchangeEntries you can pass them into the item you wish to exchange them for.
item.Exchange(exchangeEntries, callback);
Use Cases
Exchange chest for bundle
if(chest.GetExchangeEntry(1, out EchangeEntry[] entries))
{
bundle.Exchange(entries, (result, error) => {
Debug.Log("result contains the items we gave the player");
});
}
else
{
Debug.Log("The player didn't have any chests");
}
Exchange for a particular recipie;
In this use case we pick a particular recipie for the item we want to exchange ... lets say we want to exchange 10 gold and 1 gem for a random item. Lets assue our random item is defined as an item generator named randomLoot;
Lets allso assume that the recipie to do this is the first recipie in our randomLoot item.
var recipie = randomLoot.item_exchange.recipie[0];
if(randomLoot.CanExchange(recipie, out List<ExchangeEntry> entries))
{
//This returns true if the local user owns the required items
//We can use the output entries to execute the exchange
randomLoot.Exchange(entries, (responce) =>
{
if(responce.result == EResult.k_EResultOK)
Debug.Log("Complete");
else
Debug.LogWarning("Something went wrong ... check the result");
});
}
Exchange 10 iron and 50 gold for 1 ironSword;
In this example we will manually build out the exchange entries checking each one as we go.
if(iron.GetExchangeEntry(10, out EchangeEntry[] ironEntries))
{
if(gold.GetExcahngeEntry(50, out ExchangeEntry[] goldEntries))
{
var recipie = new List<ExchangeEntry>();
recipie.Add(ironEntries);
recipie.Add(goldEntries);
ironSword.Exchange(recipie, (result, error) => {
Debug.Log("results contains the sword if any");
});
}
else
{
Debug.Log("Not enough gold");
}
}
else
{
Debug.Log("Not enough iron");
}
Generate or Grant Items
From the Client API this is only avialable to developers of this app for development testing. If you need to do this in production for a non-developer then you need to use the Web API.
Grants the player this item, this is used only by developers and is meant for testing only.
item.GenerateItem(callback);
To generate multiple instances of this item you can use
item.GenerateItem(count, callback);
Start Purchase
Only items that have a valid price or price category and are not set to store hidden or hidden in general can be called to start purchase.
item.StartPurchase(callback);
or
item.StartPurchse(count, callback);
or
API.Inventory.Client.StartPurchase(items, itemQuantities, callback);
Last updated