summaryrefslogtreecommitdiff
path: root/src/main/java/ihl/utils/IHLFluidTank.java
diff options
context:
space:
mode:
authorFoghrye4 <foghrye4@gmail.com>2017-08-10 18:52:45 +0300
committerFoghrye4 <foghrye4@gmail.com>2017-08-10 18:52:45 +0300
commit0427ab89f1753a44b30cbc35ce021cbbdc845109 (patch)
treeabe418ff5ec174e712fe8dedd434548a945b15a3 /src/main/java/ihl/utils/IHLFluidTank.java
parent877312184c472d9845e5ef1008bc538f4634059f (diff)
fix missing source folder
Diffstat (limited to 'src/main/java/ihl/utils/IHLFluidTank.java')
-rw-r--r--src/main/java/ihl/utils/IHLFluidTank.java322
1 files changed, 322 insertions, 0 deletions
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<FluidStack> fluidList = new ArrayList<FluidStack>();
+ 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<FluidStack> 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<FluidStack> 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<FluidStack> 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<Integer, FluidStack> sortMap = new HashMap<Integer, FluidStack>();
+ int[] keysArray = new int[fluidList.size()];
+ Iterator<FluidStack> 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<FluidStack> newFluidList = new ArrayList<FluidStack>();
+ 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<FluidStack> 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<FluidStack> fluidOutputs, boolean doFill) {
+ if (fluidOutputs != null && !fluidOutputs.isEmpty()) {
+ Iterator<FluidStack> 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<FluidStack> fsi = this.fluidList.iterator();
+ while (fsi.hasNext()) {
+ FluidStack fs = fsi.next();
+ if (fs.amount <= 0) {
+ fsi.remove();
+ }
+ }
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-10 05:07:05 +0000