Documentation Steamworks
ISteamInventory Interface
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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle de résultat d'inventaire.
itemDefSteamItemDef_tDéfinition de l'item à transmettre.

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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle du résultat d'inventaire.
pArrayItemDefsconst SteamItemDef_t *Liste des items accordés au compte.
unArrayLengthuint32Nombre 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 );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle du résultat d'inventaire pour lequel le SteamID doit être vérifié.
steamIDExpectedCSteamIDSteamID à 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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle de résultat d'inventaire.
itemConsumeSteamItemInstanceID_tID d'instance de l'item à utiliser.
unQuantityuint32Nombre d'items à utiliser dans cette pile.

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, TransferItemQuantity

Exemple :
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 );
NomTypeDescription
pOutResultHandleSteamInventoryResult_t *Renvoie un nouveau handle de résultat d'inventaire.
pBufferconst void *Tampon à désérialiser.
unBufferSizeuint32Taille de pBuffer.
bRESERVED_MUST_BE_FALSEboolDoit ê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 );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle de résultat d'inventaire à détruire.

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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle de résultat d'inventaire.
pArrayGenerateconst 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 !
punArrayGenerateQuantityconst 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 !
unArrayGenerateLengthuint32Nombre d'items dans pArrayGenerate et punArrayGenerateQuantity. Doit être actuellement défini sur 1 !
pArrayDestroyconst SteamItemInstanceID_t *Liste des items qui seront détruits par cet appel.
punArrayDestroyQuantityconst uint32 *Quantité de chaque item dans pArrayDestroy à détruire.
unArrayDestroyLengthuint32Nombre 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, TransferItemQuantity

Exemple :
// 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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle de résultat de l'inventaire.
pArrayItemDefsconst SteamItemDef_t *Liste des items accordés au compte.
punArrayQuantityconst uint32 *Quantité de chaque item dans pArrayItemDefs à accorder. C'est optionnel, renseignez NULL pour spécifier 1 pour chaque item.
unArrayLengthuint32Nombre 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 );
NomTypeDescription
pResultHandleSteamInventoryResult_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 );
NomTypeDescription
steamIDCSteamIDSteamID du compte pour lequel sont ces items. Doit être identique à SteamInventoryEligiblePromoItemDefIDs_t.m_steamID.
pItemDefIDsSteamItemDef_t *Renvoie les ID des définitions d'items en les copiant dans ce tableau.
punItemDefIDsArraySizeuint32 *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, AddPromoItems

GetItemDefinitionIDs

bool GetItemDefinitionIDs( SteamItemDef_t *pItemDefIDs, uint32 *punItemDefIDsArraySize );
NomTypeDescription
pItemDefIDsSteamItemDef_t *Renvoie les définitions d'items en les copiant dans ce tableau.
punItemDefIDsArraySizeuint32 *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 );
NomTypeDescription
iDefinitionSteamItemDef_tDéfinition d'item dont les propriétés sont recherchées.
pchPropertyNameconst 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.
pchValueBufferchar *Renvoie la valeur associée à pchPropertyName.
punValueBufferSizeOutuint32 *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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle du résultat d'inventaire.
pInstanceIDsconst SteamItemInstanceID_t *Liste des ID de l'instance d'item à mettre à jour.
unCountInstanceIDsuint32Nombre 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 );
NomTypeDescription
iDefinitionSteamItemDef_tID de la définition de l'item pour lequel récupérer le prix.
pPriceuint64*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 : RequestPrices

GetItemsWithPrices

bool GetItemsWithPrices( SteamItemDef_t *pArrayItemDefs, uint64 *pPrices, uint32 unArrayLength );
NomTypeDescription
pArrayItemDefsSteamItemDef_t *Tableau des ID de définitions d'items à renseigner.
pPricesuint64*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.
unArrayLengthuint32Ce 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, GetItemPrice

GetNumItemsWithPrices

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 : uint32

Consulter également : RequestPrices, GetItemsWithPrices

GetResultItemProperty

bool GetResultItemProperty( SteamInventoryResult_t resultHandle, uint32 unItemIndex, const char *pchPropertyName, char *pchValueBuffer, uint32 *punValueBufferSizeOut );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle de résultat contenant l'item dont les propriétés sont recherchées.
unItemIndexuint32
pchPropertyNameconst 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.
pchValueBufferchar *Renvoie la valeur associée à pchPropertyName.
punValueBufferSizeOutuint32 *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 );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle de résultat d'inventaire dont les items sont recherchés.
pOutItemsArraySteamItemDetails_t *Détails renvoyés en les copiant dans ce tableau.
punOutItemsArraySizeuint32 *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 );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle 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 : EResult
Que 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 );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle 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 : uint32
L'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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle du résultat d'inventaire.

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 );
NomTypeDescription
steamIDCSteamIDSteamID 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, GetItemPrice

SendItemDropHeartbeat

void SendItemDropHeartbeat();
Obsolète.

SerializeResult

