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 MyInventoryConstraint PrepareConstraint(MyStringId descriptionId, IEnumerable <MyBlueprintClassDefinition> classes, bool input) { string icon = null; foreach (MyBlueprintClassDefinition definition in classes) { string str2 = input ? definition.InputConstraintIcon : definition.OutputConstraintIcon; if (str2 != null) { if (icon == null) { icon = str2; continue; } if (icon != str2) { icon = null; break; } } } MyInventoryConstraint constraint = new MyInventoryConstraint(string.Format(MyTexts.GetString(descriptionId), this.DisplayNameText), icon, true); using (IEnumerator <MyBlueprintClassDefinition> enumerator = classes.GetEnumerator()) { while (enumerator.MoveNext()) { IEnumerator <MyBlueprintDefinitionBase> enumerator2 = enumerator.Current.GetEnumerator(); try { while (enumerator2.MoveNext()) { MyBlueprintDefinitionBase current = enumerator2.Current; foreach (MyBlueprintDefinitionBase.Item item in input ? current.Prerequisites : current.Results) { constraint.Add(item.Id); } } } finally { if (enumerator2 == null) { continue; } enumerator2.Dispose(); } } } return(constraint); }
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); } }
private unsafe void PostprocessAddSubblueprint(MyBlueprintDefinitionBase blueprint, MyFixedPoint blueprintAmount) { for (int i = 0; i < blueprint.Prerequisites.Length; i++) { MyBlueprintDefinitionBase.Item toAdd = blueprint.Prerequisites[i]; MyFixedPoint *pointPtr1 = (MyFixedPoint *)ref toAdd.Amount; pointPtr1[0] *= blueprintAmount; this.AddToItemList(m_tmpPrerequisiteList, toAdd); } for (int j = 0; j < blueprint.Results.Length; j++) { MyBlueprintDefinitionBase.Item toAdd = blueprint.Results[j]; MyFixedPoint *pointPtr2 = (MyFixedPoint *)ref toAdd.Amount; pointPtr2[0] *= blueprintAmount; this.AddToItemList(m_tmpResultList, toAdd); } }
protected override bool BlueprintClassCanBeUsed(MyBlueprintClassDefinition blueprintClass) { using (IEnumerator <MyBlueprintDefinitionBase> enumerator = blueprintClass.GetEnumerator()) { while (true) { if (!enumerator.MoveNext()) { break; } MyBlueprintDefinitionBase current = enumerator.Current; if (current.Atomic) { MySandboxGame.Log.WriteLine("Blueprint " + current.DisplayNameText + " is atomic, but it is in a class used by refinery block"); return(false); } } } return(base.BlueprintClassCanBeUsed(blueprintClass)); }
public override void Postprocess() { foreach (MyBlueprintDefinitionBase.Item item in this.m_items) { if (!MyDefinitionManager.Static.HasBlueprint(item.Id)) { return; } if (MyDefinitionManager.Static.GetBlueprintDefinition(item.Id).PostprocessNeeded) { return; } } float num = 0f; bool flag = false; float num2 = 0f; this.m_blueprints = new MyBlueprintDefinitionBase[this.m_items.Length]; m_tmpPrerequisiteList.Clear(); m_tmpResultList.Clear(); for (int i = 0; i < this.m_items.Length; i++) { MyFixedPoint amount = this.m_items[i].Amount; MyBlueprintDefinitionBase blueprintDefinition = MyDefinitionManager.Static.GetBlueprintDefinition(this.m_items[i].Id); this.m_blueprints[i] = blueprintDefinition; flag = flag || blueprintDefinition.Atomic; num += blueprintDefinition.OutputVolume * ((float)amount); num2 += blueprintDefinition.BaseProductionTimeInSeconds * ((float)amount); this.PostprocessAddSubblueprint(blueprintDefinition, amount); } base.Prerequisites = m_tmpPrerequisiteList.ToArray(); base.Results = m_tmpResultList.ToArray(); m_tmpPrerequisiteList.Clear(); m_tmpResultList.Clear(); base.Atomic = flag; base.OutputVolume = num; base.BaseProductionTimeInSeconds = num2; base.PostprocessNeeded = false; }
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 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"]); }
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(); }
public MyBlueprintToProduce TryGetItemToProduce(MyBlueprintDefinitionBase blueprint) { return m_itemsToProduce.Find(x => x.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(); } }
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); } }
public void InsertQueueItemRequest(int idx, MyBlueprintDefinitionBase blueprint) { InsertQueueItemRequest(idx, blueprint, 1); }
protected MyFixedPoint MaxAmountToFitInventory(MyBlueprintDefinitionBase definition) { var inventory = (Entity as MyEntity).GetInventory(); if (inventory == null) { System.Diagnostics.Debug.Fail("Inventory was not found on the entity!"); return 0; } var maxAmount = MyFixedPoint.MaxValue; float volumeToBeRemoved = 0; float massToBeRemoved = 0; if (!MySession.Static.CreativeMode) { foreach (var item in definition.Prerequisites) { float itemMass, itemVolume; MyInventory.GetItemVolumeAndMass(item.Id, out itemMass, out itemVolume); volumeToBeRemoved += itemVolume; massToBeRemoved += itemMass; } } foreach (var item in definition.Results) { var fittableAmount = inventory.ComputeAmountThatFits(item.Id, volumeToBeRemoved, massToBeRemoved); maxAmount = MyFixedPoint.Min(fittableAmount, maxAmount); } return maxAmount; }
public MyBlueprintToProduce(MyFixedPoint amount, MyBlueprintDefinitionBase blueprint) { Amount = amount; Blueprint = blueprint; }
private void EnqueueBlueprint(MyBlueprintDefinitionBase blueprint, MyFixedPoint amount) { m_blueprintCache.Clear(); blueprint.GetBlueprints(m_blueprintCache); foreach (var entry in m_blueprintCache) m_selectedAssembler.InsertQueueItemRequest(-1, entry.Blueprint, entry.Amount * amount); m_blueprintCache.Clear(); }
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; }
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 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 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; }
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); }
private void FinishAssembling(MyBlueprintDefinitionBase blueprint) { var amountMult = (MyFixedPoint)(1.0f / MySession.Static.AssemblerEfficiencyMultiplier); for (int i = 0; i < blueprint.Prerequisites.Length; ++i) { var item = blueprint.Prerequisites[i]; InputInventory.RemoveItemsOfType(item.Amount * amountMult, item.Id); } foreach (var res in blueprint.Results) { MyObjectBuilder_PhysicalObject resOb = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(res.Id.TypeId, res.Id.SubtypeName); OutputInventory.AddItems(res.Amount, resOb); } }
private bool CheckInventoryCapacity(MyInventory inventory, MyBlueprintDefinitionBase.Item item, MyFixedPoint amountMultiplier) { return inventory.CanItemsBeAdded(item.Amount * amountMultiplier, item.Id); }
private StateEnum CheckInventory(MyBlueprintDefinitionBase blueprint) { var amountMult = (MyFixedPoint)(1.0f / MySession.Static.AssemblerEfficiencyMultiplier); if (DisassembleEnabled) { if (!CheckInventoryCapacity(InputInventory, blueprint.Prerequisites, amountMult)) return StateEnum.InventoryFull; if (!CheckInventoryContents(OutputInventory, blueprint.Results, 1)) return StateEnum.MissingItems; } else { if (!CheckInventoryCapacity(OutputInventory, blueprint.Results, 1)) return StateEnum.InventoryFull; if (!CheckInventoryContents(InputInventory, blueprint.Prerequisites, amountMult)) return StateEnum.MissingItems; } return StateEnum.Ok; }
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[] items, MyFixedPoint amountMultiplier) { if (MySession.Static.CreativeMode) return true; MyFixedPoint resultVolume = 0; foreach (var item in items) { var def = MyDefinitionManager.Static.GetPhysicalItemDefinition(item.Id); resultVolume += (MyFixedPoint)def.Volume * item.Amount * amountMultiplier; } return inventory.CurrentVolume + resultVolume <= inventory.MaxVolume; }
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; }
private bool CheckInventoryContents(MyInventory inventory, MyBlueprintDefinitionBase.Item[] item, MyFixedPoint amountMultiplier) { for (int i = 0; i < item.Length; ++i) { if (!inventory.ContainItems(item[i].Amount * amountMultiplier, item[i].Id)) return false; } return true; }
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!"); } }
private void ChangeRequirementsToResults(MyBlueprintDefinitionBase queueItem, MyFixedPoint blueprintAmount) { Debug.Assert(Sync.IsServer); if (!MySession.Static.CreativeMode) { blueprintAmount = MyFixedPoint.Min(OutputInventory.ComputeAmountThatFits(queueItem), blueprintAmount); } if (blueprintAmount == 0) return; foreach (var prerequisite in queueItem.Prerequisites) { var obPrerequisite = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(prerequisite.Id); var prerequisiteAmount = blueprintAmount * prerequisite.Amount; InputInventory.RemoveItemsOfType(prerequisiteAmount, obPrerequisite); } foreach (var result in queueItem.Results) { var resultId = result.Id; var obResult = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(resultId); var conversionRatio = result.Amount * m_refineryDef.MaterialEfficiency * UpgradeValues["Effectiveness"]; if (conversionRatio > (MyFixedPoint)1.0f) { conversionRatio = (MyFixedPoint)1.0f; } var resultAmount = blueprintAmount * conversionRatio; OutputInventory.AddItems(resultAmount, obResult); } RemoveFirstQueueItemAnnounce(blueprintAmount); }
protected virtual void AddProducedItemToInventory(MyBlueprintDefinitionBase definition, MyFixedPoint amountMult) { System.Diagnostics.Debug.Assert(Sync.IsServer, "This method should be called only on server!"); if (!Sync.IsServer) return; var inventory = (Entity as MyEntity).GetInventory(); if (inventory == null) { System.Diagnostics.Debug.Fail("Inventory was not found on the entity!"); return; } foreach (var prodItem in definition.Results) { var amountToAdd = prodItem.Amount * amountMult; IMyInventoryItem inventoryItem; if (definition is MyBlockBlueprintDefinition) inventoryItem = CreateInventoryBlockItem(prodItem.Id, amountToAdd); else inventoryItem = CreateInventoryItem(prodItem.Id, amountToAdd); var resultAdded = inventory.Add(inventoryItem, inventoryItem.Amount); System.Diagnostics.Debug.Assert(resultAdded, "Result of adding is false!"); } }