public override bool PreDraw(int i, int j, SpriteBatch spriteBatch)
{
int ID = mod.GetID <TEQETank>(i, j);
if (ID == -1)
{
return(false);
}
Tile tile = Main.tile[i, j];
if (tile.TopLeft())
{
Vector2 zero = new Vector2(Main.offScreenRange, Main.offScreenRange);
if (Main.drawToScreen)
{
zero = Vector2.Zero;
}
Vector2 position = new Vector2(i * 16 - (int)Main.screenPosition.X, j * 16 - (int)Main.screenPosition.Y) + zero;
TEQETank qeTank = (TEQETank)TileEntity.ByID[ID];
ModFluid fluid = qeTank.GetFluid();
if (fluid != null)
{
spriteBatch.Draw(ModLoader.GetTexture(FluidLoader.GetFluid(fluid.Name).Texture), new Rectangle((int)position.X + 6, (int)(position.Y + 6 + (20 - 20 * (fluid.volume / (float)TEQETank.MaxVolume))), 20, (int)(20 * (fluid.volume / (float)TEQETank.MaxVolume))), null, Color.White, 0f, Vector2.Zero, SpriteEffects.None, 0f);
}
}
return(true);
}
public override void Load(TagCompound tag)
{
if (tag.ContainsKey("Items"))
{
if (tag.ContainsKey("Frequencies"))
{
IList <Frequency> frequencies = tag.GetList <Frequency>("Frequencies");
IList <List <Item> > items = tag.GetList <List <Item> >("Items");
enderItems = frequencies.Zip(items, (frequency, list) => new KeyValuePair <Frequency, List <Item> >(frequency, list)).ToDictionary(x => x.Key, x => x.Value);
}
else
{
List <TagCompound> tags = tag.GetList <TagCompound>("Items").ToList();
enderItems = tags.Select(x => new KeyValuePair <Frequency, List <Item> >(x.Get <Frequency>("Frequency"), x.GetList <Item>("Items").ToList())).ToDictionary(x => x.Key, x => x.Value);
}
}
if (tag.ContainsKey("KeysFluids") && tag.ContainsKey("ValuesFluids"))
{
IList <Frequency> keysFluids = tag.GetList <Frequency>("KeysFluids");
IList <ModFluid> valuesFluids = tag.GetList <ModFluid>("ValuesFluids");
enderFluids = keysFluids.Zip(valuesFluids, (freq, list) => new KeyValuePair <Frequency, ModFluid>(freq, list)).ToDictionary(x => x.Key, x => x.Value);
}
else if (tag.ContainsKey("Fluids"))
{
List <TagCompound> tags = tag.GetList <TagCompound>("Fluids").ToList();
enderFluids = tags.Select(x =>
{
TagCompound fluidTag = x.Get <TagCompound>("Fluid");
ModFluid fluid = TheOneLibrary.Utility.Utility.SetDefaults(fluidTag.GetString("Type"));
fluid.volume = fluidTag.GetInt("Volume");
return(new KeyValuePair <Frequency, ModFluid>(x.Get <Frequency>("Frequency"), fluid));
}).ToDictionary(x => x.Key, x => x.Value);
}
}
public static ModFluid SetDefaults(string name)
{
ModFluid fluid = FluidLoader.fluidNames[name].NewInstance();
fluid.SetDefaults();
fluid.SetStaticDefaults();
return(fluid);
}
public static ModFluid SetDefaults(int type)
{
ModFluid fluid = FluidLoader.fluids.First(x => x.type == type).NewInstance();
fluid.SetDefaults();
fluid.SetStaticDefaults();
return(fluid);
}
public void SetFluidStorage(Frequency frequency, ModFluid value)
{
if (!enderFluids.ContainsKey(frequency))
{
enderFluids.Add(frequency, null);
Net.SyncQE();
}
enderFluids[frequency] = value;
}
public static ModFluid CopyFluidWithSize(ModFluid fluid, int size)
{
if (size == 0)
{
return(null);
}
ModFluid copy = fluid.Clone();
copy.volume = fluid.volume;
return(copy);
}
public override void LeftClickCont(int i, int j)
{
int ID = mod.GetID <TEQETank>(i, j);
if (ID == -1)
{
return;
}
TEQETank qeTank = (TEQETank)TileEntity.ByID[ID];
if (Main.LocalPlayer.HeldItem.modItem is IFluidContainerItem) // extract fluid
{
IFluidContainerItem fluidContainer = (IFluidContainerItem)Main.LocalPlayer.HeldItem.modItem;
ModFluid fluid = qeTank.GetFluid();
ModFluid itemFluid = fluidContainer.GetFluid();
int capacity = fluidContainer.GetFluidCapacity();
if (fluid != null)
{
if (itemFluid == null)
{
itemFluid = TheOneLibrary.Utility.Utility.SetDefaults(fluid.type);
int volume = Math.Min(fluid.volume, capacity - itemFluid.volume);
itemFluid.volume += volume;
fluid.volume -= volume;
if (fluid.volume <= 0)
{
fluid = null;
}
}
else if (fluid.type == itemFluid.type && itemFluid.volume < capacity)
{
int volume = Math.Min(fluid.volume, capacity - itemFluid.volume);
itemFluid.volume += volume;
fluid.volume -= volume;
if (fluid.volume <= 0)
{
fluid = null;
}
}
}
fluidContainer.SetFluid(itemFluid);
qeTank.SetFluid(fluid);
NetUtility.SyncItem(fluidContainer.GetItem().item);
Net.SyncQE();
}
}
public ModFluid InsertFluid(int slot, ModFluid fluid, bool simulate = false)
{
if (fluid == null)
{
return(null);
}
ValidateSlotIndex(slot);
if (!IsFluidValid(this, slot, fluid))
{
return(fluid);
}
ModFluid existing = Fluids[slot];
int limit = GetVolumeLimit(slot);
if (existing != null)
{
if (!fluid.Equals(existing))
{
return(fluid);
}
limit -= existing.volume;
}
if (limit <= 0)
{
return(fluid);
}
bool reachedLimit = fluid.volume > limit;
if (!simulate)
{
if (existing == null)
{
Fluids[slot] = reachedLimit ? CopyFluidWithSize(fluid, limit) : fluid;
}
else
{
this.Grow(slot, reachedLimit ? limit : fluid.volume);
}
OnContentsChanged(slot);
}
return(reachedLimit ? CopyFluidWithSize(fluid, fluid.volume - limit) : null);
}
public void AddFluid(string fluid, int volume = 1, int tanks = -1)
{
ModFluid modFluid = FluidLoader.GetFluid(fluid).NewInstance();
modFluid.volume = volume;
if (tanks == -1)
{
requiredFluids.Add(modFluid);
}
else
{
requiredFluids[tanks] = modFluid;
}
}
internal static void ReceiveFluid(BinaryReader reader, int whoAmI)
{
Frequency frequency = reader.ReadFrequency();
int slot = reader.ReadInt32();
ModFluid fluid = reader.ReadFluid();
FluidPair pair = ModContent.GetInstance <QSWorld>().QEFluidHandlers.FirstOrDefault(fluidPair => Equals(fluidPair.Frequency, frequency));
pair?.Handler.SetFluidInSlot(slot, fluid);
if (Main.netMode == NetmodeID.Server)
{
SendFluid(frequency, slot, whoAmI);
}
}
public FluidHandler Load(TagCompound tag)
{
SetSize(tag.ContainsKey("Count") ? tag.GetInt("Count") : Slots);
foreach (TagCompound compound in tag.GetList <TagCompound>("Fluids"))
{
ModFluid fluid = compound.Get <ModFluid>("Fluid");
int slot = compound.GetInt("Slot");
if (slot >= 0 && slot < Slots)
{
Fluids[slot] = fluid;
}
}
return(this);
}
public ModFluid ExtractFluid(int slot, int volume, bool simulate = false)
{
if (volume == 0)
{
return(null);
}
ValidateSlotIndex(slot);
ModFluid existing = Fluids[slot];
if (existing == null)
{
return(null);
}
int toExtract = Math.Min(volume, GetVolumeLimit(slot));
if (existing.volume <= toExtract)
{
if (!simulate)
{
Fluids[slot] = null;
OnContentsChanged(slot);
}
return(existing);
}
if (!simulate)
{
Fluids[slot] = CopyFluidWithSize(existing, existing.volume - toExtract);
OnContentsChanged(slot);
}
return(CopyFluidWithSize(existing, toExtract));
}
public void AddFluid(ModFluid fluid, int volume = 1, int tanks = -1) => AddFluid(fluid.Name, volume, tanks);
public void SetFluidInSlot(int slot, ModFluid stack)
{
ValidateSlotIndex(slot);
Fluids[slot] = stack;
OnContentsChanged(slot);
}
public void SetFluid(ModFluid value, int slot = 0) => fluid = value;
public override bool UseItem(Player player)
{
ModFluid fluid = GetFluid();
if (player.altFunctionUse == 2)
{
if (fluid != null)
{
Tile tile = Main.tile[Player.tileTargetX, Player.tileTargetY];
if ((!tile.nactive() || !Main.tileSolid[tile.type] || Main.tileSolidTop[tile.type]) && TileLoader.GetTile(tile.type)?.GetType().GetAttribute <BucketDisablePlacement>() == null)
{
if (tile.liquid == 0 || tile.liquidType() == fluid.type)
{
Main.PlaySound(19, (int)player.position.X, (int)player.position.Y);
if (tile.liquid == 0)
{
tile.liquidType(fluid.type);
}
int volume = Math.Min(fluid.volume, 255 - tile.liquid);
tile.liquid += (byte)volume;
fluid.volume -= volume;
if (fluid.volume == 0)
{
fluid = null;
}
WorldGen.SquareTileFrame(Player.tileTargetX, Player.tileTargetY);
if (Main.netMode == 1)
{
NetMessage.sendWater(Player.tileTargetX, Player.tileTargetY);
}
}
}
}
}
else
{
if (!Main.GamepadDisableCursorItemIcon)
{
player.showItemIcon = true;
Main.ItemIconCacheUpdate(item.type);
}
Tile tile = Main.tile[Player.tileTargetX, Player.tileTargetY];
if ((fluid == null || fluid.type == tile.liquidType()) && tile.liquid > 0 && TileLoader.GetTile(tile.type)?.GetType().GetAttribute <BucketDisablePickup>() == null)
{
Main.PlaySound(19, (int)player.position.X, (int)player.position.Y);
if (fluid == null)
{
fluid = TheOneLibrary.Utility.Utility.SetDefaults(tile.liquidType());
}
int drain = Math.Min(tile.liquid, TEQETank.MaxVolume - fluid.volume);
fluid.volume += drain;
tile.liquid -= (byte)drain;
if (tile.liquid <= 0)
{
tile.lava(false);
tile.honey(false);
}
WorldGen.SquareTileFrame(Player.tileTargetX, Player.tileTargetY, false);
if (Main.netMode == 1)
{
NetMessage.sendWater(Player.tileTargetX, Player.tileTargetY);
}
else
{
Liquid.AddWater(Player.tileTargetX, Player.tileTargetY);
}
}
}
SetFluid(fluid);
return(true);
}
public void SetFluid(ModFluid value, int slot = 0) => mod.GetModWorld <PSWorld>().SetFluidStorage(frequency, value);
public override void RightClickCont(int i, int j)
{
int ID = mod.GetID <TEQETank>(i, j);
if (ID == -1)
{
return;
}
TEQETank qeTank = (TEQETank)TileEntity.ByID[ID];
Point16 topLeft = TheOneLibrary.Utility.Utility.TileEntityTopLeft(i, j);
int realTileX = topLeft.X * 16;
int realTileY = topLeft.Y * 16;
Rectangle left = new Rectangle(realTileX + 2, realTileY + 2, 4, 4);
Rectangle middle = new Rectangle(realTileX + 14, realTileY + 27, 4, 4);
Rectangle right = new Rectangle(realTileX + 26, realTileY + 2, 4, 4);
if (Main.LocalPlayer.HeldItem.type == mod.ItemType <QEBucket>()) // copy frequency
{
Main.LocalPlayer.noThrow = 2;
QEBucket bucket = (QEBucket)Main.LocalPlayer.HeldItem.modItem;
bucket.frequency = qeTank.frequency;
NetUtility.SyncItem(bucket.item);
}
else if (Main.LocalPlayer.HeldItem.modItem is IFluidContainerItem) // insert fluid
{
IFluidContainerItem fluidContainer = (IFluidContainerItem)Main.LocalPlayer.HeldItem.modItem;
ModFluid fluid = qeTank.GetFluid();
ModFluid itemFluid = fluidContainer.GetFluid();
if (itemFluid != null)
{
if (fluid == null)
{
fluid = TheOneLibrary.Utility.Utility.SetDefaults(itemFluid.type);
int volume = Math.Min(itemFluid.volume, TEQETank.MaxVolume - fluid.volume);
fluid.volume += volume;
itemFluid.volume -= volume;
if (itemFluid.volume <= 0)
{
itemFluid = null;
}
}
else if (fluid.type == itemFluid.type && fluid.volume < TEQETank.MaxVolume)
{
int volume = Math.Min(itemFluid.volume, TEQETank.MaxVolume - fluid.volume);
fluid.volume += volume;
itemFluid.volume -= volume;
if (itemFluid.volume <= 0)
{
itemFluid = null;
}
}
}
fluidContainer.SetFluid(itemFluid);
qeTank.SetFluid(fluid);
NetUtility.SyncItem(fluidContainer.GetItem().item);
Net.SyncQE();
}
else // general click
{
Frequency frequency = qeTank.frequency;
bool handleFrequency = false;
if (left.Contains(Main.MouseWorld))
{
frequency.colorLeft = Utility.ColorFromItem(frequency.colorLeft);
handleFrequency = true;
}
else if (middle.Contains(Main.MouseWorld))
{
frequency.colorMiddle = Utility.ColorFromItem(frequency.colorMiddle);
handleFrequency = true;
}
else if (right.Contains(Main.MouseWorld))
{
frequency.colorRight = Utility.ColorFromItem(frequency.colorRight);
handleFrequency = true;
}
if (handleFrequency)
{
qeTank.frequency = frequency;
}
qeTank.SendUpdate();
}
}
