internal Item ItemFrom(SteamInventoryResult_t handle, SteamItemDetails_t detail, int index)
        {
            var props = new Dictionary <string, string>();

            if (inventory.GetResultItemProperty(handle, (uint)index, null, out string propertyNames))
            {
                foreach (var propertyName in propertyNames.Split(','))
                {
                    if (inventory.GetResultItemProperty(handle, (uint)index, propertyName, out string propertyValue))
                    {
                        if (propertyName == "error")
                        {
                            Console.Write("Steam item error: ");
                            Console.WriteLine(propertyValue);
                            return(null);
                        }

                        props.Add(propertyName, propertyValue);
                    }
                }
            }

            var item = new Item(this, detail.ItemId, detail.Quantity, detail.Definition);

            item.Properties = props;

            return(item);
        }
        public                          InventoryItem[] GetItems(bool includeProperties = false)
        {
            uint cnt = (uint)ItemCount;

            if (cnt <= 0)
            {
                return(null);
            }

            var pOutItemsArray = new SteamItemDetails_t[cnt];

            if (!SteamInventory.Internal.GetResultItems(_id, pOutItemsArray, ref cnt))
            {
                return(null);
            }

            var items = new InventoryItem[cnt];

            for (int i = 0; i < cnt; i++)
            {
                var item = InventoryItem.From(pOutItemsArray[i]);

                if (includeProperties)
                {
                    item._properties = InventoryItem.GetProperties(_id, i);
                }

                items[i] = item;
            }


            return(items);
        }
示例#3
0
 private void Update()
 {
     if (Global.isSteamActive && this.m_waitForResult)
     {
         EResult resultStatus = SteamInventory.GetResultStatus(this.m_resultHandle);
         if (resultStatus != EResult.k_EResultPending)
         {
             if (resultStatus == EResult.k_EResultOK)
             {
                 uint num = 0U;
                 if (SteamInventory.GetResultItems(this.m_resultHandle, null, ref num) && num > 0U)
                 {
                     SteamItemDetails_t[] array = new SteamItemDetails_t[num];
                     SteamInventory.GetResultItems(this.m_resultHandle, array, ref num);
                     this.m_itemDetails.AddRange(array);
                 }
                 this.EquipSteamInventoryItems();
             }
             else
             {
                 Debug.Log("SteamInventoryHandler.cs: Couldn't get inventory: " + resultStatus.ToString());
             }
             SteamInventory.DestroyResult(this.m_resultHandle);
             this.m_waitForResult = false;
         }
     }
 }
示例#4
0
 public InventoryItemPointer this[SteamItemDetails_t item]
 {
     get
     {
         return(this[item.m_iDefinition]);
     }
 }
示例#5
0
 public InventoryItemDefinition this[SteamItemDetails_t item]
 {
     get
     {
         return(GetDefinition(item));
     }
 }
    private void Update()
    {
        if (!Global.isSteamActive || !m_waitForResult)
        {
            return;
        }
        EResult resultStatus = SteamInventory.GetResultStatus(m_resultHandle);

        switch (resultStatus)
        {
        case EResult.k_EResultPending:
            return;

        case EResult.k_EResultOK:
        {
            uint punOutItemsArraySize = 0u;
            if (SteamInventory.GetResultItems(m_resultHandle, null, ref punOutItemsArraySize) && punOutItemsArraySize != 0)
            {
                SteamItemDetails_t[] array = new SteamItemDetails_t[punOutItemsArraySize];
                SteamInventory.GetResultItems(m_resultHandle, array, ref punOutItemsArraySize);
                m_itemDetails.AddRange(array);
            }
            EquipSteamInventoryItems();
            break;
        }

        default:
            Debug.Log("SteamInventoryHandler.cs: Couldn't get inventory: " + resultStatus);
            break;
        }
        SteamInventory.DestroyResult(m_resultHandle);
        m_waitForResult = false;
    }
