public int AddItem(MyInventoryItem item)
        {
            int newKey = m_lastUsedKey++;

            m_itemsWithKeys.Add(newKey, item);
            return(newKey);
        }
 /// <summary>
 /// Called where amount of inventory item changed
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="amountChanged"></param>
 private void OnAmountChange(MyInventoryItem sender, float amountChanged)
 {
     if (OnInventoryItemAmountChange != null)
     {
         OnInventoryItemAmountChange(this, sender, amountChanged);
     }
 }
 /// <summary>
 /// Removes inventory item from inventory
 /// </summary>
 /// <param name="item">Inventory item</param>
 /// <param name="closeInventoryItem">If true, then close inventory item's instance in pool</param>
 public void RemoveInventoryItem(MyInventoryItem item, bool closeInventoryItem = false)
 {
     if (RemoveItemFromInventoryPrivate(item, closeInventoryItem))
     {
         CallContentChange();
     }
 }
Exemple #4
0
 private MyToolKit(MySmallShip smallShipOwner, MyPlayer playerOwner, MyInventoryItem toolInventoryItem, MyToolKitDelegates[] delegates) 
 {
     m_smallShipOwner = smallShipOwner;
     m_playerOwner = playerOwner;
     m_toolInventoryItem = toolInventoryItem;
     m_delegates = delegates;
 }
        public static MyInventoryItem CreateInventoryItemFromInventoryItemObjectBuilder(MyMwcObjectBuilder_InventoryItem inventoryItemBuilder)
        {
            MyInventoryItem item = CreateInventoryItemFromObjectBuilder(inventoryItemBuilder.ItemObjectBuilder, inventoryItemBuilder.Amount);

            item.TemporaryFlags = inventoryItemBuilder.TemporaryFlags;
            return(item);
        }
        private void AddItemToInventoryPrivate(MyInventoryItem item)
        {
            if (IsDisabled(item))
            {
                MyInventory.CloseInventoryItem(item);
            }
            else
            {
                if (InventorySynchronizer != null && InventorySynchronizer.MustBeSynchronized())
                {
                    InventorySynchronizer.AddInventoryItemForSynchronization(item);
                }
                else
                {
                    if (!UnlimitedCapacity)
                    {
                        if (m_inventoryItems.Count >= m_maxItems)
                        {
                            throw new Exception("Inventory has full capacity");
                        }
                    }

                    item.OnAmountChange += m_onItemAmountChangeHandler;
                    item.Owner           = this;
                    m_inventoryItems.Add(item);
                    OnAmountChange(item, item.Amount);

                    if (UnlimitedCapacity)
                    {
                        MaxItems = Math.Max(m_inventoryItems.Count, MaxItems);
                    }
                }
            }
        }
 void EntityInventoryItemAmountChanged(MyEntity entity, MyInventory inventory, MyInventoryItem item, float number)
 {
     if (MyScriptWrapper.IsPlayerShip(entity))
     {
         CheckOre();
     }
 }
        /// <summary>
        /// Initialize inventory from objectbuilder
        /// </summary>
        /// <param name="inventoryObjectBuilder">Inventory objectbuilder</param>
        public void Init(MyMwcObjectBuilder_Inventory inventoryObjectBuilder, float defaultPriceCoeficient = DEFAULT_PRICE_COEFICIENT)
        {
            Debug.Assert(inventoryObjectBuilder != null);

            if (inventoryObjectBuilder.MaxItems == 0)
            {
                MaxItems = MyInventory.DEFAULT_MAX_ITEMS;
            }
            else
            {
                MaxItems = inventoryObjectBuilder.MaxItems;
            }

            PriceCoeficient   = inventoryObjectBuilder.PriceCoeficient != null ? inventoryObjectBuilder.PriceCoeficient.Value : defaultPriceCoeficient;
            TemplateType      = inventoryObjectBuilder.TemplateType;
            UnlimitedCapacity = inventoryObjectBuilder.UnlimitedCapacity;

            if (inventoryObjectBuilder.InventoryItems != null && inventoryObjectBuilder.InventoryItems.Count > 0)
            {
                RemoveAllInventoryItemsPrivate(true);
                List <MyInventoryItem> inventoryItemsToAdd = new List <MyInventoryItem>();
                foreach (MyMwcObjectBuilder_InventoryItem inventoryItemObjectBuilder in inventoryObjectBuilder.InventoryItems)
                {
                    if (inventoryItemsToAdd.Count >= MaxItems && !UnlimitedCapacity)
                    {
                        break;
                    }
                    // if old foundation factory is in inventory, we replace it with new prefab foundation factory
                    if (inventoryItemObjectBuilder.ItemObjectBuilder is MyMwcObjectBuilder_FoundationFactory)
                    {
                        inventoryItemObjectBuilder.ItemObjectBuilder = MyMwcObjectBuilder_Base.CreateNewObject(MyMwcObjectBuilderTypeEnum.PrefabFoundationFactory, (int)MyMwcObjectBuilder_PrefabFoundationFactory_TypesEnum.DEFAULT);
                    }

                    // hack: we need set default prefab health and max health to prefab object builder
                    if (inventoryItemObjectBuilder.ItemObjectBuilder is MyMwcObjectBuilder_PrefabBase)
                    {
                        MyMwcObjectBuilder_PrefabBase prefabBuilder = inventoryItemObjectBuilder.ItemObjectBuilder as MyMwcObjectBuilder_PrefabBase;
                        if (prefabBuilder.PrefabHealthRatio == 0f)
                        {
                            prefabBuilder.PrefabHealthRatio = MyGameplayConstants.HEALTH_RATIO_MAX;
                        }
                        if (prefabBuilder.PrefabMaxHealth == 0f)
                        {
                            prefabBuilder.PrefabMaxHealth = MyGameplayConstants.MAXHEALTH_PREFAB;
                        }
                    }

                    MyInventoryItem inventoryItem = CreateInventoryItemFromObjectBuilder(inventoryItemObjectBuilder.ItemObjectBuilder, inventoryItemObjectBuilder.Amount);
                    inventoryItem.TemporaryFlags = inventoryItemObjectBuilder.TemporaryFlags;
                    inventoryItemsToAdd.Add(inventoryItem);
                }
                AddInventoryItems(inventoryItemsToAdd);
            }
            else
            {
                ClearInventoryItems(true);
            }
        }
        private bool RemoveInventoryItemAmountPrivate(MyInventoryItem inventoryItem, float amount)
        {
            bool removed = false;

            inventoryItem.Amount -= amount;
            if (inventoryItem.Amount <= 0f)
            {
                removed = RemoveItemFromInventoryPrivate(inventoryItem, true);
            }
            return(removed);
        }
 /// <summary>
 /// Removes amout of inventory items from inventory.
 /// </summary>
 /// <param name="inventoryItem">Inventory item</param>
 /// <param name="amount">Amount to remove</param>
 public void RemoveInventoryItemAmount(ref MyInventoryItem inventoryItem, float amount)
 {
     //inventoryItem.Amount -= amount;
     //if (inventoryItem.Amount <= 0f)
     //{
     //    RemoveInventoryItem(inventoryItem, true);
     //}
     if (RemoveInventoryItemAmountPrivate(inventoryItem, amount))
     {
         CallContentChange();
     }
 }
        private void FixItemsOverMaxLimit()
        {
            bool removed = false;

            while (m_inventoryItems.Count > MaxItems)
            {
                MyInventoryItem itemToRemove = m_inventoryItems[m_inventoryItems.Count - 1];
                RemoveInventoryItem(itemToRemove, true);
                removed = true;
            }
            if (removed)
            {
                CallContentChange();
            }
        }
        private bool RemoveItemFromInventoryPrivate(MyInventoryItem item, bool closeInventoryItem)
        {
            bool result = m_inventoryItems.Remove(item);

            item.OnAmountChange -= m_onItemAmountChangeHandler;
            if (item.Amount > 0f)
            {
                OnAmountChange(item, -item.Amount);
            }
            if (closeInventoryItem)
            {
                MyInventory.CloseInventoryItem(item);
            }
            else
            {
                item.Owner = null;
            }
            return(result);
        }
        /// <summary>
        /// Returns inventory items from inventory
        /// </summary>
        /// <param name="objectBuilderType">Item's object builder type</param>
        /// <param name="objectBuilderId">Item's object builder id</param>
        /// <param name="amount">Amount to remove</param>
        public bool RemoveInventoryItemAmount(MyMwcObjectBuilderTypeEnum objectBuilderType, int?objectBuilderId, float amount)
        {
            bool  removed = false;
            float inventoryItemsAmount = GetTotalAmountOfInventoryItems(objectBuilderType, objectBuilderId);

            if (inventoryItemsAmount < amount)
            {
                return(false);
            }

            float amountToRemoveLeft = amount;

            m_helperInventoryItemsForAddAndRemove.Clear();
            GetInventoryItems(ref m_helperInventoryItemsForAddAndRemove, objectBuilderType, objectBuilderId);
            m_helperInventoryItemsForAddAndRemove.Sort((x, y) => x.Amount.CompareTo(y.Amount));
            foreach (MyInventoryItem inventoryItem in m_helperInventoryItemsForAddAndRemove)
            {
                float amountToRemove = Math.Min(inventoryItem.Amount, amountToRemoveLeft);

                MyInventoryItem inventoryItemToRemoveAmount = inventoryItem;
                if (RemoveInventoryItemAmountPrivate(inventoryItemToRemoveAmount, amountToRemove))
                {
                    removed = true;
                }

                amountToRemoveLeft -= amountToRemove;

                if (amountToRemoveLeft <= 0f)
                {
                    break;
                }
            }

            if (removed)
            {
                CallContentChange();
            }

            return(true);
        }
        public static MyInventoryItem CreateInventoryItemFromObjectBuilder(MyMwcObjectBuilder_Base objectBuilder, float amount)
        {
            float maxAmount   = MyGameplayConstants.GetGameplayProperties(objectBuilder, MyMwcObjectBuilder_FactionEnum.Euroamerican).MaxAmount;
            float amountToAdd = Math.Min(maxAmount, amount);

            int objectBuilderId = objectBuilder.GetObjectBuilderId().HasValue ? objectBuilder.GetObjectBuilderId().Value : 0;

            MyGuiHelperBase guiHelper = MyGuiObjectBuilderHelpers.GetGuiHelper(objectBuilder.GetObjectBuilderType(), objectBuilderId);

            MyCommonDebugUtils.AssertDebug(guiHelper != null);

            //warning: use default faction for get gameplay properties for inventory item
            MyGameplayProperties inventoryItemProperties = MyGameplayConstants.GetGameplayProperties(objectBuilder.GetObjectBuilderType(), objectBuilderId, MyMwcObjectBuilder_FactionEnum.Euroamerican);

            MyCommonDebugUtils.AssertDebug(inventoryItemProperties != null);



            MyInventoryItem item = MyInventory.InventoryItemsPool.Allocate();

            item.Start(guiHelper, inventoryItemProperties, objectBuilder, amountToAdd);
            return(item);
        }
 private void DisabledInvalidListboxesForDrop(MyInventoryItem draggedInventoryItem)
 {
     foreach (KeyValuePair<MyGuiControlListbox, Predicate<MyInventoryItem>> keyValuePair in m_listboxDropConditions)
     {
         if (!keyValuePair.Value(draggedInventoryItem))
         {
             keyValuePair.Key.Enabled = false;
         }
     }            
 }        
 private void InventoryContentChanged(MyInventory sender, MyInventoryItem inventoryItem, float amountChanged)
 {                        
     float oreAmount = sender.GetInventoryItemsCount(MyMwcObjectBuilderTypeEnum.Ore, null);
     if (oreAmount >= 50)
     {
         m_objectives.Find(submission => submission.ID == MyMissionID.M01_Intro_Mining).Success();
     }
 }
 private static bool IsDisabled(MyInventoryItem item)
 {
     return(MyMwcObjectBuilder_InventoryItem.IsDisabled(item.ObjectBuilderType, item.ObjectBuilderId));
 }
