public static void DestroyResult(SteamInventoryResult_t resultHandle)
{
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInventory_DestroyResult(resultHandle);
}
// Token: 0x06000805 RID: 2053 RVA: 0x00004E59 File Offset: 0x00003059
public static bool AddPromoItem(out SteamInventoryResult_t pResultHandle, SteamItemDef_t itemDef)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_AddPromoItem(out pResultHandle, itemDef));
}
// Token: 0x06000806 RID: 2054 RVA: 0x00004E67 File Offset: 0x00003067
public static bool AddPromoItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayItemDefs, uint unArrayLength)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_AddPromoItems(out pResultHandle, pArrayItemDefs, unArrayLength));
}
// Token: 0x06000800 RID: 2048 RVA: 0x00004E0E File Offset: 0x0000300E
public static bool GetItemsByID(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t[] pInstanceIDs, uint unCountInstanceIDs)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_GetItemsByID(out pResultHandle, pInstanceIDs, unCountInstanceIDs));
}
// Token: 0x06000802 RID: 2050 RVA: 0x00004E2C File Offset: 0x0000302C
public static bool DeserializeResult(out SteamInventoryResult_t pOutResultHandle, byte[] pBuffer, uint unBufferSize, bool bRESERVED_MUST_BE_FALSE = false)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_DeserializeResult(out pOutResultHandle, pBuffer, unBufferSize, bRESERVED_MUST_BE_FALSE));
}
// Token: 0x0600080B RID: 2059 RVA: 0x00004EB7 File Offset: 0x000030B7
public static bool TriggerItemDrop(out SteamInventoryResult_t pResultHandle, SteamItemDef_t dropListDefinition)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_TriggerItemDrop(out pResultHandle, dropListDefinition));
}
// Token: 0x060007FB RID: 2043 RVA: 0x00004DCA File Offset: 0x00002FCA
public static bool GetResultItems(SteamInventoryResult_t resultHandle, SteamItemDetails_t[] pOutItemsArray, ref uint punOutItemsArraySize)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_GetResultItems(resultHandle, pOutItemsArray, ref punOutItemsArraySize));
}
/// <summary>
/// <para> AddPromoItem() / AddPromoItems() are restricted versions of GrantPromoItems(). Instead of</para>
/// <para> scanning for all eligible promotional items, the check is restricted to a single item</para>
/// <para> definition or set of item definitions. This can be useful if your game has custom UI for</para>
/// <para> showing a specific promo item to the user.</para>
/// </summary>
public static bool AddPromoItem(out SteamInventoryResult_t pResultHandle, SteamItemDef_t itemDef)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_AddPromoItem(CSteamAPIContext.GetSteamInventory(), out pResultHandle, itemDef));
}
public static bool AddPromoItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayItemDefs, uint unArrayLength)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_AddPromoItems(CSteamAPIContext.GetSteamInventory(), out pResultHandle, pArrayItemDefs, unArrayLength));
}
/// <summary>
/// <para> RESULT SERIALIZATION AND AUTHENTICATION</para>
/// <para> Serialized result sets contain a short signature which can't be forged</para>
/// <para> or replayed across different game sessions. A result set can be serialized</para>
/// <para> on the local client, transmitted to other players via your game networking,</para>
/// <para> and deserialized by the remote players. This is a secure way of preventing</para>
/// <para> hackers from lying about posessing rare/high-value items.</para>
/// <para> Serializes a result set with signature bytes to an output buffer. Pass</para>
/// <para> NULL as an output buffer to get the required size via punOutBufferSize.</para>
/// <para> The size of a serialized result depends on the number items which are being</para>
/// <para> serialized. When securely transmitting items to other players, it is</para>
/// <para> recommended to use "GetItemsByID" first to create a minimal result set.</para>
/// <para> Results have a built-in timestamp which will be considered "expired" after</para>
/// <para> an hour has elapsed. See DeserializeResult for expiration handling.</para>
/// </summary>
public static bool SerializeResult(SteamInventoryResult_t resultHandle, byte[] pOutBuffer, out uint punOutBufferSize)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_SerializeResult(CSteamAPIContext.GetSteamInventory(), resultHandle, pOutBuffer, out punOutBufferSize));
}
/// <summary>
/// <para> GrantPromoItems() checks the list of promotional items for which the user may be eligible</para>
/// <para> and grants the items (one time only). On success, the result set will include items which</para>
/// <para> were granted, if any. If no items were granted because the user isn't eligible for any</para>
/// <para> promotions, this is still considered a success.</para>
/// </summary>
public static bool GrantPromoItems(out SteamInventoryResult_t pResultHandle)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_GrantPromoItems(CSteamAPIContext.GetSteamInventory(), out pResultHandle));
}
/// <summary>
/// <para> Captures the state of a subset of the current user's Steam inventory,</para>
/// <para> identified by an array of item instance IDs. The results from this call</para>
/// <para> can be serialized and passed to other players to "prove" that the current</para>
/// <para> user owns specific items, without exposing the user's entire inventory.</para>
/// <para> For example, you could call GetItemsByID with the IDs of the user's</para>
/// <para> currently equipped cosmetic items and serialize this to a buffer, and</para>
/// <para> then transmit this buffer to other players upon joining a game.</para>
/// </summary>
public static bool GetItemsByID(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t[] pInstanceIDs, uint unCountInstanceIDs)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_GetItemsByID(CSteamAPIContext.GetSteamInventory(), out pResultHandle, pInstanceIDs, unCountInstanceIDs));
}
public static bool GenerateItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayItemDefs, uint[] punArrayQuantity, uint unArrayLength)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_GenerateItems(out pResultHandle, pArrayItemDefs, punArrayQuantity, unArrayLength));
}
public static bool GetAllItems(out SteamInventoryResult_t pResultHandle)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_GetAllItems(out pResultHandle));
}
// Token: 0x06000808 RID: 2056 RVA: 0x00004E85 File Offset: 0x00003085
public static bool ExchangeItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayGenerate, uint[] punArrayGenerateQuantity, uint unArrayGenerateLength, SteamItemInstanceID_t[] pArrayDestroy, uint[] punArrayDestroyQuantity, uint unArrayDestroyLength)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_ExchangeItems(out pResultHandle, pArrayGenerate, punArrayGenerateQuantity, unArrayGenerateLength, pArrayDestroy, punArrayDestroyQuantity, unArrayDestroyLength));
}
/// <summary>
/// <para> ConsumeItem() removes items from the inventory, permanently. They cannot be recovered.</para>
/// <para> Not for the faint of heart - if your game implements item removal at all, a high-friction</para>
/// <para> UI confirmation process is highly recommended.</para>
/// </summary>
public static bool ConsumeItem(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemConsume, uint unQuantity)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_ConsumeItem(CSteamAPIContext.GetSteamInventory(), out pResultHandle, itemConsume, unQuantity));
}
// Token: 0x06000809 RID: 2057 RVA: 0x00004E9B File Offset: 0x0000309B
public static bool TransferItemQuantity(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemIdSource, uint unQuantity, SteamItemInstanceID_t itemIdDest)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_TransferItemQuantity(out pResultHandle, itemIdSource, unQuantity, itemIdDest));
}
/// <summary>
/// <para> TransferItemQuantity() is intended for use with items which are "stackable" (can have</para>
/// <para> quantity greater than one). It can be used to split a stack into two, or to transfer</para>
/// <para> quantity from one stack into another stack of identical items. To split one stack into</para>
/// <para> two, pass k_SteamItemInstanceIDInvalid for itemIdDest and a new item will be generated.</para>
/// </summary>
public static bool TransferItemQuantity(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemIdSource, uint unQuantity, SteamItemInstanceID_t itemIdDest)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_TransferItemQuantity(CSteamAPIContext.GetSteamInventory(), out pResultHandle, itemIdSource, unQuantity, itemIdDest));
}
// Token: 0x0600080C RID: 2060 RVA: 0x00004EC5 File Offset: 0x000030C5
public static bool TradeItems(out SteamInventoryResult_t pResultHandle, CSteamID steamIDTradePartner, SteamItemInstanceID_t[] pArrayGive, uint[] pArrayGiveQuantity, uint nArrayGiveLength, SteamItemInstanceID_t[] pArrayGet, uint[] pArrayGetQuantity, uint nArrayGetLength)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_TradeItems(out pResultHandle, steamIDTradePartner, pArrayGive, pArrayGiveQuantity, nArrayGiveLength, pArrayGet, pArrayGetQuantity, nArrayGetLength));
}
/// <summary>
/// <para> Playtime credit must be consumed and turned into item drops by your game. Only item</para>
/// <para> definitions which are marked as "playtime item generators" can be spawned. The call</para>
/// <para> will return an empty result set if there is not enough playtime credit for a drop.</para>
/// <para> Your game should call TriggerItemDrop at an appropriate time for the user to receive</para>
/// <para> new items, such as between rounds or while the player is dead. Note that players who</para>
/// <para> hack their clients could modify the value of "dropListDefinition", so do not use it</para>
/// <para> to directly control rarity.</para>
/// <para> See your Steamworks configuration to set playtime drop rates for individual itemdefs.</para>
/// <para> The client library will suppress too-frequent calls to this method.</para>
/// </summary>
public static bool TriggerItemDrop(out SteamInventoryResult_t pResultHandle, SteamItemDef_t dropListDefinition)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_TriggerItemDrop(CSteamAPIContext.GetSteamInventory(), out pResultHandle, dropListDefinition));
}
// Token: 0x060007FD RID: 2045 RVA: 0x00004DE6 File Offset: 0x00002FE6
public static bool CheckResultSteamID(SteamInventoryResult_t resultHandle, CSteamID steamIDExpected)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_CheckResultSteamID(resultHandle, steamIDExpected));
}
/// <summary>
/// <para> Submit the update request by handle</para>
/// </summary>
public static bool SubmitUpdateProperties(SteamInventoryUpdateHandle_t handle, out SteamInventoryResult_t pResultHandle)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_SubmitUpdateProperties(CSteamAPIContext.GetSteamInventory(), handle, out pResultHandle));
}
// Token: 0x06000801 RID: 2049 RVA: 0x00004E1D File Offset: 0x0000301D
public static bool SerializeResult(SteamInventoryResult_t resultHandle, byte[] pOutBuffer, out uint punOutBufferSize)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_SerializeResult(resultHandle, pOutBuffer, out punOutBufferSize));
}
/// <summary>
/// <para> Returns the server time at which the result was generated. Compare against</para>
/// <para> the value of IClientUtils::GetServerRealTime() to determine age.</para>
/// </summary>
public static uint GetResultTimestamp(SteamInventoryResult_t resultHandle)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_GetResultTimestamp(CSteamAPIContext.GetSteamInventory(), resultHandle));
}
// Token: 0x06000804 RID: 2052 RVA: 0x00004E4C File Offset: 0x0000304C
public static bool GrantPromoItems(out SteamInventoryResult_t pResultHandle)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_GrantPromoItems(out pResultHandle));
}
/// <summary>
/// <para> Returns true if the result belongs to the target steam ID, false if the</para>
/// <para> result does not. This is important when using DeserializeResult, to verify</para>
/// <para> that a remote player is not pretending to have a different user's inventory.</para>
/// </summary>
public static bool CheckResultSteamID(SteamInventoryResult_t resultHandle, CSteamID steamIDExpected)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamInventory_CheckResultSteamID(CSteamAPIContext.GetSteamInventory(), resultHandle, steamIDExpected));
}
// Token: 0x060007FA RID: 2042 RVA: 0x00004DBD File Offset: 0x00002FBD
public static EResult GetResultStatus(SteamInventoryResult_t resultHandle)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_GetResultStatus(resultHandle));
}
// Token: 0x06000807 RID: 2055 RVA: 0x00004E76 File Offset: 0x00003076
public static bool ConsumeItem(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemConsume, uint unQuantity)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerInventory_ConsumeItem(out pResultHandle, itemConsume, unQuantity));
}
/// <summary>
/// <para> Destroys a result handle and frees all associated memory.</para>
/// </summary>
public static void DestroyResult(SteamInventoryResult_t resultHandle)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamInventory_DestroyResult(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle);
}
/// <summary>
/// <para> INVENTORY ASYNC QUERY</para>
/// <para> Captures the entire state of the current user's Steam inventory.</para>
/// <para> You must call DestroyResult on this handle when you are done with it.</para>
/// <para> Returns false and sets *pResultHandle to zero if inventory is unavailable.</para>
/// <para> Note: calls to this function are subject to rate limits and may return</para>
/// <para> cached results if called too frequently. It is suggested that you call</para>
/// <para> this function only when you are about to display the user's full inventory,</para>
/// <para> or if you expect that the inventory may have changed.</para>
/// </summary>
public static bool GetAllItems(out SteamInventoryResult_t pResultHandle)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamInventory_GetAllItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle));
}