示例#7
0
        internal Item ItemFrom(SteamInventoryResult_t handle, SteamItemDetails_t detail, int index)
        {
            var props = new Dictionary <string, string>();

            if (inventory.GetResultItemProperty(handle, (uint)index, null, out string propertyNames))
            {
                foreach (var propertyName in propertyNames.Split(','))
                {
                    if (inventory.GetResultItemProperty(handle, (uint)index, propertyName, out string propertyValue))
                    {
                        props.Add(propertyName, propertyValue);
                    }
                }
            }

            var item = new Item()
            {
                Quantity     = detail.Quantity,
                Id           = detail.ItemId,
                DefinitionId = detail.Definition,
                TradeLocked  = ((int)detail.Flags & (int)SteamNative.SteamItemFlags.NoTrade) != 0,
                Definition   = FindDefinition(detail.Definition),
                Properties   = props
            };

            return(item);
        }
示例#8
0
    private void OnLootboxResultReady(SteamInventoryResultReady_t pCallback)
    {
        Debug.Log("@OnLootboxResultReady called, callback params: " + pCallback.m_handle + ", " + pCallback.m_result);

        LootboxResult = pCallback.m_handle;
        uint size = 0;

        SteamItemDetails_t[] items;
        bool result = SteamInventory.GetResultItems(LootboxResult, null, ref size);

        if (result && size > 0)
        {
            items  = new SteamItemDetails_t[size];
            result = SteamInventory.GetResultItems(LootboxResult, items, ref size);
            Debug.LogWarning("@OnLootboxResultReady: Get lootbox result: " + result + " with items num: " + items.Length);

            UpdateInventory(items, display: true);

            /// Dispose results and update
            Debug.Log("Disposing resources");
            SteamInventory.DestroyResult(LootboxResult);
            _lootboxesRequested -= items.Length;
            if (_lootboxesRequested <= 0)
            {
                m_LootboxResultReady.Dispose();
            }
        }
    }
示例#9
0
    private void OnInventoryResultReady(SteamInventoryResultReady_t pCallback)
    {
        Debug.Log("@OnInventoryResultReady called, callback params: " + pCallback.m_handle + ", " + pCallback.m_result);

        InventoryResult = pCallback.m_handle;
        uint size = 0;

        SteamItemDetails_t[] items;
        bool result = SteamInventory.GetResultItems(InventoryResult, null, ref size);

        if (result && size > 0)
        {
            items = new SteamItemDetails_t[size];
            bool ret = SteamInventory.GetResultItems(InventoryResult, items, ref size);
            Debug.LogWarning("@OnInventoryResultReady: Inventory fetch result: " + ret + " with items num: " + items.Length);

            /// Add anew
            UpdateInventory(items, display: false);
        }
        else
        {
            Debug.LogWarning("@OnInventoryResultReady: InventoryResult = " + InventoryResult.m_SteamInventoryResult + ", Size = " + size + ". Could not get result items, problem may be in:\n" +
                             "- InventoryResult оказался недействительным, либо дескриптор результата действий с инвентарём оказался не готов.\n" +
                             "- Массив не уместился в pOutItemsArray.\n" +
                             "- У пользователя нет предметов.");
        }

        /// Dispose result
        SteamInventory.DestroyResult(InventoryResult);
    }
    private bool SellItem(int a_index)
    {
        bool result = false;

        if (m_itemDetails != null && a_index > -1 && a_index < m_itemDetails.Count)
        {
            ulong    num = (!(null != m_client)) ? 12345678 : m_client.GetSteamId();
            object[] obj = new object[6]
            {
                "http://steamcommunity.com/profiles/",
                num,
                "/inventory#",
                348670,
                "_2_",
                null
            };
            SteamItemDetails_t steamItemDetails_t = m_itemDetails[a_index];
            obj[5] = steamItemDetails_t.m_itemId.m_SteamItemInstanceID;
            string text = string.Concat(obj);
            if (Global.isSteamActive)
            {
                SteamFriends.ActivateGameOverlayToWebPage(text);
            }
            else
            {
                Debug.Log("DEBUG: " + text);
            }
            result = true;
        }
        return(result);
    }
