public void OnEnable() { m_SteamInventoryResultReady = Callback<SteamInventoryResultReady_t>.Create(OnSteamInventoryResultReady); m_SteamInventoryFullUpdate = Callback<SteamInventoryFullUpdate_t>.Create(OnSteamInventoryFullUpdate); m_SteamInventoryDefinitionUpdate = Callback<SteamInventoryDefinitionUpdate_t>.Create(OnSteamInventoryDefinitionUpdate); m_SteamInventoryResult = SteamInventoryResult_t.Invalid; m_SteamItemDetails = null; m_SteamItemDef = null; m_SerializedBuffer = null; }
void OnSteamInventoryResultReady(SteamInventoryResultReady_t pCallback) { Debug.Log("[" + SteamInventoryResultReady_t.k_iCallback + " - SteamInventoryResultReady] - " + pCallback.m_handle + " -- " + pCallback.m_result); m_SteamInventoryResult = pCallback.m_handle; }
/// <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.ISteamGameServerInventory_GetAllItems(out pResultHandle); }
/// <summary> /// <para> Copies the contents of a result set into a flat array. The specific</para> /// <para> contents of the result set depend on which query which was used.</para> /// </summary> 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> 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.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_CheckResultSteamID(resultHandle, steamIDExpected); }
/// <summary> /// <para> ExchangeItems() is an atomic combination of GenerateItems and DestroyItems. It can be</para> /// <para> used to implement crafting recipes or transmutations, or items which unpack themselves</para> /// <para> into other items. Like GenerateItems, this is a flexible and dangerous API which is</para> /// <para> meant for rapid prototyping. You can configure restrictions on ExchangeItems via the</para> /// <para> Steamworks website, such as limiting it to a whitelist of input/output combinations</para> /// <para> corresponding to recipes.</para> /// <para> (Note: although GenerateItems may be hard or impossible to use securely in your game,</para> /// <para> ExchangeItems is perfectly reasonable to use once the whitelists are set accordingly.)</para> /// </summary> 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> 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. It is primarily useful during testing and development,</para> /// <para> where you may wish to perform experiments with different types of drops.</para> /// </summary> public static bool TriggerItemDrop(out SteamInventoryResult_t pResultHandle, SteamItemDef_t dropListDefinition) { InteropHelp.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_TriggerItemDrop(out pResultHandle, dropListDefinition); }
public static extern bool ISteamGameServerInventory_AddPromoItems(out SteamInventoryResult_t pResultHandle, [In, Out] SteamItemDef_t[] pArrayItemDefs, uint unArrayLength);
public static extern bool ISteamGameServerInventory_ConsumeItem(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemConsume, uint unQuantity);
public static extern bool ISteamGameServerInventory_GrantPromoItems(out SteamInventoryResult_t pResultHandle);
public static extern bool ISteamGameServerInventory_AddPromoItem(out SteamInventoryResult_t pResultHandle, SteamItemDef_t itemDef);
public static extern bool ISteamGameServerInventory_GenerateItems(out SteamInventoryResult_t pResultHandle, [In, Out] SteamItemDef_t[] pArrayItemDefs, [In, Out] uint[] punArrayQuantity, uint unArrayLength);
public static extern bool ISteamGameServerInventory_DeserializeResult(out SteamInventoryResult_t pOutResultHandle, [In, Out] byte[] pBuffer, uint unBufferSize, [MarshalAs(UnmanagedType.I1)] bool bRESERVED_MUST_BE_FALSE);
public static extern bool ISteamGameServerInventory_SerializeResult(SteamInventoryResult_t resultHandle, [In, Out] byte[] pOutBuffer, out uint punOutBufferSize);
void OnSteamInventoryFullUpdate(SteamInventoryFullUpdate_t pCallback) { Debug.Log("[" + SteamInventoryFullUpdate_t.k_iCallback + " - SteamInventoryFullUpdate] - " + pCallback.m_handle); m_SteamInventoryResult = pCallback.m_handle; }
public static extern bool ISteamGameServerInventory_ExchangeItems(out SteamInventoryResult_t pResultHandle, [In, Out] SteamItemDef_t[] pArrayGenerate, [In, Out] uint[] punArrayGenerateQuantity, uint unArrayGenerateLength, [In, Out] SteamItemInstanceID_t[] pArrayDestroy, [In, Out] uint[] punArrayDestroyQuantity, uint unArrayDestroyLength);
/// <summary> /// <para> ConsumeItem() removes items from the inventory, permenantly. 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. Similar to GenerateItems, punArrayQuantity</para> /// <para> can be NULL or else an array of the same length as pArrayItems which describe the quantity</para> /// <para> of each item to destroy. ConsumeItem can be restricted to certain item definitions or</para> /// <para> fully blocked via the Steamworks website to minimize support/abuse issues such as the</para> /// <para> clasic "my brother borrowed my laptop and deleted all of my rare items".</para> /// </summary> public static bool ConsumeItem(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemConsume, uint unQuantity) { InteropHelp.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_ConsumeItem(out pResultHandle, itemConsume, unQuantity); }
public static extern bool ISteamGameServerInventory_TransferItemQuantity(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemIdSource, uint unQuantity, SteamItemInstanceID_t 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.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_TransferItemQuantity(out pResultHandle, itemIdSource, unQuantity, itemIdDest); }
public static extern bool ISteamGameServerInventory_TriggerItemDrop(out SteamInventoryResult_t pResultHandle, SteamItemDef_t dropListDefinition);
/// <summary> /// <para> IN-GAME TRADING</para> /// <para> TradeItems() implements limited in-game trading of items, if you prefer not to use</para> /// <para> the overlay or an in-game web browser to perform Steam Trading through the website.</para> /// <para> You should implement a UI where both players can see and agree to a trade, and then</para> /// <para> each client should call TradeItems simultaneously (+/- 5 seconds) with matching</para> /// <para> (but reversed) parameters. The result is the same as if both players performed a</para> /// <para> Steam Trading transaction through the web. Each player will get an inventory result</para> /// <para> confirming the removal or quantity changes of the items given away, and the new</para> /// <para> item instance id numbers and quantities of the received items.</para> /// <para> (Note: new item instance IDs are generated whenever an item changes ownership.)</para> /// </summary> 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); }
public static extern bool ISteamGameServerInventory_TradeItems(out SteamInventoryResult_t pResultHandle, CSteamID steamIDTradePartner, [In, Out] SteamItemInstanceID_t[] pArrayGive, [In, Out] uint[] pArrayGiveQuantity, uint nArrayGiveLength, [In, Out] SteamItemInstanceID_t[] pArrayGet, [In, Out] uint[] pArrayGetQuantity, uint nArrayGetLength);
/// <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.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_GetResultTimestamp(resultHandle); }
/// <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.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_SerializeResult(resultHandle, pOutBuffer, out punOutBufferSize); }
/// <summary> /// <para> Destroys a result handle and frees all associated memory.</para> /// </summary> public static void DestroyResult(SteamInventoryResult_t resultHandle) { InteropHelp.TestIfAvailableGameServer(); NativeMethods.ISteamGameServerInventory_DestroyResult(resultHandle); }
/// <summary> /// <para> Deserializes a result set and verifies the signature bytes. Returns false</para> /// <para> if bRequireFullOnlineVerify is set but Steam is running in Offline mode.</para> /// <para> Otherwise returns true and then delivers error codes via GetResultStatus.</para> /// <para> The bRESERVED_MUST_BE_FALSE flag is reserved for future use and should not</para> /// <para> be set to true by your game at this time.</para> /// <para> DeserializeResult has a potential soft-failure mode where the handle status</para> /// <para> is set to k_EResultExpired. GetResultItems() still succeeds in this mode.</para> /// <para> The "expired" result could indicate that the data may be out of date - not</para> /// <para> just due to timed expiration (one hour), but also because one of the items</para> /// <para> in the result set may have been traded or consumed since the result set was</para> /// <para> generated. You could compare the timestamp from GetResultTimestamp() to</para> /// <para> ISteamUtils::GetServerRealTime() to determine how old the data is. You could</para> /// <para> simply ignore the "expired" result code and continue as normal, or you</para> /// <para> could challenge the player with expired data to send an updated result set.</para> /// </summary> 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); }
/// <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.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_GetItemsByID(out pResultHandle, pInstanceIDs, unCountInstanceIDs); }
/// <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.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_AddPromoItem(out pResultHandle, itemDef); }
void DestroyResult() { if (m_SteamInventoryResult != SteamInventoryResult_t.Invalid) { SteamInventory.DestroyResult(m_SteamInventoryResult); print("SteamInventory.DestroyResult(" + m_SteamInventoryResult + ")"); m_SteamInventoryResult = SteamInventoryResult_t.Invalid; } }
public static bool AddPromoItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayItemDefs, uint unArrayLength) { InteropHelp.TestIfAvailableGameServer(); return NativeMethods.ISteamGameServerInventory_AddPromoItems(out pResultHandle, pArrayItemDefs, unArrayLength); }