// 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 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;
}
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);
}