示例#11
0
        private static void updateFilter()
        {
            string text = MenuSurvivorsClothingUI.searchField.text;

            if (text == null || text.Length < 1)
            {
                MenuSurvivorsClothingUI.filteredItems = new List <SteamItemDetails_t>(Provider.provider.economyService.inventory);
            }
            else
            {
                MenuSurvivorsClothingUI.filteredItems = new List <SteamItemDetails_t>();
                for (int i = 0; i < Provider.provider.economyService.inventory.Length; i++)
                {
                    SteamItemDetails_t item          = Provider.provider.economyService.inventory[i];
                    string             inventoryName = Provider.provider.economyService.getInventoryName(item.m_iDefinition.m_SteamItemDef);
                    if (inventoryName.IndexOf(text, StringComparison.OrdinalIgnoreCase) != -1)
                    {
                        MenuSurvivorsClothingUI.filteredItems.Add(item);
                    }
                    else
                    {
                        string inventoryType = Provider.provider.economyService.getInventoryType(item.m_iDefinition.m_SteamItemDef);
                        if (inventoryType.IndexOf(text, StringComparison.OrdinalIgnoreCase) != -1)
                        {
                            MenuSurvivorsClothingUI.filteredItems.Add(item);
                        }
                    }
                }
            }
        }
 public void addLocalItem(SteamItemDetails_t item)
 {
     SteamItemDetails_t[] array = new SteamItemDetails_t[this.inventory.Length + 1];
     for (int i = 0; i < this.inventory.Length; i++)
     {
         array[i] = this.inventory[i];
     }
     array[this.inventory.Length] = item;
     this.inventoryDetails        = array;
 }
 private bool HasItemDef(int a_itemDef)
 {
     for (int i = 0; i < m_itemDetails.Count; i++)
     {
         SteamItemDetails_t steamItemDetails_t = m_itemDetails[i];
         if (steamItemDetails_t.m_iDefinition.m_SteamItemDef == a_itemDef)
         {
             return(true);
         }
     }
     return(false);
 }
示例#14
0
        internal static InventoryItem From(SteamItemDetails_t details)
        {
            var i = new InventoryItem
            {
                _id       = details.ItemId,
                _def      = details.Definition,
                _flags    = (SteamItemFlags)details.Flags,
                _quantity = details.Quantity
            };

            return(i);
        }
    private void HandleDropResult()
    {
        if (!m_waitForResult || !Global.isSteamActive)
        {
            return;
        }
        bool    flag         = false;
        EResult resultStatus = SteamInventory.GetResultStatus(m_itemDropHandle);

        switch (resultStatus)
        {
        case EResult.k_EResultPending:
            return;

        case EResult.k_EResultOK:
        {
            uint punOutItemsArraySize = 0u;
            if (!SteamInventory.GetResultItems(m_itemDropHandle, null, ref punOutItemsArraySize))
            {
                break;
            }
            SteamItemDetails_t[] array = new SteamItemDetails_t[punOutItemsArraySize];
            if (punOutItemsArraySize != 0)
            {
                SteamInventory.GetResultItems(m_itemDropHandle, array, ref punOutItemsArraySize);
                for (int i = 0; i < array.Length; i++)
                {
                    if ((array[i].m_unFlags & 0x100) == 0)
                    {
                        m_itemPopupGui.ShowGui(true, array[i].m_iDefinition.m_SteamItemDef);
                        break;
                    }
                }
            }
            else
            {
                flag = true;
            }
            break;
        }

        default:
            Debug.Log("RemoteCharacter.cs: Couldn't get item drop: " + resultStatus);
            break;
        }
        SteamInventory.DestroyResult(m_itemDropHandle);
        m_waitForResult = false;
        if (flag)
        {
            GetPromoItem();
        }
    }
 private void Update()
 {
     UpdateInventory();
     if (!m_waitForResult && !m_caseOpenGui.InProgress() && m_caseOpenFlag)
     {
         UpdateInventoryDisplay();
         m_caseOpenFlag = false;
     }
     if (!Input.GetKeyDown(KeyCode.P))
     {
         return;
     }
     if (Global.isSteamActive)
     {
         if ("vidiludi" == m_client.GetPlayerName() || "Ethan" == m_client.GetPlayerName() || "Editor" == m_client.GetPlayerName())
         {
             SteamItemDef_t[] array  = new SteamItemDef_t[4];
             uint[]           array2 = new uint[4];
             array[0].m_SteamItemDef = 2004;
             array[1].m_SteamItemDef = 2004;
             array[2].m_SteamItemDef = 3000;
             array[3].m_SteamItemDef = 3000;
             array2[0]         = 1u;
             array2[1]         = 1u;
             array2[2]         = 1u;
             array2[3]         = 1u;
             m_waitForResult   = SteamInventory.GenerateItems(out m_resultHandle, array, null, 4u);
             m_completeRefresh = false;
         }
     }
     else
     {
         SteamItemDetails_t item = default(SteamItemDetails_t);
         item.m_iDefinition.m_SteamItemDef = 2004;
         item.m_unQuantity = 1;
         m_itemDetails.Add(item);
         for (int i = 0; i < 10; i++)
         {
             item.m_iDefinition.m_SteamItemDef = 20000 + i;
             item.m_unQuantity = 1;
             m_itemDetails.Add(item);
         }
         item.m_iDefinition.m_SteamItemDef = 2004;
         item.m_unQuantity = 1;
         m_itemDetails.Add(item);
         UpdateInventoryDisplay();
     }
 }
