public void AddItem(MyDefinitionId groupId, int itemValue, int amount)
{
List <int> list = null;
MyComponentGroupDefinition componentGroup = MyDefinitionManager.Static.GetComponentGroup(groupId);
if (componentGroup != null)
{
if (!this.m_groups.TryGetValue(groupId, out list))
{
list = this.m_listAllocator.Allocate();
list.Clear();
int num = 0;
while (true)
{
if (num > componentGroup.GetComponentNumber())
{
this.m_groups.Add(groupId, list);
break;
}
list.Add(0);
num++;
}
}
List <int> list2 = list;
int num2 = itemValue;
list2[num2] += amount;
this.m_totalItemCounter += amount;
}
}
private int TryCreatingItemsBySplit(MyComponentGroupDefinition group, int itemValue, int itemCount)
{
int num = 0;
for (int i = itemValue + 1; i <= group.GetComponentNumber(); i++)
{
int splitCount = i / itemValue;
int num4 = itemCount / splitCount;
int num5 = itemCount % splitCount;
int num7 = this.TryRemovePresentItems(i, num4 + ((num5 == 0) ? 0 : 1));
if (num7 > 0)
{
int numItemsToSplit = Math.Min(num7, num4);
if (numItemsToSplit != 0)
{
int num9 = this.SplitHelper(group, i, itemValue, numItemsToSplit, splitCount);
num += num9;
itemCount -= num9;
}
if ((num7 - num4) > 0)
{
int num10 = this.SplitHelper(group, i, itemValue, 1, num5);
num += num10;
itemCount -= num10;
}
}
}
return(num);
}
private void UpdatePresentItems(MyComponentGroupDefinition group, Dictionary <MyDefinitionId, MyFixedPoint> componentCounts)
{
m_presentItems.Clear();
for (int i = 1; i <= group.GetComponentNumber(); i++)
{
var compDef = group.GetComponentDefinition(i);
MyFixedPoint amount = 0;
componentCounts.TryGetValue(compDef.Id, out amount);
m_presentItems[i] = (int)amount;
}
}
public bool Solve(Dictionary <MyDefinitionId, MyFixedPoint> componentCounts)
{
this.m_solution.Clear();
this.m_solvedItemCounter = 0;
foreach (KeyValuePair <MyDefinitionId, List <int> > pair in this.m_groups)
{
MyComponentGroupDefinition componentGroup = MyDefinitionManager.Static.GetComponentGroup(pair.Key);
List <int> list = pair.Value;
this.UpdatePresentItems(componentGroup, componentCounts);
int itemValue = 1;
while (true)
{
if (itemValue > componentGroup.GetComponentNumber())
{
int componentNumber = componentGroup.GetComponentNumber();
while (true)
{
if (componentNumber < 1)
{
for (int i = 1; i <= componentGroup.GetComponentNumber(); i++)
{
int num8 = list[i];
if (num8 > 0)
{
int num9 = this.TryCreatingItemsByMerge(componentGroup, i, num8);
list[i] = num8 - num9;
this.m_solvedItemCounter += num9;
}
}
break;
}
int itemCount = list[componentNumber];
int num6 = this.TryCreatingItemsBySplit(componentGroup, componentNumber, itemCount);
list[componentNumber] = itemCount - num6;
this.m_solvedItemCounter += num6;
componentNumber--;
}
break;
}
int removeCount = list[itemValue];
int num3 = this.TryRemovePresentItems(itemValue, removeCount);
if (num3 > 0)
{
this.AddRemovalToSolution(componentGroup.GetComponentDefinition(itemValue).Id, num3);
list[itemValue] = Math.Max(0, removeCount - num3);
}
this.m_solvedItemCounter += num3;
itemValue++;
}
}
return(this.m_totalItemCounter == this.m_solvedItemCounter);
}
private int SplitHelper(MyComponentGroupDefinition group, int splitItemValue, int resultItemValue, int numItemsToSplit, int splitCount)
{
int itemValue = splitItemValue - (splitCount * resultItemValue);
MyDefinitionId removedComponentId = group.GetComponentDefinition(splitItemValue).Id;
if (itemValue == 0)
{
this.AddRemovalToSolution(removedComponentId, numItemsToSplit);
}
else
{
this.AddPresentItems(itemValue, numItemsToSplit);
this.AddChangeToSolution(removedComponentId, group.GetComponentDefinition(itemValue).Id, numItemsToSplit);
}
return(splitCount * numItemsToSplit);
}
private int SplitHelper(MyComponentGroupDefinition group, int splitItemValue, int resultItemValue, int numItemsToSplit, int splitCount)
{
int remainder = splitItemValue - (splitCount * resultItemValue);
MyDefinitionId removedComponentId = group.GetComponentDefinition(splitItemValue).Id;
if (remainder != 0)
{
MyDefinitionId addedComponentId = group.GetComponentDefinition(remainder).Id;
AddPresentItems(remainder, numItemsToSplit);
AddChangeToSolution(removedComponentId, addedComponentId, numItemsToSplit);
}
else
{
AddRemovalToSolution(removedComponentId, numItemsToSplit);
}
return(splitCount * numItemsToSplit);
}
public MyFixedPoint GetItemAmountCombined(MyInventoryBase inventory, MyDefinitionId contentId)
{
if (inventory == null)
{
return(0);
}
int amount = 0;
MyComponentGroupDefinition groupForComponent = MyDefinitionManager.Static.GetGroupForComponent(contentId, out amount);
if (groupForComponent == null)
{
return(amount + inventory.GetItemAmount(contentId, MyItemFlags.None, true));
}
this.Clear();
inventory.CountItems(m_componentCounts);
this.AddItem(groupForComponent.Id, amount, 0x7fffffff);
this.Solve(m_componentCounts);
return(this.GetSolvedItemCount());
}
private int TryCreatingItemsBySplit(MyComponentGroupDefinition group, int itemValue, int itemCount)
{
int createdCount = 0;
// Avoid making too much "mess" by trying to find the best-fitting items first
for (int k = itemValue + 1; k <= group.GetComponentNumber(); k++)
{
int fitNumber = k / itemValue; // How many items fit into k-item
int wholeCount = itemCount / fitNumber; // How many k-items will be fully split
int partialFitNumber = itemCount % fitNumber; // How many items will be created from the last k-item
int partialCount = partialFitNumber == 0 ? 0 : 1; // How many k-items will be partially split (either 0 or 1 that is)
int removedCount = TryRemovePresentItems(k, wholeCount + partialCount);
if (removedCount > 0)
{
int removedWholeCount = Math.Min(removedCount, wholeCount);
if (removedWholeCount != 0)
{
int created = SplitHelper(group, k, itemValue, removedWholeCount, fitNumber);
createdCount += created;
itemCount -= created;
}
if (removedCount - wholeCount > 0)
{
Debug.Assert(removedCount == wholeCount + partialCount && partialCount == 1, "Calculation problem in cutting solver");
int created = SplitHelper(group, k, itemValue, 1, partialFitNumber);
createdCount += created;
itemCount -= created;
}
}
}
return(createdCount);
}
public void RemoveItemsCombined(MyInventoryBase inventory, DictionaryReader <MyDefinitionId, int> toRemove)
{
this.Clear();
foreach (KeyValuePair <MyDefinitionId, int> pair in toRemove)
{
int amount = 0;
MyComponentGroupDefinition groupForComponent = MyDefinitionManager.Static.GetGroupForComponent(pair.Key, out amount);
if (groupForComponent != null)
{
this.AddItem(groupForComponent.Id, amount, pair.Value);
continue;
}
if ((MySessionComponentEquivalency.Static != null) && MySessionComponentEquivalency.Static.HasEquivalents(pair.Key))
{
HashSet <MyDefinitionId> equivalents = MySessionComponentEquivalency.Static.GetEquivalents(pair.Key);
if (equivalents == null)
{
continue;
}
int num2 = pair.Value;
foreach (MyDefinitionId id in equivalents)
{
if (num2 <= 0)
{
break;
}
num2 -= (int)inventory.RemoveItemsOfType(num2, id, MyItemFlags.None, false);
}
continue;
}
inventory.RemoveItemsOfType(pair.Value, pair.Key, MyItemFlags.None, false);
}
inventory.CountItems(m_componentCounts);
this.Solve(m_componentCounts);
inventory.ApplyChanges(this.m_solution);
}
public bool CanCombineItems(MyInventoryBase inventory, DictionaryReader <MyDefinitionId, int> items)
{
bool result = true;
Clear();
inventory.CountItems(m_componentCounts);
foreach (var item in items)
{
int itemValue = 0;
int neededAmount = item.Value;
MyComponentGroupDefinition group = null;
group = MyDefinitionManager.Static.GetGroupForComponent(item.Key, out itemValue);
if (group == null)
{
MyFixedPoint itemAmount;
// Checking if this component is not provided by the group
MyComponentSubstitutionDefinition substitutions;
if (MyDefinitionManager.Static.TryGetComponentSubstitutionDefinition(item.Key, out substitutions))
{
int providedAmount;
if (!substitutions.IsProvidedByComponents(m_componentCounts, out providedAmount))
{
result = false;
break;
}
else if (providedAmount < neededAmount)
{
result = false;
break;
}
}
else if (!m_componentCounts.TryGetValue(item.Key, out itemAmount))
{
result = false;
break;
}
else if (itemAmount < neededAmount)
{
result = false;
break;
}
}
else
{
AddItem(group.Id, itemValue, neededAmount);
}
}
if (result)
{
result &= Solve(m_componentCounts);
}
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW)
{
if (result == false)
{
MyRenderProxy.DebugDrawText2D(new Vector2(0.0f, 0.0f), "Can not build", Color.Red, 1.0f);
}
else
{
List <MyComponentChange> solution = null;
GetSolution(out solution);
float yCoord = 0.0f;
foreach (var change in solution)
{
string text = "";
if (change.IsAddition())
{
text += "+ " + change.Amount.ToString() + "x" + change.ToAdd.ToString();
MyRenderProxy.DebugDrawText2D(new Vector2(0.0f, yCoord), text, Color.Green, 1.0f);
yCoord += 20.0f;
}
else if (change.IsRemoval())
{
text += "- " + change.Amount.ToString() + "x" + change.ToRemove.ToString();
MyRenderProxy.DebugDrawText2D(new Vector2(0.0f, yCoord), text, Color.Red, 1.0f);
yCoord += 20.0f;
}
else
{
text += "- " + change.Amount.ToString() + "x" + change.ToRemove.ToString();
MyRenderProxy.DebugDrawText2D(new Vector2(0.0f, yCoord), text, Color.Orange, 1.0f);
yCoord += 20.0f;
text = "";
text += "+ " + change.Amount.ToString() + "x" + change.ToAdd.ToString();
MyRenderProxy.DebugDrawText2D(new Vector2(0.0f, yCoord), text, Color.Orange, 1.0f);
yCoord += 20.0f;
}
}
}
}
return(result);
}
private int TryCreatingItemsByMerge(MyComponentGroupDefinition group, int itemValue, int itemCount)
{
// Removal buffer is here so that the method does not do anything until it's clear that the operation can be successful
List <int> removalBuffer = m_listAllocator.Allocate();
removalBuffer.Clear();
for (int i = 0; i <= group.GetComponentNumber(); ++i)
{
removalBuffer.Add(0);
}
int createdCount = 0;
// Create the items one-by-one
for (int i = 0; i < itemCount; ++i)
{
// What remains to be found to create this item
int remainder = itemValue;
// Fill this item with smaller items as long as possible
for (int k = itemValue - 1; k >= 1; k--)
{
int amount = 0;
if (m_presentItems.TryGetValue(k, out amount))
{
int removeCount = Math.Min(remainder / k, amount);
if (removeCount > 0)
{
remainder = remainder - k * removeCount;
amount -= removeCount;
removalBuffer[k] += removeCount;
}
}
}
// The remainder was not reduced by the remaining items, which means that we don't have any items left
if (remainder == itemValue)
{
Debug.Assert(m_presentItems.Count == 0 || itemValue == 1, "There are still items present in the cutting solver, but they were not used in the solution!");
break;
}
// There are no more smaller items to fill the remainder. Try to split one of the larger ones
if (remainder != 0)
{
for (int j = remainder + 1; j <= group.GetComponentNumber(); ++j)
{
int present = 0;
m_presentItems.TryGetValue(j, out present);
// If there is some present item that is not planned to be removed, use it
if (present > removalBuffer[j])
{
MyDefinitionId removedComponentId = group.GetComponentDefinition(j).Id;
MyDefinitionId addedComponentId = group.GetComponentDefinition(j - remainder).Id;
AddChangeToSolution(removedComponentId, addedComponentId, 1);
int removed = TryRemovePresentItems(j, 1);
AddPresentItems(j - remainder, 1);
Debug.Assert(removed == 1);
remainder = 0;
break;
}
}
}
if (remainder == 0)
{
createdCount++;
// Add the buffered removals of the smaller items here
for (int k = 1; k <= group.GetComponentNumber(); ++k)
{
if (removalBuffer[k] > 0)
{
MyDefinitionId removedComponentId = group.GetComponentDefinition(k).Id;
int removed = TryRemovePresentItems(k, removalBuffer[k]);
Debug.Assert(removed == removalBuffer[k]);
AddRemovalToSolution(removedComponentId, removalBuffer[k]);
removalBuffer[k] = 0; // We need to clear the buffer for the next item
}
}
} // The item could not be created and neither would be the others
else if (remainder > 0)
{
break;
}
}
m_listAllocator.Deallocate(removalBuffer);
return(createdCount);
}
public void RemoveItemsCombined(MyInventoryBase inventory, DictionaryReader <MyDefinitionId, int> toRemove)
{
Clear();
foreach (var material in toRemove) // rename material to component
{
int groupAmount = 0;
MyComponentGroupDefinition group = MyDefinitionManager.Static.GetGroupForComponent(material.Key, out groupAmount);
// The component does not belong to any component group => we are looking exactly for the given component
if (group == null)
{
MyComponentSubstitutionDefinition substitutionDefinition = null;
if (MyDefinitionManager.Static.TryGetComponentSubstitutionDefinition(material.Key, out substitutionDefinition))
{
int amountToRemove = material.Value;
foreach (var entry in substitutionDefinition.ProvidingComponents)
{
if (amountToRemove > 0)
{
var removed = inventory.RemoveItemsOfType(amountToRemove * entry.Value, entry.Key);
amountToRemove -= (int)removed;
}
else
{
break;
}
}
if (amountToRemove > 0)
{
var removed = inventory.RemoveItemsOfType(amountToRemove, material.Key);
amountToRemove -= (int)removed;
}
}
else
{
inventory.RemoveItemsOfType(material.Value, material.Key);
continue;
}
}
else
{
AddItem(group.Id, groupAmount, material.Value);
}
}
inventory.CountItems(m_componentCounts);
bool success = Solve(m_componentCounts);
Debug.Assert(success, "Could not combine required items!");
inventory.ApplyChanges(m_solution);
/*CheckUpdate();
*
* m_remainder.Clear();
* foreach (var material in toRemove)
* {
* m_remainder.Add(material.Key, material.Value);
* }
*
* bool success = true;
*
* m_cuttingSolver.Clear();
* foreach (var material in m_remainder)
* {
* int groupAmount = 0;
* MyComponentGroupDefinition group = MyDefinitionManager.Static.GetGroupForComponent(material.Key, out groupAmount);
*
* // The component does not belong to any component group => we are looking exactly for the given component
* if (group == null)
* {
* success &= RemoveItemsOfTypeInternal(material.Key, material.Value);
* Debug.Assert(success, "Could not find the required component although we were permitted to build!");
* continue;
* }
* else
* {
* m_cuttingSolver.AddItem(group.Id, groupAmount, material.Value);
* }
*
* m_componentCounts.Clear();
* CollectItems(m_componentCounts);
* success &= m_cuttingSolver.Solve(m_componentCounts);
*
* List<MyComponentCombiner.ComponentChange> changes = null;
* m_cuttingSolver.GetSolution(out changes);
* foreach (var change in changes)
* {
* if (change.IsRemoval())
* {
* success &= RemoveItemsOfTypeInternal(change.ToRemove, change.Amount);
* Debug.Assert(success, "Could not remove compnents, although the solver told us it should be possible!");
* }
* else if (change.IsChange())
* {
* ComponentInfo cInfo = null;
* m_componentInfos.TryGetValue(change.ToRemove, out cInfo);
* Debug.Assert(cInfo != null, "Could not find a component in MyAreaInventory!");
*
* if (cInfo == null) continue;
*
* for (int i = 0; i < change.Amount; ++i)
* {
* int dummy = 0;
* long entityId = cInfo.RemoveComponent(1, out dummy);
* if (entityId == 0) break;
*
* var grid = TryGetComponent(entityId);
* if (grid == null)
* {
* break;
* }
*
* SpawnRemainingData spawnData = new SpawnRemainingData();
* PrepareSpawnRemainingMaterial(grid, ref spawnData);
*
* grid.Physics.Enabled = false;
* grid.SyncObject.SendCloseRequest();
*
* spawnData.DefId = change.ToAdd;
* SpawnRemainingMaterial(ref spawnData);
* }
* }
* }
* }
*
* return success;*/
}
private int TryCreatingItemsByMerge(MyComponentGroupDefinition group, int itemValue, int itemCount)
{
int num;
List <int> item = this.m_listAllocator.Allocate();
item.Clear();
int num2 = 0;
while (true)
{
if (num2 <= group.GetComponentNumber())
{
item.Add(0);
num2++;
continue;
}
num = 0;
int num3 = 0;
while (true)
{
if (num3 >= itemCount)
{
break;
}
int num4 = itemValue;
int key = itemValue - 1;
while (true)
{
if (key >= 1)
{
int num6 = 0;
if (this.m_presentItems.TryGetValue(key, out num6))
{
int num7 = Math.Min(num4 / key, num6);
if (num7 > 0)
{
num4 -= key * num7;
num6 -= num7;
List <int> list2 = item;
int num8 = key;
list2[num8] += num7;
}
}
key--;
continue;
}
if (num4 != itemValue)
{
if (num4 != 0)
{
for (int i = num4 + 1; i <= group.GetComponentNumber(); i++)
{
int num10 = 0;
this.m_presentItems.TryGetValue(i, out num10);
if (num10 > item[i])
{
MyDefinitionId removedComponentId = group.GetComponentDefinition(i).Id;
this.AddChangeToSolution(removedComponentId, group.GetComponentDefinition(i - num4).Id, 1);
this.TryRemovePresentItems(i, 1);
this.AddPresentItems(i - num4, 1);
num4 = 0;
break;
}
}
}
if (num4 == 0)
{
num++;
for (int i = 1; i <= group.GetComponentNumber(); i++)
{
if (item[i] > 0)
{
MyDefinitionId id = group.GetComponentDefinition(i).Id;
this.TryRemovePresentItems(i, item[i]);
this.AddRemovalToSolution(id, item[i]);
item[i] = 0;
}
}
break;
}
if (num4 <= 0)
{
break;
}
}
break;
}
num3++;
}
break;
}
this.m_listAllocator.Deallocate(item);
return(num);
}
public bool CanCombineItems(MyInventoryBase inventory, DictionaryReader <MyDefinitionId, int> items)
{
bool flag = true;
this.Clear();
inventory.CountItems(m_componentCounts);
foreach (KeyValuePair <MyDefinitionId, int> pair in items)
{
int amount = 0;
int num2 = pair.Value;
MyComponentGroupDefinition groupForComponent = null;
groupForComponent = MyDefinitionManager.Static.GetGroupForComponent(pair.Key, out amount);
if (groupForComponent != null)
{
this.AddItem(groupForComponent.Id, amount, num2);
continue;
}
if ((MySessionComponentEquivalency.Static != null) && MySessionComponentEquivalency.Static.HasEquivalents(pair.Key))
{
if (MySessionComponentEquivalency.Static.IsProvided(m_componentCounts, pair.Key, pair.Value))
{
continue;
}
flag = false;
}
else
{
MyFixedPoint point;
if (!m_componentCounts.TryGetValue(pair.Key, out point))
{
flag = false;
}
else
{
if (point >= num2)
{
continue;
}
flag = false;
}
}
break;
}
if (flag)
{
flag &= this.Solve(m_componentCounts);
}
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW)
{
if (!flag)
{
MyRenderProxy.DebugDrawText2D(new Vector2(0f, 0f), "Can not build", Color.Red, 1f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, false);
}
else
{
List <MyComponentChange> changes = null;
this.GetSolution(out changes);
float y = 0f;
foreach (MyComponentChange change in changes)
{
string text = "";
if (change.IsAddition())
{
string[] textArray1 = new string[] { text, "+ ", change.Amount.ToString(), "x", change.ToAdd.ToString() };
text = string.Concat(textArray1);
MyRenderProxy.DebugDrawText2D(new Vector2(0f, y), text, Color.Green, 1f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, false);
y += 20f;
continue;
}
if (change.IsRemoval())
{
string[] textArray2 = new string[] { text, "- ", change.Amount.ToString(), "x", change.ToRemove.ToString() };
text = string.Concat(textArray2);
MyRenderProxy.DebugDrawText2D(new Vector2(0f, y), text, Color.Red, 1f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, false);
y += 20f;
continue;
}
string[] textArray3 = new string[] { text, "- ", change.Amount.ToString(), "x", change.ToRemove.ToString() };
text = string.Concat(textArray3);
MyRenderProxy.DebugDrawText2D(new Vector2(0f, y), text, Color.Orange, 1f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, false);
y += 20f;
text = "";
string[] textArray4 = new string[] { text, "+ ", change.Amount.ToString(), "x", change.ToAdd.ToString() };
text = string.Concat(textArray4);
MyRenderProxy.DebugDrawText2D(new Vector2(0f, y), text, Color.Orange, 1f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, false);
y += 20f;
}
}
}
return(flag);
}
