private void DoDeposit(Item item)
{
if (Main.netMode == NetmodeID.SinglePlayer)
{
heart.DepositItem(item);
}
else
{
NetHelper.SendDeposit(heart.ID, item);
item.SetDefaults(0, true);
}
}
private static void DoDeposit(Item item)
{
TEStorageHeart heart = GetHeart();
if (Main.netMode == 0)
{
heart.DepositItem(item);
}
else
{
NetHelper.SendDeposit(heart.ID, item);
item.SetDefaults(0, true);
}
}
internal List <Item> DoCraft(TEStorageHeart heart, List <Item> toWithdraw, Item result)
{
List <Item> items = new List <Item>();
foreach (Item tryWithdraw in toWithdraw)
{
Item withdrawn = heart.TryWithdraw(tryWithdraw);
if (!withdrawn.IsAir)
{
items.Add(withdrawn);
}
if (withdrawn.stack < tryWithdraw.stack)
{
for (int k = 0; k < items.Count; k++)
{
heart.DepositItem(items[k]);
if (items[k].IsAir)
{
items.RemoveAt(k);
k--;
}
}
return(items);
}
}
items.Clear();
heart.DepositItem(result);
if (!result.IsAir)
{
items.Add(result);
}
return(items);
}
public bool InjectItem(int x, int y, Item item)
{
int oldstack = item.stack;
TEStorageHeart targetHeart = FindHeart(x, y);
if (targetHeart == null)
{
return(false);
}
targetHeart.DepositItem(item);
if (oldstack != item.stack)
{
HandleStorageItemChange(targetHeart);
return(true);
}
return(false);
}
public static bool TryDepositAll()
{
Player player = Main.player[Main.myPlayer];
TEStorageHeart heart = StoragePlayer.GetStorageHeart();
bool changed = false;
if (Main.netMode == 0)
{
for (int k = 10; k < 50; k++)
{
if (!player.inventory[k].IsAir && !player.inventory[k].favorited)
{
int oldStack = player.inventory[k].stack;
heart.DepositItem(player.inventory[k]);
if (oldStack != player.inventory[k].stack)
{
changed = true;
}
}
}
}
else
{
List <Item> items = new List <Item>();
for (int k = 10; k < 50; k++)
{
if (!player.inventory[k].IsAir && !player.inventory[k].favorited)
{
items.Add(player.inventory[k]);
}
}
NetHelper.SendDepositAll(heart.ID, items);
foreach (Item item in items)
{
item.SetDefaults(0, true);
}
changed = true;
items.Clear();
}
return(changed);
}
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 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);
}
public static bool TryQuickStack(bool stackToCurrentlyOpenIfNotSearchForNearbyAccess)
{
Player player = Main.player[Main.myPlayer];
if (player.IsStackingItems())
{
return(false);
}
TEStorageHeart heart = StoragePlayer.GetStorageHeart();
if (!stackToCurrentlyOpenIfNotSearchForNearbyAccess)
{
// Vanilla quick stack to all chests is approximately a circle with radius 12.5
for (int i = -13; i <= 13; i++)
{
for (int j = -13; j <= 13; j++)
{
int x = (int)player.position.X / 16 + i;
int y = (int)player.position.Y / 16 + j;
Tile tile = Main.tile[x, y];
if (tile == null)
{
continue;
}
if (tile.frameX % 36 == 18)
{
x--;
}
if (tile.frameY % 36 == 18)
{
y--;
}
int tileType = tile.type;
ModTile modTile = TileLoader.GetTile(tileType);
if (modTile == null || !(modTile is StorageAccess))
{
continue;
}
if ((player.Center - new Vector2(x, y) * 16).Length() < 200)
{
heart = ((StorageAccess)modTile).GetHeart(x, y);
}
}
}
}
if (heart == null)
{
return(false);
}
List <Item> items = new List <Item>();
for (int k = 10; k < 50; k++)
{
var item = player.inventory[k];
if (!item.IsAir && !item.favorited)
{
if (heart.HasItem(item, true))
{
items.Add(player.inventory[k]);
}
}
}
if (Main.netMode == 0)
{
foreach (Item item in items)
{
heart.DepositItem(item);
}
}
else
{
NetHelper.SendDepositAll(heart.ID, items);
foreach (Item item in items)
{
item.SetDefaults(0, true);
}
}
// Play the stash sound
// The if is here so minimize IL hacking in DrawInventory...
if (items.Count != 0 && !stackToCurrentlyOpenIfNotSearchForNearbyAccess)
{
Main.PlaySound(7, -1, -1, 1, 1f, 0f);
}
return(items.Count != 0);
}
public static void ReceiveStorageOperation(BinaryReader reader, int sender)
{
int ent = reader.ReadInt32();
byte op = reader.ReadByte();
/*
* if (Main.netMode == NetmodeID.Server)
* Console.WriteLine($"Receiving Storage Operation {op} from entity {ent}");
* else
* Main.NewText($"Receiving Storage Operation {op} from entity {ent}");
*/
if (Main.netMode != 2)
{
//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 == 3)
{
int count = reader.ReadByte();
for (int i = 0; i < count; i++)
{
ItemIO.Receive(reader, true);
}
}
return;
}
if (!TileEntity.ByID.ContainsKey(ent) || !(TileEntity.ByID[ent] is TEStorageHeart))
{
return;
}
TEStorageHeart heart = (TEStorageHeart)TileEntity.ByID[ent];
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);
}