示例#17
0
        // Token: 0x0600174A RID: 5962 RVA: 0x00086218 File Offset: 0x00084618
        public void addLocalItem(SteamItemDetails_t item, string tags, string dynamic_props)
        {
            SteamItemDetails_t[] array = new SteamItemDetails_t[this.inventory.Length + 1];
            for (int i = 0; i < this.inventory.Length; i++)
            {
                array[i] = this.inventory[i];
            }
            array[this.inventory.Length] = item;
            this.inventoryDetails        = array;
            this.dynamicInventoryDetails.Remove(item.m_itemId.m_SteamItemInstanceID);
            DynamicEconDetails value = default(DynamicEconDetails);

            value.tags          = ((!string.IsNullOrEmpty(tags)) ? tags : string.Empty);
            value.dynamic_props = ((!string.IsNullOrEmpty(dynamic_props)) ? dynamic_props : string.Empty);
            this.dynamicInventoryDetails.Add(item.m_itemId.m_SteamItemInstanceID, value);
        }
示例#18
0
    private SteamItemDetails_t GetRandomItemFromInventory(int a_defIdFrom, int a_defIdTo)
    {
        if (this.m_itemDetails != null)
        {
            for (int i = 0; i < this.m_itemDetails.Count; i++)
            {
                if (this.m_itemDetails[i].m_iDefinition.m_SteamItemDef <= a_defIdTo && this.m_itemDetails[i].m_iDefinition.m_SteamItemDef >= a_defIdFrom)
                {
                    return(this.m_itemDetails[i]);
                }
            }
        }
        SteamItemDetails_t result = default(SteamItemDetails_t);

        result.m_itemId.m_SteamItemInstanceID = 0UL;
        return(result);
    }
示例#19
0
 private void HandleDropResult()
 {
     if (this.m_waitForResult && Global.isSteamActive)
     {
         bool    flag         = false;
         EResult resultStatus = SteamInventory.GetResultStatus(this.m_itemDropHandle);
         if (resultStatus != EResult.k_EResultPending)
         {
             if (resultStatus == EResult.k_EResultOK)
             {
                 uint num = 0U;
                 if (SteamInventory.GetResultItems(this.m_itemDropHandle, null, ref num))
                 {
                     SteamItemDetails_t[] array = new SteamItemDetails_t[num];
                     if (num > 0U)
                     {
                         SteamInventory.GetResultItems(this.m_itemDropHandle, array, ref num);
                         for (int i = 0; i < array.Length; i++)
                         {
                             if ((array[i].m_unFlags & 256) == 0)
                             {
                                 this.m_itemPopupGui.ShowGui(true, array[i].m_iDefinition.m_SteamItemDef);
                                 break;
                             }
                         }
                     }
                     else
                     {
                         flag = true;
                     }
                 }
             }
             else
             {
                 Debug.Log("RemoteCharacter.cs: Couldn't get item drop: " + resultStatus.ToString());
             }
             SteamInventory.DestroyResult(this.m_itemDropHandle);
             this.m_waitForResult = false;
             if (flag)
             {
                 this.GetPromoItem();
             }
         }
     }
 }