Exemple #18
0
        public static MyToolKit CreateInstance(MySmallShip smallShipOwner, MyPlayer playerOwner, MyInventoryItem toolInventoryItem) 
        {
            Debug.Assert(smallShipOwner != null);
            Debug.Assert(playerOwner != null);
            Debug.Assert(IsSupportedToolKitItem(toolInventoryItem));

            MyToolKitDelegates[] delegates = m_delegatesPerToolKitType[toolInventoryItem.ObjectBuilderId.Value];
            Debug.Assert(delegates.Length > 0);
            return new MyToolKit(smallShipOwner, playerOwner, toolInventoryItem, delegates);
        }
        /// <summary>
        /// Adds new inventory item from object builder
        /// </summary>
        /// <param name="objectBuilder">Item object builder</param>
        /// <param name="amount">Amount of inventory item</param>
        /// <param name="allAmountAddAsNewInventoryItems">If true, then all amount adds as new inventory items, if false, then try find old inventory items of same type, and add amount to them as first</param>
        public float AddInventoryItem(MyMwcObjectBuilder_Base objectBuilder, float amount, bool allAmountAddAsNewInventoryItems, bool increaseCapacityIfIsFull = false)
        {
            bool added = false;
            MyMwcObjectBuilderTypeEnum objectBuilderType = objectBuilder.GetObjectBuilderType();
            int?objectBuilderId = objectBuilder.GetObjectBuilderId();

            m_helperInventoryItemsForAddAndRemove.Clear();
            GetInventoryItems(ref m_helperInventoryItemsForAddAndRemove, objectBuilderType, objectBuilderId);

            float amountToAddLeft = amount;

            if (!allAmountAddAsNewInventoryItems)
            {
                foreach (MyInventoryItem inventoryItem in m_helperInventoryItemsForAddAndRemove)
                {
                    if (amountToAddLeft <= 0f)
                    {
                        break;
                    }
                    float amountToAdd = Math.Min(inventoryItem.MaxAmount - inventoryItem.Amount, amountToAddLeft);
                    if (InventorySynchronizer != null && InventorySynchronizer.MustBeSynchronized())
                    {
                        InventorySynchronizer.AddInventoryItemAmountChangeForSynchronization(objectBuilderType, objectBuilderId, inventoryItem.Amount, amountToAdd);
                    }
                    else
                    {
                        inventoryItem.Amount += amountToAdd;
                    }
                    amountToAddLeft -= amountToAdd;
                }
            }

            while (amountToAddLeft > 0f)
            {
                if (IsFull)
                {
                    if (increaseCapacityIfIsFull)
                    {
                        MaxItems++;
                    }
                    else
                    {
                        break;
                    }
                }
                MyInventoryItem newInventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(objectBuilder);
                float           amountToAdd      = Math.Min(newInventoryItem.MaxAmount, amountToAddLeft);
                //AddInventoryItem(newInventoryItem);
                AddItemToInventoryPrivate(newInventoryItem);
                newInventoryItem.Amount = amountToAdd; //After AddInventoryItem otherwise Amount event is not called
                amountToAddLeft        -= amountToAdd;
                added = true;
            }

            if (added)
            {
                CallContentChange();
            }

            return(amountToAddLeft);
        }
        private MyGuiControlListboxItem CreateListboxItemAndAddToRepository(MyInventoryItem inventoryItem) 
        {
            int inventoryItemKey = m_inventoryItemsRepository.AddItem(inventoryItem);            

            StringBuilder description = null;
            if (inventoryItem.Icon == null)
            {
                description = inventoryItem.MultiLineDescription;
            }

            MyToolTips toolTips = new MyToolTips();
            toolTips.AddToolTip(inventoryItem.MultiLineDescription, Color.White, 0.7f);            

            MyGuiControlListboxItem listboxItem = new MyGuiControlListboxItem(inventoryItemKey, description, inventoryItem.Icon, toolTips, MyGuiConstants.LABEL_TEXT_SCALE);
            listboxItem.IconTexts = new MyIconTexts();

            // add amount icon's text
            if (inventoryItem.Amount != 1f || inventoryItem.Amount != inventoryItem.MaxAmount)
            {
                StringBuilder amount = new StringBuilder();
                amount.Append(inventoryItem.Amount.ToString());
                MyGuiDrawAlignEnum align;
                Vector2 offset;
                if (inventoryItem.AmountTextAlign == MyInventoryAmountTextAlign.MiddleRight)
                {
                    align = MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER;
                    offset = new Vector2(-0.004f, 0.0038f);
                }
                else if (inventoryItem.AmountTextAlign == MyInventoryAmountTextAlign.BottomRight)
                {
                    align = MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_BOTTOM;
                    offset = new Vector2(-0.004f, -0.0025f);
                }
                else
                {
                    throw new MyMwcExceptionApplicationShouldNotGetHere();
                }
                listboxItem.IconTexts[align] = new MyColoredText(amount, Color.White, Color.White, MyGuiManager.GetFontMinerWarsWhite(), 0.5f, offset);
            }

            return listboxItem;
        }
