public MyRepairBlueprintToProduce(MyFixedPoint amount, MyBlueprintDefinitionBase blueprint, uint inventoryItemId, MyObjectBuilderType inventoryItemType, MyStringHash inventoryItemSubtypeId) : base(amount, blueprint)
 {
     System.Diagnostics.Debug.Assert(Blueprint is MyRepairBlueprintDefinition, "MyRepairBlueprintToProduce class should be used together with blueprints type of MyRepairBlueprintDefinition only!");
     InventoryItemId = inventoryItemId;
     InventoryItemType = inventoryItemType;
     InventoryItemSubtypeId = inventoryItemSubtypeId;
 }

        private void PostprocessAddSubblueprint(MyBlueprintDefinitionBase blueprint, MyFixedPoint blueprintAmount)
        {
            for (int i = 0; i < blueprint.Prerequisites.Length; ++i)
            {
                Item prerequisite = blueprint.Prerequisites[i];
                prerequisite.Amount *= blueprintAmount;
                AddToItemList(m_tmpPrerequisiteList, prerequisite);
            }

            for (int i = 0; i < blueprint.Results.Length; ++i)
            {
                Item result = blueprint.Results[i];
                result.Amount *= blueprintAmount;
                AddToItemList(m_tmpResultList, result);
            }
        }

 public void InsertQueueItemRequest(int idx, MyBlueprintDefinitionBase blueprint, MyFixedPoint amount)
 {
     if (MyFakes.ENABLE_PRODUCTION_SYNC)
     {
         if (Sync.IsServer)
         {
             InsertQueueItem(idx, blueprint, amount);
             SyncObject.AddQueueItemAnnounce(blueprint, amount, idx);
         }
         else
             SyncObject.AddQueueItemRequest(blueprint, amount, idx);
     }
     else
     {
         InsertQueueItem(idx, blueprint, amount);
     }
 }

 protected override void InsertQueueItem(int idx, MyBlueprintDefinitionBase blueprint, MyFixedPoint amount)
 {
     if (idx == 0)
     {
         var queueItem = TryGetFirstQueueItem();
         if (queueItem.HasValue && queueItem.Value.Blueprint != blueprint)
             CurrentProgress = 0f;
     }
     base.InsertQueueItem(idx, blueprint, amount);
 }

 private bool CheckInventoryContents(MyInventory inventory, MyBlueprintDefinitionBase.Item item, MyFixedPoint amountMultiplier)
 {
     return inventory.ContainItems(item.Amount * amountMultiplier, item.Id);
 }

 private bool CheckInventoryCapacity(MyInventory inventory, MyBlueprintDefinitionBase.Item item, MyFixedPoint amountMultiplier)
 {
     return inventory.CanItemsBeAdded(item.Amount * amountMultiplier, item.Id);
 }

        private void FinishDisassembling(MyBlueprintDefinitionBase blueprint)
        {
            if (RepeatEnabled && Sync.IsServer) OutputInventory.ContentsChanged -= OutputInventory_ContentsChanged;
            foreach (var res in blueprint.Results)
            {
                OutputInventory.RemoveItemsOfType(res.Amount, res.Id);
            }
            if (RepeatEnabled && Sync.IsServer) OutputInventory.ContentsChanged += OutputInventory_ContentsChanged;

            var amountMult = (MyFixedPoint)(1.0f / MySession.Static.AssemblerEfficiencyMultiplier);
            for (int i = 0; i < blueprint.Prerequisites.Length; ++i)
            {
                var item = blueprint.Prerequisites[i];
                var itemOb = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(item.Id.TypeId, item.Id.SubtypeName);
                InputInventory.AddItems(item.Amount * amountMult, itemOb);
            }
        }

 private float calculateBlueprintProductionTime(MyBlueprintDefinitionBase currentBlueprint)
 {
     return currentBlueprint.BaseProductionTimeInSeconds * 1000 / (MySession.Static.AssemblerSpeedMultiplier * ((MyAssemblerDefinition)BlockDefinition).AssemblySpeed + UpgradeValues["Productivity"]);
 }

 public void RemoveItemToProduce(MyFixedPoint amount, MyBlueprintDefinitionBase blueprint, long senderEntityId, int itemId = -1)
 {        
     SerializableDefinitionId blueprintId = blueprint.Id;
     MyMultiplayer.RaiseEvent(this, x => x.RemoveItemToProduce_Request, amount, blueprintId, senderEntityId, itemId);
 }

 public void AddItemToRepair(MyFixedPoint amount, MyBlueprintDefinitionBase blueprint, long senderEntityId, uint inventoryItemId, MyObjectBuilderType inventoryItemType, MyStringHash inventoryItemSubtypeId)
 {
     SerializableDefinitionId blueprintId = blueprint.Id;
     MyMultiplayer.RaiseEvent(this, x => x.AddItemToRepair_Request, amount, blueprintId, senderEntityId, inventoryItemId, inventoryItemType, inventoryItemSubtypeId);
 }

        public bool CanUseBlueprint(MyBlueprintDefinitionBase blueprint)
        {
            System.Diagnostics.Debug.Assert(blueprint != null, "Passing blueprint as null argument!");

            foreach (var blueprintClass in m_blueprintClasses)
                if (blueprintClass.ContainsBlueprint(blueprint)) return true;

            return false;
        }

 public MyBlueprintToProduce(MyFixedPoint amount, MyBlueprintDefinitionBase blueprint)
 {
     Amount = amount;
     Blueprint = blueprint;
 }

 protected void OnBlueprintProduced(MyBlueprintDefinitionBase blueprint, MyFixedPoint amount)
 {
     SerializableDefinitionId blueprintId = blueprint.Id;
     MyMultiplayer.RaiseEvent(this, x => x.OnBlueprintProduced_Implementation, blueprintId, amount);   
 }

 protected void RaiseEvent_MissingRequiredItem(MyBlueprintDefinitionBase blueprint, MyBlueprintDefinitionBase.Item missingItem)
 {
     MyMultiplayer.RaiseEvent(this, x => x.MissingRequiredItem_Implementation, (SerializableDefinitionId)blueprint.Id, (SerializableDefinitionId)missingItem.Id);
 }

        protected virtual void InsertQueueItem(int idx, MyBlueprintDefinitionBase blueprint, MyFixedPoint amount)
        {
            Debug.Assert(idx <= m_queue.Count);
            Debug.Assert(CanUseBlueprint(blueprint));
            Debug.Assert(amount > 0);

            QueueItem item = new QueueItem();
            item.Amount = amount;
            item.Blueprint = blueprint;

            if (CanUseBlueprint(item.Blueprint))
            {
                if (m_queue.IsValidIndex(idx) && m_queue[idx].Blueprint == item.Blueprint)
                {
                    // Increase amount if there is same kind of item at this index.
                    item.Amount += m_queue[idx].Amount;
                    item.ItemId = m_queue[idx].ItemId;
                    m_queue[idx] = item;
                }
                else if (m_queue.Count > 0 && (idx >= m_queue.Count || idx == -1) && m_queue[m_queue.Count - 1].Blueprint == item.Blueprint)
                {
                    // Add to the last item in the queue if it is the same.
                    item.Amount += m_queue[m_queue.Count - 1].Amount;
                    item.ItemId = m_queue[m_queue.Count - 1].ItemId;
                    m_queue[m_queue.Count - 1] = item;
                }
                else
                {
                    if (idx == -1)
                        idx = m_queue.Count;

                    // Reset timer when adding first item. Otherwise we might produce it faster than possible.
                    if (m_queue.Count == 0)
                        m_lastUpdateTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;

                    // Put new item into the queue with given amount and type.
                    item.ItemId = NextItemId;
                    m_queue.Insert(idx, item);
                }

                UpdatePower();

                OnQueueChanged();
            }
        }

        private void ShowBlueprintComponents(MyBlueprintDefinitionBase blueprint, MyFixedPoint amount)
        {
            m_materialsList.Clear();
            if (blueprint == null)
                return;

            AddComponentPrerequisites(blueprint, amount, m_requiredCountCache);
            FillMaterialList(m_requiredCountCache);
            m_requiredCountCache.Clear();
        }

        private static void AddComponentPrerequisites(MyBlueprintDefinitionBase blueprint, MyFixedPoint multiplier, Dictionary<MyDefinitionId, MyFixedPoint> outputAmounts)
        {
            foreach (var prerequisite in blueprint.Prerequisites)
            {
                if (!outputAmounts.ContainsKey(prerequisite.Id))
                    outputAmounts[prerequisite.Id] = 0;

                var amountMult = (MyFixedPoint)(1.0f / MySession.Static.AssemblerEfficiencyMultiplier);
                outputAmounts[prerequisite.Id] += prerequisite.Amount * multiplier * amountMult;
            }
        }

        public MyFixedPoint MaxProducableAmount(MyBlueprintDefinitionBase blueprintDefinition, bool raiseMissingRequiredItemEvent = false)
        {
            if (MySession.Static.CreativeMode)
                return MyFixedPoint.MaxValue;

            var inventory = (Entity as MyEntity).GetInventory();

            if (inventory == null)
            {
                System.Diagnostics.Debug.Fail("Inventory was not found on the entity!");
                return 0;
            }

            MyFixedPoint maxProducableAmount = MyFixedPoint.MaxValue;

            foreach (var requiredItem in blueprintDefinition.Prerequisites)
            {
                var itemAmount = inventory.GetItemAmount( requiredItem.Id, substitute: true);
                var producableAmount = MyFixedPoint.Floor((MyFixedPoint)((float)itemAmount / (float)requiredItem.Amount));
                maxProducableAmount = MyFixedPoint.Min(maxProducableAmount, producableAmount);
                if (maxProducableAmount == 0)
                {
                    if (raiseMissingRequiredItemEvent)
                    {
                        RaiseEvent_MissingRequiredItem(blueprintDefinition, requiredItem);
                    }
                    return maxProducableAmount;
                }
            }

            return maxProducableAmount;           
        }

        public MyFixedPoint ComputeAmountThatFits(MyBlueprintDefinitionBase blueprint)
        {
            if (!MyPerGameSettings.ConstrainInventory())
                return MyFixedPoint.MaxValue;

            var amountThatFits = (MaxVolume - m_currentVolume) * (1.0f / blueprint.OutputVolume);
            amountThatFits = MyFixedPoint.Max(amountThatFits, 0); // In case we added more than we can carry using debug keys.

            if (blueprint.Atomic)
                amountThatFits = MyFixedPoint.Floor(amountThatFits);

            return amountThatFits;
        }

        protected void RemovePrereqItemsFromInventory(MyBlueprintDefinitionBase definition, MyFixedPoint amountMult)
        {
            System.Diagnostics.Debug.Assert(Sync.IsServer, "This method should be called only on server!");

            if (!Sync.IsServer)
                return;

            if (MySession.Static.CreativeMode)
                return;

            var inventory = (Entity as MyEntity).GetInventory();

            if (inventory == null)
            {
                System.Diagnostics.Debug.Fail("Inventory was not found on the entity!");
                return;
            }

            foreach (var reqItem in definition.Prerequisites)
            {
                MyFixedPoint amountToRemove = reqItem.Amount * amountMult;
                MyDefinitionId itemId = reqItem.Id;
                MyFixedPoint removed = 0;

                if (MySessionComponentEquivalency.Static != null && MySessionComponentEquivalency.Static.HasEquivalents(itemId))
                {
                    MyFixedPoint amountRemaining = amountToRemove;
                    var eqGroup = MySessionComponentEquivalency.Static.GetEquivalents(itemId);
                    foreach (var element in eqGroup)
                    {
                        MyFixedPoint removedThisItem = inventory.RemoveItemsOfType(amountRemaining, element);
                        amountRemaining -= removedThisItem;
                        removed += removedThisItem;
                        if (amountRemaining == 0) break;
                    }
                }
                else
                {
                    System.Diagnostics.Debug.Assert(amountToRemove <= inventory.GetItemAmount(reqItem.Id, substitute: true), "Trying to remove higher amount than is present in inventory!");
                    removed += inventory.RemoveItemsOfType(amountToRemove, itemId);
                }
                System.Diagnostics.Debug.Assert(removed == amountToRemove, "Removed different amount, than expected!");
            }
        }