示例#20
0
        /// <summary>
        /// Splits an instance quantity, if the destination instance is -1 this will create a new stack of the defined quantity.
        /// </summary>
        /// <param name="source">The instance to split</param>
        /// <param name="quantity">The number of items to remove from the source stack</param>
        /// <param name="destination">The target to move the quanity to</param>
        /// <returns></returns>
        public bool TransferQuantity(SteamItemDetails_t source, uint quantity, SteamItemInstanceID_t destination)
        {
            if (source.m_unQuantity >= quantity)
            {
                var ret = SteamworksPlayerInventory.TransferQuantity(source.m_itemId, quantity, destination, (result) =>
                {
                    Instances.RemoveAll(p => p.m_itemId == source.m_itemId);
                    source.m_unQuantity -= Convert.ToUInt16(quantity);
                    Instances.Add(source);
                });

                return(ret);
            }
            else
            {
                return(false);
            }
        }
示例#21
0
    private void OnItemResultReady(SteamInventoryResultReady_t pCallback)
    {
        Debug.Log("@OnItemResultReady called, callback params: " + pCallback.m_handle + ", " + pCallback.m_result);

        ItemResult = pCallback.m_handle;
        uint size = 0;

        SteamItemDetails_t[] items;
        bool result = SteamInventory.GetResultItems(ItemResult, null, ref size);

        if (result && size > 0)
        {
            items  = new SteamItemDetails_t[size];
            result = SteamInventory.GetResultItems(ItemResult, items, ref size);
            Debug.LogWarning("@OnItemResultReady: Get item result: " + result + " with items num: " + items.Length);

            UpdateInventory(items, display: true);
        }
    }
