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++;
}
}
}
