From 0427ab89f1753a44b30cbc35ce021cbbdc845109 Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Thu, 10 Aug 2017 18:52:45 +0300 Subject: fix missing source folder --- src/main/java/ihl/utils/IHLFluidTank.java | 322 ++++++++++++++++++++++++++++++ 1 file changed, 322 insertions(+) create mode 100644 src/main/java/ihl/utils/IHLFluidTank.java (limited to 'src/main/java/ihl/utils/IHLFluidTank.java') diff --git a/src/main/java/ihl/utils/IHLFluidTank.java b/src/main/java/ihl/utils/IHLFluidTank.java new file mode 100644 index 0000000..67597e1 --- /dev/null +++ b/src/main/java/ihl/utils/IHLFluidTank.java @@ -0,0 +1,322 @@ +package ihl.utils; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import ihl.recipes.IRecipeInputFluid; +import ihl.worldgen.ores.IHLFluid; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; + +public class IHLFluidTank implements IFluidTank { + private final List fluidList = new ArrayList(); + private final int capacity; + + public IHLFluidTank(int capacity) { + this.capacity = capacity; + } + + public IHLFluidTank(int capacity, boolean isOpenVessel1) { + this.capacity = capacity; + } + + public IHLFluidTank readFromNBT(NBTTagCompound nbt) { + if (!nbt.hasKey("Empty")) { + NBTTagList fluidList1 = nbt.getTagList("fluids", 10); + for (int i = 0; i < fluidList1.tagCount(); i++) { + NBTTagCompound fluidNBT1 = fluidList1.getCompoundTagAt(i); + FluidStack fluid = FluidStack.loadFluidStackFromNBT(fluidNBT1); + if (fluid != null) { + fluidList.add(fluid); + } + } + } + return this; + } + + public NBTTagCompound writeToNBT(NBTTagCompound nbt) { + if (!fluidList.isEmpty()) { + NBTTagList fluids = new NBTTagList(); + Iterator fli = fluidList.iterator(); + while (fli.hasNext()) { + FluidStack fluid = fli.next(); + if (fluid != null) { + NBTTagCompound fluidNBT1 = new NBTTagCompound(); + fluid.writeToNBT(fluidNBT1); + fluids.appendTag(fluidNBT1); + } + } + nbt.setTag("fluids", fluids); + } else { + nbt.setString("Empty", ""); + } + return nbt; + } + + /* IFluidTank */ + @Override + public FluidStack getFluid() { + if (this.fluidList.isEmpty()) { + return null; + } + return this.fluidList.get(0); + } + + public FluidStack getLigthestFluid() { + if (this.fluidList.isEmpty()) { + return IHLUtils.getFluidStackWithSize("air", this.capacity); + } + return this.fluidList.get(this.fluidList.size() - 1); + } + + @Override + public int getFluidAmount() { + int amount = 0; + Iterator fli = fluidList.iterator(); + while (fli.hasNext()) { + FluidStack fluid = fli.next(); + if (fluid != null) { + amount += fluid.amount; + } + } + return amount; + } + + @Override + public int getCapacity() { + return capacity; + } + + @Override + public FluidTankInfo getInfo() { + return new FluidTankInfo(this); + } + + @Override + public int fill(FluidStack resource, boolean doFill) { + if (resource == null) + return 0; + int freeSpace = capacity - this.getFluidAmount(); + int amount1 = Math.min(freeSpace, resource.amount); + if (resource.getFluid() == null || amount1<=0) { + return 0; + } + if (!doFill) { + return amount1; + } + FluidStack fluid = getFluidStackWithSameFluid(resource); + if (fluid != null) { + fluid.amount += amount1; + return amount1; + } + fluid = copyWithSize(resource, amount1); + fluidList.add(fluid); + this.sortFluidsByDensity(); + return amount1; + } + + @Override + public FluidStack drain(int maxDrain, boolean doDrain) { + if (fluidList.isEmpty()) { + return null; + } + FluidStack fstack = this.getFluid().copy(); + fstack.amount = maxDrain; + return this.drain(fstack, doDrain); + } + + public FluidStack drainLightest(int maxDrain, boolean doDrain) { + if (fluidList.isEmpty()) { + return null; + } + FluidStack fstack = this.getLigthestFluid().copy(); + fstack.amount = maxDrain; + return this.drain(fstack, doDrain); + } + + public FluidStack drain(Object fluidStack, boolean doDrain) { + if (fluidList.isEmpty()) { + return null; + } + int drained = 0; + if (fluidStack instanceof FluidStack) { + drained = ((FluidStack) fluidStack).amount; + } else { + drained = ((IRecipeInputFluid) fluidStack).getAmount(); + } + FluidStack fluid = this.getFluidStackWithSameFluid(fluidStack); + if (fluid == null) { + return null; + } + if (fluid.amount < drained) { + drained = fluid.amount; + } + FluidStack stack = copyWithSize(fluid, drained); + if (doDrain) { + fluid.amount -= drained; + if (fluid.amount <= 0) { + this.fluidList.remove(fluid); + } + } + return stack; + } + + public FluidStack getFluidStackWithSameFluid(Object fluidStack) { + Iterator fli = fluidList.iterator(); + while (fli.hasNext()) { + FluidStack fluid = fli.next(); + if (fluid != null) { + if (fluidStack instanceof FluidStack) { + if (fluid.isFluidEqual((FluidStack) fluidStack)) { + return fluid; + } + } else { + if (((IRecipeInputFluid) fluidStack).matches(fluid)) { + return fluid; + } + } + } + } + return null; + } + + public int getNumberOfFluids() { + return this.fluidList.size(); + } + + public void setFluidAmount(int amount1, int index) { + if (this.fluidList.size() <= index) { + while (this.fluidList.size() <= index) { + this.fluidList.add(new FluidStack(FluidRegistry.WATER, 1)); + } + } + this.fluidList.get(index).amount = amount1; + } + + public int getFluidAmount(int index) { + if (this.fluidList.size() <= index || this.fluidList.get(index) == null) { + return 0; + } + return this.fluidList.get(index).amount; + } + + public int getFluidID(int i) { + if (this.fluidList.get(i) == null) { + return -1; + } + return this.fluidList.get(i).getFluid().getID(); + } + + public void sortFluidsByDensity() { + Map sortMap = new HashMap(); + int[] keysArray = new int[fluidList.size()]; + Iterator fli = fluidList.iterator(); + while (fli.hasNext()) { + FluidStack fluid = fli.next(); + if (fluid == null) { + return; + } + int key = Math.round(IHLFluid.getRealDensity(fluid.getFluid()) * 100F); + while (sortMap.containsKey(key)) { + key++; + } + sortMap.put(key, fluid); + keysArray[fluidList.indexOf(fluid)] = key; + } + Arrays.sort(keysArray); + ArrayList newFluidList = new ArrayList(); + for (int i = keysArray.length - 1; i >= 0; i--) { + newFluidList.add(sortMap.get(keysArray[i])); + } + this.fluidList.clear(); + this.fluidList.addAll(newFluidList); + } + + public FluidStack getFluid(int i) { + return this.fluidList.get(i); + } + + public void setTag(String string, int t1_1) { + if (this.getFluid().tag == null) { + this.getFluid().tag = new NBTTagCompound(); + } + this.getFluid().tag.setInteger(string, t1_1); + } + + public void setEmpty() { + this.fluidList.clear(); + } + + public List getFluidList() { + return this.fluidList; + } + + public void drain(List fluidInputs, boolean doDrain) { + if (fluidInputs != null && !fluidInputs.isEmpty()) { + Iterator fsi = fluidInputs.iterator(); + while (fsi.hasNext()) { + this.drain(fsi.next(), doDrain); + } + } + } + + public void fill(List fluidOutputs, boolean doFill) { + if (fluidOutputs != null && !fluidOutputs.isEmpty()) { + Iterator fsi = fluidOutputs.iterator(); + while (fsi.hasNext()) { + this.fill(fsi.next(), doFill); + } + } + } + + private FluidStack copyWithSize(FluidStack resource, int amount1) { + FluidStack fluid = resource.copy(); + fluid.amount = amount1; + if (resource.tag != null) { + fluid.tag = (NBTTagCompound) resource.tag.copy(); + } + return fluid; + } + + public FluidStack drain(IRecipeInputFluid fluidStack, int amount, boolean doDrain) { + if (fluidList.isEmpty()) { + return null; + } + int drained = amount; + FluidStack fluid = this.getFluidStackWithSameFluid(fluidStack); + if (fluid == null) { + return null; + } + if (fluid.amount < drained) { + drained = fluid.amount; + } + FluidStack stack = copyWithSize(fluid, drained); + if (doDrain) { + fluid.amount -= drained; + if (fluid.amount <= 0) { + this.fluidList.remove(fluid); + } + } + return stack; + } + + public void checkCorrectState() { + if (!this.fluidList.isEmpty()) { + Iterator fsi = this.fluidList.iterator(); + while (fsi.hasNext()) { + FluidStack fs = fsi.next(); + if (fs.amount <= 0) { + fsi.remove(); + } + } + } + } +} -- cgit v1.2.3