示例#22
0
        /// <summary>
        /// Moves the quantity from the source into a new stack
        /// </summary>
        /// <param name="source">Source instance to move units from</param>
        /// <param name="quantity">The number of units to move</param>
        /// <returns></returns>
        public bool SplitInstance(SteamItemDetails_t source, uint quantity)
        {
            if (source.m_unQuantity >= quantity)
            {
                var ret = SteamworksPlayerInventory.TransferQuantity(source.m_itemId, quantity, SteamItemInstanceID_t.Invalid, (result) =>
                {
                    Instances.RemoveAll(p => p.m_itemId == source.m_itemId);
                    source.m_unQuantity -= Convert.ToUInt16(quantity);
                    Instances.Add(source);
                });

                return(ret);
            }
            else
            {
                Debug.LogWarning("Unable to split instance, insufficent units available to move.");
                return(false);
            }
        }
    private int GetClickedItemIndex(string a_clickedBtnName)
    {
        int result = -1;

        string[] array = a_clickedBtnName.Split('-');
        if (array != null && 1 < array.Length && "sii" == array[0])
        {
            int num = -1;
            try
            {
                num = int.Parse(array[1]);
            }
            catch (Exception ex)
            {
                Debug.LogWarning("SteamInventoryGUI.cs: " + ex.ToString());
            }
            if (num > -1 && m_itemDetails != null && num < m_itemDetails.Count)
            {
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                m_contextMenu.transform.position       = ray.GetPoint(3.5f);
                m_contextMenu.transform.localPosition += new Vector3(0.2f, -0.1f, 0f);
                SteamItemDetails_t steamItemDetails_t = m_itemDetails[num];
                int    steamItemDef = steamItemDetails_t.m_iDefinition.m_SteamItemDef;
                string empty        = string.Empty;
                if (10000 > steamItemDef)
                {
                    empty = "STEAM_INV_OPEN_CASE";
                }
                else
                {
                    int lookItemDef = m_steamInventoryHandler.GetLookItemDef();
                    int skinItemDef = m_steamInventoryHandler.GetSkinItemDef();
                    empty = ((lookItemDef != steamItemDef && skinItemDef != steamItemDef) ? "STEAM_INV_EQUIP" : "STEAM_INV_UNEQUIP");
                }
                m_txtEquipOpen.text = LNG.Get(empty);
                result = num;
                m_contextMenu.SetActive(true);
            }
        }
        return(result);
    }
        private IEconomyRequestResult createInventoryRequestResult(SteamInventoryResult_t steamInventoryResult)
        {
            uint num = 0u;

            SteamworksEconomyItem[] array2;
            if (SteamGameServerInventory.GetResultItems(steamInventoryResult, null, ref num) && num > 0u)
            {
                SteamItemDetails_t[] array = new SteamItemDetails_t[num];
                SteamGameServerInventory.GetResultItems(steamInventoryResult, array, ref num);
                array2 = new SteamworksEconomyItem[num];
                for (uint num2 = 0u; num2 < num; num2 += 1u)
                {
                    SteamItemDetails_t    newSteamItemDetail    = array[(int)((UIntPtr)num2)];
                    SteamworksEconomyItem steamworksEconomyItem = new SteamworksEconomyItem(newSteamItemDetail);
                    array2[(int)((UIntPtr)num2)] = steamworksEconomyItem;
                }
            }
            else
            {
                array2 = new SteamworksEconomyItem[0];
            }
            return(new EconomyRequestResult(EEconomyRequestState.SUCCESS, array2));
        }
        // bool
        // using: Detect_MultiSizeArrayReturn
        public SteamItemDetails_t[] GetResultItems(SteamInventoryResult_t resultHandle /*SteamInventoryResult_t*/)
        {
            uint punOutItemsArraySize = 0;

            bool success = false;

            success = platform.ISteamInventory_GetResultItems(resultHandle.Value, IntPtr.Zero, out punOutItemsArraySize);
            if (!success || punOutItemsArraySize == 0)
            {
                return(null);
            }

            var pOutItemsArray = new SteamItemDetails_t[punOutItemsArraySize];

            fixed(void *pOutItemsArray_ptr = pOutItemsArray)
            {
                success = platform.ISteamInventory_GetResultItems(resultHandle.Value, (IntPtr)pOutItemsArray_ptr, out punOutItemsArraySize);
                if (!success)
                {
                    return(null);
                }
                return(pOutItemsArray);
            }
        }
示例#26
0
 /// <summary>
 /// Splits an instance quantity, if the destination instance is -1 this will create a new stack of the defined quantity.
 /// </summary>
 /// <param name="source">The instance to split</param>
 /// <param name="quantity">The number of items to remove from the source stack</param>
 /// <param name="destination">The target to move the quanity to</param>
 /// <returns></returns>
 public bool TransferQuantity(InventoryItemDefinition item, SteamItemDetails_t source, uint quantity, SteamItemInstanceID_t destination)
 {
     return(item.TransferQuantity(source, quantity, destination));
 }
 // Token: 0x060017E6 RID: 6118 RVA: 0x00088784 File Offset: 0x00086B84
 public SteamworksEconomyItem(SteamItemDetails_t newSteamItemDetail)
 {
     this.steamItemDetail  = newSteamItemDetail;
     this.itemDefinitionID = new SteamworksEconomyItemDefinition(this.steamItemDetail.m_iDefinition);
     this.itemInstanceID   = new SteamworksEconomyItemInstance(this.steamItemDetail.m_itemId);
 }