bool SerializeResult( SteamInventoryResult_t resultHandle, void *pOutBuffer, uint32 *punOutBufferSize );
NomTypeDescription
resultHandleSteamInventoryResult_tHandle de résultat d'inventaire à sérialiser.
pOutBuffervoid *Tampon dans lequel le résultat reproduit en série sera copié.
punOutBufferSizeuint32 *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 );
NomTypeDescription
pArrayItemDefsSteamItemDef_t *Tableau des ID de définitions d'items que la personne souhaite acheter.
punArrayQuantityuint32 *Tableau des quantités de chaque item que la personne souhaite acheter.
unArrayLengthuint32Ce 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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle du résultat d'inventaire.
itemIdSourceSteamItemInstanceID_tItem source à transférer.
unQuantityuint32Quantité de l'item qui sera transférée de itemIdSource à itemIdDest.
itemIdDestSteamItemInstanceID_tDestination de l'item. Vous pouvez passer k_SteamItemInstanceIDInvalid pour diviser l'ensemble source en un nouvel ensemble d'items avec la quantité d'unités requise.

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, ExchangeItems

Exemple :
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 );
NomTypeDescription
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle du résultat d'inventaire.
dropListDefinitionSteamItemDef_tDoit 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_t

Consulter également : SetProperty, RemoveProperty, SubmitUpdateProperties

SubmitUpdateProperties

bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle );
NomTypeDescription
handleSteamInventoryUpdateHandle_tLe handle mis à jour qui correspond à la demande de transaction et qui est renvoyé par StartUpdateProperties.
pResultHandleSteamInventoryResult_t *Renvoie un nouveau handle de résultat d'inventaire.

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, RemoveProperty

RemoveProperty

bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName );
NomTypeDescription
handleSteamInventoryUpdateHandle_tHandle de la mise à jour correspondant à la demande de transaction, renvoyé par StartUpdateProperties.
nItemIDSteamItemInstanceID_tID de l'item en cours de modification.
pchPropertyNameconst char*Propriété dynamique en cours d'élimination.

Supprime une propriété dynamique pour l'item donné.

Éléments renvoyés : bool

Consulter également : StartUpdateProperties, SetProperty, SubmitUpdateProperties

SetProperty

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 );
NomTypeDescription
handleSteamInventoryUpdateHandle_tHandle de la mise à jour correspondant à la demande de transaction, renvoyé par StartUpdateProperties.
nItemIDSteamItemInstanceID_tID de l'item en cours de modification.
pchPropertyNameconst char*Propriété dynamique ajoutée ou mise à jour.
pchPropertyValueconst char*Valeur de la string en cours de définition.
bValueboolValeur booléenne en cours de définition.
nValueint64Valeur de l'entier non signé de 64 bits en cours de définition.
flValuefloatValeur à 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, SubmitUpdateProperties

Rappels

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 : LoadItemDefinitions

SteamInventoryEligiblePromoItemDefIDs_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.

NomTypeDescription
m_resultEResultRenvoie k_EResultOK en cas de réussite. Toute autre valeur renvoyée signale un échec.
m_steamIDCSteamIDSteamID du compte pour lequel sont ces items.
m_numEligiblePromoItemDefsintNombre 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_bCachedDataboolIndique 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 : RequestEligiblePromoItemDefinitionsIDs

SteamInventoryFullUpdate_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.

NomTypeDescription
m_handleSteamInventoryResult_tNouveau handle de résultats relatifs à l'inventaire.

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.

NomTypeDescription
m_handleSteamInventoryResult_tRésultat d'inventaire désormais prêt.
m_resultEResultNouvel état du handle. Cela revient à appeler GetResultStatus.

SteamInventoryStartPurchaseResult_t

Renvoyé après l'appel de StartPurchase.

NomTypeDescription
m_resultEResultRenvoie k_EResultOK en cas de réussite. Toute autre valeur renvoyée signale un échec.
m_ulOrderIDuint64ID de commande automatiquement généré pour l'achat initié.
m_ulTransIDuint64ID de transaction automatiquement généré pour l'achat initié.

SteamInventoryRequestPricesResult_t

Renvoyé après l'appel de RequestPrices.

NomTypeDescription
m_resultEResultRenvoie k_EResultOK en cas de réussite. Toute autre valeur renvoyée signale un échec.
m_rgchCurrencycharChaine 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



NomTypeDescription
m_itemIdSteamItemInstanceID_tHandle d'instance d'item unique au monde.
m_iDefinitionSteamItemDef_tNuméro de définition d'item pour cet item.
m_unQuantityuint16Quantité actuelle de l'item.
m_unFlagsuint16Ceci est un ensemble de ESteamItemFlags qui a reçu un masque de bits.

Énumérations

Voici les énumérations destinées à être utilisées avec ISteamInventory.

ESteamItemFlags

Ce sont des indicateurs binaires définis dans SteamItemDetails_t.

NomValeurDescription
k_ESteamItemNoTrade1 << 0Cet 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_ESteamItemRemoved1 << 8L'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_ESteamItemConsumed1 << 9La 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.

NomType de baseDescription
SteamInventoryResult_tint32Handle menant vers un résultat d'inventaire asynchrone.
SteamItemDef_tint32Les 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_tuint64Chaque 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_tuint64Renvoyé 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.

NomTypeValeurDescription
k_SteamInventoryResultInvalidSteamInventoryResult_t-1Handle de résultat d'inventaire Steam invalide.
k_SteamItemInstanceIDInvalidSteamItemInstanceID_t(SteamItemInstanceID_t)~0ID 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_VERSIONconst char *"STEAMINVENTORY_INTERFACE_V002"