public override void NetSend(BinaryWriter writer)
{
writer.Write(BitsByte.ComposeBitsBytesChain(false, _items.Select(i => !i.IsAir).ToArray())[0]);
writer.Write(BitsByte.ComposeBitsBytesChain(false, _dyes.Select(i => !i.IsAir).ToArray())[0]);
for (int i = 0; i < 8; i++)
{
var item = _items[i];
if (!item.IsAir)
{
ItemIO.Send(item, writer, true);
}
}
for (int i = 0; i < 8; i++)
{
var dye = _dyes[i];
if (!dye.IsAir)
{
ItemIO.Send(dye, writer, true);
}
}
}
public override void NetSend(BinaryWriter writer, bool lightSend)
{
foreach (Item item in stations)
{
ItemIO.Send(item, writer, true, false);
}
}
protected override void SendData(BinaryWriter writer, TEStorageUnit unit)
{
writer.Write(unit.items.Count);
foreach (Item item in unit.items)
{
ItemIO.Send(item, writer, true, false);
}
}
//Adds number of Items and each Item to the writer
private void SendItems(ref BinaryWriter writer, Item[] itemArray, bool writeFavs = false)
{
writer.Write(itemArray.Length);
foreach (var item in itemArray)
{
ItemIO.Send(item, writer, writeStack: true, writeFavourite: writeFavs);
}
}
public static void SendDepositStation(int ent, Item item)
{
if (Main.netMode == NetmodeID.MultiplayerClient)
{
ModPacket packet = PrepareStationOperation(ent, 0);
ItemIO.Send(item, packet, true);
packet.Send();
}
}
public override void NetSend(BinaryWriter writer, bool lightSend)
{
base.NetSend(writer, lightSend);
writer.Write(items.Count);
foreach (Item item in items)
{
ItemIO.Send(item, writer, true, false);
}
}
internal void SendSingleItemPacket(PacketMessageType message, Item item, int toWho, int fromWho)
{
ModPacket packet = mod.GetPacket();
packet.Write((byte)message);
packet.Write((byte)player.whoAmI);
ItemIO.Send(item, packet);
packet.Send(toWho, fromWho);
}
public static void SendDeposit(int ent, Item item)
{
if (Main.netMode == 1)
{
ModPacket packet = PrepareStorageOperation(ent, StorageOp.Deposit);
ItemIO.Send(item, packet, true);
packet.Send();
}
}
public static void CMapDeviceMapItemChanged(int mapDeviceID, Item item)
{
ModPacket packet = Instance.GetPacket((byte)PacketType.MapDeviceMapItemChanged);
packet.Write((byte)Main.myPlayer);
packet.Write(mapDeviceID);
ItemIO.Send(item, packet, true);
packet.Send();
}
public static void SendWithdraw(int ent, Item item, StorageOp type)
{
if (Main.netMode == 1)
{
ModPacket packet = PrepareStorageOperation(ent, type);
ItemIO.Send(item, packet, true);
packet.Send();
}
}
public static void SendWithdraw(int ent, Item item, bool toInventory = false)
{
if (Main.netMode == 1)
{
ModPacket packet = PrepareStorageOperation(ent, (byte)(toInventory ? 3 : 1));
ItemIO.Send(item, packet, true);
packet.Send();
}
}
public static void SendStationSlotClick(int ent, Item item, int slot)
{
if (Main.netMode == 1)
{
ModPacket packet = PrepareStationOperation(ent, 2);
ItemIO.Send(item, packet, true);
packet.Write((byte)slot);
packet.Send();
}
}
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 override void SyncPlayer(int toWho, int fromWho, bool newPlayer)
{
ModPacket packet = mod.GetPacket();
packet.Write((byte)PacketMessageType.All);
packet.Write((byte)player.whoAmI);
ItemIO.Send(EquipSlot.Item, packet);
ItemIO.Send(VanitySlot.Item, packet);
ItemIO.Send(DyeSlot.Item, packet);
packet.Send(toWho, fromWho);
}
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 static void SendDepositAll(int ent, List <Item> items)
{
if (Main.netMode == 1)
{
ModPacket packet = PrepareStorageOperation(ent, StorageOp.DepositList);
packet.Write((byte)items.Count);
foreach (Item item in items)
{
ItemIO.Send(item, packet, true);
}
packet.Send();
}
}
public override void NetSend(BinaryWriter writer, bool lightSend)
{
writer.Write(RitualOfTheStone);
writer.Write(RoSType);
writer.Write(RitualOfTheMiner);
writer.Write(RoMinType);
writer.Write(RitualOfMidas);
writer.Write(RoMidType);
writer.Write(RitualOfSouls);
writer.Write(RoSoType);
writer.Write(RoSoDelay);
writer.Write(RitualOwner);
ItemIO.Send(BloodCrystal, writer, true);
}
public override void NetSend(BinaryWriter writer, bool lightSend)
{
//PathOfModifiers.Instance.Logger.Info($"NetSend: {Main.netMode}");
writer.Write(timeLeft);
bool isBoundsNull = !bounds.HasValue;
writer.Write(isBoundsNull);
if (!isBoundsNull)
{
writer.Write((Rectangle)bounds);
}
ItemIO.Send(mapItem, writer, true);
}
public static void SendCraftRequest(int heart, List <Item> toWithdraw, Item result)
{
if (Main.netMode == 1)
{
ModPacket packet = MagicStorage.Instance.GetPacket();
packet.Write((byte)MessageType.CraftRequest);
packet.Write(heart);
packet.Write(toWithdraw.Count);
foreach (Item item in toWithdraw)
{
ItemIO.Send(item, packet, true);
}
ItemIO.Send(result, packet, true);
packet.Send();
}
}
public static void SendCraftRequest(int heart, int craftingAccess, List <Item> toWithdraw, Item result)
{
if (Main.netMode == NetmodeID.MultiplayerClient)
{
ModPacket packet = MagicStorageTwo.Instance.GetPacket();
packet.Write((byte)MessageType.CraftRequest);
packet.Write(heart);
packet.Write(craftingAccess);
packet.Write(toWithdraw.Count);
foreach (Item item in toWithdraw)
{
ItemIO.Send(item, packet, true);
}
ItemIO.Send(result, packet, true);
packet.Send();
}
}
private void HandleSlotChange(int owner, SlotKind kind, int slot)
{
if (Main.netMode == 2)
{
ModPacket packet = NetRouter.GetPacketTo(this, mod);
packet.Write(owner);
packet.Write((byte)kind);
packet.Write(slot);
Item[] targetInventory = GetInventoryFromKind(owner, kind);
ItemIO.Send(targetInventory[slot], packet, true, true);
packet.Send();
}
else if (Main.netMode == 0)
{
Recipe.FindRecipes();
}
}
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);
}
protected override void SendData(BinaryWriter writer, TEStorageUnit unit)
{
ItemIO.Send(data, writer, true, false);
}
public override void NetSend(BinaryWriter writer, bool lightSend)
{
ItemIO.Send(item, writer);
}
public override void NetSend(BinaryWriter writer) => ItemIO.Send(item, writer, 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 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);
}
