From 05c78126859231a68e199dc34613689bd0978e2f Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Mon, 11 Apr 2016 19:44:54 +0300 Subject: Initial commit --- ihl/utils/IHLFluidTank.java | 439 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 439 insertions(+) create mode 100644 ihl/utils/IHLFluidTank.java (limited to 'ihl/utils/IHLFluidTank.java') diff --git a/ihl/utils/IHLFluidTank.java b/ihl/utils/IHLFluidTank.java new file mode 100644 index 0000000..aef2b46 --- /dev/null +++ b/ihl/utils/IHLFluidTank.java @@ -0,0 +1,439 @@ +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; + private boolean isOpenVessel=false; + private int temperature=293; + + public IHLFluidTank(int capacity) + { + this.capacity = capacity; + } + + public IHLFluidTank(int capacity, boolean isOpenVessel1) + { + this.isOpenVessel=isOpenVessel1; + this.capacity = capacity; + } + + public IHLFluidTank readFromNBT(NBTTagCompound nbt) + { + if (!nbt.hasKey("Empty")) + { + NBTTagList fluidList1 = nbt.getTagList("fluids", 10); + for(int i=0;i 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); + nbt.setInteger("temperature", temperature); + } + 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 null; + } + 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 || resource.getFluid() == null || resource.amount<=0) + { + return 0; + } + if (!doFill) + { + if (fluidList.isEmpty()) + { + return Math.min(capacity, resource.amount); + } + return Math.min(capacity - this.getFluidAmount(), resource.amount); + } + if (fluidList.isEmpty()) + { + FluidStack fluid = copyWithSize(resource,Math.min(capacity, resource.amount)); + fluidList.add(fluid); + this.temperature=fluid.getFluid().getTemperature(); + return fluid.amount; + } + this.temperature=alignTemperatures(resource); + FluidStack fluid = getFluidStackWithSameFluid(resource); + if(fluid!=null) + { + int amount1=Math.min(capacity - this.getFluidAmount(), resource.amount); + fluid.amount+=amount1; + return amount1; + } + fluid = copyWithSize(resource,Math.min(capacity, resource.amount)); + fluidList.add(fluid); + this.sortFluidsByDensity(); + return fluid.amount; + } + + private int alignTemperatures(FluidStack resource) + { + int amountOfFluidInTank = this.getFluidAmount(); + int averageT=(this.temperature*amountOfFluidInTank+resource.getFluid().getTemperature()*resource.amount)/(amountOfFluidInTank+resource.amount); + return averageT; + } + + @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); + fluid = null; + } + } + 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 int getTemperature() + { + return this.temperature; + } + + public void setTemperature(int t1) + { + this.temperature=t1; + } + + 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); + fluid = null; + } + } + 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