// Context: Server private MyFixedPoint CountComponents(IEnumerable <IMyInventory> inventories, MyDefinitionId id, int amount, ICollection <MyTuple <IMyInventory, IMyInventoryItem, MyFixedPoint> > items = null) { MyFixedPoint targetAmount = amount; foreach (IMyInventory inv in inventories) { IMyInventoryItem invItem = inv.FindItem(id); if (invItem != null) { if (invItem.Amount >= targetAmount) { if (items != null) { items.Add(new MyTuple <IMyInventory, IMyInventoryItem, MyFixedPoint>(inv, invItem, targetAmount)); } targetAmount = 0; break; } else { if (items != null) { items.Add(new MyTuple <IMyInventory, IMyInventoryItem, MyFixedPoint>(inv, invItem, invItem.Amount)); } targetAmount -= invItem.Amount; } } } return(targetAmount); }
public static MyToolbarItem CreateToolbarItemFromInventoryItem(IMyInventoryItem inventoryItem) { var itemDefinitionId = inventoryItem.GetDefinitionId(); MyDefinitionBase itemDefinition; if (MyDefinitionManager.Static.TryGetDefinition(itemDefinitionId, out itemDefinition)) { if ((itemDefinition is MyPhysicalItemDefinition) || (itemDefinition is MyCubeBlockDefinition)) { var itemBuilder = MyToolbarItemFactory.ObjectBuilderFromDefinition(itemDefinition); if (itemBuilder is MyObjectBuilder_ToolbarItemMedievalWeapon) { var meWeaponBuilder = itemBuilder as MyObjectBuilder_ToolbarItemMedievalWeapon; meWeaponBuilder.ItemId = inventoryItem.ItemId; } if (itemBuilder != null && !(itemBuilder is MyObjectBuilder_ToolbarItemEmpty)) { return(MyToolbarItemFactory.CreateToolbarItem(itemBuilder)); } } } return(null); }
public static ItemType GetItemType(this IMyInventoryItem item) { ItemType res; Types.TryGetValue(item.Content.TypeId.ToString().Substring(TSUBSTR), out res); return(res); }
public static int CompareTo(Container A, Container B, IMyInventoryItem item) { if (A == B) { return(0); } return(B.GetAffinity(item) - A.GetAffinity(item)); }
public EasyItem(EasyBlock Block, int InventoryIndex, IMyInventory Inventory, int ItemIndex, IMyInventoryItem Item) { this.Block = Block; this.InventoryIndex = InventoryIndex; this.Inventory = Inventory; this.ItemIndex = ItemIndex; this.Item = Item; }
public RefineryWrapper(IMyRefinery refinery) { Refinery = refinery; Inventory = refinery.GetInventory(0); var items = Inventory.GetItems(); Item = items.Count > 0 ? items[0] : null; Amount = Item != null ? (float)Item.Amount : 0.0f; }
private bool HasItem(IMyInventoryItem item) { if (_cargo == null) { return(false); } // TODO use FindItem instead ? return(_cargo.GetInventory().GetItems().Any(it => it.Content.SubtypeName == item.Content.SubtypeName)); }
public void Adapt(IMyInventoryItem inventoryItem) { m_physItem = null; m_blockDef = null; var poob = inventoryItem.Content as MyObjectBuilder_PhysicalObject; if (poob != null) Adapt(poob.GetObjectId()); else Adapt(inventoryItem.GetDefinitionId()); }
public static MyDefinitionId GetDefinitionId(this IMyInventoryItem self) { MyObjectBuilder_PhysicalObject content = self.Content as MyObjectBuilder_PhysicalObject; if (content != null) { return(content.GetObjectId()); } return(new MyDefinitionId(self.Content.TypeId, self.Content.SubtypeId)); }
/// <summary> /// Sorts all containers /// </summary> /// <param name="_item">The item to be transfered</param> /// <param name="_itemIndex">Index of the item to be transfered</param> /// <param name="_containers">The list containing containers</param> /// <param name="_transferFrom">The container to transfer from</param> private void Sort_Item(IMyInventoryItem _item, int _itemIndex, List <IMyCargoContainer> _containers, IMyCargoContainer _transferFrom) { for (int i = 0; i < _containers.Count; i++) { if (_containers [i].CustomData == _item.Content.TypeId.ToString().Split('_') [1]) { _containers [i].GetInventory().TransferItemFrom(_transferFrom.GetInventory(), _itemIndex, stackIfPossible: true); } } }
public string GetInventoryItemByName(IMyInventoryItem item) { string itemName = item.GetDefinitionId().ToString(); char[] delimChar = "/".ToCharArray(); string[] newString = itemName.Split(delimChar); return(newString[1]); }
public string GetItemTypeName(IMyInventoryItem item) { string name = item.Content.ToString(); char[] delimChars = "_".ToCharArray(); string[] splitString = name.Split(delimChars); name = splitString.Last(); return(name); }
private void doSortInventory(IMyTerminalBlock Block, IMyInventory Inventory, Dictionary <string, List <IMyTerminalBlock> > targets) { debug(" Item Count: " + Inventory.GetItems().Count.ToString()); for (int i_Item = Inventory.GetItems().Count - 1; i_Item >= 0; i_Item--) { IMyInventoryItem Item = Inventory.GetItems()[i_Item]; debug(" Start Sorting Item " + (i_Item + 1).ToString() + "/" + Inventory.GetItems().Count.ToString() + ": " + Item.ToString()); doSortItem(Block, Inventory, Item, targets); debug(" End Sorting Item " + (i_Item + 1).ToString() + "/" + Inventory.GetItems().Count.ToString() + ": " + Item.ToString()); } }
public override bool Remove(IMyInventoryItem item, MyFixedPoint amount) { foreach (MyInventoryBase inventory in m_children.Reader) { if (inventory.ItemsCanBeRemoved(amount, item) && inventory.Remove(item, amount)) { return(true); } } return(false); }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount, bool stack = true) { foreach (MyInventoryBase inventory in m_children.Reader) { if (inventory.ItemsCanBeAdded(amount, item) && inventory.Add(item, amount, stack)) { return(true); } } return(false); }
public override bool Remove(IMyInventoryItem item, MyFixedPoint amount) { if (item.Content is MyObjectBuilder_PhysicalObject) { return(RemoveItemsOfType(amount, item.Content as MyObjectBuilder_PhysicalObject)); } else { return(false); } }
// MK: TODO: ItemsCanBeAdded, ItemsCanBeRemoved, Add and Remove should probably support getting stuff from several inventories at once public override bool ItemsCanBeAdded(MyFixedPoint amount, IMyInventoryItem item) { foreach (MyInventoryBase inventory in m_children.Reader) { if (inventory.ItemsCanBeAdded(amount, item)) { return(true); } } return(false); }
public override bool ItemsCanBeAdded(MyFixedPoint amount, IMyInventoryItem item) { if (amount == 0) { return(true); } if (item == null) { return(false); } return(CanItemsBeAdded(amount, item.GetDefinitionId())); }
public InventoryItem(IMyInventoryItem item) { var content = item.Content; var adapter = MyInventoryItemAdapter.Static; adapter.Adapt(content.GetId()); Amount = (float)item.Amount; Mass = adapter.Mass * Amount; Volume = adapter.Volume * Amount; Type = $"{content.TypeId}/{content.SubtypeName}"; }
public static string GetItemType(IMyInventoryItem invItem) { string itype = invItem.Content.TypeId.ToString(); itype = itype.Substring(itype.LastIndexOf('_') + 1); string stype = invItem.Content.SubtypeId.ToString(); if (itype.StartsWith("Ore") || itype.StartsWith("Ingot")) { return($"{itype}/{stype}"); } return(stype); }
void SortPeriphInv(IMyInventory inv) { List <IMyInventoryItem> items = inv.GetItems(); bool main_full = false; bool ore_full = false; for (int i = items.Count - 1; i >= 0; i--) { IMyInventoryItem item = items[i]; switch (items[i].Content.TypeId.ToString()) { case "MyObjectBuilder_Ore": case "MyObjectBuilder_Ingot": if (inv == OreInv) { continue; } if (OreInv.IsFull) { ore_full = true; continue; } inv.TransferItemTo(OreInv, i, stackIfPossible: true); break; default: if (inv != MainInv) { if (MainInv.IsFull) { main_full = true; } else { inv.TransferItemTo(MainInv, i, stackIfPossible: true); } } break; } } if (main_full) { pr("Warning: Main storage full"); } if (ore_full) { pr("Warning: Ore storage full"); } }
public void Adapt(IMyInventoryItem inventoryItem) { this.m_physItem = null; this.m_blockDef = null; MyObjectBuilder_PhysicalObject content = inventoryItem.Content as MyObjectBuilder_PhysicalObject; if (content != null) { this.Adapt(content.GetObjectId()); } else { this.Adapt(inventoryItem.GetDefinitionId()); } }
public override bool ItemsCanBeRemoved(MyFixedPoint amount, IMyInventoryItem item) { if (amount == 0) return true; if (item == null) return false; var physItemObject = GetItemByID(item.ItemId); if (physItemObject.HasValue) { MyPhysicalInventoryItem physicalItem = physItemObject.Value; if (physicalItem.Amount >= amount) { return true; } } return false; }
/// <summary> /// Transfers safely given item from one to another inventory, uses ItemsCanBeAdded and ItemsCanBeRemoved checks /// </summary> /// <returns>true if items were succesfully transfered, otherwise, false</returns> public static bool TransferItems(MyInventoryBase sourceInventory, MyInventoryBase destinationInventory, IMyInventoryItem item, MyFixedPoint amount) { if (sourceInventory == null) { System.Diagnostics.Debug.Fail("Source inventory is null!"); return false; } if (destinationInventory == null) { System.Diagnostics.Debug.Fail("Destionation inventory is null!"); return false; } if (item == null) { System.Diagnostics.Debug.Fail("Item is null!"); return false; } if (amount == 0) { return true; } if (destinationInventory.ItemsCanBeAdded(amount, item) && sourceInventory.ItemsCanBeRemoved(amount, item)) { if (Sync.IsServer) { if (destinationInventory.Add(item, amount)) { if (sourceInventory.Remove(item, amount)) { // successfull transaction return true; } else { System.Diagnostics.Debug.Fail("Error! Items were added to inventory, but can't be removed!"); } } } else { MySyncInventory.SendTransferItemsMessage(sourceInventory, destinationInventory, item, amount); } } return false; }
public InventoryItemEntity(Object backingObject, InventoryEntity parent) { m_backingObject = backingObject; m_parentContainer = parent; IMyInventoryItem item = (IMyInventoryItem)backingObject; MyObjectBuilder_InventoryItem newItem = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_InventoryItem>( ); newItem.Amount = item.Amount; newItem.Content = item.Content; newItem.ItemId = item.ItemId; m_objectBuilder = newItem; m_definition = MyDefinitionManager.Static.GetPhysicalItemDefinition(item.Content.GetId( )); m_definitionId = m_definition.Id; }
private void doSortItem(IMyTerminalBlock Block, IMyInventory Inventory, IMyInventoryItem Item, Dictionary <string, List <IMyTerminalBlock> > targets) { string TypeName = getSimpleType(Item.Content.TypeId.ToString()); string SubTypeName = Item.Content.SubtypeName.ToLower(); debug(" Itemtype: " + TypeName + "/" + SubTypeName); bool isInRightInventory = hasContainerTag(TypeName, SubTypeName, Block); debug(" Item is" + (isInRightInventory?" ":" not ") + "in matching Inventory."); if (!isInRightInventory) { List <IMyTerminalBlock> TargetBlocks = getTargetsByItem(new string[] { TypeName, SubTypeName }, targets); debug(" Found " + TargetBlocks.Count.ToString() + " Target Blocks."); tryMoveItem(Block, Inventory, TargetBlocks, Item); } }
public void Adapt(IMyInventoryItem inventoryItem) { m_physItem = null; m_blockDef = null; var poob = inventoryItem.Content as MyObjectBuilder_PhysicalObject; if (poob != null) { Adapt(poob.GetObjectId()); } else { Adapt(inventoryItem.GetDefinitionId()); } }
public static void ConsumeItem(MyInventory inventory, IMyInventoryItem item, MyFixedPoint amount, long consumerEntityId = 0) { if (inventory == null || inventory.Owner == null) { return; } var msg = new ConsumeItemMsg() { OwnerEntityId = inventory.Owner.EntityId, InventoryId = inventory.InventoryIdx, ItemId = item.GetDefinitionId(), Amount = amount, ConsumerEntityId = consumerEntityId, }; Sync.Layer.SendMessageToServer(ref msg); }
public int GetAffinity(IMyInventoryItem item) { int hasItem = HasItem(item) ? 1 : 0; if (IsGeneric()) { return(hasItem + 2); } if (_containedSubtypes.Contains(item.GetItemSubype().ToLower())) { return(hasItem + 6); } if (_containedTypes.Contains(item.GetItemType())) { return(hasItem + 4); } return(hasItem); }
public override bool ItemsCanBeRemoved(MyFixedPoint amount, IMyInventoryItem item) { using (List <MyComponentBase> .Enumerator enumerator = this.m_children.Reader.GetEnumerator()) { while (true) { if (!enumerator.MoveNext()) { break; } if (((MyInventoryBase)enumerator.Current).ItemsCanBeRemoved(amount, item)) { return(true); } } } return(false); }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount) { using (List <MyComponentBase> .Enumerator enumerator = this.m_children.Reader.GetEnumerator()) { while (true) { if (!enumerator.MoveNext()) { break; } MyInventoryBase current = (MyInventoryBase)enumerator.Current; if (current.ItemsCanBeAdded(amount, item) && current.Add(item, amount)) { return(true); } } } return(false); }
void updateReactorData() { System.Text.RegularExpressions.Match match = reactorPowerRegex.Match(reactor.DetailedInfo); double parsedDouble = 0.0f; if (match.Success) { if (Double.TryParse(match.Groups[1].Value, out parsedDouble)) maxOutput = parsedDouble * Math.Pow(1000.0, POWER_MULTIPLIERS.IndexOf(match.Groups[2].Value)); if (Double.TryParse(match.Groups[3].Value, out parsedDouble)) currentOutput = parsedDouble * Math.Pow(1000.0, POWER_MULTIPLIERS.IndexOf(match.Groups[4].Value)); } IMyInventory inv = reactor.GetInventory(); maxUranContained = (double)inv.MaxVolume * uraniumDensity; IMyInventoryItem uranium = inv.GetItems()[0]; uranLeft = (double)uranium.Amount; double outputRatio = currentOutput / maxOutput; currentConsumption = maxUranPerSec * outputRatio; }
public static MyToolbarItem CreateToolbarItemFromInventoryItem(IMyInventoryItem inventoryItem) { var itemDefinitionId = inventoryItem.GetDefinitionId(); MyDefinitionBase itemDefinition; if (MyDefinitionManager.Static.TryGetDefinition(itemDefinitionId, out itemDefinition)) { if ((itemDefinition is MyPhysicalItemDefinition) || (itemDefinition is MyCubeBlockDefinition)) { var itemBuilder = MyToolbarItemFactory.ObjectBuilderFromDefinition(itemDefinition); if (itemBuilder is MyObjectBuilder_ToolbarItemMedievalWeapon) { var meWeaponBuilder = itemBuilder as MyObjectBuilder_ToolbarItemMedievalWeapon; meWeaponBuilder.ItemId = inventoryItem.ItemId; } if (itemBuilder != null && !(itemBuilder is MyObjectBuilder_ToolbarItemEmpty)) { return MyToolbarItemFactory.CreateToolbarItem(itemBuilder); } } } return null; }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount) { // CH: TODO: use this line only in local transfers (otherwise, there's no point imho) uint? itemId = m_usedIds.Contains(item.ItemId) ? (uint?)null : item.ItemId; return AddItems(amount, item.Content, itemId, -1); }
public override bool ItemsCanBeAdded(MyFixedPoint amount, IMyInventoryItem item) { if (amount == 0) return true; if (item == null) return false; if (Entity == null || Entity.MarkedForClose) return false; return CanItemsBeAdded(amount, item.GetDefinitionId()); }
public override bool Remove(IMyInventoryItem item, MyFixedPoint amount) { if (item.Content is MyObjectBuilder_PhysicalObject) { return RemoveItemsOfType(amount, item.Content as MyObjectBuilder_PhysicalObject); } else { return false; } }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount) { return AddItems(amount, item.Content); }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount, bool stack = true) { uint? itemId = item.ItemId; foreach (var invItem in m_items) { if (invItem.ItemId == itemId) { itemId = null; break; } } return AddItems(amount, item.Content, itemId, -1, stack); }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount, bool stack = true) { return AddItems(amount, item.Content, -1, stack); }
/// <summary> /// Transfers safely given item from inventory given as parameter to this instance. /// </summary> /// <returns>true if items were succesfully transfered, otherwise, false</returns> public abstract bool TransferItemsFrom(MyInventoryBase sourceInventory, IMyInventoryItem item, MyFixedPoint amount, bool stack);
public override bool Remove(IMyInventoryItem item, MyFixedPoint amount) { foreach(MyInventoryBase inventory in m_children.Reader) { if (inventory.ItemsCanBeRemoved(amount, item) && inventory.Remove(item, amount)) return true; } return false; }
public override bool Add(IMyInventoryItem item, MyFixedPoint amount, bool stack = true) { foreach(MyInventoryBase inventory in m_children.Reader) { if (inventory.ItemsCanBeAdded(amount, item) && inventory.Add(item, amount, stack)) return true; } return false; }
/// <summary> /// Transfers safely given item from one to another inventory, uses ItemsCanBeAdded and ItemsCanBeRemoved checks. If sourceInventory == destionationInventory, it splits the amount. /// </summary> /// <returns>true if items were succesfully transfered, otherwise, false</returns> public static bool TransferItems(MyInventoryBase sourceInventory, MyInventoryBase destinationInventory, IMyInventoryItem item, MyFixedPoint amount, bool stack) { if (sourceInventory == null) { System.Diagnostics.Debug.Fail("Source inventory is null!"); return false; } if (destinationInventory == null) { System.Diagnostics.Debug.Fail("Destionation inventory is null!"); return false; } if (item == null) { System.Diagnostics.Debug.Fail("Item is null!"); return false; } if (amount == 0) { return true; } if ((destinationInventory.ItemsCanBeAdded(amount, item) || destinationInventory == sourceInventory ) && sourceInventory.ItemsCanBeRemoved(amount, item)) { if (Sync.IsServer) { if (destinationInventory != sourceInventory) { // try to add first and then remove to ensure this items don't disappear if (destinationInventory.Add(item, amount, stack)) { if (sourceInventory.Remove(item, amount)) { // successfull transaction return true; } else { System.Diagnostics.Debug.Fail("Error! Items were added to inventory, but can't be removed!"); } } } else { // same inventory transfer = splitting amount, need to remove first and add second if (sourceInventory.Remove(item, amount) && destinationInventory.Add(item, amount, stack)) { return true; } else { System.Diagnostics.Debug.Fail("Error! Unsuccesfull splitting!"); } } } } return false; }
public static void ConsumeItem(MyInventory inventory, IMyInventoryItem item, MyFixedPoint amount, long consumerEntityId = 0) { if(inventory == null || inventory.Owner == null) return; var msg = new ConsumeItemMsg() { OwnerEntityId = inventory.Owner.EntityId, InventoryId = inventory.InventoryIdx, ItemId = item.GetDefinitionId(), Amount = amount, ConsumerEntityId = consumerEntityId, }; Sync.Layer.SendMessageToServer(ref msg); }
public override bool Remove(IMyInventoryItem item, MyFixedPoint amount) { if (item.Content is MyObjectBuilder_PhysicalObject) { var index = GetItemIndexById(item.ItemId); if (index != -1) { RemoveItemsAt(index, amount); return true; } return RemoveItemsOfType(amount, item.Content as MyObjectBuilder_PhysicalObject); } else { return false; } }
public abstract bool ItemsCanBeRemoved(MyFixedPoint amount, IMyInventoryItem item);
/// <summary> /// Transfers safely given item from inventory given as parameter to this instance. /// </summary> /// <returns>true if items were succesfully transfered, otherwise, false</returns> public override bool TransferItemsFrom(MyInventoryBase sourceInventory, IMyInventoryItem item, MyFixedPoint amount) { if (sourceInventory == null) { System.Diagnostics.Debug.Fail("Source inventory is null!"); return false; } if (item == null) { System.Diagnostics.Debug.Fail("Item is null!"); return false; } if (amount == 0) { return true; } bool transfered = false; if ((ItemsCanBeAdded(amount, item) || this == sourceInventory) && sourceInventory.ItemsCanBeRemoved(amount, item)) { if (Sync.IsServer) { if (this != sourceInventory) { // try to add first and then remove to ensure this items don't disappear if (Add(item, amount)) { if (sourceInventory.Remove(item, amount)) { // successfull transaction return true; } else { // This can happend, that it can't be removed due to some lock, then we need to revert the add. Remove(item, amount); } } } else { // same inventory transfer = splitting amount, need to remove first and add second if (sourceInventory.Remove(item, amount) && Add(item, amount)) { return true; } else { System.Diagnostics.Debug.Fail("Error! Unsuccesfull splitting!"); } } } else { Debug.Assert(sourceInventory != null); MyInventoryTransferEventContent eventParams = new MyInventoryTransferEventContent(); eventParams.Amount = amount; eventParams.ItemId = item.ItemId; eventParams.SourceOwnerId = sourceInventory.Entity.EntityId; eventParams.SourceInventoryId = sourceInventory.InventoryId; eventParams.DestinationOwnerId = Entity.EntityId; MyMultiplayer.RaiseStaticEvent(s => InventoryBaseTransferItem_Implementation, eventParams); } } return transfered; }
public abstract bool Add(IMyInventoryItem item, MyFixedPoint amount, bool stack = true);
string GetInventoryItemName(IMyInventoryItem item) { return item.Content.GetType().ToString().Split('_')[1] + "/" + item.Content.SubtypeName; }
public abstract bool Remove(IMyInventoryItem item, MyFixedPoint amount);
// MK: TODO: ItemsCanBeAdded, ItemsCanBeRemoved, Add and Remove should probably support getting stuff from several inventories at once public override bool ItemsCanBeAdded(MyFixedPoint amount, IMyInventoryItem item) { foreach(MyInventoryBase inventory in m_children.Reader) { if (inventory.ItemsCanBeAdded(amount, item)) return true; } return false; }
internal static void SendTransferItemsMessage(MyInventoryBase sourceInventory, MyInventoryBase destinationInventory, IMyInventoryItem item, MyFixedPoint amount) { if (sourceInventory == null || destinationInventory == null || item == null) { Debug.Fail("Invalid parameters!"); return; } Debug.Assert(amount > 0, "Amount is <= 0! Sending meaningless message! Don't call this if transferring amount is 0"); var msg = new TransferItemsBaseMsg(); msg.Amount = amount; msg.SourceContainerId = sourceInventory.Container.Entity.EntityId; msg.DestinationContainerId = destinationInventory.Container.Entity.EntityId; msg.SourceItemId = item.ItemId; msg.SourceInventoryId = MyStringHash.GetOrCompute(sourceInventory.InventoryId.ToString()); msg.DestinationInventoryId = MyStringHash.GetOrCompute(destinationInventory.InventoryId.ToString()); Sync.Layer.SendMessageToServer(ref msg); }