Exemple #21
0
 public static bool IsSupportedToolKitItem(MyInventoryItem toolInventoryItem) 
 {
     return toolInventoryItem != null &&
            toolInventoryItem.Amount > 0f &&
            toolInventoryItem.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.SmallShip_Tool &&
            toolInventoryItem.ObjectBuilderId != null &&
            m_delegatesPerToolKitType.ContainsKey(toolInventoryItem.ObjectBuilderId.Value);
 }
        private float GetTradeItemPrice(MyInventoryItem inventoryItem) 
        {
            Debug.Assert(m_otherSideInventoryBuilder.PriceCoeficient != null);
            Debug.Assert(m_smallShipsBuilders[m_currentShipBuilderIndex].Builder.Inventory.PriceCoeficient != null);
            float otherSidePriceCoeficient = m_otherSideInventoryBuilder.PriceCoeficient.Value;
            float shipPriceCoeficient = m_smallShipsBuilders[m_currentShipBuilderIndex].Builder.Inventory.PriceCoeficient.Value;

            float priceCoeficient = 1f;

            if (inventoryItem.Owner == m_otherSideInventoryBuilder)
            {
                priceCoeficient = otherSidePriceCoeficient / shipPriceCoeficient;
            }
            else
            {
                priceCoeficient = shipPriceCoeficient / otherSidePriceCoeficient;
            }

            return inventoryItem.Price * priceCoeficient;
        }
 public int AddItem(MyInventoryItem item)
 {
     int newKey = m_lastUsedKey++;
     m_itemsWithKeys.Add(newKey, item);
     return newKey;
 }
 public static void CloseInventoryItem(MyInventoryItem item)
 {
     item.Owner = null;
     MyInventory.InventoryItemsPool.Deallocate(item);
 }
 void OreAmountChanged(MyEntity entity, MyInventory inventory, MyInventoryItem item, float number)
 {
     if (MyScriptWrapper.IsPlayerShip(entity))
     {
         if (item.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.Ore)
         {
             if (!MyScriptWrapper.IsMissionFinished(MyMissionID.RIFT_URANITE))
             {
                 if (item.ObjectBuilderId == (int)MyMwcObjectBuilder_Ore_TypesEnum.URANITE)
                 {
                     float ammount = MyScriptWrapper.GetInventoryItemAmount(MyScriptWrapper.GetPlayerInventory(), MyMwcObjectBuilderTypeEnum.Ore, (int)MyMwcObjectBuilder_Ore_TypesEnum.URANITE);
                     if (ammount > 0.5f && m_miningquotes == 1)
                     {
                         MyScriptWrapper.PlayDialogue(MyDialogueEnum.RIFT_0700_MINING_COLOR);
                         m_miningquotes++;
                     }
                     else if (ammount > 1.0f && m_miningquotes == 2)
                     {
                         MyScriptWrapper.PlayDialogue(MyDialogueEnum.RIFT_0800_MINING_TUNE);
                         m_miningquotes++;
                     }
                     else if (ammount > 1.5f && m_miningquotes == 3)
                     {
                         MyScriptWrapper.PlayDialogue(MyDialogueEnum.RIFT_0900_MINING_TUNE_2);
                         m_miningquotes++;
                     }
                 }
             }
         }
     }
 }
 private bool CanDropItem(MyInventoryItem item, MyGuiControlListbox dropFrom, MyGuiControlListbox dropTo) 
 {
     if (dropTo != dropFrom && NeedHandleSmallShipDrop(item) && dropTo == m_shipInventoryListBox)
     {
         MySmallShipBuilderWithName builderWithName = m_smallShipsBuilders.Find(x => x.Builder == item.GetInventoryItemObjectBuilder(false));
         Debug.Assert(builderWithName != null);
         int index = m_smallShipsBuilders.IndexOf(builderWithName);
         Debug.Assert(index > -1);
         // we can't drop same ship to current ship's inventory
         return index != m_currentShipBuilderIndex;
     }
     else 
     {
         return true;
     }
 }
        private bool HandleTradeForMoney(MyGuiControlListbox listboxFrom, MyGuiControlListbox listboxTo, MyInventoryItem inventoryItem)
        {            
            float moneyToAdd = 0f;
            float itemPrice = GetTradeItemPrice(inventoryItem);
            
            // item move from other side to player's ship)
            if (listboxFrom == m_otherSideInventoryListBox && listboxTo != m_otherSideInventoryListBox)
            {
                moneyToAdd = -itemPrice;
            }
            // item move from player's ship to other side
            else if (listboxFrom != m_otherSideInventoryListBox && listboxTo == m_otherSideInventoryListBox)
            {
                moneyToAdd = itemPrice;
            }            

            if (m_money + moneyToAdd < 0f) 
            {
                // this can't happen
                throw new MyMwcExceptionApplicationShouldNotGetHere();
                //MyGuiManager.AddScreen(new MyGuiScreenMessageBox(MyMessageBoxType.ERROR,
                //                                                     MyTextsWrapperEnum.NotificationYouDontHaveEnoughMoney,
                //                                                     MyTextsWrapperEnum.TradeResultTitle,
                //                                                     MyTextsWrapperEnum.Ok, YouDontHaveEnoughMoneyMessageBoxCallBack));
                return false;
            }
            SetMoney(m_money + moneyToAdd);
            return true;
        }
 public void AddInventoryItemForSynchronization(MyInventoryItem item) 
 {
     m_inventoryItemsToAdd.Add(item);
 }
 private bool NeedHandleSmallShipDrop(MyInventoryItem item) 
 {
     return item.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.SmallShip_Player &&
         m_inventoryScreenType == MyGuiScreenInventoryType.Game && !m_tradeForMoney;
 }
 /// <summary>
 /// Adds inventory item to inventory
 /// </summary>
 /// <param name="item">Inventory item</param>
 public void AddInventoryItem(MyInventoryItem item)
 {
     AddItemToInventoryPrivate(item);
     CallContentChange();
 }
 private void HandleSmallShipDrop(MyGuiControlListbox listboxFrom, MyGuiControlListbox listboxTo, MyInventoryItem item) 
 {
     if (listboxFrom != listboxTo) 
     {
         if (listboxTo == m_otherSideInventoryListBox)
         {
             MySmallShipBuilderWithName builderWithName = new MySmallShipBuilderWithName(item.GetInventoryItemObjectBuilder(false) as MyMwcObjectBuilder_SmallShip_Player);
             m_smallShipsBuilders.Add(builderWithName);
             m_smallShipsInventoryItemIDs.Add(GetInventoryItemIDsFromObjectBuilder(builderWithName.Builder));
             if (m_shipsCombobox != null)
             {
                 m_shipsCombobox.AddItem(m_shipsCombobox.GetItemsCount(), builderWithName.Name);
             }
             item.IsTemporaryItem = true;
         }
         else if (listboxTo == m_shipInventoryListBox)
         {
             MySmallShipBuilderWithName builderWithName = m_smallShipsBuilders.Find(x => x.Builder == item.GetInventoryItemObjectBuilder(false));
             Debug.Assert(builderWithName != null);
             int index = m_smallShipsBuilders.IndexOf(builderWithName);
             Debug.Assert(index > -1);                                        
             SaveIntentoryItemsToObjectBuilder(index);                    
             item.ObjectBuilder = m_smallShipsBuilders[index].Builder;
             DealocateInventoryItemsFromInventoryIDs(index);
             m_smallShipsInventoryItemIDs.RemoveAt(index);
             m_smallShipsBuilders.RemoveAt(index);
             if (m_shipsCombobox != null)
             {
                 m_shipsCombobox.RemoveItemByIndex(index);
             }
             if (m_currentShipBuilderIndex > index) 
             {
                 m_currentShipBuilderIndex--;
             }
             Debug.Assert(m_currentShipBuilderIndex >= 0 && m_currentShipBuilderIndex <= m_smallShipsBuilders.Count - 1);
             item.IsTemporaryItem = false;
             //bool reloadShipInventory = m_currentShipBuilderIndex > index;
             //m_currentShipBuilderIndex = Math.Min(m_currentShipBuilderIndex, m_smallShipsBuilders.Count - 1);
             //if (reloadShipInventory)
             //{
             //    LoadShipInventory(m_currentShipBuilderIndex);
             //}
         }
         else 
         {
             throw new MyMwcExceptionApplicationShouldNotGetHere();
         }
     }            
 }
Exemple #32
0
 public void AddInventoryItemForSynchronization(MyInventoryItem item)
 {
     m_inventoryItemsToAdd.Add(item);
 }