Merge pull request #45 from GTNewHorizons/feature/tfft-rework

TFFT rework

1 files changed, 0 insertions, 397 deletions

diff --git a/src/main/java/kekztech/MultiFluidHandler.java b/src/main/java/kekztech/MultiFluidHandler.java
deleted file mode 100644
index 232931b6fc..0000000000
--- a/src/main/java/kekztech/MultiFluidHandler.java
+++ /dev/null
@@ -1,397 +0,0 @@
-package kekztech;
-
-import java.util.ArrayList;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.util.EnumChatFormatting;
-import net.minecraftforge.fluids.FluidStack;
-
-public class MultiFluidHandler {
-
-    private final FluidStack[] fluids;
-    private final int maxDistinctFluids;
-    private final int capacityPerFluid;
-
-    private boolean locked = true;
-    private boolean doVoidExcess = false;
-    private byte fluidSelector = -1;
-
-    public MultiFluidHandler(int maxDistinctFluids, int capacityPerFluid, FluidStack[] fluidsToAdd) {
-        this.maxDistinctFluids = maxDistinctFluids;
-        this.fluids = new FluidStack[maxDistinctFluids];
-        if (fluidsToAdd != null) {
-            int tFluidLengt = (maxDistinctFluids < fluidsToAdd.length) ? maxDistinctFluids : fluidsToAdd.length;
-            for (int i = 0; i < tFluidLengt; i++) {
-                this.fluids[i] = fluidsToAdd[i];
-            }
-        }
-        this.capacityPerFluid = capacityPerFluid;
-    }
-
-    /**
-     * Initialize a new MultiFluidHandler object with the given parameters
-     * @param maxDistinctFluids
-     * 				How many different fluids can be stored
-     * @param capacityPerFluid
-     * 				How much capacity each fluid should have
-     * @param fluidsToAdd
-     * 				Fluids to add immediately
-     * @return
-     * 				A new instance
-     */
-    public static MultiFluidHandler newInstance(
-            int maxDistinctFluids, int capacityPerFluid, FluidStack... fluidsToAdd) {
-        return new MultiFluidHandler(maxDistinctFluids, capacityPerFluid, fluidsToAdd);
-    }
-
-    /**
-     * Deep copy a MultiFluidHandler instance with a new capacity
-     * @param toCopy
-     * 				The MultiFluidHandler that should be copied
-     * @param capacityPerFluid
-     * 				How much capacity each fluid should have
-     * @return
-     * 				A new instance
-     */
-    public static MultiFluidHandler newAdjustedInstance(MultiFluidHandler toCopy, int capacityPerFluid) {
-        return new MultiFluidHandler(toCopy.maxDistinctFluids, capacityPerFluid, toCopy.fluids);
-    }
-
-    /**
-     * Lock internal tanks in case T.F.F.T is not running.
-     *
-     * @param state
-     * 				Lock state.
-     */
-    public void setLock(boolean state) {
-        locked = state;
-    }
-
-    public void setDoVoidExcess(boolean doVoidExcess) {
-        this.doVoidExcess = doVoidExcess;
-    }
-
-    /**
-     * Used to tell the MFH if a fluid is selected by
-     * an Integrated Circuit in the controller.
-     * If the Integrate Circuit configuration exceeds
-     * the number of stored fluid, the configuration will be ignored.
-     *
-     * @param fluidSelector
-     * 				Selected fluid or -1 if no fluid is selected
-     */
-    public void setFluidSelector(byte fluidSelector) {
-        this.fluidSelector = fluidSelector < fluids.length ? fluidSelector : -1;
-    }
-
-    /**
-     *
-     * @return
-     * 				Selected fluid or -1 if no fluid is selected
-     */
-    public byte getSelectedFluid() {
-        return fluidSelector;
-    }
-
-    public FluidStack[] getAllFluids() {
-        return fluids;
-    }
-
-    public int getFluidPosistion(FluidStack aFluid) {
-
-        for (int i = 0; i < fluids.length; i++) {
-            FluidStack tFluid = fluids[i];
-            if (tFluid != null && tFluid.isFluidEqual(aFluid)) return i;
-        }
-        return -1;
-    }
-
-    public boolean contains(FluidStack aFluid) {
-        if (locked) return false;
-        return getFluidPosistion(aFluid) >= 0;
-    }
-
-    public int countFluids() {
-        int tCount = 0;
-        for (int i = 0; i < fluids.length; i++) {
-            if (fluids[i] != null) tCount++;
-        }
-        return tCount;
-    }
-
-    public int getCapacity() {
-        return capacityPerFluid;
-    }
-
-    public int getMaxDistinctFluids() {
-        return maxDistinctFluids;
-    }
-
-    /**
-     * Returns a deep copy of the the FluidStack in the requested slot
-     * @param slot
-     * 				requested slot
-     * @return
-     * 				deep copy of the requested FluidStack
-     */
-    public FluidStack getFluidCopy(int slot) {
-        if (slot >= fluids.length) return null;
-        if (!locked && fluids.length > 0 && slot >= 0 && slot < maxDistinctFluids) {
-            FluidStack tFluid = fluids[slot];
-            if (tFluid != null) return tFluid.copy();
-        }
-        return null;
-    }
-
-    /**
-     * Returns the amount of different fluids currently stored.
-     * @return
-     * 				amount of different fluids currently stored (0-25)
-     */
-    public int getDistinctFluids() {
-        int distinctFluids = 0;
-        for (FluidStack f : fluids) {
-            if (f != null) distinctFluids++;
-        }
-        return distinctFluids;
-    }
-
-    /**
-     * Helper method to save a MultiFluidHandler to NBT data
-     * @param nbt
-     * 				The NBT Tag to write to
-     * @return
-     * 				Updated NBT Tag
-     */
-    public NBTTagCompound saveNBTData(NBTTagCompound nbt) {
-        nbt = (nbt == null) ? new NBTTagCompound() : nbt;
-
-        nbt.setInteger("capacityPerFluid", getCapacity());
-        nbt.setInteger("maxDistinctFluids", this.maxDistinctFluids);
-        int c = 0;
-        for (FluidStack f : fluids) {
-            if (f == null) {
-                c++;
-                continue;
-            }
-            nbt.setTag(String.valueOf(c), f.writeToNBT(new NBTTagCompound()));
-            c++;
-        }
-        return nbt;
-    }
-
-    /**
-     * Helper method to initialize a MultiFluidHandler from NBT data
-     * @param nbt
-     * 				The NBT Tag to read from
-     * @return
-     * 				A new Instance
-     */
-    public static MultiFluidHandler loadNBTData(NBTTagCompound nbt) {
-        nbt = (nbt == null) ? new NBTTagCompound() : nbt;
-
-        final int capacityPerFluid = nbt.getInteger("capacityPerFluid");
-        final NBTTagCompound fluidsTag = (NBTTagCompound) nbt.getTag("fluids");
-        int distinctFluids = nbt.getInteger("maxDistinctFluids");
-        if (!nbt.hasKey("maxDistinctFluids")) distinctFluids = 25; // adding it so it doesent break on upgrading
-        final FluidStack[] loadedFluids = new FluidStack[distinctFluids];
-
-        if (fluidsTag != null) {
-            for (int i = 0; i < distinctFluids; i++) {
-                final NBTTagCompound fluidNBT = (NBTTagCompound) fluidsTag.getTag("" + i);
-                if (fluidNBT == null) {
-                    loadedFluids[i] = null;
-                } else {
-                    loadedFluids[i] = FluidStack.loadFluidStackFromNBT(fluidNBT);
-                }
-            }
-        }
-        return new MultiFluidHandler(distinctFluids, capacityPerFluid, loadedFluids);
-    }
-
-    public ArrayList<String> getInfoData() {
-        final ArrayList<String> lines = new ArrayList<>(fluids.length);
-        lines.add(EnumChatFormatting.YELLOW + "Stored Fluids:" + EnumChatFormatting.RESET);
-        for (int i = 0; i < fluids.length; i++) {
-            FluidStack tFluid = fluids[i];
-            if (tFluid == null) {
-                lines.add(i + " - " + "null" + ": " + "0" + "L (" + "0" + "%)");
-            } else {
-                lines.add(i + " - " + tFluid.getLocalizedName() + ": "
-                        + tFluid.amount + "L ("
-                        + (Math.round(100.0f * tFluid.amount / getCapacity())) + "%)");
-            }
-        }
-
-        return lines;
-    }
-
-    /**
-     * Fill fluid into a tank.
-     *
-     * @param push
-     * 				Fluid type and quantity to be inserted.
-     * @param doPush
-     * 				If false, fill will only be simulated.
-     * @return Amount of fluid that was (or would have been, if simulated) filled.
-     */
-    public int pushFluid(FluidStack push, boolean doPush) {
-        if (locked) {
-            return 0;
-        }
-        int empty = getNullSlot();
-        int fluidCount = countFluids();
-        if (fluidCount >= maxDistinctFluids && !contains(push)) {
-            // Already contains 25 fluids and this isn't one of them
-            return 0;
-        } else if (empty < maxDistinctFluids && !contains(push)) {
-            // Add new fluid
-            final int fit = Math.min(getCapacity(), push.amount);
-            if (doPush) {
-                if (empty == -1) return 0;
-                else fluids[empty] = new FluidStack(push.getFluid(), fit);
-            }
-            // If doVoidExcess, pretend all of it fit
-            return doVoidExcess ? push.amount : fit;
-        } else {
-            // Add to existing fluids
-            int index = getFluidPosistion(push);
-            if (index < 0) return 0;
-            final FluidStack existing = fluids[index];
-            final int fit = Math.min(getCapacity() - existing.amount, push.amount);
-            if (doPush) {
-                existing.amount += fit;
-            }
-            // If doVoidExcess, pretend all of it fit
-            return doVoidExcess ? push.amount : fit;
-        }
-    }
-
-    public int getNullSlot() {
-        for (int i = 0; i < fluids.length; i++) {
-            if (fluids[i] == null) return i;
-        }
-        return -1;
-    }
-
-    /**
-     * Fill fluid into the specified tank.
-     *
-     * @param push
-     * 				Fluid type and quantity to be inserted.
-     * @param slot
-     * 				Tank the fluid should go into.
-     * @param doPush
-     * 				If false, fill will only be simulated.
-     * @return Amount of fluid that was (or would have been, if simulated) filled.
-     */
-    public int pushFluid(FluidStack push, int slot, boolean doPush) {
-        if (locked) {
-            return 0;
-        }
-        FluidStack tFluid = fluids[slot];
-        if (slot < 0 || slot >= maxDistinctFluids) {
-            // Invalid slot
-            return 0;
-        }
-        if ((tFluid != null) && !tFluid.equals(push)) {
-            // Selected slot is taken by a non-matching fluid
-            return 0;
-        } else {
-            int fit = 0;
-            // Add to existing fluid
-            if (tFluid == null) {
-                fit = Math.min(getCapacity(), push.amount);
-                fluids[slot] = new FluidStack(push.getFluid(), fit);
-            } else {
-                fit = Math.min(getCapacity() - tFluid.amount, push.amount);
-                if (doPush) {
-                    tFluid.amount += fit;
-                }
-            }
-            // If doVoidExcess, pretend all of it fit
-            return doVoidExcess ? push.amount : fit;
-        }
-    }
-
-    /**
-     * Drains fluid out of the internal tanks.
-     *
-     * @param pull
-     * 				Fluid type and quantity to be pulled.
-     * @param doPull
-     * 				If false, drain will only be simulated.
-     * @return Amount of fluid that was (or would have been, if simulated) pulled.
-     */
-    public int pullFluid(FluidStack pull, boolean doPull) {
-        if (locked) {
-            return 0;
-        } else {
-            int tIndex = getFluidPosistion(pull);
-            if (tIndex < 0) return 0;
-            FluidStack src = fluids[tIndex];
-            final int rec = Math.min(pull.amount, src.amount);
-            if (doPull) {
-                src.amount -= rec;
-            }
-            if (src.amount == 0) {
-                fluids[tIndex] = null;
-            }
-            return rec;
-        }
-    }
-
-    /**
-     * Drains fluid out of the specified internal tank.
-     *
-     * @param pull
-     * 				Fluid type and quantity to be pulled.
-     * @param slot
-     * 				Tank fluid should be drained from.
-     * @param doPull
-     * 				If false, drain will only be simulated.
-     * @return Amount of fluid that was (or would have been, if simulated) pulled.
-     */
-    public int pullFluid(FluidStack pull, int slot, boolean doPull) {
-        if (locked || slot >= fluids.length) {
-            return 0;
-        }
-        if (slot < 0 || slot >= maxDistinctFluids) {
-            return 0;
-        }
-        FluidStack tFluid = fluids[slot];
-        if (tFluid == null || !tFluid.equals(pull)) {
-            return 0;
-        } else {
-            final int rec = Math.min(pull.amount, tFluid.amount);
-            if (doPull) {
-                tFluid.amount -= rec;
-            }
-            if (tFluid.amount == 0) {
-                fluids[slot] = null;
-            }
-            return rec;
-        }
-    }
-
-    /**
-     * Test whether the given fluid type and quantity can be inserted into the internal tanks.
-     * @param push
-     * 				Fluid type and quantity to be tested
-     * @return True if there is sufficient space
-     */
-    public boolean couldPush(FluidStack push) {
-        if (locked) {
-            return false;
-        }
-        int tFluidIndex = getFluidPosistion(push);
-        int fluidCount = countFluids();
-        if (fluidCount >= maxDistinctFluids && !contains(push)) {
-            return false;
-        } else if (fluidCount < maxDistinctFluids && !contains(push)) {
-            return Math.min(getCapacity(), push.amount) > 0;
-        } else {
-            final int remcap = getCapacity() - fluids[tFluidIndex].amount;
-            return doVoidExcess || (Math.min(remcap, push.amount) > 0);
-        }
-    }
-}