public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
MyDebug.AssertDebug(BlockDefinition is MyRefineryDefinition);
m_refineryDef = BlockDefinition as MyRefineryDefinition;
InputInventory.Constraint = m_refineryDef.InputInventoryConstraint;
bool removed = InputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
InputInventory.ContentsChanged += inventory_OnContentsChanged;
OutputInventory.Constraint = m_refineryDef.OutputInventoryConstraint;
removed = OutputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
OutputInventory.ContentsChanged += inventory_OnContentsChanged;
m_queueNeedsRebuild = true;
UpgradeValues.Add("Productivity", 0f);
UpgradeValues.Add("Effectiveness", 1f);
UpgradeValues.Add("PowerEfficiency", 1f);
ResourceSink.RequiredInputChanged += PowerReceiver_RequiredInputChanged;
OnUpgradeValuesChanged += UpdateDetailedInfo;
UpdateDetailedInfo();
}
public override MyObjectBuilder_CubeBlock GetObjectBuilderCubeBlock(bool copy = false)
{
var ob = (MyObjectBuilder_ProductionBlock)base.GetObjectBuilderCubeBlock(copy);
ob.InputInventory = InputInventory.GetObjectBuilder();
ob.OutputInventory = OutputInventory.GetObjectBuilder();
ob.UseConveyorSystem = m_useConveyorSystem;
ob.NextItemId = m_nextItemId;
if (m_queue.Count > 0)
{
ob.Queue = new MyObjectBuilder_ProductionBlock.QueueItem[m_queue.Count];
for (int i = 0; i < m_queue.Count; ++i)
{
ob.Queue[i].Id = m_queue[i].Blueprint.Id;
ob.Queue[i].Amount = m_queue[i].Amount;
ob.Queue[i].ItemId = m_queue[i].ItemId;
}
}
else
{
ob.Queue = null;
}
return(ob);
}
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)Sandbox.Common.ObjectBuilders.Serializer.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)Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject(resultId);
var resultAmount = blueprintAmount * result.Amount * m_refineryDef.MaterialEfficiency * UpgradeValues["Effectiveness"];
OutputInventory.AddItems(resultAmount, obResult);
}
RemoveFirstQueueItemAnnounce(blueprintAmount);
}
private void ChangeRequirementsToResults(MyBlueprintDefinitionBase queueItem, MyFixedPoint blueprintAmount)
{
Debug.Assert(Sync.IsServer);
Debug.Assert(m_refineryDef != null, "m_refineryDef shouldn't be null!!!");
if (Sync.IsServer == false)
{
return;
}
if (MySession.Static == null || queueItem == null || queueItem.Prerequisites == null || OutputInventory == null || InputInventory == null || queueItem.Results == null)
{
return;
}
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);
if (obPrerequisite == null)
{
Debug.Fail("obPrerequisite shouldn't be null!!!");
continue;
}
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);
if (obResult == null)
{
Debug.Fail("obResult shouldn't be null!!!");
continue;
}
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 void InitializeInventoryCounts(bool inputInventory = true)
{
m_tmpInventoryCounts.Clear();
foreach (var item in inputInventory ? InputInventory.GetItems() : OutputInventory.GetItems())
{
MyFixedPoint count = 0;
MyDefinitionId itemId = new MyDefinitionId(item.Content.TypeId, item.Content.SubtypeId);
m_tmpInventoryCounts.TryGetValue(itemId, out count);
m_tmpInventoryCounts[itemId] = count + item.Amount;
}
}
private void ProcessQueueItems(int timeDelta)
{
// Prevent refreshing of queue.
m_processingLock = true;
if (Sync.IsServer)
{
while (!IsQueueEmpty && timeDelta > 0)
{
var wrappedItem = TryGetFirstQueueItem();
Debug.Assert(wrappedItem.HasValue);
QueueItem queueItem = wrappedItem.Value;
// Compute how much blueprints could be processed in remaining time.
MyFixedPoint blueprintsProcessed = (MyFixedPoint)((timeDelta * (m_refineryDef.RefineSpeed + UpgradeValues["Productivity"]) * MySession.Static.RefinerySpeedMultiplier) / (queueItem.Blueprint.BaseProductionTimeInSeconds * 1000));
// Fix that number according to how much items are in the inventory
foreach (var prerequisite in queueItem.Blueprint.Prerequisites)
{
MyFixedPoint oreAvailable = InputInventory.GetItemAmount(prerequisite.Id);
MyFixedPoint oreProcessed = blueprintsProcessed * prerequisite.Amount;
if (oreAvailable < oreProcessed)
{
blueprintsProcessed = oreAvailable * (1f / (float)prerequisite.Amount);
}
}
//GR: This assertion happens on last item to be removed when allowing duplicate blueprints. The queue is emptied but with small delay. Synchronization needed?
//Debug.Assert(blueprintsProcessed > 0, "No items in inventory but there are blueprints in the queue!");
if (blueprintsProcessed == 0)
{
//GR: For now comment out bcause it spams the log on servers on occasions
//MySandboxGame.Log.WriteLine("MyRefinery.ProcessQueueItems: Inventory empty while there are still blueprints in the queue!");
m_queueNeedsRebuild = true;
break;
}
// Math.Max has to be here to avoid situations in which timeDelta wouldn't change at all.
// Basically, this means that the refinery cannot spend less time processing items than 1ms, which is OK, I guess
timeDelta = timeDelta - System.Math.Max(1, (int)((float)blueprintsProcessed * queueItem.Blueprint.BaseProductionTimeInSeconds / m_refineryDef.RefineSpeed * 1000));
if (timeDelta < 0)
{
timeDelta = 0;
}
ChangeRequirementsToResults(queueItem.Blueprint, blueprintsProcessed);
}
}
IsProducing = !IsQueueEmpty;
m_processingLock = false;
}
private void Awake()
{
if (Instance)
{
Destroy(this);
}
else
{
Instance = this;
}
Inventory = new InputEntity[InventorySize];
}
private bool checkInputInventory()
{
foreach (var inputItem in getActualInputItems())
{
Item itemInInv = InputInventory.TryGetItem(inputItem);
if (itemInInv.getAmount() < inputItem.getAmount())
{
notEnoughItems = true;
return(false);
}
}
notEnoughItems = false;
return(true);
}
private void SmeltItem()
{
if (checkInputInventory())
{
foreach (var inputItem in getActualInputItems())
{
InputInventory.RemoveItem(inputItem);
}
foreach (var outputItem in getOutputItems())
{
OutputInventory.AddItem(Item.CreateItem(outputItem, outputItem.getAmount()));
}
}
}
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)Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject(res.Id.TypeId, res.Id.SubtypeName);
OutputInventory.AddItems(res.Amount, resOb);
}
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
// Need to be initialized before base.Init because when loading world with producting refinery
// it will be missing when recompute power and cause disappearing of refinery.
UpgradeValues.Add("Productivity", 0f);
UpgradeValues.Add("Effectiveness", 1f);
UpgradeValues.Add("PowerEfficiency", 1f);
base.Init(objectBuilder, cubeGrid);
MyDebug.AssertDebug(BlockDefinition is MyRefineryDefinition);
m_refineryDef = BlockDefinition as MyRefineryDefinition;
if (InventoryAggregate.InventoryCount > 2)
{
Debug.Fail("Inventory aggregate has to many inventories, probably wrong save. If you continue the unused inventories will be removed. Save the world to correct it. Please report this is if problem prevail.");
FixInputOutputInventories(m_refineryDef.InputInventoryConstraint, m_refineryDef.OutputInventoryConstraint);
}
InputInventory.Constraint = m_refineryDef.InputInventoryConstraint;
bool removed = InputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
OutputInventory.Constraint = m_refineryDef.OutputInventoryConstraint;
removed = OutputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
m_queueNeedsRebuild = true;
m_baseIdleSound = BlockDefinition.PrimarySound;
m_processSound = BlockDefinition.ActionSound;
ResourceSink.RequiredInputChanged += PowerReceiver_RequiredInputChanged;
OnUpgradeValuesChanged += UpdateDetailedInfo;
UpdateDetailedInfo();
NeedsUpdate |= VRage.ModAPI.MyEntityUpdateEnum.EACH_100TH_FRAME;
}
private void setMaxInventory(Tier tier)
{
switch (tier)
{
case Tier.Bronze:
maxInventory = 10;
break;
case Tier.Iron:
maxInventory = 20;
break;
case Tier.Silver:
maxInventory = 40;
break;
case Tier.Gold:
maxInventory = 60;
break;
case Tier.Titanium:
maxInventory = 80;
break;
case Tier.Diamond:
maxInventory = 100;
break;
}
if (InputInventory == null)
{
InputInventory = new ItemInventory();
}
else
{
InputInventory.setMaxInventoryWeight(maxInventory);
}
}
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)Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject(item.Id.TypeId, item.Id.SubtypeName);
InputInventory.AddItems(item.Amount * amountMult, itemOb);
}
}
private void RebuildQueue()
{
Debug.Assert(Sync.IsServer);
m_queueNeedsRebuild = false;
ClearQueue(false);
//Changed by Gregory: Allow for duplicate blueprints cause it should be a supported functionality to add resources of the same type more than once
//So now the index is essentially given by input items of inventory. Maybe try something more efficient?
m_tmpSortedBlueprints.Clear();
var inputItems = InputInventory.GetItems();
for (int indx = 0; indx < inputItems.Count; indx++)
{
for (int i = 0; i < m_refineryDef.BlueprintClasses.Count; ++i)
{
foreach (var blueprint in m_refineryDef.BlueprintClasses[i])
{
bool found = false;
MyDefinitionId inputItemId = new MyDefinitionId(inputItems[indx].Content.TypeId, inputItems[indx].Content.SubtypeId);
for (int j = 0; j < blueprint.Prerequisites.Length; ++j)
{
if (blueprint.Prerequisites[j].Id.Equals(inputItemId))
{
found = true;
break;
}
}
if (found)
{
m_tmpSortedBlueprints.Add(new KeyValuePair <int, MyBlueprintDefinitionBase>(indx, blueprint));
break;
}
}
}
}
MyFixedPoint buildAmount, remainingAmount;
for (int i = 0; i < m_tmpSortedBlueprints.Count; i++)
{
var blueprint = m_tmpSortedBlueprints[i].Value;
buildAmount = MyFixedPoint.MaxValue;
foreach (var requirement in blueprint.Prerequisites)
{
remainingAmount = inputItems[i].Amount;
if (remainingAmount == 0)
{
buildAmount = 0;
break;
}
buildAmount = MyFixedPoint.Min((remainingAmount * (1f / (float)requirement.Amount)), buildAmount);
}
if (blueprint.Atomic)
{
buildAmount = MyFixedPoint.Floor(buildAmount);
}
if (buildAmount > 0 && buildAmount != MyFixedPoint.MaxValue)
{
InsertQueueItemRequest(-1, blueprint, buildAmount);
}
}
m_tmpSortedBlueprints.Clear();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
m_inputInventory = new MyInventory(
ProductionBlockDefinition.InventoryMaxVolume,
ProductionBlockDefinition.InventorySize,
MyInventoryFlags.CanReceive,
this);
m_outputInventory = new MyInventory(
ProductionBlockDefinition.InventoryMaxVolume,
ProductionBlockDefinition.InventorySize,
MyInventoryFlags.CanSend,
this);
var ob = (MyObjectBuilder_ProductionBlock)objectBuilder;
if (ob.InputInventory != null)
{
InputInventory.Init(ob.InputInventory);
}
if (ob.OutputInventory != null)
{
OutputInventory.Init(ob.OutputInventory);
}
m_nextItemId = ob.NextItemId;
bool nextIdWasZero = m_nextItemId == 0;
base.IsWorkingChanged += CubeBlock_IsWorkingChanged;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Factory,
false,
ProductionBlockDefinition.OperationalPowerConsumption,
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
if (ob.Queue != null)
{
m_queue.Clear();
if (m_queue.Capacity < ob.Queue.Length)
{
m_queue.Capacity = ob.Queue.Length;
}
for (int i = 0; i < ob.Queue.Length; ++i)
{
var item = ob.Queue[i];
Debug.Assert(item.ItemId != null || nextIdWasZero, "Item index was null while next id for production block was given non-zero. This is inconsistency.");
var deserializedItem = DeserializeQueueItem(item);
Debug.Assert(deserializedItem.Blueprint != null, "Could not add item into production block's queue: Blueprint was not found.");
if (deserializedItem.Blueprint != null)
{
m_queue.Add(deserializedItem);
MySandboxGame.Log.WriteLine(string.Format("Could not add item into production block's queue: Blueprint {0} was not found.", item.Id));
}
}
UpdatePower();
}
m_useConveyorSystem = ob.UseConveyorSystem;
m_lastUpdateTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
}
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();
}
if (InputInventory.VolumeFillFactor < 0.99f)
{
var next = false;
int i = 0;
var time = 0f;
do
{
var item = TryGetQueueItem(i);
if (item.HasValue)
{
var factor = MySession.Static.AssemblerSpeedMultiplier / MySession.Static.AssemblerEfficiencyMultiplier;
var itemAmount = 1;
var remainingTime = TIME_IN_ADVANCE - time;
if (item.Value.Blueprint.BaseProductionTimeInSeconds < remainingTime)
{
itemAmount = Math.Min((int)item.Value.Amount, Convert.ToInt32(Math.Floor(remainingTime / (item.Value.Blueprint.BaseProductionTimeInSeconds / factor))));
time += itemAmount * item.Value.Blueprint.BaseProductionTimeInSeconds / MySession.Static.AssemblerSpeedMultiplier;
if (time < TIME_IN_ADVANCE)
{
next = true;
}
}
foreach (var component in item.Value.Blueprint.Prerequisites)
{
var availableAmount = InputInventory.GetItemAmount(component.Id);
if (i > 0)
{
availableAmount = 0;
}
var neededAmount = component.Amount * itemAmount - availableAmount;
if (neededAmount <= 0)
{
continue;
}
MyGridConveyorSystem.ItemPullRequest(this, InputInventory, OwnerId, component.Id, neededAmount);
}
}
if (i > 0)
{
next = false;
}
i++;
} while (next);
}
if (OutputInventory.VolumeFillFactor > 0.75f)
{
Debug.Assert(OutputInventory.GetItems().Count > 0);
MyGridConveyorSystem.PushAnyRequest(this, OutputInventory, OwnerId);
}
}
}
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_cubeGrid = cubeGrid;
MyDebug.AssertDebug(BlockDefinition is MyAssemblerDefinition);
m_assemblerDef = BlockDefinition as MyAssemblerDefinition;
InputInventory.Constraint = m_assemblerDef.InputInventoryConstraint;
OutputInventory.Constraint = m_assemblerDef.OutputInventoryConstraint;
if (Sync.IsServer)
{
OutputInventory.ContentsChanged += OutputInventory_ContentsChanged;
}
bool removed = InputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
var builder = (MyObjectBuilder_Assembler)objectBuilder;
if (builder.OtherQueue != null)
{
m_otherQueue.Clear();
if (m_otherQueue.Capacity < builder.OtherQueue.Length)
{
m_otherQueue.Capacity = builder.OtherQueue.Length;
}
for (int i = 0; i < builder.OtherQueue.Length; ++i)
{
var item = builder.OtherQueue[i];
var blueprint = MyDefinitionManager.Static.TryGetBlueprintDefinitionByResultId(item.Id);
if (blueprint != null)
{
m_otherQueue.Add(new QueueItem()
{
Blueprint = blueprint,
Amount = item.Amount,
});
}
else
{
MySandboxGame.Log.WriteLine(string.Format("No blueprint that produces a single result with Id '{0}'", item.Id));
}
}
}
CurrentProgress = builder.CurrentProgress;
m_disassembleEnabled = builder.DisassembleEnabled;
m_repeatAssembleEnabled = builder.RepeatAssembleEnabled;
m_repeatDisassembleEnabled = builder.RepeatDisassembleEnabled;
m_slave = builder.SlaveEnabled;
UpdateInventoryFlags();
UpgradeValues.Add("Productivity", 0f);
UpgradeValues.Add("PowerEfficiency", 1f);
OnUpgradeValuesChanged += UpdateDetailedInfo;
PowerReceiver.RequiredInputChanged += PowerReceiver_RequiredInputChanged;
UpdateDetailedInfo();
}
private void UpdateInventoryFlags()
{
OutputInventory.SetFlags(DisassembleEnabled ? MyInventoryFlags.CanReceive : MyInventoryFlags.CanSend);
InputInventory.SetFlags(DisassembleEnabled ? MyInventoryFlags.CanSend : MyInventoryFlags.CanReceive);
}
public void deliverJobCall(Item itemToBeDelivered, IInventory minerInventory)
{
InputInventory.TakeItem(itemToBeDelivered, minerInventory);
JobController.Instance.successJobCall(this, itemToBeDelivered);
}
public void depositItem(Item item, IInventory minerInventory, int?amount = null)
{
InputInventory.putItem(item, minerInventory, amount);
checkInputInventory();
}
private void RebuildQueue()
{
Debug.Assert(Sync.IsServer || !MyFakes.ENABLE_PRODUCTION_SYNC);
m_queueNeedsRebuild = false;
ClearQueue(false);
InitializeInventoryCounts(inputInventory: true);
// Find all blueprints that contain as a prerequisite any item from the input inventory and sort them by the input inventory
// index of the first item found.
m_tmpSortedBlueprints.Clear();
var inputItems = InputInventory.GetItems();
for (int i = 0; i < m_refineryDef.BlueprintClasses.Count; ++i)
{
foreach (var blueprint in m_refineryDef.BlueprintClasses[i])
{
int firstRequirementIndex = 0;
bool found = false;
while (firstRequirementIndex < inputItems.Count)
{
MyDefinitionId inputItemId = new MyDefinitionId(inputItems[firstRequirementIndex].Content.TypeId, inputItems[firstRequirementIndex].Content.SubtypeId);
for (int j = 0; j < blueprint.Prerequisites.Length; ++j)
{
if (blueprint.Prerequisites[j].Id.Equals(inputItemId))
{
found = true;
break;
}
}
if (found)
{
m_tmpSortedBlueprints.Add(new KeyValuePair <int, MyBlueprintDefinitionBase>(firstRequirementIndex, blueprint));
break;
}
firstRequirementIndex++;
}
}
}
m_tmpSortedBlueprints.Sort((pair1, pair2) => pair1.Key - pair2.Key);
MyFixedPoint buildAmount, remainingAmount;
foreach (var pair in m_tmpSortedBlueprints)
{
var blueprint = pair.Value;
buildAmount = MyFixedPoint.MaxValue;
foreach (var requirement in blueprint.Prerequisites)
{
remainingAmount = 0;
m_tmpInventoryCounts.TryGetValue(requirement.Id, out remainingAmount);
if (remainingAmount == 0)
{
buildAmount = 0;
break;
}
buildAmount = MyFixedPoint.Min((remainingAmount * (1f / (float)requirement.Amount)), buildAmount);
}
if (blueprint.Atomic)
{
buildAmount = MyFixedPoint.Floor(buildAmount);
}
if (buildAmount > 0 && buildAmount != MyFixedPoint.MaxValue)
{
InsertQueueItemRequest(-1, blueprint, buildAmount);
foreach (var prerequisite in blueprint.Prerequisites)
{
m_tmpInventoryCounts.TryGetValue(prerequisite.Id, out remainingAmount);
remainingAmount -= prerequisite.Amount * buildAmount;
//Debug.Assert(remainingAmount >= 0);
if (remainingAmount == 0)
{
m_tmpInventoryCounts.Remove(prerequisite.Id);
}
else
{
m_tmpInventoryCounts[prerequisite.Id] = remainingAmount;
}
}
}
}
m_tmpSortedBlueprints.Clear();
m_tmpInventoryCounts.Clear();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_cubeGrid = cubeGrid;
MyDebug.AssertDebug(BlockDefinition is MyAssemblerDefinition);
m_assemblerDef = BlockDefinition as MyAssemblerDefinition;
if (InventoryAggregate.InventoryCount > 2)
{
Debug.Fail("Inventory aggregate has to many inventories, probably wrong save. If you continue the unused inventories will be removed. Save the world to correct it. Please report this is if problem prevail.");
FixInputOutputInventories(m_assemblerDef.InputInventoryConstraint, m_assemblerDef.OutputInventoryConstraint);
}
InputInventory.Constraint = m_assemblerDef.InputInventoryConstraint;
OutputInventory.Constraint = m_assemblerDef.OutputInventoryConstraint;
bool removed = InputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
var builder = (MyObjectBuilder_Assembler)objectBuilder;
if (builder.OtherQueue != null)
{
m_otherQueue.Clear();
if (m_otherQueue.Capacity < builder.OtherQueue.Length)
{
m_otherQueue.Capacity = builder.OtherQueue.Length;
}
for (int i = 0; i < builder.OtherQueue.Length; ++i)
{
var item = builder.OtherQueue[i];
var blueprint = MyDefinitionManager.Static.TryGetBlueprintDefinitionByResultId(item.Id);
if (blueprint != null)
{
m_otherQueue.Add(new QueueItem()
{
Blueprint = blueprint,
Amount = item.Amount,
});
}
else
{
MySandboxGame.Log.WriteLine(string.Format("No blueprint that produces a single result with Id '{0}'", item.Id));
}
}
}
CurrentProgress = builder.CurrentProgress;
m_disassembleEnabled = builder.DisassembleEnabled;
m_repeatAssembleEnabled = builder.RepeatAssembleEnabled;
m_repeatDisassembleEnabled = builder.RepeatDisassembleEnabled;
m_slave = builder.SlaveEnabled;
UpdateInventoryFlags();
UpgradeValues.Add("Productivity", 0f);
UpgradeValues.Add("PowerEfficiency", 1f);
m_baseIdleSound = BlockDefinition.PrimarySound;
m_processSound = BlockDefinition.ActionSound;
OnUpgradeValuesChanged += UpdateDetailedInfo;
ResourceSink.RequiredInputChanged += PowerReceiver_RequiredInputChanged;
UpdateDetailedInfo();
}
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);
}
}
}
}
