public static void ReceiveCablePlacement(BinaryReader reader, int sender)
{
TagCompound tag = TagIO.Read(reader);
Point16 position = tag.Get <Point16>("Position");
string name = tag.GetString("Name");
Cable cable = new Cable();
cable.SetDefaults(name);
cable.position = position;
cable.layer = PTWorld.Instance.layer;
cable.grid = new CableGrid
{
energy = new EnergyStorage(cable.MaxIO * 2, cable.MaxIO),
tiles = new List <Cable> {
cable
}
};
PTWorld.Instance.layer.Add(position, cable);
cable.Merge();
cable.Frame();
foreach (Cable merge in Cable.sides.Select(x => x + position).Where(PTWorld.Instance.layer.ContainsKey).Select(x => PTWorld.Instance.layer[x]).Where(x => x.name == name))
{
merge.Frame();
}
if (Main.netMode == NetmodeID.Server)
{
SendCablePlacement(cable, sender);
}
}
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
int messageID = reader.ReadByte();
if (messageID == 0)
{
int player = reader.ReadByte();
if (Main.netMode == NetmodeID.Server || player != Main.myPlayer)
{
Main.player[player].GetModPlayer <PartsPlayer>().parts = TagIO.Read(reader);
return;
}
}
if (messageID == 1)
{
int player = reader.ReadByte();
int info = reader.ReadInt32();
if (Main.netMode == NetmodeID.Server || player != Main.myPlayer)
{
PartsPlayer pl = Main.player[player].GetModPlayer <PartsPlayer>();
pl.ZoneFakeGranite = ((info & 0x1) != 0);
pl.ZoneRealGranite = ((info & 0x2) != 0);
pl.ZoneFakeMarble = ((info & 0x4) != 0);
pl.ZoneRealMarble = ((info & 0x8) != 0);
pl.ZoneFakeSpiderCave = ((info & 0x10) != 0);
pl.ZoneRealSpiderCave = ((info & 0x20) != 0);
}
}
}
public static void SyncQEReceive(BinaryReader reader, int sender)
{
if (Main.netMode == NetmodeID.Server)
{
PortableStorage.Instance.GetModWorld <PSWorld>().Load(TagIO.Read(reader));
}
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
TagCompound tag = TagIO.Read(reader);
energy = new EnergyCore(tag.GetAsInt("maxEnergy"));
energy.addEnergy(tag.GetAsInt("energy"));
}
public static void ReceiveGridReform(BinaryReader reader, int sender)
{
TagCompound tag = TagIO.Read(reader);
Cable cable = PTWorld.Instance.layer[tag.Get <Point16>("Position")];
cable.grid.ReformGrid();
if (Main.netMode == NetmodeID.Server)
{
SendGridReform(cable, sender);
}
}
public static void ReceiveGridMerge(BinaryReader reader, int sender)
{
TagCompound tag = TagIO.Read(reader);
Cable cable1 = PTWorld.Instance.layer[tag.Get <Point16>("Position1")];
Cable cable2 = PTWorld.Instance.layer[tag.Get <Point16>("Position2")];
cable1.grid.MergeGrids(cable2.grid);
if (Main.netMode == NetmodeID.Server)
{
SendGridMerge(cable1, cable2, sender);
}
}
public static void ReceiveCableModification(BinaryReader reader, int sender)
{
TagCompound tag = TagIO.Read(reader);
Cable cable = PTWorld.Instance.layer[tag.Get <Point16>("Position")];
cable.connections = tag.GetList <bool>("Connections").ToList();
cable.IO = (IO)tag.GetInt("IO");
cable.Frame();
if (Main.netMode == NetmodeID.Server)
{
SendCableModification(cable, sender);
}
}
public static void ReceiveGridEnergy(BinaryReader reader, int sender)
{
TagCompound tag = TagIO.Read(reader);
Point16 position = tag.Get <Point16>("Position");
long delta = tag.GetLong("Energy");
if (PTWorld.Instance.layer.ContainsKey(position))
{
PTWorld.Instance.layer[position].grid.energy.ModifyEnergyStored(delta);
if (Main.netMode == NetmodeID.Server)
{
SendGridEnergy(position, delta, sender);
}
}
}
public static void ReceiveCableRemovement(BinaryReader reader, int sender)
{
Cable cable = PTWorld.Instance.layer[TagIO.Read(reader).Get <Point16>("Position")];
cable.grid.RemoveTile(cable);
PTWorld.Instance.layer.Remove(cable.position);
foreach (Point16 point in Cable.sides.Select(x => x + cable.position).Where(x => PTWorld.Instance.layer.ContainsKey(x)))
{
PTWorld.Instance.layer[point].Frame();
}
if (Main.netMode == NetmodeID.Server)
{
SendCableRemovement(cable, sender);
}
}
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
int type = reader.ReadByte();
if (type == 1)
{
int vmID = reader.ReadInt16();
if (VendingMachineWorld.vm[vmID] == null)
{
VendingMachineWorld.vm[vmID] = new VendingMachineData();
//VendingMachineWorld.vm[vmID].Load(TagIO.Read(reader));
}
TagCompound vmTag = TagIO.Read(reader);
VendingMachineWorld.vm[vmID].Load(vmTag);
if (Main.netMode == 2)
{
ModPacket p = this.GetPacket();
p.Write((byte)1);
p.Write((short)vmID);
TagIO.Write(vmTag, p);
p.Send();
}
}
if (type == 2)
{
int vmID = reader.ReadInt16();
if (VendingMachineWorld.vm[vmID] != null && !VendingMachineWorld.vm[vmID].isClear())
{
WorldGen.KillTile(VendingMachineWorld.vm[vmID].x, VendingMachineWorld.vm[vmID].y);
//VendingMachineWorld.vm[vmID] = null;
}
if (Main.netMode == 2)
{
ModPacket p = this.GetPacket();
p.Write((byte)2);
p.Write((short)vmID);
p.Send();
}
}
}
public override void NetRecieve(BinaryReader reader) => Load(TagIO.Read(reader));
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
int messageID = reader.ReadByte();
Logger.Info("Received Message id " + messageID);
/*message 0: Share research with server (not used)
* int Player
* TAGCompound Research*/
if (messageID == 0)
{
int player = reader.ReadByte();
if (Main.netMode == NetmodeID.Server || player != Main.myPlayer)
{
TagCompound tempResearch = TagIO.Read(reader);
foreach (KeyValuePair <string, object> read in tempResearch)
{
Main.player[player].GetModPlayer <ResearchPlayer>().research[read.Key] = tempResearch.GetAsInt(read.Key);
}
Main.player[player].GetModPlayer <ResearchPlayer>().dirtyCache = true;
Main.player[player].GetModPlayer <ResearchPlayer>().RebuildCache();
return;
}
}
/*message 1: dirty cache
* int player
* refreshes the cache*/
if (messageID == 1)
{
int player = reader.ReadByte();
Main.player[player].GetModPlayer <ResearchPlayer>().dirtyCache = true;
Main.player[player].GetModPlayer <ResearchPlayer>().RebuildCache();
return;
}
/*message 10 : P2P item cache sharing
* byte player
* int count
* int[count] itemIDs
* Share the cache with another player. Meant to share multiple, fully researched items at once.
* Will send another such message to the sender (with this whoAmI) with the researched items,
* and will keep sending them to one another until the cache is equal*/
if (messageID == 10) //Shared item Cache
{
ResearchPlayer rp = Main.player[Main.myPlayer].GetModPlayer <ResearchPlayer>();
int sendTo = reader.ReadByte();
//Logger.Info("Received shared cache Message to "+i);
List <int> oldCache = new List <int>();
oldCache.AddRange(rp.researchedCache);
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
int id = reader.ReadInt32();
if (!rp.IsResearched(id))
{
rp.AddResearchedAmount(id, ResearchTable.GetTotalResearch(id));
rp.CheckRecipesForItem(id);
}
}
if (Main.netMode == NetmodeID.Server || sendTo != Main.myPlayer)
{
rp.shareCacheTo(sendTo);
}
return;
}
/*message 11: Share single item with intermediate result
* byte player to send to
* byte player that sent the message
* int item
* int research count
*
* Adds the research count to the player's research, and replies with the same message with its previous research count
*/
if (messageID == 11)
{
ResearchPlayer rp = Main.player[Main.myPlayer].GetModPlayer <ResearchPlayer>();
int sendTo = reader.ReadByte();
int orgSender = reader.ReadByte();
int itm = reader.ReadInt32();
int amount = reader.ReadInt32();
int prevResearch = rp.GetResearchedAmount(itm);
int res = rp.AddResearchedAmount(itm, amount);
if (Main.netMode == NetmodeID.Server)
{
ModPacket pk = GetPacket();
pk.Write((byte)11);
pk.Write((byte)(sendTo));
pk.Write((byte)(orgSender));
pk.Write(itm);
pk.Write(amount);
pk.Send(sendTo);
return;
}
//Logger.Info("Received share single item Message from " + sender + ". Item " + itm + " with amount "+ amount);
if (rp.IsResearched(itm) && res != amount)
{
rp.CheckRecipesForItem(itm);
//Logger.Info("Item "+ itm + " was fully researched with " + amount);
rp.RebuildCache();
if (orgSender == Main.myPlayer)
{
return;
}
ModPacket pk = GetPacket();
pk.Write((byte)11);
pk.Write((byte)(orgSender));
pk.Write((byte)(orgSender));
pk.Write(itm);
pk.Write(prevResearch + amount);
pk.Send();
}
else
{
//Logger.Info("Item " + itm + " was not fully researched with " + amount);
}
return;
}
/*message 12: Share prefixes
* byte player to send to
* int itm
* int count
* byte[count] prefixes
*
* Sends all prefixes for item itm, with no replies. Only adds prefixes.*/
if (messageID == 12)
{
ResearchPlayer rp = Main.player[Main.myPlayer].GetModPlayer <ResearchPlayer>();
int sendTo = reader.ReadByte();
int itm = reader.ReadInt32();
int count = reader.ReadInt32();
List <byte> prefixes = new List <byte>();
for (int i = 0; i < count; i++)
{
byte p = reader.ReadByte();
prefixes.Add(p);
rp.AddResearchPrefix(itm, p);
}
if (Main.netMode == NetmodeID.Server)
{
ModPacket pk = GetPacket();
pk.Write((byte)12);
pk.Write((byte)(sendTo));
pk.Write(prefixes.Count);
for (int k = 0; k < prefixes.Count; k++)
{
pk.Write((byte)(prefixes[k]));
}
pk.Send(sendTo);
}
return;
}
if (messageID == 99)
{
int player = reader.ReadByte();
ResearchTable.InitResearchTable();
if (Main.netMode == NetmodeID.Server)
{
ModPacket pk = this.GetPacket();
pk.Write((byte)99);
pk.Write((byte)player);
pk.Send(-1, player);
ModContent.GetInstance <ExceptionListConfig>().forceReload = false;
SaveListConfig();
}
else
{
Main.player[Main.myPlayer].GetModPlayer <ResearchPlayer>().RebuildCache();
}
ModContent.GetInstance <ExceptionListConfig>().forceReload = false;
return;
}
}
public override void NetReceive(BinaryReader reader, bool lightReceive) => Load(TagIO.Read(reader));
public override void NetRecieve(BinaryReader reader)
{
data = TagIO.Read(reader);
modName = data.GetString("mod");
itemName = data.GetString("name");
}
/// <summary>
/// Do not override this method to class work correctly.
/// </summary>
public override void Receive(BinaryReader reader)
{
SavedDimensionsTag = TagIO.Read(reader) ?? new TagCompound();
}
public override void NetReceive(BinaryReader reader)
{
Setup(TagIO.Read(reader));
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
Load(TagIO.Read(reader));
timer = reader.ReadInt32();
}
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
int type = reader.ReadByte();
if (type == 1)
{
int playerID = reader.ReadByte();
int slot = reader.ReadByte();
int chest = reader.ReadInt32();
int x = reader.ReadInt32();
int y = reader.ReadInt32();
TagCompound bagContents = TagIO.Read(reader);
if (Main.netMode == NetmodeID.Server)
{
GenericHoldingBag bag = Main.player[playerID].inventory[slot].modItem as GenericHoldingBag;
if (bag == null)
{
bag = new TrueOmniBag();
}
bag.items = bagContents;
if (chest > -1)
{
int trueChest = GenericHoldingBag.getChestAtTarget(x, y);
if (Main.chest[trueChest] != null && !GenericHoldingBag.IsPlayerInChest(trueChest) && !Chest.isLocked(Main.chest[trueChest].x, Main.chest[trueChest].y))
{
bag.emptyBagOnInventory(Main.player[playerID], Main.chest[trueChest].item, trueChest);
}
}
else
{
bag.emptyBagOnMagicStorage(Main.player[playerID], x, y);
}
bagContents = bag.items;
}
ModPacket p = GetPacket();
p.Write((byte)2);
p.Write((byte)playerID);
p.Write((byte)slot);
TagIO.Write(bagContents, p);
p.Send(playerID);
return;
}
if (type == 2)
{
int playerID = reader.ReadByte();
int slot = reader.ReadByte();
TagCompound bagContents = TagIO.Read(reader);
GenericHoldingBag bag = Main.player[playerID].inventory[slot].modItem as GenericHoldingBag;
if (bag != null)
{
bag.items.Clear();
foreach (KeyValuePair <string, object> k in bagContents)
{
bag.items.Add(k);
}
}
}
if (type == 3)
{
if (Main.netMode == NetmodeID.MultiplayerClient)
{
int flags = reader.ReadByte();
BagPlayer pl = Main.player[Main.myPlayer].GetModPlayer <BagPlayer>();
pl.checkAccessories = (flags & 1) == 1;
pl.checkVanity = (flags & 2) == 2;
pl.checkHotbar = (flags & 4) == 4;
pl.checkInventory = (flags & 8) == 1;
pl.tryPlace = (flags & 16) == 1;
}
}
/*
* if(type == 4) // check Order lists with server
* {
* if (Main.netMode == NetmodeID.Server) {
* int player = reader.ReadByte();
*
* ulong dirtBagHash = reader.ReadUInt64();
* ulong oreBagHash = reader.ReadUInt64();
* ulong gemBagHash = reader.ReadUInt64();
*
* GenericHoldingBag bg = new DirtBag();
* bool anyBag = false;
* if (dirtBagHash != bg.getOrderHashCode())
* {
* sendBagOrder(player, bg);
* anyBag = true;
* }
* bg = new OreBag();
* if(oreBagHash != bg.getOrderHashCode())
* {
* sendBagOrder(player, bg);
* anyBag = true;
* }
* bg = new GemBag();
* if (gemBagHash != bg.getOrderHashCode())
* {
* sendBagOrder(player, bg);
* anyBag = true;
* }
*
* if (anyBag)
* {
* ModPacket pk = GetPacket();
* pk.Write((byte)5);
* pk.Write((byte)new OmniBag().bagID);
* pk.Send(player);
* }
*
* }
*
*
*
* }
*
* if(type == 5) // Clear order and not pickup list for this bag
* {
* if(Main.netMode == NetmodeID.MultiplayerClient)
* {
* GenericHoldingBag bg = getBagFromID(reader.ReadByte());
* bg.order.Clear();
* bg.preventPickup.Clear();
* }
* }
* if(type == 6) // add String to order list;
* {
*
* }
* if(type == 7) // add String to not pickup
* {
*
* }
*/
}
public static IList <Item> Read(this BinaryReader reader) => Load(TagIO.Read(reader));
