private void MissingRequiredItem_Implementation(SerializableDefinitionId blueprintId, SerializableDefinitionId missingItemId) { MyBlueprintDefinitionBase.Item missingItem = default(MyBlueprintDefinitionBase.Item); MyDefinitionId definitionId = missingItemId; bool found = false; MyBlueprintDefinitionBase blueprint = MyDefinitionManager.Static.GetBlueprintDefinition(blueprintId); if (blueprint == null) { System.Diagnostics.Debug.Fail("Couldn't find blueprint definition for: " + blueprintId); return; } foreach (var requiredItem in blueprint.Prerequisites) { if (requiredItem.Id == definitionId) { missingItem = requiredItem; found = true; } } if (!found) { System.Diagnostics.Debug.Fail("Item " + definitionId + " wasn't found in blueprint " + blueprint); } var handler = MissingRequiredItem; if (handler != null && found) { handler(this, blueprint, missingItem); } }
public static AmountedDefinitionId ToAmountedDefinition(this MyBlueprintDefinitionBase.Item item) { return(new AmountedDefinitionId() { Id = item.Id.ToDefinitionId(), Amount = item.Amount.ToIntSafe() }); }
private void ProcessQueueItems(int timeDelta) { this.m_processingLock = true; if (Sync.IsServer) { goto TR_0010; } TR_0000: base.IsProducing = !base.IsQueueEmpty; this.m_processingLock = false; return; TR_0010: while (true) { if (!base.IsQueueEmpty && (timeDelta > 0)) { MyProductionBlock.QueueItem item = base.TryGetFirstQueueItem().Value; MyFixedPoint blueprintAmount = (MyFixedPoint)(((timeDelta * (this.m_refineryDef.RefineSpeed + base.UpgradeValues["Productivity"])) * MySession.Static.RefinerySpeedMultiplier) / (item.Blueprint.BaseProductionTimeInSeconds * 1000f)); MyBlueprintDefinitionBase.Item[] prerequisites = item.Blueprint.Prerequisites; int index = 0; while (true) { if (index < prerequisites.Length) { MyBlueprintDefinitionBase.Item item2 = prerequisites[index]; MyFixedPoint point2 = base.InputInventory.GetItemAmount(item2.Id, MyItemFlags.None, false); MyFixedPoint point3 = blueprintAmount * item2.Amount; if (point2 < point3) { blueprintAmount = point2 * (1f / ((float)item2.Amount)); } index++; continue; } if (blueprintAmount != 0) { timeDelta -= Math.Max(1, (int)(((((float)blueprintAmount) * item.Blueprint.BaseProductionTimeInSeconds) / this.m_refineryDef.RefineSpeed) * 1000f)); if (timeDelta < 0) { timeDelta = 0; } this.ChangeRequirementsToResults(item.Blueprint, blueprintAmount); continue; } else { this.m_queueNeedsRebuild = true; } break; } } goto TR_0000; } goto TR_0010; }
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)); }
protected void RaiseEvent_MissingRequiredItem(MyBlueprintDefinitionBase blueprint, MyBlueprintDefinitionBase.Item missingItem) { MyMultiplayer.RaiseEvent(this, x => x.MissingRequiredItem_Implementation, (SerializableDefinitionId)blueprint.Id, (SerializableDefinitionId)missingItem.Id); }
public override void UpdateBeforeSimulation100() { base.UpdateBeforeSimulation100(); if (m_inventoryOwnersDirty) { GetCoveyorInventoryOwners(); } if (Sync.IsServer && IsWorking && m_useConveyorSystem) { if (DisassembleEnabled) // Dissasembling { if (OutputInventory.VolumeFillFactor < 0.99f) { //MyGridConveyorSystem.PullAllRequest(this, OutputInventory, OwnerId, OutputInventory.Constraint); var item = TryGetFirstQueueItem(); if (item != null) { if (!OutputInventory.ContainItems(null, item.Value.Blueprint.Results[0].Id)) { MyGridConveyorSystem.ItemPullRequest(this, OutputInventory, OwnerId, item.Value.Blueprint.Results[0].Id, item.Value.Amount); } } } if (InputInventory.VolumeFillFactor > 0.75f) { Debug.Assert(InputInventory.GetItems().Count > 0); MyGridConveyorSystem.PushAnyRequest(this, InputInventory, OwnerId); } } else // Assembling { //if (IsSlave && m_queue.Count < 1 && MyFakes.ENABLE_ASSEMBLER_COOPERATION && !RepeatEnabled) //{ // GetItemFromOtherAssemblers(TIME_IN_ADVANCE); //} if (InputInventory.VolumeFillFactor < 0.99f) { m_requiredComponents.Clear(); var next = false; int i = 0; var time = 0f; do { var item = TryGetQueueItem(i); var remainingTime = TIME_IN_ADVANCE - time; if (item.HasValue) { var productivity = (((MyAssemblerDefinition)BlockDefinition).AssemblySpeed + UpgradeValues["Productivity"]); var factor = MySession.Static.AssemblerSpeedMultiplier * productivity; var itemAmount = 1; if (item.Value.Blueprint.BaseProductionTimeInSeconds / factor < remainingTime) { itemAmount = Math.Min((int)item.Value.Amount, Convert.ToInt32(Math.Ceiling(remainingTime / (item.Value.Blueprint.BaseProductionTimeInSeconds / factor)))); } time += itemAmount * item.Value.Blueprint.BaseProductionTimeInSeconds / factor; if (time < TIME_IN_ADVANCE) { next = true; } var amountMult = (MyFixedPoint)(1.0f / MySession.Static.AssemblerEfficiencyMultiplier); foreach (var component in item.Value.Blueprint.Prerequisites) { var requiredAmount = component.Amount * itemAmount * amountMult; bool found = false; for (int j = 0; j < m_requiredComponents.Count; j++) { if (m_requiredComponents[j].Id == component.Id) { m_requiredComponents[j] = new MyBlueprintDefinitionBase.Item { Amount = m_requiredComponents[j].Amount + requiredAmount, Id = component.Id }; found = true; break; } } if (!found) { m_requiredComponents.Add(new MyBlueprintDefinitionBase.Item { Amount = requiredAmount, Id = component.Id }); } } } i++; if (i >= m_queue.Count) { next = false; } } while (next); foreach (var component in m_requiredComponents) { var availableAmount = InputInventory.GetItemAmount(component.Id); var neededAmount = component.Amount - availableAmount; if (neededAmount <= 0) { continue; } MyGridConveyorSystem.ItemPullRequest(this, InputInventory, OwnerId, component.Id, neededAmount); } if (IsSlave && !RepeatEnabled) { var remainingTime = TIME_IN_ADVANCE - time; if (remainingTime > 0) { GetItemFromOtherAssemblers(remainingTime); } } } if (OutputInventory.VolumeFillFactor > 0.75f) { Debug.Assert(OutputInventory.GetItems().Count > 0); MyGridConveyorSystem.PushAnyRequest(this, OutputInventory, OwnerId); } } } }
private void InitBlock() { MyCubeBlock entity = base.Entity as MyCubeBlock; MyInventory inventory = null; entity.Components.ComponentAdded -= new Action <System.Type, MyEntityComponentBase>(this.OnNewComponentAdded); if (entity != null) { if (entity.InventoryCount == 0) { entity.Components.ComponentAdded += new Action <System.Type, MyEntityComponentBase>(this.OnNewComponentAdded); return; } inventory = entity.GetInventory(0); inventory.SetFlags(MyInventoryFlags.CanSend | MyInventoryFlags.CanReceive); MyInventoryConstraint constraint = new MyInventoryConstraint("Crafting constraints", null, true); using (List <MyBlueprintClassDefinition> .Enumerator enumerator = base.m_blueprintClasses.GetEnumerator()) { while (enumerator.MoveNext()) { IEnumerator <MyBlueprintDefinitionBase> enumerator2 = enumerator.Current.GetEnumerator(); try { while (enumerator2.MoveNext()) { MyBlueprintDefinitionBase current = enumerator2.Current; MyBlueprintDefinitionBase.Item[] results = current.Results; int index = 0; while (true) { if (index >= results.Length) { results = current.Prerequisites; index = 0; while (index < results.Length) { MyBlueprintDefinitionBase.Item item2 = results[index]; constraint.Add(item2.Id); index++; } break; } MyBlueprintDefinitionBase.Item item = results[index]; constraint.Add(item.Id); index++; } } } finally { if (enumerator2 == null) { continue; } enumerator2.Dispose(); } } } inventory.Constraint = constraint; } this.UpdateBlock(); }
private void RebuildQueue() { this.m_queueNeedsRebuild = false; base.ClearQueue(false); this.m_tmpSortedBlueprints.Clear(); MyPhysicalInventoryItem[] itemArray = base.InputInventory.GetItems().ToArray(); int index = 0; while (true) { int num2; while (true) { if (index < itemArray.Length) { num2 = 0; break; } int num4 = 0; while (num4 < this.m_tmpSortedBlueprints.Count) { KeyValuePair <int, MyBlueprintDefinitionBase> pair = this.m_tmpSortedBlueprints[num4]; MyBlueprintDefinitionBase blueprint = pair.Value; MyFixedPoint maxValue = MyFixedPoint.MaxValue; MyBlueprintDefinitionBase.Item[] prerequisites = blueprint.Prerequisites; int num5 = 0; while (true) { if (num5 < prerequisites.Length) { MyBlueprintDefinitionBase.Item item = prerequisites[num5]; MyFixedPoint amount = itemArray[num4].Amount; if (amount != 0) { maxValue = MyFixedPoint.Min(amount * (1f / ((float)item.Amount)), maxValue); num5++; continue; } maxValue = 0; } if (blueprint.Atomic) { maxValue = MyFixedPoint.Floor(maxValue); } if ((maxValue > 0) && (maxValue != MyFixedPoint.MaxValue)) { base.InsertQueueItemRequest(-1, blueprint, maxValue); } num4++; break; } } this.m_tmpSortedBlueprints.Clear(); return; } while (true) { if (num2 >= this.m_refineryDef.BlueprintClasses.Count) { index++; break; } using (IEnumerator <MyBlueprintDefinitionBase> enumerator = this.m_refineryDef.BlueprintClasses[num2].GetEnumerator()) { while (true) { if (enumerator.MoveNext()) { MyBlueprintDefinitionBase current = enumerator.Current; bool flag = false; MyDefinitionId other = new MyDefinitionId(itemArray[index].Content.TypeId, itemArray[index].Content.SubtypeId); int num3 = 0; while (true) { if (num3 < current.Prerequisites.Length) { if (!current.Prerequisites[num3].Id.Equals(other)) { num3++; continue; } flag = true; } if (!flag) { continue; } else { this.m_tmpSortedBlueprints.Add(new KeyValuePair <int, MyBlueprintDefinitionBase>(index, current)); } break; } } break; } } num2++; } } }