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 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!");
}
}