//auxiliary function to skil a boring step from the process of declar ing the inventory lists private List <MyInventoryItem> fillListFromInventory(IMyInventory vfCargo) { List <MyInventoryItem> itemInv = new List <MyInventoryItem>(); vfCargo.GetItems(itemInv); return(itemInv); }
private void ViewCargoInventory(IMyCargoContainer cargo) { if (cargo == null) { Print("Контейнер не найден"); return; } Print($"Контейнер: {cargo.CustomName}"); IMyInventory inventory = cargo.GetInventory(); if (inventory != null) { Print($"items: {inventory.GetItems().Count}"); foreach (var item in inventory.GetItems()) { Print( $"{cargo.CustomName} \n\t\tN: {item.Content.SubtypeName}, \n\t\tI: {item.Content.SubtypeId}, \n\t\tT: {item.Content.TypeId}"); } } else { Print("Конейнер пуст"); } }
private bool Transfer(IMyInventory source, IMyInventory destination, string itemType, VRage.MyFixedPoint amount) { //Moves given amount of given type from source to destination int ixSource; List <MyInventoryItem> sourceItems = GetInventoryItems(source); ixSource = IndexOfFirstTradeItem(source, itemType, false); if (ixSource < 0) { Display(Info.MsgErrTransferNoItemsInSource, itemType, source.ToString()); return(false); } MyInventoryItem item = sourceItems[ixSource]; if (amount > item.Amount) { Display(Info.MsgErrTransferInsufficientItemsInSource, source.ToString(), item.Amount + "/" + amount.ToString() + " " + itemType); return(false); } if (!source.TransferItemTo(destination, ixSource, null, true, amount)) { Display(Info.MsgErrTransferFailed, amount.ToString() + " " + itemType, source.ToString() + " -> " + destination.ToString()); return(false); } return(true); }
public void setupContainerDict(IMyCargoContainer container) { bool found = false; List <IMyCargoContainer> tempList = new List <IMyCargoContainer>(); IMyInventory tempInv = container.GetInventory(); string volumeString = ""; if ((float)tempInv.CurrentVolume > 0.0f) { volumeString = " (" + (((float)tempInv.CurrentVolume / (float)tempInv.MaxVolume) * 100.0f).ToString("N1") + "%)"; } else { volumeString = " (0%)"; } foreach (string vString in CargoPrefix) { if (!(container_dict.ContainsKey(vString))) { container.CustomName = vString + " Cargo Container 01" + volumeString; tempList.Add(container); container_dict.Add(vString, tempList); found = true; break; } } if (!(found)) { Echo("Dict already contains the proper key.\n" + container.CustomName + " is lost"); } }
public void Main(string containerName) { IMyCargoContainer cargo = FindBlock <IMyCargoContainer>(containerName); IMyTextPanel debug = FindBlock <IMyTextPanel>("debug"); if (cargo == null || debug == null) { debug.WritePublicText("Cargo or debug not found!", false); return; } IMyInventory cargoInventory = cargo.GetInventory(0); var assemblers = new List <IMyTerminalBlock>(); GridTerminalSystem.GetBlocksOfType <IMyAssembler>(assemblers); for (int i = 0; i < assemblers.Count; i++) { if (!assemblers[i].HasInventory) { continue; } IMyInventory inventory = assemblers[i].GetInventory(1); List <IMyInventoryItem> items = inventory.GetItems(); debug.WritePublicText("Items Moved:" + items.Count + "\n", true); // Move items to cargo for (int j = 0; j < items.Count; j++) { inventory.TransferItemTo(cargoInventory, 0, null, stackIfPossible: true); } } }
bool AddItemToInventory(string type, int amountRequired, int fetchAmount) { int amountRemaining = amountRequired; for (int i = 0; i < SourceInventories.Count; i++) { IMyInventory sourceInventory = SourceInventories[i]; Nullable <MyInventoryItem> item = InventoryUtils.FindItemInInventoryBySubType(sourceInventory, type); if (item.HasValue) { int amountToAdd = item.Value.Amount.ToIntSafe() > amountRemaining ? amountRemaining : item.Value.Amount.ToIntSafe(); bool result = InventoryUtils.TransferItemToAvailableInventory(item.Value, (MyFixedPoint)amountToAdd, sourceInventory, MyInventories, fetchAmount); if (result) { amountRemaining = amountRemaining - amountToAdd; } } if (amountRemaining <= 0) { return(true); } } ; return(false); }
internal void GetAvailableComponents(ref Dictionary <string, int> result) { if (MyAPIGateway.Session.CreativeMode) { return; } IMyInventory inventory = GetConstructionInventory(); if (inventory != null) { foreach (var item in inventory.GetItems()) { //Logging.Instance.WriteLine(string.Format("Item: {0} - {1}", item.Amount, item.Content.SubtypeName)); if ((int)item.Amount < 1) { continue; } if (!result.ContainsKey(item.Content.SubtypeName)) { result.Add(item.Content.SubtypeName, (int)item.Amount); } else { result[item.Content.SubtypeName] += (int)item.Amount; } } } }
public void UpdateInventories() { /* * grabs all blocks with inventories on the grid (except assemblers, reactors, etc.) * adds blocks to different sorting categories (potentially multiple) */ ClearGridInfo(); inventoryBlocks.Clear(); parent.GridTerminalSystem.GetBlocksOfType(inventoryBlocks, b => InventoryBlockIsValid(b)); foreach (IMyTerminalBlock block in inventoryBlocks) { if (!idToCategoryKeySet.ContainsKey(block.EntityId)) // to avoid creating new dictionaries literally every run { idToCategoryKeySet[block.EntityId] = new HashSet <string>(); } if (!AddCategoriesToBlock(block)) { miscInventoryBlocks.Add(block); IMyInventory inventory = block.GetInventory(); CurrentMiscVolume += inventory.CurrentVolume; MaxMiscVolume += inventory.MaxVolume; } } }
public int GetItemCountFromInventory(IMyInventory inventory, string itemName) { MyDefinitionId myDefinitionId = GetMyDefinitionIdByName(itemName); MyItemType myItemType = MyItemType.MakeComponent(myDefinitionId.SubtypeId.ToString()); return((int)inventory.GetItemAmount(myItemType)); }
private void getCounts(string itemstring) { int count = 0; List <IMyCargoContainer> containers = new List <IMyCargoContainer>(); GridTerminalSystem.GetBlocksOfType(containers, (IMyCargoContainer block) => block.HasInventory); //Echo("Found " + containers.Count.ToString() + " containers"); for (int i = 0; i < containers.Count; i++) { IMyCargoContainer cont = containers[i]; List <MyInventoryItem> items = new List <MyInventoryItem>(); if (cont.HasInventory) { IMyInventory cont_inv = cont.GetInventory() as IMyInventory; cont_inv.GetItems(items, (MyInventoryItem item) => item.Type.ToString() == itemstring); //Echo("Found " + items.Count.ToString() + " items in " + cont.Name); for (int j = 0; j < items.Count; j++) { var item = items[j]; count += item.Amount.ToIntSafe(); } } } counts[itemstring] = count; }
private bool AddCategoriesToBlock(IMyTerminalBlock block) { /* * try (and add) all relevant categories to a block, mark the category as active, and increment inventory counts * true if any category was added, false if not */ bool hasCategory = false; string[] customData = block.CustomData.Split(newLine); foreach (string tag in customData) { string categoryKey; if (tagToCategoryKey.TryGetValue(tag, out categoryKey)) { Category category = Categories[categoryKey]; ActiveCategories[categoryKey] = category; // doesn't really matter what's used for this key category.Inventories.Add(block); IMyInventory inventory = block.GetInventory(); category.CurrentVolume += inventory.CurrentVolume; category.MaxVolume += inventory.MaxVolume; idToCategoryKeySet[block.EntityId].Add(categoryKey); hasCategory = true; } } return(hasCategory); }
//this makes sure all tools are connected to the same conveyor system private bool AreToolsConnected(List <IMyCubeBlock> tools) { if (tools.Count != 8) { return(false); } bool found = true; Wrapper.GameAction(() => { for (int i = 1; i < tools.Count; ++i) { IMyInventory toolInventory = (IMyInventory)((IMyShipToolBase)tools[0]).GetInventory(0); IMyInventory compareInventory = (IMyInventory)((IMyShipToolBase)tools[i]).GetInventory(0); if (compareInventory == null || toolInventory == null) { continue; } if (!toolInventory.IsConnectedTo(compareInventory)) { found = false; } } }); return(found); }
/// <summary> /// Finds the next higher level tool. /// Returns true if the id was changed. /// </summary> private bool Upgrade(ref MyDefinitionId id, int index) { if (MyAPIGateway.Session.CreativeMode) { if (index == Ids.Length - 1) { return(false); } EquipIndex = index + 1; id = Ids[EquipIndex]; return(true); } IMyInventory inv = p.Character.GetInventory(); MyFixedPoint one = 1; for (int i = index + 1; i < Ids.Length; i++) { if (inv.ContainItems(one, Ids[i])) { id = Ids[i]; return(true); } } return(false); }
/// <summary> /// Finds the best available tool. /// Returns true if the id was changed. /// </summary> private bool MakeBest(ref MyDefinitionId id, int index) { if (MyAPIGateway.Session.CreativeMode) { if (index == EquipIndex) { return(false); } id = Ids[EquipIndex]; return(true); } IMyInventory inv = p.Character.GetInventory(); MyFixedPoint one = 1; for (int i = Ids.Length - 1; i > index; i--) { if (inv.ContainItems(one, Ids[i])) { id = Ids[i]; return(true); } } return(false); }
public static double RemoveFromInventory(IMyInventory inventory, MyDefinitionId itemDefinition, double amount) { var content = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(itemDefinition); MyObjectBuilder_InventoryItem item = new MyObjectBuilder_InventoryItem { Amount = new MyFixedPoint { RawValue = (long)(amount * _multi) }, PhysicalContent = content }; MyFixedPoint inventoryAmount = inventory.GetItemAmount(itemDefinition); if (inventoryAmount >= item.Amount) { inventory.RemoveItemsOfType(item.Amount, item.PhysicalContent); return(amount); } if (inventoryAmount <= 0) { return(0); } inventory.RemoveItemsOfType(inventoryAmount, item.PhysicalContent); return(inventoryAmount.RawValue == 0 ? 0 : inventoryAmount.RawValue / _multi); }
public void UpdateItemAmount(InventoryItemEntity item, float newAmount) { if (BackingObject != null) { SandboxGameAssemblyWrapper.Instance.GameAction(new Action(delegate() { IMyInventory myInventory = (IMyInventory)BackingObject; if (newAmount == 0) { myInventory.RemoveItems(item.ItemId); } else if (newAmount > item.Amount) { myInventory.AddItems((MyFixedPoint)(newAmount - item.Amount), item.PhysicalContent, (int)item.ItemId); } else if (newAmount < item.Amount) { myInventory.RemoveItemsAt((int)item.ItemId, (MyFixedPoint)(item.Amount - newAmount), true); } })); } /* * InventoryDelta delta = new InventoryDelta(); * delta.item = item; * delta.oldAmount = item.Amount; * delta.newAmount = newAmount; * * m_itemDeltaQueue.Enqueue(delta); * * Action action = InternalUpdateItemAmount; * SandboxGameAssemblyWrapper.Instance.EnqueueMainGameAction(action); */ }
void EmptyInventory(IMyInventory inventory, int fetchAmount) { List <MyInventoryItem> items = new List <MyInventoryItem>(); inventory.GetItems(items); items.ForEach(item => InventoryUtils.TransferItemToAvailableInventory(item, item.Amount, inventory, SourceInventories, fetchAmount)); }
/// <summary> /// Push all components into destinations /// </summary> public static bool PushComponents(this IMyInventory srcInventory, List <IMyInventory> destinations) { var moved = false; lock (destinations) { var srcItems = srcInventory.GetItems(); for (int i1 = srcItems.Count - 1; i1 >= 0; i1--) { var srcItem = srcItems[i1]; foreach (var destInventory in destinations) { if (destInventory.CanItemsBeAdded(srcItem.Amount, srcItem.Content.GetId())) { moved = srcInventory.TransferItemTo(destInventory, i1, null, true, srcItem.Amount) || moved; break; } //If not the whole amount could be transfered i give up. //I could check if parts could be transfered, but as long as ComputeAmountThatFits is not available, //it would be try and error and a performance gain } } } return(moved); }
private void RemoveBlockInventory(MyCubeBlock block) { if (block is IMyGunBaseUser) { return; } if (block.HasInventory) { IMyInventory inventory = block.GetInventory(0); if (inventory != null) { Inventories.Remove(inventory); } inventory = block.GetInventory(1); if (inventory != null) { Inventories.Remove(inventory); } inventory = block.GetInventory(2); // just adding this because if (inventory != null) { Inventories.Remove(inventory); } } }
private void fillSpecialInventory(IMyInventory inventory, MyContext context) { for (int i = 0; i < DESIRED_ITEMS.Length; ++i) { fillSpecialInventoryWithItem(inventory, i, context); } }
public bool Eject(IMyInventory inventory, MyInventoryItem item) { //Log.Info($"IfFull: {IsFull}"); if (IsFull) { return(false); } var dst = Ejectors[Index].GetInventory(0); do { while (dst.IsFull) { Index++; Used++; //Log.Info($"Index:{Index}, Used:{Used}"); if (Index >= Ejectors.Count) { //Log.Info("resetting Index"); Index = 0; } if (Used >= Ejectors.Count) { //Log.Info("setting IsFull"); IsFull = true; return(false); } dst = Ejectors[Index].GetInventory(0); } } while(!inventory.TransferItemTo(dst, item)); return(true); }
public void RefineryCleanup(int inventory_index, List <IMyCargoContainer> cargo_list) { foreach (IMyRefinery refinery in refinery_list) { IMyInventory refinery_inventory = refinery.GetInventory(inventory_index); List <MyInventoryItem> items = new List <MyInventoryItem>(); refinery_inventory.GetItems(items); MyInventoryItem[] refinery_items = items.ToArray(); for (int idx = 0; idx < refinery_items.Length; idx++) { MyInventoryItem refinery_item = refinery_items[idx]; foreach (IMyCargoContainer cargo in cargo_list) { IMyInventory cargo_inventory = cargo.GetInventory(0); if (!cargo_inventory.IsFull) { refinery_inventory.TransferItemTo(cargo_inventory, idx, null, true, null); } if (refinery_item.Amount.ToIntSafe() < 1) { break; } } } } }
public Dictionary <string, double> Count(string end_with) { Dictionary <string, double> count = new Dictionary <string, double>(); foreach (IMyCargoContainer cargo in cargo_list) { IMyInventory cargo_inventory = cargo.GetInventory(0); List <MyInventoryItem> items = new List <MyInventoryItem>(); cargo_inventory.GetItems(items); foreach (MyInventoryItem refinery_item in items) { if (refinery_item.Type.TypeId.ToString().EndsWith(end_with)) { string name = Property.GetName(refinery_item); double amount = 0; Double.TryParse(refinery_item.Amount.ToString(), out amount); if (count.ContainsKey(name)) { count[name] = count[name] + amount; } else { count.Add(name, amount); } } } } return(count); }
/// <summary> /// Push all components into destinations /// </summary> public static bool PushComponents(this IMyInventory srcInventory, List <IMyInventory> destinations, ExcludeInventory exclude) { var moved = false; lock (destinations) { var srcItems = new List <MyInventoryItem>(); srcInventory.GetItems(srcItems); for (int srcItemIndex = srcItems.Count - 1; srcItemIndex >= 0; srcItemIndex--) { var srcItem = srcItems[srcItemIndex]; moved = TryTransferItemTo(srcInventory, destinations, srcItemIndex, srcItem, true, exclude) || moved; } if (!moved) { srcItems.Clear(); srcInventory.GetItems(srcItems); for (int srcItemIndex = srcItems.Count - 1; srcItemIndex >= 0; srcItemIndex--) { var srcItem = srcItems[srcItemIndex]; moved = TryTransferItemTo(srcInventory, destinations, srcItemIndex, srcItem, false, exclude) || moved; } } } return(moved); }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { Block = Entity as IMyCollector; inventory = Block.GetInventory(); Block.UseConveyorSystem = false; NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME; }
/// <summary> /// As long as ComputeAmountThatFits is not available for modding we have to try /// </summary> public static VRage.MyFixedPoint MaxItemsAddable(this IMyInventory destInventory, VRage.MyFixedPoint maxNeeded, MyItemType itemType) { if (destInventory.CanItemsBeAdded(maxNeeded, itemType)) { return(maxNeeded); } int maxPossible = 0; int currentStep = Math.Max((int)maxNeeded / 2, 1); int currentTry = 0; while (currentStep > 0) { currentTry = maxPossible + currentStep; if (destInventory.CanItemsBeAdded(currentTry, itemType)) { maxPossible = currentTry; } else { if (currentStep <= 1) { break; } } if (currentStep > 1) { currentStep = currentStep / 2; } } return(maxPossible); }
void MoveToContainer( MyInventoryItem item, IMyInventory currentInv, int itemIndex, List <CargoContainer> containers) { List <CargoContainer> candidateContainers = new List <CargoContainer>(); FindCargoSpace(item, currentInv, containers, candidateContainers); foreach (CargoContainer container in candidateContainers) { IMyInventory targetInv = container.container.GetInventory(); float remainingItemVolume = ItemVolume(item); float transferrableVolume = Math.Min(remainingItemVolume, targetInv.MaxVolume.RawValue - targetInv.CurrentVolume.RawValue); if (currentInv.TransferItemTo( targetInv, item, ItemAmount(item.Type, transferrableVolume) )) { remainingItemVolume -= transferrableVolume; if (remainingItemVolume == 0f) { break; } } } }
private void RemoveInventory(IMyInventory playerInventory, List <Sandbox.Game.Entities.MyEntity> cargoBlocks, MyFixedPoint amount, MyDefinitionId definitionId) { var available = playerInventory.GetItemAmount(definitionId); if (amount <= available) { playerInventory.RemoveItemsOfType(amount, definitionId); amount = 0; } else { playerInventory.RemoveItemsOfType(available, definitionId); amount -= available; } foreach (var cubeBlock in cargoBlocks) { if (amount > 0) { var cubeInventory = cubeBlock.GetInventory(); available = cubeInventory.GetItemAmount(definitionId); if (amount <= available) { cubeInventory.RemoveItemsOfType(amount, definitionId); amount = 0; } else { cubeInventory.RemoveItemsOfType(available, definitionId); amount -= available; } } } }
private List <MyInventoryItem> GetInventoryItems(IMyInventory container) { List <MyInventoryItem> items = new List <MyInventoryItem>(); container.GetItems(items); return(items); }
public override void UpdateOnceBeforeFrame() { resourceSink = Entity.Components.Get <MyResourceSinkComponent>(); resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f); setPowerConsumption = 0.0001f; m_inventory = ((Sandbox.ModAPI.Ingame.IMyTerminalBlock)Entity).GetInventory(0) as IMyInventory; }
public static MyGuiScreenInventory OpenInventory(MyGuiScreenInventoryType inventoryScreenType, MyEntity otherSide = null, MySmallShipInteractionActionEnum? action = null) { MyMwcLog.WriteLine("OpenInventory()"); // return harvester when opening inventory, harvester can update inventory, which would not propagete to inventory screen and closing inventory would override those changes var harvester = MySession.PlayerShip.Weapons.GetMountedHarvestingDevice(); if (harvester != null && harvester.CurrentState != MyHarvestingDeviceEnum.InsideShip) harvester.Shot(null); StringBuilder otherSideInventoryName = null; MyInventory otherSideInventory = null; List<MySmallShipBuilderWithName> shipsObjectBuilders = null; bool closeOtherSideInventory = false; m_inventoryScreenType = inventoryScreenType; m_shipsInventoryOwner = MySession.Static; m_player = MySession.Static.Player; m_detectedEntity = otherSide; m_detectedAction = action; shipsObjectBuilders = new List<MySmallShipBuilderWithName>(); shipsObjectBuilders.Add(new MySmallShipBuilderWithName(MySession.PlayerShip.GetObjectBuilder(true) as MyMwcObjectBuilder_SmallShip_Player)); switch(m_inventoryScreenType) { case MyGuiScreenInventoryType.GodEditor: LoadGodEditorInventory(ref otherSideInventory, ref otherSideInventoryName, ref shipsObjectBuilders); closeOtherSideInventory = true; break; case MyGuiScreenInventoryType.InGameEditor: LoadIngameEditorInventory(ref otherSideInventory, ref otherSideInventoryName); break; case MyGuiScreenInventoryType.Game: LoadGameInventory(ref otherSideInventory, ref otherSideInventoryName, ref shipsObjectBuilders); break; } var currentShipBuilder = shipsObjectBuilders[0]; shipsObjectBuilders.Sort((x, y) => ((int)x.Builder.ShipType).CompareTo((int)y.Builder.ShipType)); m_curentIndex = shipsObjectBuilders.IndexOf(currentShipBuilder); MyMwcObjectBuilder_Inventory otherSideInventoryBuilder = otherSideInventory != null ? otherSideInventory.GetObjectBuilder(true) : null; if (closeOtherSideInventory) { Debug.Assert(otherSideInventory != null); otherSideInventory.Close(); } m_currentInventoryScreen = new MyGuiScreenInventory(shipsObjectBuilders, m_curentIndex, m_player.Money, m_tradeForMoney, otherSideInventoryBuilder, otherSideInventoryName, m_inventoryScreenType); m_currentInventoryScreen.OnSave += Save; m_currentInventoryScreen.Closed += OnInventoryScreenClosed; MyGuiScreenGamePlay.Static.HideSelectAmmo(); return m_currentInventoryScreen; }
void IMySlimBlock.IncreaseMountLevel(float welderMountAmount, long welderOwnerPlayerId, IMyInventory outputInventory, float maxAllowedBoneMovement, bool isHelping, MyOwnershipShareModeEnum share) { IncreaseMountLevel(welderMountAmount, welderOwnerPlayerId, outputInventory as MyInventoryBase, maxAllowedBoneMovement, isHelping, share); }
void IMySlimBlock.ClearConstructionStockpile(IMyInventory outputInventory) { ClearConstructionStockpile(outputInventory as MyInventoryBase); }
void IMySlimBlock.MoveItemsToConstructionStockpile(IMyInventory fromInventory) { MoveItemsToConstructionStockpile(fromInventory as MyInventoryBase); }
private bool TransferItemsTo(IMyInventory dst, int sourceItemIndex, int? targetItemIndex, VRage.MyFixedPoint? amount,bool useConveyor) { MyInventory dstInventory = dst as MyInventory; if (dstInventory != null) { if (sourceItemIndex < 0 || sourceItemIndex >= this.m_items.Count || (useConveyor == true && IsConnected(dstInventory) == false)) { return false; } Transfer(this as MyInventory, dstInventory, this.GetItems()[sourceItemIndex].ItemId, targetItemIndex.HasValue ? targetItemIndex.Value : -1, amount); return true; } return false; }
void IMySlimBlock.MoveItemsFromConstructionStockpile(IMyInventory toInventory, Sandbox.Common.ObjectBuilders.MyItemFlags flags) { MoveItemsFromConstructionStockpile(toInventory as MyInventory, flags); }
private bool TransferItemsFrom(IMyInventory sourceInventory, int sourceItemIndex, int? targetItemIndex, bool? stackIfPossible, VRage.MyFixedPoint? amount,bool useConveyors) { MyInventory srcInventory = sourceInventory as MyInventory; if (srcInventory != null && (useConveyors == false || IsConnected(srcInventory) == true)) { TransferItemFrom(srcInventory, sourceItemIndex, targetItemIndex, stackIfPossible, amount); return true; } return false; }
bool IMyInventory.IsConnectedTo(IMyInventory dst) { MyInventory dstInventory = dst as MyInventory; if (dstInventory != null) { return IsConnected(dstInventory); } return false; }
void IMySlimBlock.MoveItemsFromConstructionStockpile(IMyInventory toInventory, MyItemFlags flags) { MoveItemsFromConstructionStockpile(toInventory as MyInventory, flags); }
/// <summary> /// Get the component amount and index from an inventory. /// </summary> /// <param name="inventory">Inventory to search.</param> /// <param name="defId">Component definition</param> /// <param name="amount">Amount of components in inventory</param> /// <param name="index">Component position in inventory</param> private void GetComponentInInventory(IMyInventory inventory, MyDefinitionId defId, out int amount, out int index) { amount = (int)inventory.GetItemAmount(defId); if (amount == 0) { index = -1; return; } var allItems = inventory.GetItems(); for (index = 0; index < allItems.Count; index++) if (allItems[index].Content.GetId() == defId) return; }
private static void LoadIngameEditorInventory(ref MyInventory otherSideInventory, ref StringBuilder otherSideInventoryName) { m_otherSideInventoryOwner = MyEditor.Static.FoundationFactory.PrefabContainer; otherSideInventory = m_otherSideInventoryOwner.Inventory; otherSideInventoryName = new StringBuilder(); otherSideInventoryName.Append(MyEditor.Static.FoundationFactory.PrefabContainer.DisplayName); //otherSideInventoryName.Append(MyTextsWrapper.Get(MyTextsWrapperEnum.OtherSideInventory)); }
/// <summary> /// Gets inventory, only items which affect multiplayer /// </summary> MyMwcObjectBuilder_Inventory GetInventory(IMyInventory ship, bool gameMechanicsItemsOnly) { var builder = ship.Inventory.GetObjectBuilder(false); builder.InventoryItems.RemoveAll(ItemPredicateRemoveShips); if (gameMechanicsItemsOnly) { builder.InventoryItems.RemoveAll(ItemPredicateRemove); } return builder; }
private static void LoadGameInventory(ref MyInventory otherSideInventory, ref StringBuilder otherSideInventoryName, ref List<MySmallShipBuilderWithName> shipsObjectBuilders) { if (MySession.PlayerShip.TradeDetector != null && m_detectedEntity == null) { m_detectedEntity = MySession.PlayerShip.TradeDetector.GetNearestEntity(); } if (m_detectedEntity != null) { if (m_detectedAction == null) { m_detectedAction = (MySmallShipInteractionActionEnum)MySession.PlayerShip.TradeDetector.GetNearestEntityCriterias(); } m_otherSideInventoryOwner = m_detectedEntity as IMyInventory; otherSideInventory = m_otherSideInventoryOwner.Inventory; string entityName; if (m_detectedEntity is MyPrefabHangar) { entityName = ((m_detectedEntity) as MyPrefabHangar).GetOwner().GetCorrectDisplayName(); } else { entityName = m_detectedEntity.GetCorrectDisplayName(); } switch (m_detectedAction) { case MySmallShipInteractionActionEnum.TradeForFree: if (IsTradingWithMothership()) { List<MyInventoryItem> inventoryItems = new List<MyInventoryItem>(); foreach (MyInventoryItem inventoryItem in m_shipsInventoryOwner.Inventory.GetInventoryItems()) { if (inventoryItem.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.SmallShip_Player) { shipsObjectBuilders.Add(new MySmallShipBuilderWithName(inventoryItem.GetInventoryItemObjectBuilder(false) as MyMwcObjectBuilder_SmallShip_Player)); } else if (inventoryItem.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.SmallShip_HackingTool) { inventoryItem.CanBeMoved = false; } else { continue; } inventoryItem.IsTemporaryItem = true; inventoryItems.Add(inventoryItem); } //m_shipsInventoryOwner.Inventory.RemoveInventoryItems(inventoryItems); //m_shipsInventoryOwner.Inventory.RemoveInventoryItems(MyMwcObjectBuilderTypeEnum.SmallShip_Player, null); //m_shipsInventoryOwner.Inventory.ClearInventoryItems(false); m_shipsInventoryOwner.Inventory.RemoveInventoryItems(inventoryItems, false); otherSideInventory.AddInventoryItems(inventoryItems); } break; case MySmallShipInteractionActionEnum.TradeForMoney: m_tradeForMoney = true; if (m_detectedEntity is MySmallShipBot) { otherSideInventory.PriceCoeficient = 3f; } break; case MySmallShipInteractionActionEnum.Blocked: case MySmallShipInteractionActionEnum.Build: case MySmallShipInteractionActionEnum.Loot: case MySmallShipInteractionActionEnum.Examine: case MySmallShipInteractionActionEnum.ExamineEmpty: break; default: throw new MyMwcExceptionApplicationShouldNotGetHere(); } otherSideInventoryName = new StringBuilder(); if (string.IsNullOrEmpty(entityName)) { otherSideInventoryName.Append(MyTextsWrapper.Get(MyTextsWrapperEnum.OtherSide)); } else { otherSideInventoryName.Append(entityName); //otherSideInventoryName.Append(MyTextsWrapper.Get(MyTextsWrapperEnum.OtherSideInventory)); } if (OpeningInventoryScreen != null) { OpeningInventoryScreen(m_detectedEntity, m_detectedAction.Value); } } }
private static void Clear() { m_otherSideInventoryOwner = null; m_player = null; m_shipsInventoryOwner = null; m_tradeForMoney = false; m_entityDetector = null; m_detectedAction = null; m_currentInventoryScreen.OnSave -= Save; m_currentInventoryScreen.Closed -= OnInventoryScreenClosed; m_currentInventoryScreen = null; }
public MissingStock(IMyInventory inventory, VRage.MyFixedPoint amount) { Inventory = inventory; Amount = amount; }
void IMySlimBlock.DecreaseMountLevel(float grinderAmount, IMyInventory outputInventory, bool useDefaultDeconstructEfficiency) { DecreaseMountLevel(grinderAmount, outputInventory as MyInventoryBase, useDefaultDeconstructEfficiency); }
public bool TransferItemTo(IMyInventory dst, int sourceItemIndex, int? targetItemIndex = default(int?), bool? stackIfPossible = default(bool?), MyFixedPoint? amount = default(MyFixedPoint?)) { throw new NotImplementedException(); }
bool IMyInventory.TransferItemFrom(IMyInventory sourceInventory, int sourceItemIndex, int? targetItemIndex, bool? stackIfPossible, VRage.MyFixedPoint? amount) { return TransferItemsFrom(sourceInventory, sourceItemIndex, targetItemIndex, stackIfPossible, amount,true); }
public bool IsConnectedTo(IMyInventory dst) { throw new NotImplementedException(); }
bool VRage.Game.ModAPI.IMyInventory.TransferItemFrom(IMyInventory sourceInventory, int sourceItemIndex, int? targetItemIndex = null, bool? stackIfPossible = null, VRage.MyFixedPoint? amount = null, bool checkConnection = false) { return TransferItemsFrom(sourceInventory, sourceItemIndex, targetItemIndex, stackIfPossible, amount, checkConnection); }
public static bool InventoryAdd(IMyInventory inventory, MyFixedPoint amount, MyDefinitionId definitionId) { var content = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(definitionId); var gasContainer = content as MyObjectBuilder_GasContainerObject; if (gasContainer != null) gasContainer.GasLevel = 1f; MyObjectBuilder_InventoryItem inventoryItem = new MyObjectBuilder_InventoryItem { Amount = amount, Content = content }; if (inventory.CanItemsBeAdded(inventoryItem.Amount, definitionId)) { inventory.AddItems(inventoryItem.Amount, (MyObjectBuilder_PhysicalObject)inventoryItem.Content, -1); return true; } // Inventory full. Could not add the item. return false; }
bool IMyInventory.TransferItemTo(IMyInventory dst, int sourceItemIndex, int? targetItemIndex, bool? stackIfPossible, VRage.MyFixedPoint? amount) { return TransferItemsTo(dst, sourceItemIndex, targetItemIndex, amount,true); }
bool IMySlimBlock.CanContinueBuild(IMyInventory sourceInventory) { return CanContinueBuild(sourceInventory as MyInventory); }
bool Sandbox.ModAPI.IMyInventory.TransferItemTo(IMyInventory dst, int sourceItemIndex, int? targetItemIndex = null, bool? stackIfPossible = null, VRage.MyFixedPoint? amount = null, bool checkConnection=false) { return TransferItemsTo(dst, sourceItemIndex, targetItemIndex, amount, checkConnection); }
void IMySlimBlock.FullyDismount(IMyInventory outputInventory) { FullyDismount(outputInventory as MyInventory); }