示例#1
0
        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;
            }
        }
示例#2
0
        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;
     }
 }
示例#4
0
 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);
 }
示例#5
0
        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);
        }
示例#7
0
        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);
        }
示例#9
0
 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;*/
        }
示例#13
0
        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);
        }
示例#14
0
        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);
        }