protected override bool PreReceive(BinaryReader reader, int fromWho)
{
bool result = base.PreReceive(reader, fromWho);
if (!ModPlayer.Initialized)
{
ModPlayer.Init();
}
for (int i = 1; i < ModPlayer.Inventory.Page.Length; i += 1)
{
for (int j = 0; j < ModPlayer.Inventory.Page[i].item.Length; j += 1)
{
ModPlayer.Inventory.Page[i].item[j] = ItemIO.Receive(reader, true, true);
}
}
foreach (AlignmentStat stat in ModPlayer.Character.AlignmentStats.Values)
{
if (stat.DoSave)
{
stat.BaseAmount = reader.ReadInt32();
}
}
foreach (MinorStat stat in ModPlayer.Character.MinorStats.Values)
{
if (stat.DoSave)
{
stat.BaseAmount = reader.ReadSingle();
}
}
return(result);
}
public static void ReceiveStationResult(BinaryReader reader)
{
if (Main.netMode != 1)
{
return;
}
Player player = Main.player[Main.myPlayer];
byte op = reader.ReadByte();
Item item = ItemIO.Receive(reader, true);
if (op == 2 && Main.playerInventory && Main.mouseItem.IsAir)
{
Main.mouseItem = item;
item = new Item();
}
else if (op == 2 && Main.playerInventory && Main.mouseItem.type == item.type)
{
int total = Main.mouseItem.stack + item.stack;
if (total > Main.mouseItem.maxStack)
{
total = Main.mouseItem.maxStack;
}
int difference = total - Main.mouseItem.stack;
Main.mouseItem.stack = total;
item.stack -= total;
}
if (item.stack > 0)
{
item = player.GetItem(Main.myPlayer, item, false, true);
if (!item.IsAir)
{
player.QuickSpawnClonedItem(item, item.stack);
}
}
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
//PathOfModifiers.Instance.Logger.Info($"NetReceive: {Main.netMode}");
var newTimeLeft = reader.ReadInt32();
bool isBoundsNull = reader.ReadBoolean();
var newBounds = isBoundsNull ? null : (Rectangle?)reader.ReadRectangle();
mapItem = ItemIO.Receive(reader, true);
if (timeLeft == 0 && newTimeLeft != 0)
{
MapBorder.AddActiveBounds(newBounds.Value);
}
else if (timeLeft != 0 && newTimeLeft == 0)
{
MapBorder.RemoveActiveBounds(bounds.Value);
}
timeLeft = newTimeLeft;
bounds = newBounds;
if (Main.netMode == NetmodeID.MultiplayerClient)
{
if (MapDevice.activeMD?.Position == Position)
{
MapDeviceUI.ShowUI(this);
}
}
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
for (int k = 0; k < stations.Length; k++)
{
stations[k] = ItemIO.Receive(reader, true, false);
}
}
//Receive Inventories stored on the world from the server and rebuilds the dictionary of inventories
public override void NetReceive(BinaryReader reader)
{
mod.Logger.Debug($"Net receive");
playerDeathInventoryMap = new Dictionary <Point, PlayerDeathInventory>();
Point position = new Point();
string playerName = "";
int dInventoryLength = 0;
int dArmorLength = 0;
int dDyeLength = 0;
int dMiscEquipsLength = 0;
int dMiscDyesLength = 0;
int numOfInventories = reader.ReadInt32();
for (int i = 0; i < numOfInventories; i++)
{
position = new Point(reader.ReadInt32(), reader.ReadInt32());
playerName = reader.ReadString();
dInventoryLength = reader.ReadInt32();
Item[] dInventory = new Item[dInventoryLength];
for (int j = 0; j < dInventoryLength; j++)
{
dInventory[j] = ItemIO.Receive(reader, readStack: true, readFavorite: true);
}
dArmorLength = reader.ReadInt32();
Item[] dArmor = new Item[dArmorLength];
for (int j = 0; j < dArmorLength; j++)
{
dArmor[j] = ItemIO.Receive(reader, readStack: true);
}
dDyeLength = reader.ReadInt32();
Item[] dDye = new Item[dDyeLength];
for (int j = 0; j < dDyeLength; j++)
{
dDye[j] = ItemIO.Receive(reader, readStack: true);
}
dMiscEquipsLength = reader.ReadInt32();
Item[] dMiscEquips = new Item[dMiscEquipsLength];
for (int j = 0; j < dMiscEquipsLength; j++)
{
dMiscEquips[j] = ItemIO.Receive(reader, readStack: true);
}
dMiscDyesLength = reader.ReadInt32();
Item[] dMiscDyes = new Item[dMiscDyesLength];
for (int j = 0; j < dMiscDyesLength; j++)
{
dMiscDyes[j] = ItemIO.Receive(reader, readStack: true);
}
playerDeathInventoryMap[position] = new PlayerDeathInventory(dInventory, dArmor, dDye, dMiscEquips, dMiscDyes, playerName);
}
}
void SReceiveModifierForgeModifierItemChanged(BinaryReader reader)
{
byte ignoreClient = reader.ReadByte();
int mfID = reader.ReadInt32();
var mf = (ModifierForgeTE)TileEntity.ByID[mfID];
mf.modifierItem = ItemIO.Receive(reader, true);
mf.SendToClients(ignoreClient);
}
void SReceiveMapDeviceMapItemChanged(BinaryReader reader)
{
byte ignoreClient = reader.ReadByte();
int mdID = reader.ReadInt32();
var md = (MapDeviceTE)TileEntity.ByID[mdID];
md.mapItem = ItemIO.Receive(reader, true);
md.SendToClients(ignoreClient);
}
public void HandlePacket(BinaryReader reader, int WhoAmI)
{
int owner = reader.ReadInt32();
SlotKind kind = (SlotKind)reader.ReadByte();
int slot = reader.ReadInt32();
Item[] targetInventory = GetInventoryFromKind(owner, kind);
ItemIO.Receive(targetInventory[slot], reader, true, true);
}
public static void ReceiveOperationResult(BinaryReader reader)
{
byte op = reader.ReadByte();
/*
* if (Main.netMode == NetmodeID.Server)
* Console.WriteLine($"Receiving Operation Result {op}");
* else
* Main.NewText($"Receiving Operation Result {op}");
*/
if (Main.netMode != 1)
{
//The data still needs to be read for exceptions to not be thrown...
if (op == 0 || op == 1 || op == 3)
{
ItemIO.Receive(reader, true);
}
else if (op == 2)
{
int count = reader.ReadByte();
for (int i = 0; i < count; i++)
{
ItemIO.Receive(reader, true);
}
}
return;
}
if (op == 0 || op == 1 || op == 3)
{
Item item = ItemIO.Receive(reader, true);
/*
* Main.NewText($"Item Read: [type: {item.type}, prefix: {item.prefix}, stack: {item.stack}]");
* Main.NewText($"Reader Position: {reader.BaseStream.Position}");
*/
StoragePlayer.GetItem(item, op != 3);
}
else if (op == 2)
{
int count = reader.ReadByte();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true);
/*
* Main.NewText($"Item Read: [type: {item.type}, prefix: {item.prefix}, stack: {item.stack}]");
* Main.NewText($"Reader Position: {reader.BaseStream.Position}");
*/
StoragePlayer.GetItem(item, false);
}
}
}
public static void ReceiveCraftResult(BinaryReader reader)
{
Player player = Main.player[Main.myPlayer];
int count = reader.ReadInt32();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true);
player.QuickSpawnClonedItem(item, item.stack);
}
}
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
PacketMessageType message = (PacketMessageType)reader.ReadByte();
byte player = reader.ReadByte();
MagicalPlayer modPlayer = Main.player[player].GetModPlayer <MagicalPlayer>();
switch (message)
{
case PacketMessageType.All:
modPlayer.EquipShoeSlot.Item = ItemIO.Receive(reader);
modPlayer.VanityShoeSlot.Item = ItemIO.Receive(reader);
modPlayer.ShoeDyeSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == NetmodeID.Server)
{
ModPacket packet = GetPacket();
packet.Write((byte)PacketMessageType.All);
packet.Write(player);
ItemIO.Send(modPlayer.EquipShoeSlot.Item, packet);
ItemIO.Send(modPlayer.VanityShoeSlot.Item, packet);
ItemIO.Send(modPlayer.ShoeDyeSlot.Item, packet);
packet.Send(-1, whoAmI);
}
break;
case PacketMessageType.EquipShoeSlot:
modPlayer.EquipShoeSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == NetmodeID.Server)
{
modPlayer.SendSingleItemPacket(PacketMessageType.EquipShoeSlot, modPlayer.EquipShoeSlot.Item, -1, whoAmI);
}
break;
case PacketMessageType.VanityShoeSlot:
modPlayer.VanityShoeSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == NetmodeID.Server)
{
modPlayer.SendSingleItemPacket(PacketMessageType.VanityShoeSlot, modPlayer.VanityShoeSlot.Item, -1, whoAmI);
}
break;
case PacketMessageType.ShoeDyeSlot:
modPlayer.ShoeDyeSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == NetmodeID.Server)
{
modPlayer.SendSingleItemPacket(PacketMessageType.ShoeDyeSlot, modPlayer.ShoeDyeSlot.Item, -1, whoAmI);
}
break;
default:
Logger.InfoFormat("Magical Things: Unknown message type: ", DisplayName);
//ErrorLogger.Log("Magical Things: Unknown message type: " + message);
break;
}
}
public void HandlePacket(BinaryReader reader, int WhoAmI)
{
if (Main.netMode != 2)
{
return;
}
TransferFilterTileEntity FilterEntity = (TransferFilterTileEntity)ByID[reader.ReadInt32()];
FilterEntity.item = ItemIO.Receive(reader);
NetMessage.SendData(MessageID.TileEntitySharing, -1, WhoAmI, null, FilterEntity.ID, FilterEntity.Position.X, FilterEntity.Position.Y);
}
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
PacketMessageType message = (PacketMessageType)reader.ReadByte();
byte player = reader.ReadByte();
WingSlotPlayer modPlayer = Main.player[player].GetModPlayer <WingSlotPlayer>();
switch (message)
{
case PacketMessageType.All:
modPlayer.EquipSlot.Item = ItemIO.Receive(reader);
modPlayer.VanitySlot.Item = ItemIO.Receive(reader);
modPlayer.DyeSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == 2)
{
ModPacket packet = GetPacket();
packet.Write((byte)PacketMessageType.All);
packet.Write(player);
ItemIO.Send(modPlayer.EquipSlot.Item, packet);
ItemIO.Send(modPlayer.VanitySlot.Item, packet);
ItemIO.Send(modPlayer.DyeSlot.Item, packet);
packet.Send(-1, whoAmI);
}
break;
case PacketMessageType.EquipSlot:
modPlayer.EquipSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == 2)
{
modPlayer.SendSingleItemPacket(PacketMessageType.EquipSlot, modPlayer.EquipSlot.Item, -1, whoAmI);
}
break;
case PacketMessageType.VanitySlot:
modPlayer.VanitySlot.Item = ItemIO.Receive(reader);
if (Main.netMode == 2)
{
modPlayer.SendSingleItemPacket(PacketMessageType.VanitySlot, modPlayer.VanitySlot.Item, -1, whoAmI);
}
break;
case PacketMessageType.DyeSlot:
modPlayer.DyeSlot.Item = ItemIO.Receive(reader);
if (Main.netMode == 2)
{
modPlayer.SendSingleItemPacket(PacketMessageType.DyeSlot, modPlayer.DyeSlot.Item, -1, whoAmI);
}
break;
default:
Logger.InfoFormat("[Wing Slot] Unknown message type: {0}", message);
break;
}
}
public static void ReceiveStationOperation(BinaryReader reader, int sender)
{
if (Main.netMode != 2)
{
return;
}
int ent = reader.ReadInt32();
if (!TileEntity.ByID.ContainsKey(ent) || !(TileEntity.ByID[ent] is TECraftingAccess))
{
return;
}
TECraftingAccess access = (TECraftingAccess)TileEntity.ByID[ent];
Item[] stations = access.stations;
byte op = reader.ReadByte();
if (op == 0)
{
Item item = ItemIO.Receive(reader, true);
access.TryDepositStation(item);
if (item.stack > 0)
{
ModPacket packet = PrepareStationResult(op);
ItemIO.Send(item, packet, true);
packet.Send();
}
}
else if (op == 1)
{
int slot = reader.ReadByte();
Item item = access.TryWithdrawStation(slot);
if (!item.IsAir)
{
ModPacket packet = PrepareStationResult(op);
ItemIO.Send(item, packet, true);
packet.Send();
}
}
else if (op == 2)
{
Item item = ItemIO.Receive(reader, true);
int slot = reader.ReadByte();
item = access.DoStationSwap(item, slot);
if (!item.IsAir)
{
ModPacket packet = PrepareStationResult(op);
ItemIO.Send(item, packet, true);
packet.Send();
}
}
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
//PathOfModifiers.Log($"NetReceive{Main.netMode}");
modifiedItem = ItemIO.Receive(reader, true);
modifierItem = ItemIO.Receive(reader, true);
if (Main.netMode != 2)
{
if (ModifierForge.activeForge?.Position == Position)
{
ModifierForgeUI.ShowUI(this);
}
}
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
RitualOfTheStone = reader.ReadBoolean();
RoSType = reader.ReadUInt16();
RitualOfTheMiner = reader.ReadBoolean();
RoMinType = reader.ReadUInt16();
RitualOfMidas = reader.ReadBoolean();
RoMidType = reader.ReadInt16();
RitualOfSouls = reader.ReadBoolean();
RoSoType = reader.ReadInt32();
RoSoDelay = reader.ReadUInt16();
RitualOwner = reader.ReadInt32();
BloodCrystal = ItemIO.Receive(reader, true);
}
public override void NetReceive(BinaryReader reader)
{
BitsByte presentItems = reader.ReadByte();
BitsByte presentDyes = reader.ReadByte();
for (int i = 0; i < 8; i++)
{
_items[i] = presentItems[i] ? ItemIO.Receive(reader, true) : new Item();
}
for (int i = 0; i < 8; i++)
{
_dyes[i] = presentDyes[i] ? ItemIO.Receive(reader, true) : new Item();
}
}
public override bool PostReceive(BinaryReader reader, int fromWho)
{
if (!ModPlayer.initialized)
{
ModPlayer.Init();
}
for (int i = 1; i < ModPlayer.inventory.page.Length; i += 1)
{
for (int j = 0; j < ModPlayer.inventory.page[i].item.Length; j += 1)
{
ModPlayer.inventory.page[i].item[j] = ItemIO.Receive(reader, true, true);
}
}
return(base.PostReceive(reader, fromWho));
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
base.NetReceive(reader, lightReceive);
ClearItemsData();
int count = reader.ReadInt32();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true, false);
items.Add(item);
ItemData data = new ItemData(item);
if (item.stack < item.maxStack)
{
hasSpaceInStack.Add(data);
}
hasItem.Add(data);
}
}
protected override bool ReceiveData(BinaryReader reader, TEStorageUnit unit)
{
unit.ClearItemsData();
int count = reader.ReadInt32();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true, false);
unit.items.Add(item);
ItemData data = new ItemData(item);
if (item.stack < item.maxStack)
{
unit.hasSpaceInStack.Add(data);
}
unit.hasItem.Add(data);
}
return(false);
}
public static void ReceiveCraftRequest(BinaryReader reader, int sender)
{
int ent = reader.ReadInt32();
int count = reader.ReadInt32();
if (Main.netMode != 2)
{
//Still need to read the data for exceptions to not be thrown
for (int i = 0; i < count; i++)
{
ItemIO.Receive(reader, true);
}
ItemIO.Receive(reader, true);
return;
}
if (!TileEntity.ByID.ContainsKey(ent) || !(TileEntity.ByID[ent] is TEStorageHeart))
{
return;
}
TEStorageHeart heart = (TEStorageHeart)TileEntity.ByID[ent];
List <Item> toWithdraw = new List <Item>();
for (int k = 0; k < count; k++)
{
toWithdraw.Add(ItemIO.Receive(reader, true));
}
Item result = ItemIO.Receive(reader, true);
List <Item> items = CraftingGUI.DoCraft(heart, toWithdraw, result);
if (items.Count > 0)
{
ModPacket packet = MagicStorage.Instance.GetPacket();
packet.Write((byte)MessageType.CraftResult);
packet.Write(items.Count);
foreach (Item item in items)
{
ItemIO.Send(item, packet, true);
}
packet.Send(sender);
}
SendRefreshNetworkItems(ent);
}
public static void ReceiveCraftRequest(BinaryReader reader, int sender)
{
if (Main.netMode != NetmodeID.Server)
{
return;
}
int heartID = reader.ReadInt32();
if (!TileEntity.ByID.ContainsKey(heartID) || !(TileEntity.ByID[heartID] is TEStorageHeart))
{
return;
}
TEStorageHeart heart = (TEStorageHeart)TileEntity.ByID[heartID];
TECraftingAccess access = (TECraftingAccess)TileEntity.ByID[reader.ReadInt32()];
int count = reader.ReadInt32();
List <Item> toWithdraw = new List <Item>();
for (int k = 0; k < count; k++)
{
toWithdraw.Add(ItemIO.Receive(reader, true));
}
Item result = ItemIO.Receive(reader, true);
List <Item> items = access.DoCraft(heart, toWithdraw, result);
if (items.Count > 0)
{
ModPacket packet = MagicStorageTwo.Instance.GetPacket();
packet.Write((byte)MessageType.CraftResult);
packet.Write(items.Count);
foreach (Item item in items)
{
ItemIO.Send(item, packet, true);
}
packet.Send(sender);
}
SendRefreshNetworkItems(heartID);
}
public static void ReceiveOpResult(BinaryReader reader)
{
if (Main.netMode != 1)
{
return;
}
var op = (StorageOp)reader.ReadByte();
if (op == StorageOp.Deposit || op == StorageOp.Withdraw || op == StorageOp.WithdrawToInventory)
{
Item item = ItemIO.Receive(reader, true);
StoragePlayer.GetItem(item, op != StorageOp.WithdrawToInventory);
}
else if (op == StorageOp.DepositList)
{
int count = reader.ReadByte();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true);
StoragePlayer.GetItem(item, false);
}
}
}
public static void ReceiveOperationResult(BinaryReader reader)
{
if (Main.netMode != 1)
{
return;
}
Player player = Main.player[Main.myPlayer];
byte op = reader.ReadByte();
if (op == 0 || op == 1 || op == 3)
{
Item item = ItemIO.Receive(reader, true);
StoragePlayer.GetItem(item, op != 3);
}
else if (op == 2)
{
int count = reader.ReadByte();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true);
StoragePlayer.GetItem(item, false);
}
}
}
protected override bool ReceiveData(BinaryReader reader, TEStorageUnit unit)
{
unit.TryWithdraw(ItemIO.Receive(reader, true, false));
return(true);
}
public override void NetReceive(BinaryReader reader) => item = ItemIO.Receive(reader, true);
public static void ReceiveStorageOp(BinaryReader reader, int sender)
{
if (Main.netMode != 2)
{
return;
}
int ent = reader.ReadInt32();
if (!TileEntity.ByID.ContainsKey(ent) || !(TileEntity.ByID[ent] is TEStorageHeart))
{
return;
}
TEStorageHeart heart = (TEStorageHeart)TileEntity.ByID[ent];
var op = (StorageOp)reader.ReadByte();
if (op == StorageOp.Deposit)
{
Item item = ItemIO.Receive(reader, true);
heart.DepositItem(item);
if (!item.IsAir)
{
ModPacket packet = PrepareOpResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
else if (op == StorageOp.DepositList)
{
int count = reader.ReadByte();
List <Item> items = new List <Item>();
StartUpdateQueue();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true);
heart.DepositItem(item);
if (!item.IsAir)
{
items.Add(item);
}
}
ProcessUpdateQueue();
if (items.Count > 0)
{
ModPacket packet = PrepareOpResult(op);
packet.Write((byte)items.Count);
foreach (Item item in items)
{
ItemIO.Send(item, packet, true);
}
packet.Send(sender);
}
}
else if (op == StorageOp.Withdraw || op == StorageOp.WithdrawToInventory)
{
Item item = ItemIO.Receive(reader, true);
item = heart.TryWithdraw(item);
if (!item.IsAir)
{
ModPacket packet = PrepareOpResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
else if (op == StorageOp.WithdrawJustRemove)
{
// @Robustness: We assume that nothing could go wrong here.
// And maybe nothing could. But still something to look at for potential bugs...
Item item = ItemIO.Receive(reader, true);
heart.TryWithdraw(item);
}
SendRefreshNetworkItems(ent);
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
item = ItemIO.Receive(reader);
}
public static void ReceiveStationOperation(BinaryReader reader, int sender)
{
if (Main.netMode != 2)
{
return;
}
int ent = reader.ReadInt32();
if (!TileEntity.ByID.ContainsKey(ent) || !(TileEntity.ByID[ent] is TECraftingAccess))
{
return;
}
TECraftingAccess access = (TECraftingAccess)TileEntity.ByID[ent];
Item[] stations = access.stations;
byte op = reader.ReadByte();
if (op == 0)
{
Item item = ItemIO.Receive(reader, true);
access.TryDepositStation(item);
if (item.stack > 0)
{
ModPacket packet = PrepareStationResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
else if (op == 1)
{
int slot = reader.ReadByte();
Item item = access.TryWithdrawStation(slot);
if (!item.IsAir)
{
ModPacket packet = PrepareStationResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
else if (op == 2)
{
Item item = ItemIO.Receive(reader, true);
int slot = reader.ReadByte();
item = access.DoStationSwap(item, slot);
if (!item.IsAir)
{
ModPacket packet = PrepareStationResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
Point16 pos = access.Position;
StorageAccess modTile = TileLoader.GetTile(Main.tile[pos.X, pos.Y].type) as StorageAccess;
if (modTile != null)
{
TEStorageHeart heart = modTile.GetHeart(pos.X, pos.Y);
if (heart != null)
{
SendRefreshNetworkItems(heart.ID);
}
}
}
public static void ReceiveStorageOperation(BinaryReader reader, int sender)
{
if (Main.netMode != 2)
{
return;
}
int ent = reader.ReadInt32();
if (!TileEntity.ByID.ContainsKey(ent) || !(TileEntity.ByID[ent] is TEStorageHeart))
{
return;
}
TEStorageHeart heart = (TEStorageHeart)TileEntity.ByID[ent];
byte op = reader.ReadByte();
if (op == 0)
{
Item item = ItemIO.Receive(reader, true);
heart.DepositItem(item);
if (!item.IsAir)
{
ModPacket packet = PrepareOperationResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
else if (op == 1 || op == 3)
{
Item item = ItemIO.Receive(reader, true);
item = heart.TryWithdraw(item);
if (!item.IsAir)
{
ModPacket packet = PrepareOperationResult(op);
ItemIO.Send(item, packet, true);
packet.Send(sender);
}
}
else if (op == 2)
{
int count = reader.ReadByte();
List <Item> items = new List <Item>();
StartUpdateQueue();
for (int k = 0; k < count; k++)
{
Item item = ItemIO.Receive(reader, true);
heart.DepositItem(item);
if (!item.IsAir)
{
items.Add(item);
}
}
ProcessUpdateQueue();
if (items.Count > 0)
{
ModPacket packet = PrepareOperationResult(op);
packet.Write((byte)items.Count);
foreach (Item item in items)
{
ItemIO.Send(item, packet, true);
}
packet.Send(sender);
}
}
SendRefreshNetworkItems(ent);
}