示例#28
0
            public static bool Prefix(ref SteamInventoryResultReady_t callback,
                                      ref SteamInventoryResult_t ___inventoryResult,
                                      ref Dictionary <ulong, DynamicEconDetails> ___dynamicInventoryDetails,
                                      TempSteamworksEconomy __instance)
            {
                bool inst = false;

                if ((___inventoryResult != SteamInventoryResult_t.Invalid) && (callback.m_handle == ___inventoryResult))
                {
                    ___dynamicInventoryDetails.Clear();
                    uint num12 = 0;
                    if (SteamInventory.GetResultItems(___inventoryResult, null, ref num12) && (num12 > 0))
                    {
                        SteamItemDetails_t[] _tArray3 = new SteamItemDetails_t[num12];
                        SteamInventory.GetResultItems(___inventoryResult, _tArray3, ref num12);
                        for (uint i = 0; i < num12; i++)
                        {
                            string str7;

                            string str8;
                            uint   num14 = 0x400;
                            SteamInventory.GetResultItemProperty(___inventoryResult, i, "tags", out str7, ref num14);
                            uint num15 = 0x400;
                            SteamInventory.GetResultItemProperty(___inventoryResult, i, "dynamic_props", out str8, ref num15);
                            DynamicEconDetails details2 = new DynamicEconDetails
                            {
                                tags          = !string.IsNullOrEmpty(str7) ? str7 : string.Empty,
                                dynamic_props = !string.IsNullOrEmpty(str8) ? str8 : string.Empty
                            };
                            ___dynamicInventoryDetails.Add(_tArray3[i].m_itemId.m_SteamItemInstanceID, details2);
                        }

                        __instance.inventoryDetails = new List <SteamItemDetails_t>(_tArray3);

                        inst = true;
                    }

                    if (!inst)
                    {
                        __instance.inventoryDetails = new List <SteamItemDetails_t>();
                    }

                    //Add custom skins
                    foreach (Sk t in SkinList)
                    {
                        __instance.inventoryDetails.Add(new SteamItemDetails_t()
                        {
                            m_iDefinition = new SteamItemDef_t(t.itemDef),
                            m_itemId      = new SteamItemInstanceID_t(t.instanceId),
                            m_unFlags     = 0,
                            m_unQuantity  = 1
                        });
                    }

                    __instance.consolidateStacks();
                    __instance.onInventoryRefreshed?.Invoke();
                    __instance.isInventoryAvailable = true;
                    Provider.isLoadingInventory     = false;
                    SteamInventory.DestroyResult(___inventoryResult);
                    ___inventoryResult = SteamInventoryResult_t.Invalid;

                    return(false);
                }

                return(true);
            }
示例#29
0
 /// <summary>
 /// Moves the source instance in its entirety to the destination.
 /// </summary>
 /// <param name="source">The source to move</param>
 /// <param name="destination">The target destination</param>
 /// <returns></returns>
 public bool StackInstance(InventoryItemDefinition item, SteamItemDetails_t source, SteamItemInstanceID_t destination)
 {
     return(item.StackInstance(source, destination));
 }
示例#30
0
 /// <summary>
 /// Moves the quantity from the source into a new stack
 /// </summary>
 /// <param name="source">Source instance to move units from</param>
 /// <param name="quantity">The number of units to move</param>
 /// <returns></returns>
 public bool SplitInstance(InventoryItemDefinition item, SteamItemDetails_t source, uint quantity)
 {
     return(item.SplitInstance(source, quantity));
 }
示例#31
0
 public abstract bool GetResultItems(int resultHandle,out SteamItemDetails_t [] pOutItemsArray);
示例#32
0
 public override bool GetResultItems(int resultHandle,out SteamItemDetails_t [] pOutItemsArray)
 {
     CheckIfUsable();
     uint punOutItemsArraySize = 0;
     bool result = NativeEntrypoints.SteamAPI_ISteamInventory_GetResultItems(m_pSteamInventory,resultHandle,null,ref punOutItemsArraySize);
     pOutItemsArray= new SteamItemDetails_t[punOutItemsArraySize];
      result = NativeEntrypoints.SteamAPI_ISteamInventory_GetResultItems(m_pSteamInventory,resultHandle,pOutItemsArray,ref punOutItemsArraySize);
     return result;
 }