API de requête et de manipulation de l'inventaire Steam.
Pour plus d'informations, veuillez consulter la section
Service d'inventaire Steam.
Fonctions membres
Les fonctions membres de
ISteamInventory
sont appelées par le biais de la fonction d'accesseur global
SteamInventory()
.
AddPromoItem
bool AddPromoItem( SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef );
Envoyer un item promotionnel spécifique à l'utilisatrice ou l'utilisateur actuel.
Cette fonction peut être appelée en toute sécurité depuis le client, car les items qu'elle est susceptible de distribuer peuvent être verrouillés via des règles dans les définitions d'items. L'un des scénarios principaux pour cet appel est l'octroi d'un item à une personne possédant également un autre jeu spécifique. Elle peut s'avérer utile si votre jeu dispose d'une interface utilisateur personnalisée permettant d'afficher un item spécifique. Si vous souhaitez envoyer plusieurs items promotionnels, utilisez
AddPromoItems ou
GrantPromoItems.
Tous les items pouvant être distribués DOIVENT disposer d'un attribut "promo" dans leur définition. Cette liste d'items promotionnels est un ensemble d'AppID que l'utilisateur ou l'utilisatrice doit posséder pour se voir distribuer cet item particulier. Cette version distribuera tous les items qui ont des attributs promo spécifiés pour eux dans les définitions d'items configurées. Ceci permet l'ajout d'items promotionnels supplémentaires sans avoir à mettre à jour le client du jeu. Par exemple, le code suivant permettra à l'item d'être distribué si la personne possède soit TF2 soit SpaceWar.
promo: owns:440;owns:480
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
En cas de succès, le résultat relatif à l'inventaire inclura les items distribués, s'il y a lieu. Si aucun item n'a été distribué, car la personne n'est pas éligible à une promotion, le résultat sera toujours considéré comme un succès.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Exemple :void CInventory::GrantPromoItems()
{
SteamInventory()->AddPromoItem( &s_GenerateRequestResult, 110 );
}
AddPromoItems
bool AddPromoItems( SteamInventoryResult_t *pResultHandle, const SteamItemDef_t *pArrayItemDefs, uint32 unArrayLength );
Nom | Type | Description |
pResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle du résultat d'inventaire. |
pArrayItemDefs | const SteamItemDef_t * | Liste des items accordés au compte. |
unArrayLength | uint32 | Nombre d'items dans pArrayItemDefs . |
Envoie un item promotionnel spécifique à l'utilisatrice ou l'utilisateur actuel.
Cette fonction peut être appelée en toute sécurité depuis le client, car les items qu'elle est susceptible de distribuer peuvent être verrouillés via des règles dans les définitions d'items. L'un des scénarios principaux pour cet appel est l'octroi d'un item à une personne possédant également un autre jeu spécifique. Utilisez
AddPromoItem pour envoyer un seul item promotionnel. Utilisez
GrantPromoItems pour envoyer tous les items promotionnels possibles.
Tous les items pouvant être distribués DOIVENT disposer d'un attribut "promo" dans leur définition. Cette liste d'items promotionnels est un ensemble d'AppID que l'utilisateur doit posséder pour se voir distribuer cet item particulier. Cette version distribuera tous les items qui ont des attributs promo spécifiés pour eux dans les définitions d'items configurées. Ceci permet l'ajout d'items promotionnels supplémentaires sans avoir à mettre à jour le client du jeu. Par exemple, le code suivant permettra à l'item d'être distribué si la personne possède soit TF2 soit SpaceWar.
promo: owns:440;owns:480
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
En cas de succès, le résultat relatif à l'inventaire inclura les items distribués, s'il y a lieu. Si aucun item n'a été distribué, car la personne n'est pas éligible à une promotion, le résultat sera toujours considéré comme un succès.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Exemple :void CInventory::GrantPromoItems()
{
SteamItemDef_t newItems[2];
newItems[0] = 110;
newItems[1] = 111;
SteamInventory()->AddPromoItems( &s_GenerateRequestResult, newItems, 2 );
}
CheckResultSteamID
bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDExpected );
Nom | Type | Description |
resultHandle | SteamInventoryResult_t | Handle du résultat d'inventaire pour lequel le SteamID doit être vérifié. |
steamIDExpected | CSteamID | SteamID à vérifier. |
Vérifie si un handle de résultat d'inventaire appartient au SteamID spécifié.
Cette fonction est importante pour l'utilisation de
DeserializeResult et permet de confirmer la réalité de l'inventaire d'un compte à distance (que ce n'est pas une usurpation).
Éléments renvoyés : bool
true si le résultat appartient au SteamID de la cible. Sinon, renvoie
false.
ConsumeItem
bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity );
Utilise des items de l'inventaire d'une personne. Si la quantité de l'item en question passe à zéro, celui-ci est retiré de manière permanente.
Un item retiré ne peut être récupéré. Cette fonction est réservée aux plus téméraires : implémenter la suppression d'objets dans votre jeu nécessite un processus de confirmation d'UI particulièrement robuste.
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Consulter également : ExchangeItems,
TransferItemQuantityExemple :void CInventory::DrinkOnePotion( SteamItemInstanceID_t itemID )
{
SteamInventory()->ConsumeItem( &s_ConsumeRequestResult, itemID, 1 );
}
DeserializeResult
bool DeserializeResult( SteamInventoryResult_t *pOutResultHandle, const void *pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE = false );
Nom | Type | Description |
pOutResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle de résultat d'inventaire. |
pBuffer | const void * | Tampon à désérialiser. |
unBufferSize | uint32 | Taille de pBuffer . |
bRESERVED_MUST_BE_FALSE | bool | Doit être false ! |
Désérialise un ensemble de résultats et vérifie les octets de signature.
Cet appel peut résulter en un échec partiel dans lequel le statut du handle est défini comme
k_EResultExpired.
GetResultItems continuera de fonctionner dans ce cas. Obtenir un résultat « expiré » peut indiquer une obsolescence des données, non seulement à cause du délai d'expiration (une heure), mais également car l'un des items mentionnés dans les résultats peut avoir été échangé ou utilisé depuis la création de l'ensemble. Vous pouvez comparer les horaires entre
GetResultTimestamp et
ISteamUtils::GetServerRealTime afin de déterminer quand les données ont été émises. Vous pouvez choisir de ne pas tenir compte du code de résultat « expiré » ou demander à la personne dont les données sont obsolètes d'envoyer un ensemble de résultats mis à jour.
Il est recommandé de vérifier la validité du handle de résultat en appelant
CheckResultSteamID afin de s'assurer que la personne ne tente pas d'usurper l'inventaire d'un autre compte.
REMARQUE : le paramètre
bRESERVED_MUST_BE_FALSE
est réservé à un usage ultérieur et ne devrait jamais être défini sur true.
Éléments renvoyés : bool
Renvoie toujours
true puis fournit des codes d'erreur via
GetResultStatus.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
DestroyResult
void DestroyResult( SteamInventoryResult_t resultHandle );
Détruit un handle de résultat et libère toute la mémoire associée.
ExchangeItems
bool ExchangeItems( SteamInventoryResult_t *pResultHandle, const SteamItemDef_t *pArrayGenerate, const uint32 *punArrayGenerateQuantity, uint32 unArrayGenerateLength, const SteamItemInstanceID_t *pArrayDestroy, const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength );
Nom | Type | Description |
pResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle de résultat d'inventaire. |
pArrayGenerate | const SteamItemDef_t * | Liste les items qui seront générés par cet appel. Cette fonction ne peut pour le moment concerner qu'un seul item ! |
punArrayGenerateQuantity | const uint32 * | Quantité de chaque item dans pArrayGenerate à créer. Actuellement, ce paramètre ne peut concerner qu'un seul item et doit donc être réglé sur 1 ! |
unArrayGenerateLength | uint32 | Nombre d'items dans pArrayGenerate et punArrayGenerateQuantity . Doit être actuellement défini sur 1 ! |
pArrayDestroy | const SteamItemInstanceID_t * | Liste des items qui seront détruits par cet appel. |
punArrayDestroyQuantity | const uint32 * | Quantité de chaque item dans pArrayDestroy à détruire. |
unArrayDestroyLength | uint32 | Nombre d'items dans pArrayDestroy et punArrayDestroyQuantity . |
Donner un item en échange d'un ensemble d'autres objets.
Cette fonction permet d'implémenter le fonctionnement des recettes ou des transmutations, ou encore des items donnant d'autres items (comme les coffres).
La personne appelant cette API passe l'item demandé et un tableau des items existants, ainsi que les quantités relatives à l'échange. Actuellement, l'API se base sur un tableau pour générer des items, mais la taille de ce tableau et la quantité du nouvel item ainsi créé doivent être de 1.
Tous les items pouvant être distribués DOIVENT disposer d'un attribut d'échange dans leur définition. L'attribut d'échange définit un ensemble de recettes permettant d'échanger cet item. Les recettes d'échange sont analysées par le service d'inventaire. Si des composantes sont manquantes, en quantité insuffisante, ou ne correspondent pas à la recette, l'échange sera un échec.
Exemple :
Échange : 101x1,102x1 ; 103x5 ; 104x3,105x3
Permettra à l'item d'être échangé contre un nº 101 et un nº 102, cinq nº 103 ou trois nº 104 et trois nº 105. Pour plus d'informations, veuillez consulter la section
Schéma de l'inventaire Steam de la documentation.
Éléments renvoyés : bool
Cette fonction renvoie
true pour indiquer sa réussite, et renvoie
false lorsqu'elle est appelée depuis SteamGameServer ou bien quand
unArrayGenerateLength
ou
punArrayGenerateQuantity
n'est pas défini sur
1.
Les échanges ne correspondant à aucune recette ou ne comprenant pas les quantités nécessaires échoueront.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Consulter également : ConsumeItem,
TransferItemQuantityExemple :// Trouve un item dans l'inventaire du compte grâce à la définition de l'item donnée.
SteamItemInstanceID_t CInventory::GetItemIdFromInventory( SteamItemDef_t itemDefId );
void CInventory::Exchange()
{
SteamItemInstanceID_t inputItems[2];
uint32 inputQuantities[2];
inputItems[0] = GetItemIdFromInventory( 103 );
inputQuantities[0] = 3;
inputItems[1] = GetItemIdFromInventory( 104 );
inputQuantities[1] = 3;
SteamItemDef_t outputItems[1];
outputItems[0] = 100;
uint32 outputQuantity[1];
outputQuantity[0] = 1;
SteamInventory()->ExchangeItems( &s_ExchangeRequestResult, outputItems, outputQuantity, 1, inputItems, inputQuantities, 2 );
}
GenerateItems
bool GenerateItems( SteamInventoryResult_t *pResultHandle, const SteamItemDef_t *pArrayItemDefs, const uint32 *punArrayQuantity, uint32 unArrayLength );
Nom | Type | Description |
pResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle de résultat de l'inventaire. |
pArrayItemDefs | const SteamItemDef_t * | Liste des items accordés au compte. |
punArrayQuantity | const uint32 * | Quantité de chaque item dans pArrayItemDefs à accorder. C'est optionnel, renseignez NULL pour spécifier 1 pour chaque item. |
unArrayLength | uint32 | Nombre d'items dans pArrayItemDefs . |
Attribue des items spécifiques au compte actuel, pour les équipes de développement uniquement.
Cette API n'est destinée qu'à la production de prototypes et n'est utilisable que par les comptes Steam appartenant au groupe d'édition de votre jeu.
Vous pouvez renseigner un tableau d'items, identifiés par leur
SteamItemDef_t, ainsi qu'un second tableau optionnel relatif aux quantités correspondantes. La taille de ces tableaux DOIT être la même !
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Exemple :void CInventory::GrantTestItems()
{
SteamItemDef_t newItems[2];
uint32 quantities[2];
newItems[0] = 110;
newItems[1] = 111;
quantities[0] = 1;
quantities[1] = 1;
SteamInventory()->GenerateItems( &s_GenerateRequestResult, newItems, quantities, 2 );
}
GetAllItems
bool GetAllItems( SteamInventoryResult_t *pResultHandle );
Nom | Type | Description |
pResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle de résultat de l'inventaire. |
Récupérer tous les objets présents dans l'inventaire de l'utilisatrice ou de l'utilisateur actuel.
REMARQUE : les appels de cette fonction ne peuvent être effectués qu'à une fréquence limitée. Les résultats renvoyés sont susceptibles d'être en cache en cas d'appels trop fréquents. Il est recommandé d'appeler cette fonction uniquement lorsque vous êtes sur le point d'afficher tout l'inventaire de la personne, ou lorsque vous supposez que des modifications ont eu lieu dans l'inventaire.
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Exemple :void SpaceWarItem::LoadInventory( IGameEngine *pGameEngine )
{
SteamInventory()->GetAllItems( &s_RequestResult );
}
GetEligiblePromoItemDefinitionIDs
bool GetEligiblePromoItemDefinitionIDs( CSteamID steamID, SteamItemDef_t *pItemDefIDs, uint32 *punItemDefIDsArraySize );
Nom | Type | Description |
steamID | CSteamID | SteamID du compte pour lequel sont ces items. Doit être identique à SteamInventoryEligiblePromoItemDefIDs_t.m_steamID . |
pItemDefIDs | SteamItemDef_t * | Renvoie les ID des définitions d'items en les copiant dans ce tableau. |
punItemDefIDsArraySize | uint32 * | Doit être de la même taille que pItemDefIDs et SteamInventoryEligiblePromoItemDefIDs_t.m_numEligiblePromoItemDefs . |
Obtenir la liste des ID des définitions d'items pouvant être envoyés à un compte.
Cet appel devrait être effectué lors du traitement du résultat d'un appel de
SteamInventoryEligiblePromoItemDefIDs_t afin d'extraire la liste des ID des définitions d'items.
Éléments renvoyés : bool
Consulter également : AddPromoItem,
AddPromoItemsGetItemDefinitionIDs
bool GetItemDefinitionIDs( SteamItemDef_t *pItemDefIDs, uint32 *punItemDefIDsArraySize );
Nom | Type | Description |
pItemDefIDs | SteamItemDef_t * | Renvoie les définitions d'items en les copiant dans ce tableau. |
punItemDefIDsArraySize | uint32 * | Doit être défini à la longueur de pItemDefIDs . Si pItemDefIDs est NULL, alors renvoie le nombre d'éléments que le tableau doit contenir. |
Renvoie l'ensemble des ID des définitions d'items spécifiées dans la section Admin. de l'application du site de Steamworks.
Ces définitions d'items ne constituent pas forcément des nombres entiers contigus.
Cet appel ne devrait être effectué qu'en réponse à un rappel
SteamInventoryDefinitionUpdate_t. Il n'y a aucune raison d'appeler cette fonction si les ID des définitions numériques sont codées en dur dans votre jeu (par ex. masque facial violet = 20, modification d'arme bleue = 55) et si l'ajout de nouveaux types d'items sans un correctif du client n'est pas autorisé.
Éléments renvoyés : bool
Cet appel renvoie
true après réussite. Renvoie false uniquement
false si les définitions d'items n'ont pas été téléchargées du serveur ou si aucune définition d'item n'existe pour l'application actuelle.
Si la fonction est utilisée avec succès, alors
punItemDefIDsArraySize
contiendra le nombre de définitions d'items disponibles.
GetItemDefinitionProperty
bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPropertyName, char *pchValueBuffer, uint32 *punValueBufferSizeOut );
Nom | Type | Description |
iDefinition | SteamItemDef_t | Définition d'item dont les propriétés sont recherchées. |
pchPropertyName | const char * | Nom de la propriété pour laquelle obtenir une valeur. Si vous renseignez NULL, alors pchValueBuffer contiendra une liste des noms disponibles, séparés par des virgules. |
pchValueBuffer | char * | Renvoie la valeur associée à pchPropertyName . |
punValueBufferSizeOut | uint32 * | Ceci devrait être défini sur la taille de pchValueBuffer , et renvoie le nombre total d'octets requis pour maintenir la valeur. |
Obtient une propriété de chaine de caractères depuis la définition d'item spécifiée.
Obtient une valeur de propriété pour une définition d'item spécifiée.
Veuillez noter que certaines propriétés (par exemple, "name") peuvent être traduites et ainsi dépendre des paramètres de langue de Steam (voir
ISteamApps::GetCurrentGameLanguage). Les noms des propriétés sont toujours en caractères alphanumériques ASCII et en tirets bas.
Renseignez
NULL pour
pchPropertyName
afin d'obtenir une liste des noms de propriétés disponibles, séparés par des virgules. Dans ce mode,
punValueBufferSizeOut
contiendra la taille de tampon suggérée. Sinon, elle sera du nombre d'octets réellement copiés dans
pchValueBuffer
.
Éléments renvoyés : bool
Renvoie
true en cas de succès et
false en cas d'échec, c'est-à-dire si les définitions de l'item n'ont pas été chargées depuis le serveur, si aucune définition de l'item n'existe pour l'application actuelle, ou si le nom de la propriété n'a pas été trouvé dans la définition de l'item.
La valeur associée est renvoyée via
pchValueBuffer
, et le nombre total d'octets requis pour retenir la valeur est disponible grâce à
punValueBufferSizeOut
. Il est recommandé d'appeler cette fonction deux fois, la première avec
pchValueBuffer
défini sur
NULL, puis avec
punValueBufferSizeOut
défini sur zéro afin d'obtenir la taille de tampon requise pour l'appel suivant.
Le retour doit ressembler à cela :
pchPropertyName
défini sur
NULL :
appid,itemdefid,Timestamp
etc…
pchPropertyName
défini sur
"name" :
SW_DECORATION_HAT
REMARQUE : appelez
LoadItemDefinitions d'abord, pour vous assurer que les items sont prêts à être utilisés avant d'appeler GetItemDefinitionProperty.
GetItemsByID
bool GetItemsByID( SteamInventoryResult_t *pResultHandle, const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs );
Nom | Type | Description |
pResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle du résultat d'inventaire. |
pInstanceIDs | const SteamItemInstanceID_t * | Liste des ID de l'instance d'item à mettre à jour. |
unCountInstanceIDs | uint32 | Nombre d'items dans pInstanceIDs . |
Obtient l'état d'un sous-ensemble de l'inventaire du compte actuel.
Ce sous-ensemble est défini par un tableau d'ID d'instance d'item.
Ce retour peut être produit en série en utilisant
SerializeResult et transmis aux autres personnes afin de « prouver » que l'utilisatrice ou utilisateur actuel dispose de certains items sans pour autant montrer l'intégralité de son inventaire. Par exemple, vous pouvez effectuer cet appel avec les ID des objets actuellement équipés par la personne, puis le reproduire en série dans une mémoire tampon, pour enfin transmettre les résultats du tampon aux autres personnes qui rejoignent la partie.
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
GetItemPrice
bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pPrice );
Nom | Type | Description |
iDefinition | SteamItemDef_t | ID de la définition de l'item pour lequel récupérer le prix. |
pPrice | uint64* | Pointeur du prix à remplir. Les prix sont exprimés dans la devise locale du compte en question. |
Après un appel réussi de
RequestPrices, vous pouvez appeler cette méthode afin d'obtenir le prix de la définition d'un item spécifique.
Éléments renvoyés : bool
true en cas de succès, ce qui indique que
pPrice
a bien été renseigné avec le prix attribué à l'ID de la définition de l'item en question.
false si les paramètres ne sont pas valides ou qu'aucun prix n'a été déterminé pour l'ID de la définition de l'item donné.
Consulter également : RequestPricesGetItemsWithPrices
bool GetItemsWithPrices( SteamItemDef_t *pArrayItemDefs, uint64 *pPrices, uint32 unArrayLength );
Nom | Type | Description |
pArrayItemDefs | SteamItemDef_t * | Tableau des ID de définitions d'items à renseigner. |
pPrices | uint64* | Tableau des prix correspondant à chaque ID de la définition d'un item dans pArrayItemDefs. Les prix sont exprimés dans la devise locale du compte en question. |
unArrayLength | uint32 | Ce paramètre doit être défini sur la longueur des tableaux de pArrayItemDefs et de pPrices , qui sont le résultat de l'appel GetNumItemsWithPrices. |
Après un appel résusi de
RequestPrices, vous pouvez appeler cette méthode afin d'obtenir tous les prix des définitions des items concernés. Utilisez le résultat de
GetNumItemsWithPrices pour déterminer la taille des tableaux à passer.
Éléments renvoyés : bool
true en cas de succès, ce qui indique que
pArrayItemDefs
et
pPrice
ont bien été renseignés avec les ID de définitions et les prix attribués aux items en solde.
false si les paramètres ne sont pas valides.
Consulter également : RequestPrices,
GetItemPriceGetNumItemsWithPrices
uint32 GetNumItemsWithPrices();
Après un appel réussi de
RequestPrices, renvoie le nombre de définitions d'items ayant un prix valide.
Éléments renvoyés : uint32Consulter également : RequestPrices,
GetItemsWithPricesGetResultItemProperty
bool GetResultItemProperty( SteamInventoryResult_t resultHandle, uint32 unItemIndex, const char *pchPropertyName, char *pchValueBuffer, uint32 *punValueBufferSizeOut );
Nom | Type | Description |
resultHandle | SteamInventoryResult_t | Handle de résultat contenant l'item dont les propriétés sont recherchées. |
unItemIndex | uint32 | |
pchPropertyName | const char * | Nom de la propriété pour laquelle obtenir une valeur. Si vous renseignez NULL, alors pchValueBuffer contiendra une liste des noms disponibles, séparés par des virgules. |
pchValueBuffer | char * | Renvoie la valeur associée à pchPropertyName . |
punValueBufferSizeOut | uint32 * | Ceci devrait être défini sur la taille de pchValueBuffer , et renvoie le nombre total d'octets requis pour retenir la valeur. |
Obtient les propriétés dynamiques d'un item dans un ensemble de résultats d'inventaire.
Les noms de propriétés sont toujours composés de lettres, de chiffres et/ou de tirets bas faisant partie de l'ASCII.
Si les résultats dépassent le tampon alloué, des résultats partiels peuvent être copiés.
Éléments renvoyés : bool
Renvoie
true en cas de réussite, et
false en cas d'échec. Cela indique que le handle de résultat d'inventaire n'est pas valable ou que l'index fourni ne contient pas d'item.
GetResultItems
bool GetResultItems( SteamInventoryResult_t resultHandle, SteamItemDetails_t *pOutItemsArray, uint32 *punOutItemsArraySize );
Nom | Type | Description |
resultHandle | SteamInventoryResult_t | Handle de résultat d'inventaire dont les items sont recherchés. |
pOutItemsArray | SteamItemDetails_t * | Détails renvoyés en les copiant dans ce tableau. |
punOutItemsArraySize | uint32 * | Doit être défini à la longueur de pOutItemsArray . Si pOutItemsArray est NULL, alors renvoie le nombre d'éléments que le tableau doit contenir. |
Obtenir les objets associés à un handle de résultat d'inventaire.
Éléments renvoyés : bool
true si l'appel s'est effectué avec succès, sinon
false.
Les motifs d'échec potentiels comprennent :
-
resultHandle
n'est pas valide ou le handle du résultat d'inventaire n'est pas prêt.
-
pOutItemsArray
n'est pas assez grand pour contenir le tableau.
- L'utilisateur ou l'utilisatrice n'a pas d'items.
Si la fonction est utilisée avec succès, alors
punItemDefIDsArraySize
contiendra le nombre de définitions d'items disponible.
Exemple :bool bGotResult = false;
std::vector<SteamItemDetails_t> vecDetails;
uint32 count = 0;
if ( SteamInventory()->GetResultItems( callback->m_handle, NULL, &count ) )
{
vecDetails.resize( count );
bGotResult = SteamInventory()->GetResultItems( callback->m_handle, vecDetails.data(), &count );
}
GetResultStatus
EResult GetResultStatus( SteamInventoryResult_t resultHandle );
Nom | Type | Description |
resultHandle | SteamInventoryResult_t | Handle de résultat d'inventaire dont le statut est recherché. |
Trouver l'état d'un handle de résultat d'inventaire asynchrone.
Il s'agit d'un interrogatoire équivalent à l'enregistrement d'une fonction de rappel pour
SteamInventoryResultReady_t.
Éléments renvoyés : EResultQue l'appel se soit effectué avec succès ou non.
Valeurs possibles :
Exemple :void SpaceWarItem::CheckInventory( IGameEngine *pGameEngine )
{
if ( s_RequestResult != 0 )
{
EResult result = SteamInventory()->GetResultStatus( s_RequestResult );
if ( result == k_EResultOK )
{
// Faire quelque chose ici.
}
}
}
GetResultTimestamp
uint32 GetResultTimestamp( SteamInventoryResult_t resultHandle );
Nom | Type | Description |
resultHandle | SteamInventoryResult_t | Handle des résultats relatifs à l'inventaire dont l'horodatage est recherché. |
Obtient l'heure du serveur à laquelle le résultat a été généré.
Éléments renvoyés : uint32L'heure est communiquée au format « depuis l'époque Unix » (temps écoulé depuis le 1ᵉʳ janvier 1970).
Vous pouvez comparer cette valeur à
ISteamUtils::GetServerRealTime afin de déterminer l'âge du résultat.
GrantPromoItems
bool GrantPromoItems( SteamInventoryResult_t *pResultHandle );
Accorde à l'utilisatrice ou l'utilisateur actuel tous les items promotionnels potentiels à usage unique.
Cette fonction peut être appelée en toute sécurité depuis le client, car les items qu'elle est susceptible de distribuer peuvent être verrouillés via des règles dans les définitions d'items. L'un des scénarios principaux pour cet appel est l'octroi d'un item à des personnes possédant également un autre jeu spécifique. Si vous souhaitez distribuer des objets promotionnels spécifiques plutôt que l'ensemble des objets, voir
AddPromoItem et
AddPromoItems.
Tous les items pouvant être distribués DOIVENT disposer d'un attribut "promo" dans leur définition. Cette liste d'items promotionnels est un ensemble d'AppID que l'utilisateur ou l'utilisatrice doit posséder pour se voir distribuer cet item particulier. Cette version distribuera tous les items qui comportent des attributs promo spécifiés pour eux dans les définitions d'items configurées. Ceci permet l'ajout d'items promotionnels supplémentaires sans avoir à mettre à jour le client du jeu. Par exemple, le code suivant permettra à l'item d'être distribué si la personne possède soit TF2 soit SpaceWar.
promo: owns:440;owns:480
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
En cas de succès, le résultat d'inventaire inclura les items distribués, s'il y a lieu. Si aucun item n'a été distribué, car la personne n'est pas éligible à une promotion, le résultat sera toujours considéré comme un succès.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Exemple :void CInventory::GrantPromoItems()
{
SteamInventory()->GrantPromoItems( &s_GenerateRequestResult );
}
LoadItemDefinitions
bool LoadItemDefinitions();
Déclenche un chargement et une actualisation asynchrone des définitions d'items.
Les définitions d'items sont une réorientation des « ID de définition » (nombres entiers compris entre 1 et 999 999 999) menant à un ensemble de propriétés de chaine. Certaines de ces propriétés sont requises pour l'affichage d'objets sur le site Web de la communauté Steam. D'autres propriétés peuvent être définies par les applications. Il n'y a aucune raison d'appeler cette fonction si votre jeu a codé en dur les ID de définition numériques (par ex. masque facial violet = 20, modification d'arme bleue = 55) et n'autorise pas l'ajout de nouveaux types d'objets sans un correctif du client.
Éléments renvoyés : bool
Déclenche un rappel
SteamInventoryDefinitionUpdate_t.
Renvoie toujours
true.
RequestEligiblePromoItemDefinitionsIDs
SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID );
Nom | Type | Description |
steamID | CSteamID | SteamID du compte pour lequel faire une requête d'objets promotionnels. |
Demande la liste des objets promotionnels « éligibles » pouvant être distribués manuellement à une personne donnée.
Il s'agit d'objets promotionnels de type « manuel » qui ne seront pas distribués automatiquement. Un exemple d'utilisation de ce paramètre est un item qui devient disponible chaque semaine.
Après avoir appelé cette fonction, vous devez appeler
GetEligiblePromoItemDefinitionIDs pour obtenir les bons ID de définitions d'items.
Éléments renvoyés : SteamAPICall_t, à utiliser avec un résultat d'appel
SteamInventoryEligiblePromoItemDefIDs_t.
Renvoie
k_uAPICallInvalid si le
steamID
n'est pas un compte individuel valide.
RequestPrices
SteamAPICall_t RequestPrices();
Demande les prix pour toutes les définitions d'items qui peuvent être achetés dans la devise du compte actuel. Un résultat d'appel
SteamInventoryRequestPricesResult_t sera renvoyé avec le code de la devise locale du compte actuel. Après cela, appelez
GetNumItemsWithPrices et
GetItemsWithPrices pour obtenir les prix de toutes les définitions d'items connues, ou appelez
GetItemPrice pour obtenir une définition d'item spécifique.
Éléments renvoyés : SteamAPICall_t à utiliser avec un rappel
SteamInventoryRequestPricesResult_t.
Renvoie
k_uAPICallInvalid en cas de problème interne.
Consulter également : GetNumItemsWithPrices,
GetItemsWithPrices,
GetItemPriceSendItemDropHeartbeat
void SendItemDropHeartbeat();
Obsolète.
SerializeResult
bool SerializeResult( SteamInventoryResult_t resultHandle, void *pOutBuffer, uint32 *punOutBufferSize );
Nom | Type | Description |
resultHandle | SteamInventoryResult_t | Handle de résultat d'inventaire à sérialiser. |
pOutBuffer | void * | Tampon dans lequel le résultat reproduit en série sera copié. |
punOutBufferSize | uint32 * | Doit être défini à la taille de pOutBuffer . Si pOutBuffer est NULL, alors renvoie la taille requise pour maintenir le tampon. |
Les ensembles de résultats reproduits en série contiennent une courte signature ne pouvant être contrefaite ou rejouée sur différentes sessions de jeu.
Un ensemble de résultats peut être reproduit en série sur le client local, transmis aux autres joueurs et joueuses via votre réseau en jeu et converti en instances uniques par les personnes distantes. Il s'agit d'un moyen sécurisé d'empêcher des pirates de mentir en déclarant des objets rares/de haute valeur en leur possession. Reproduit un résultat défini avec des octets de signature vers un tampon de sortie. La taille d'un résultat reproduit en série dépend du nombre d'objets à reproduire. Lors de la transmission sécurisée d'items à d'autres personnes, il est recommandé d'utiliser
GetItemsByID en premier lieu afin de créer un ensemble de résultats minimal.
Les résultats disposent d'un horodateur intégré qui sera considéré comme « expiré » après une heure. Consultez
DeserializeResult pour le traitement de l'expiration.
Si
pOutBuffer
est défini sur
NULL, alors
punOutBufferSize
sera défini sur la taille de tampon requise. Vous pourrez ainsi créer le tampon et l'appeler à nouveau pour le remplir de données.
Éléments renvoyés : bool
true en cas de réussite. Cela indique que
punOutBufferSize
a été rempli avec succès à la taille du tampon, et si
pOutBuffer
désigne un tampon de taille suffisante, il est alors rempli également.
false dans les conditions suivantes.
- La fonction n'a pas été appelée par une utilisatrice ou un utilisateur normal. Cet appel n'est pas pris en charge sur GameServers.
-
resultHandle
n'est pas valide ou le handle du résultat d'inventaire n'est pas prêt.
- La valeur renseignée dans
punOutBufferSize
était plus petite que prévue et pOutBuffer
n'était pas NULL.
StartPurchase
SteamAPICall_t StartPurchase( const SteamItemDef_t *pArrayItemDefs, const uint32 *punArrayQuantity, uint32 unArrayLength );
Nom | Type | Description |
pArrayItemDefs | SteamItemDef_t * | Tableau des ID de définitions d'items que la personne souhaite acheter. |
punArrayQuantity | uint32 * | Tableau des quantités de chaque item que la personne souhaite acheter. |
unArrayLength | uint32 | Ce paramètre doit être défini sur la longueur des tableaux de pArrayItemDefs et punArrayQuantity . |
Amorce le processus d'achat pour l'utilisateur ou l'utilisatrice, avec un « panier » de définitions d'items qu'il ou elle a l'intention d'acquérir. Il ou elle sera invité à compléter son achat dans l'overlay Steam dans sa devise locale, et si nécessaire, à fournir son portemonnaie Steam.
Si le processus d'achat est correctement amorcé, alors
m_ulOrderID
et
m_ulTransID
seront valides dans le résultat d'appel
SteamInventoryStartPurchaseResult_t.
Si la personne autorise la transaction et finalise son achat, alors le rappel
SteamInventoryResultReady_t sera déclenché et vous pourrez aller chercher les nouveaux items acquis par celle-ci.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire une fois que vous avez terminé.
Éléments renvoyés : SteamAPICall_t à utiliser avec un rappel
SteamInventoryStartPurchaseResult_t.
Renvoie
k_uAPICallInvalid si l'entrée n'était pas valide.
Effectuer des tests en cours de développement : lorsque vous testez StartPurchase avant de publier votre application, toutes les transactions effectuées par les membres de l'équipe de développement et de publication seront réalisées en interne par l'API bac à sable (sandbox) pour les microtransactions. Cela signifie que si vous faites partie du groupe d'édition Steamworks, vous ne serez pas facturé(e) pour les achats effectués avant la sortie de l'application.
TransferItemQuantity
bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest );
Transfère les items entre les piles au sein de l'inventaire d'un compte.
Ceci peut être utilisé pour empiler, diviser et déplacer des objets. Les objets source et destination doivent avoir la même définition d'item. Pour déplacer des objets sur un empilement de destination, spécifiez la source, la quantité à déplacer et l'ID de l'item destination. Pour diviser un ensemble existant, passez
k_SteamItemInstanceIDInvalid dans
itemIdDest
. Un nouvel empilement d'objets de la quantité requise sera généré.
REMARQUE : les restrictions de cessibilité/commercialisation sont copiées en même temps que les objets transférés. L'empilement de destination reçoit la dernière date de cessibilité/commercialisation de tout item dans sa composition.
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Consulter également : ConsumeItem,
ExchangeItemsExemple :void CInventory::CombineItems()
{
SteamInventoryResult_t transferResult;
// sépare deux items d'une pile existante.
SteamItemInstanceID_t bigStack = GetItemIdFromInventory( ... );
SteamInventory()->TransferItemQuantity( &transferResult, bigStack, 1, k_SteamItemInstanceIDInvalid );
// déplace deux items de la pile A à la pile B.
SteamItemInstanceID_t originStack = GetItemIdFromInventory( ... );
SteamItemInstanceID_t destStack = GetItemIdFromInventory( ... );
SteamInventory()->TransferItemQuantity( &transferResult, originStack, 2, destStack );
}
TriggerItemDrop
bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition );
Nom | Type | Description |
pResultHandle | SteamInventoryResult_t * | Renvoie un nouveau handle du résultat d'inventaire. |
dropListDefinition | SteamItemDef_t | Doit se référer à un ID de définition d'item de type "playtimegenerator". Pour plus d'informations, veuillez consulter la documentation sur le schéma d'inventaire. |
Déclenche une distribution d'item si le temps de jeu a été suffisamment long.
Cette période peut être personnalisée à deux endroits :
- Au niveau de l'application au sein du service d'inventaire : distribution d'items basés sur le temps de jeu. Ceci s'applique automatiquement à tous les items "playtimegenerator" n'ayant pas spécifié de substitutions.
- Dans une définition d'item "playtimegenerator" individuelle. Les paramètres de référence priment sur tout paramètre de niveau applications.
Seules des définitions d'items identifiées comme générateurs d'items en fonction du temps de jeu peuvent être générées.
En règle générale, cette fonction doit être appelée à la fin d'une partie, d'un niveau, d'un match ou de tout autre point d'importance du jeu pour lequel une distribution d'item pourrait avoir lieu. L'échelle des paramètres du générateur de temps de jeu se mesure en minutes, aussi l'appeler plus fréquemment qu'en minutes n'est pas utile et le débit sera limité dans le client Steam. Les serveurs Steam tiendront une comptabilité du temps de jeu afin d'empêcher des distributions trop fréquentes. Les serveurs gèreront également l'ajout de l'item à l'inventaire des joueurs et joueuses.
Éléments renvoyés : bool
Cette fonction renvoie toujours
true lorsqu'elle est appelée par une utilisatrice ou un utilisateur normal, et renvoie toujours
false lorsqu'elle est appelée par SteamGameServer.
Renvoie un nouveau handle de résultat via
pResultHandle
.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Le résultat renvoyé par cette fonction sera le nouvel item distribué si la personne est éligible. Si ce n'est pas le cas, il renverra alors un résultat vide ('[]').
Exemple :void CInventory::FinishGame()
{
SteamInventory()->TriggerItemDrop( &s_PlaytimeRequestResult, 10 );
}
StartUpdateProperties
SteamInventoryUpdateHandle_t StartUpdateProperties();
Démarre une demande de transaction qui mettra à jour les
propriétés dynamiques des objets pour l'utilisatrice ou l'utilisateur actuel. Il ou elle limite ces appels, c'est pourquoi les modifications des propriétés doivent être regroupées autant que possible (par exemple, au bout d'une carte ou à la fin d'une partie de jeu). Après avoir appelé
SetProperty ou
RemoveProperty pour tous les items que vous souhaitez modifier, vous devrez appeler
SubmitUpdateProperties pour envoyer la demande aux serveurs Steam. Un appel
SteamInventoryResultReady_t sera envoyé avec les résultats de l'opération.
Exemple :void CInventory::FinishLevel()
{
SteamInventoryUpdateHandle_t updateHandle = SteamInventory()->StartUpdateProperties();
for ( SteamItemInstanceID_t itemid : m_vecItemIDs )
{
SteamInventory()->SetProperty( updateHandle, itemid, "string_value", "blah" );
SteamInventory()->SetProperty( updateHandle, itemid, "bool_value", true );
SteamInventory()->SetProperty( updateHandle, itemid, "int64_value", (int64)55 );
SteamInventory()->SetProperty( updateHandle, itemid, "float_value", 123.456f );
}
SteamInventoryResult_t resultHandle;
SteamInventory()->SubmitUpdateProperties( updateHandle, &resultHandle );
}
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé pour
SubmitUpdateProperties lorsque vous avez terminé.
Éléments renvoyés : SteamInventoryUpdateHandle_tConsulter également : SetProperty,
RemoveProperty,
SubmitUpdatePropertiesSubmitUpdateProperties
bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle );
Envoie une demande de transaction qui modifiera les
propriétés dynamiques des items pour l'utilisatrice ou l'utilisateur actuel. Voir
StartUpdateProperties.
REMARQUE : vous devez appeler
DestroyResult sur le résultat d'inventaire renvoyé lorsque vous avez terminé.
Éléments renvoyés : bool
Consulter également : StartUpdateProperties,
SetProperty,
RemovePropertyRemoveProperty
bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName );
Supprime une
propriété dynamique pour l'item donné.
Éléments renvoyés : bool
Consulter également : StartUpdateProperties,
SetProperty,
SubmitUpdatePropertiesSetProperty
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue );
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue );
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue );
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue );
Nom | Type | Description |
handle | SteamInventoryUpdateHandle_t | Handle de la mise à jour correspondant à la demande de transaction, renvoyé par StartUpdateProperties. |
nItemID | SteamItemInstanceID_t | ID de l'item en cours de modification. |
pchPropertyName | const char* | Propriété dynamique ajoutée ou mise à jour. |
pchPropertyValue | const char* | Valeur de la string en cours de définition. |
bValue | bool | Valeur booléenne en cours de définition. |
nValue | int64 | Valeur de l'entier non signé de 64 bits en cours de définition. |
flValue | float | Valeur à virgule flottante en cours de définition. |
Définit une
propriété dynamique pour l'item donné. Les types de valeurs admis sont les chaines de caractères, les valeurs booléennes, les nombres entiers de 64 bits et les nombres à virgule flottante de 32 bits.
Éléments renvoyés : bool
Consulter également : StartUpdateProperties,
RemoveProperty,
SubmitUpdatePropertiesRappels
Voici les rappels qui peuvent être activés en appelant
SteamAPI_RunCallbacks. La plupart seront activés directement en réponse aux fonctions membres de
ISteamInventory
.
SteamInventoryDefinitionUpdate_t
Ce rappel est déclenché lorsque des définitions d'item sont mises à jour, ce qui peut être en réponse à
LoadItemDefinitions ou à chaque fois que de nouvelles définitions d'item sont disponibles (par ex. par l'ajout dynamique de nouveaux types d'items alors que les personnes sont toujours en jeu).
Ce rappel n'a pas de champ.
Fonctions associées : LoadItemDefinitionsSteamInventoryEligiblePromoItemDefIDs_t
Renvoyé lorsque vous demandez la liste des items promotionnels éligibles ("eligible") pouvant être distribués manuellement au compte donné. Il s'agit d'items promotionnels de type manuel ("manual") qui ne seront pas distribués automatiquement. Un exemple d'utilisation de ce paramètre est un item qui devient disponible chaque semaine.
Nom | Type | Description |
m_result | EResult | Renvoie k_EResultOK en cas de réussite. Toute autre valeur renvoyée signale un échec. |
m_steamID | CSteamID | SteamID du compte pour lequel sont ces items. |
m_numEligiblePromoItemDefs | int | Nombre d'items promotionnels éligibles et disponibles pour ce compte. Utilisez ceci afin de créer un tampon SteamItemDef_t à utiliser avec GetEligiblePromoItemDefinitionIDs pour obtenir les définitions d'item réelles. |
m_bCachedData | bool | Indique que les données ont été récupérées depuis le cache et non le serveur. Ceci se produit si l'utilisatrice ou utilisateur n'est pas connecté ou ne peut pas se connecter aux serveurs Steam. |
Fonctions associées : RequestEligiblePromoItemDefinitionsIDsSteamInventoryFullUpdate_t
Déclenché lorsque GetAllItems renvoie avec succès un résultat plus récent que le dernier résultat connu. (Ne se déclenche pas si l'inventaire n'a pas été modifié, ou si les résultats de deux appels se chevauchant sont inversés en cours de processus et que l'obsolescence du résultat précédent est déjà connue.)
Le rappel habituel
SteamInventoryResultReady_t sera toujours déclenché immédiatement après. Il s'agit d'une notification supplémentaire simplement destinée à vous aider.
SteamInventoryResultReady_t
Ceci est activé lorsqu'un résultat d'inventaire passe de
k_EResultPending à tout autre état achevé, voir
GetResultStatus pour la liste complète des états. Il y aura toujours exactement un rappel par handle.
SteamInventoryStartPurchaseResult_t
Renvoyé après l'appel de
StartPurchase.
Nom | Type | Description |
m_result | EResult | Renvoie k_EResultOK en cas de réussite. Toute autre valeur renvoyée signale un échec. |
m_ulOrderID | uint64 | ID de commande automatiquement généré pour l'achat initié. |
m_ulTransID | uint64 | ID de transaction automatiquement généré pour l'achat initié. |
SteamInventoryRequestPricesResult_t
Renvoyé après l'appel de
RequestPrices.
Nom | Type | Description |
m_result | EResult | Renvoie k_EResultOK en cas de réussite. Toute autre valeur renvoyée signale un échec. |
m_rgchCurrency | char | Chaine de caractères détaillant le code de la devise du compte en question. |
Structures
Voici les structures que les fonctions de ISteamInventory peuvent renvoyer et/ou avec lesquelles elles peuvent interagir.
SteamItemDetails_t
Énumérations
Voici les énumérations destinées à être utilisées avec ISteamInventory.
ESteamItemFlags
Ce sont des indicateurs binaires définis dans
SteamItemDetails_t.
Nom | Valeur | Description |
k_ESteamItemNoTrade | 1 << 0 | Cet item est lié au compte et ne peut être échangé ou donné. Ceci est un marqueur d'état d'item lié de manière permanente à des instances d'item spécifiques. |
k_ESteamItemRemoved | 1 << 8 | L'item a été détruit, échangé, a expiré ou a été invalidé de quelque autre façon. Ceci est un marqueur de confirmation d'action qui n'est défini qu'une seule fois, dans le cadre d'un ensemble de résultats. |
k_ESteamItemConsumed | 1 << 9 | La quantité de l'item a été diminuée de 1 via l'API ConsumeItem. Ceci est un marqueur de confirmation d'action qui n'est défini qu'une seule fois, dans le cadre d'un ensemble de résultats. |
Typedefs
Voici les typedefs destinés à être utilisés avec ISteamInventory.
Nom | Type de base | Description |
SteamInventoryResult_t | int32 | Handle menant vers un résultat d'inventaire asynchrone. |
SteamItemDef_t | int32 | Les types d'items dans votre jeu sont identifiés par un nombre de définition d'item ("item definition number") de 32 bits. Tout nombre de définition valide doit être compris entre 1 et 999 999 999. Tout nombre inférieur ou égal à zéro n'est pas valide. Tout nombre plus grand ou égal à un milliard (1x10^9) est réservé à un usage interne à Steam. |
SteamItemInstanceID_t | uint64 | Chaque instance individuelle d'un item possède un ID d'instance unique. Cet identifiant est propre à l'association entre un compte et l'instance spécifique d'un item. Il ne pourra pas être transféré vers un autre compte ou être réutilisé pour un autre item. |
SteamInventoryUpdateHandle_t | uint64 | Renvoyé après l'appel de StartUpdateProperties, ce qui initie une demande de transaction pour modifier les propriétés dynamiques des items du compte actuel. |
Constantes
Voici les constantes destinées à être utilisées avec ISteamInventory.
Nom | Type | Valeur | Description |
k_SteamInventoryResultInvalid | SteamInventoryResult_t | -1 | Handle de résultat d'inventaire Steam invalide. |
k_SteamItemInstanceIDInvalid | SteamItemInstanceID_t | (SteamItemInstanceID_t)~0 | ID d'instance d'item invalide. Ceci est généralement renvoyé lorsqu'une opération a échoué. Il est recommandé d'initialiser toutes les nouvelles instances d'item avec cette valeur. |
STEAMINVENTORY_INTERFACE_VERSION | const char * | "STEAMINVENTORY_INTERFACE_V002" | |