From f7c75cbe3675733eca0279f0c7256daf459e109d Mon Sep 17 00:00:00 2001
From: Yang Xizhi <60341015+GlodBlock@users.noreply.github.com>
Date: Sun, 24 Apr 2022 14:42:46 +0800
Subject: add quadruple input hatch (#1016)

* add quadruple input hatch

* pull all fluid slot thing to GT_Container
---
 .../GT_MetaTileEntity_Hatch_Input.java             |  11 +
 .../GT_MetaTileEntity_Hatch_MultiInput.java        | 291 +++++++++++++++++++++
 .../GT_MetaTileEntity_MultiBlockBase.java          |  43 ++-
 3 files changed, 335 insertions(+), 10 deletions(-)
 create mode 100644 src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_MultiInput.java

(limited to 'src/main/java/gregtech/api/metatileentity/implementations')

diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java
index 972ac87d02..99c89e091a 100644
--- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java
+++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java
@@ -24,6 +24,13 @@ public class GT_MetaTileEntity_Hatch_Input extends GT_MetaTileEntity_Hatch {
                 "Capacity: " + GT_Utility.formatNumbers(8000*(1<<aTier)) + "L"});
     }
 
+    public GT_MetaTileEntity_Hatch_Input(int aID, int aSlot, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, aSlot, new String[]{
+            "Fluid Input for Multiblocks",
+            "Capacity: " + GT_Utility.formatNumbers(8000*(1<<aTier) / aSlot) + "L",
+            "Can hold " + aSlot + " types of fluid."});
+    }
+
     public GT_MetaTileEntity_Hatch_Input(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, 3, aDescription, aTextures);
     }
@@ -32,6 +39,10 @@ public class GT_MetaTileEntity_Hatch_Input extends GT_MetaTileEntity_Hatch {
         super(aName, aTier, 3, aDescription, aTextures);
     }
 
+    public GT_MetaTileEntity_Hatch_Input(String aName, int aSlots, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aSlots, aDescription, aTextures);
+    }
+
     @Override
     public ITexture[] getTexturesActive(ITexture aBaseTexture) {
         return GT_Mod.gregtechproxy.mRenderIndicatorsOnHatch ?
diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_MultiInput.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_MultiInput.java
new file mode 100644
index 0000000000..39599006f2
--- /dev/null
+++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_MultiInput.java
@@ -0,0 +1,291 @@
+package gregtech.api.metatileentity.implementations;
+
+import gregtech.GT_Mod;
+import gregtech.api.enums.ItemList;
+import gregtech.api.gui.GT_Container_2by2_Fluid;
+import gregtech.api.gui.GT_GUIContainer_2by2_Fluid;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Utility;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
+public class GT_MetaTileEntity_Hatch_MultiInput extends GT_MetaTileEntity_Hatch_Input {
+
+    public FluidStack[] mStoredFluid;
+    public int mCapacityPer;
+
+    public GT_MetaTileEntity_Hatch_MultiInput(int aID, int aSlot, String aName, String aNameRegional, int aTier) {
+        super(aID, aSlot, aName, aNameRegional, aTier);
+        this.mStoredFluid = new FluidStack[aSlot];
+        mCapacityPer = 8000 * (1 << aTier) / aSlot;
+    }
+
+    public GT_MetaTileEntity_Hatch_MultiInput(String aName, int aSlot, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aSlot, aDescription, aTextures);
+        this.mStoredFluid = new FluidStack[aSlot];
+        mCapacityPer = 8000 * (1 << aTier) / aSlot;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_Hatch_MultiInput(mName, getMaxType(), mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        if (mStoredFluid != null) {
+            for (int i = 0; i < mStoredFluid.length; i++) {
+                if (mStoredFluid[i] != null)
+                    aNBT.setTag("mFluid" + i, mStoredFluid[i].writeToNBT(new NBTTagCompound()));
+            }
+        }
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        if (mStoredFluid != null) {
+            for (int i = 0; i < mStoredFluid.length; i++) {
+                if (aNBT.hasKey("mFluid" + i)) {
+                    mStoredFluid[i] = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluid" + i));
+                }
+            }
+        }
+    }
+
+    public FluidStack[] getStoredFluid() {
+        return mStoredFluid;
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[]{aBaseTexture, TextureFactory.of(OVERLAY_INPUT_HATCH_2x2)};
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[]{aBaseTexture, TextureFactory.of(OVERLAY_INPUT_HATCH_2x2)};
+    }
+
+    public int getMaxType() {
+        return mStoredFluid.length;
+    }
+
+    @Override
+    public FluidStack getFluid() {
+        for (FluidStack tFluid : mStoredFluid) {
+            if (tFluid != null && tFluid.amount > 0)
+                return tFluid;
+        }
+        return null;
+    }
+
+    public FluidStack getFluid(int aSlot) {
+        if (mStoredFluid == null || aSlot < 0 || aSlot >= getMaxType()) return null;
+        return mStoredFluid[aSlot];
+    }
+
+    @Override
+    public int getFluidAmount() {
+        if (getFluid() != null) {
+            return getFluid().amount;
+        }
+        return 0;
+    }
+
+    @Override
+    public int getCapacity() {
+        return mCapacityPer;
+    }
+
+    public int getFirstEmptySlot() {
+        for (int i = 0; i < mStoredFluid.length; i++) {
+            if (mStoredFluid[i] == null || mStoredFluid[i].amount <= 0)
+                return i;
+        }
+        return -1;
+    }
+
+    public boolean hasFluid(FluidStack aFluid) {
+        if (aFluid == null) return false;
+        for (FluidStack tFluid : mStoredFluid) {
+            if (aFluid.isFluidEqual(tFluid))
+                return true;
+        }
+        return false;
+    }
+
+    public int getFluidSlot(FluidStack tFluid) {
+        if (tFluid == null) return -1;
+        for (int i = 0; i < mStoredFluid.length; i++) {
+            if (tFluid.equals(mStoredFluid[i]))
+                return i;
+        }
+        return -1;
+    }
+
+    public int getFluidAmount(FluidStack tFluid) {
+        int tSlot = getFluidSlot(tFluid);
+        if (tSlot != -1) {
+            return mStoredFluid[tSlot].amount;
+        }
+        return 0;
+    }
+
+    public void setFluid(FluidStack aFluid, int aSlot) {
+        if (aSlot < 0 || aSlot >= getMaxType()) return;
+        mStoredFluid[aSlot] = aFluid;
+    }
+
+    public void addFluid(FluidStack aFluid, int aSlot) {
+        if (aSlot < 0 || aSlot >= getMaxType()) return;
+        if (aFluid.equals(mStoredFluid[aSlot])) mStoredFluid[aSlot].amount += aFluid.amount;
+        if (mStoredFluid[aSlot] == null) mStoredFluid[aSlot] = aFluid.copy();
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            mFluid = getFluid();
+        }
+        super.onPreTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public int fill(FluidStack aFluid, boolean doFill) {
+        if (aFluid == null || aFluid.getFluid().getID() <= 0 || aFluid.amount <= 0 || !canTankBeFilled() || !isFluidInputAllowed(aFluid))
+            return 0;
+        if (!hasFluid(aFluid) && getFirstEmptySlot() != -1) {
+            int tFilled = Math.min(aFluid.amount, mCapacityPer);
+            if (doFill) {
+                FluidStack tFluid = aFluid.copy();
+                tFluid.amount = tFilled;
+                addFluid(tFluid, getFirstEmptySlot());
+                getBaseMetaTileEntity().markDirty();
+            }
+            return tFilled;
+        }
+        if (hasFluid(aFluid)) {
+            int tLeft = mCapacityPer - getFluidAmount(aFluid);
+            int tFilled = Math.min(tLeft, aFluid.amount);
+            if (doFill) {
+                FluidStack tFluid = aFluid.copy();
+                tFluid.amount = tFilled;
+                addFluid(tFluid, getFluidSlot(tFluid));
+                getBaseMetaTileEntity().markDirty();
+            }
+            return tFilled;
+        }
+        return 0;
+    }
+
+    @Override
+    public FluidStack drain(int maxDrain, boolean doDrain) {
+        if (getFluid() == null || !canTankBeEmptied()) return null;
+        if (getFluid().amount <= 0 && isFluidChangingAllowed()) {
+            setFluid(null, getFluidSlot(getFluid()));
+            getBaseMetaTileEntity().markDirty();
+            return null;
+        }
+        FluidStack tRemove = getFluid().copy();
+        tRemove.amount = Math.min(maxDrain, tRemove.amount);
+        if (doDrain) {
+            getFluid().amount -= tRemove.amount;
+            getBaseMetaTileEntity().markDirty();
+        }
+        if (getFluid() == null || getFluid().amount <= 0 && isFluidChangingAllowed()) {
+            setFluid(null, getFluidSlot(getFluid()));
+            getBaseMetaTileEntity().markDirty();
+        }
+        return tRemove;
+    }
+
+    @Override
+    public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+        return fill(resource, doFill);
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, FluidStack aFluid, boolean doDrain) {
+        if (getFluid() != null && aFluid != null && getFluid().isFluidEqual(aFluid)) {
+            if (hasFluid(aFluid) && !canTankBeEmptied()) {
+                FluidStack tStored = mStoredFluid[getFluidSlot(aFluid)];
+                if (tStored.amount <= 0 && isFluidChangingAllowed()) {
+                    setFluid(null, getFluidSlot(tStored));
+                    getBaseMetaTileEntity().markDirty();
+                    return null;
+                }
+                FluidStack tRemove = tStored.copy();
+                tRemove.amount = Math.min(aFluid.amount, tRemove.amount);
+                if (doDrain) {
+                    tStored.amount -= tRemove.amount;
+                    getBaseMetaTileEntity().markDirty();
+                }
+                if (tStored.amount <= 0 && isFluidChangingAllowed()) {
+                    setFluid(null, getFluidSlot(tStored));
+                    getBaseMetaTileEntity().markDirty();
+                }
+                return tRemove;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+        FluidTankInfo[] FTI = new FluidTankInfo[getMaxType()];
+        for (int i = 0; i < getMaxType(); i++) {
+            FTI[i] = new FluidTankInfo(mStoredFluid[i], mCapacityPer);
+        }
+        return FTI;
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_2by2_Fluid(aPlayerInventory, aBaseMetaTileEntity, "Quadruple Input Hatch");
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_Container_2by2_Fluid(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide() && mStoredFluid != null) {
+            for (int i = 0; i < getMaxType(); i ++) {
+                if (mStoredFluid[i] != null && mStoredFluid[i].amount <= 0) {
+                    mStoredFluid[i] = null;
+                }
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex >= 4;
+    }
+
+    @Override
+    public void updateFluidDisplayItem() {
+        for (int i = 0; i < 4; i ++) {
+            if (getFluid(i) == null || getFluid(i).amount <= 0) {
+                if (ItemList.Display_Fluid.isStackEqual(mInventory[i], true, true))
+                    mInventory[i] = null;
+            }
+            else {
+                mInventory[i] = GT_Utility.getFluidDisplayStack(getFluid(i), true, !displaysStackSize());
+            }
+        }
+    }
+}
diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java
index a2d6f3a05b..6fea43e960 100644
--- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java
+++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java
@@ -35,8 +35,7 @@ import org.lwjgl.input.Keyboard;
 import java.util.ArrayList;
 import java.util.List;
 
-import static gregtech.api.enums.GT_Values.V;
-import static gregtech.api.enums.GT_Values.VN;
+import static gregtech.api.enums.GT_Values.*;
 import static mcp.mobius.waila.api.SpecialChars.GREEN;
 import static mcp.mobius.waila.api.SpecialChars.RED;
 import static mcp.mobius.waila.api.SpecialChars.RESET;
@@ -763,12 +762,23 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity {
         for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
             tHatch.mRecipeMap = getRecipeMap();
             if (isValidMetaTileEntity(tHatch)) {
-                FluidStack tLiquid = tHatch.getFluid();
-                if (tLiquid != null && tLiquid.isFluidEqual(aLiquid)) {
-                    tLiquid = tHatch.drain(aLiquid.amount, false);
-                    if (tLiquid != null && tLiquid.amount >= aLiquid.amount) {
-                        tLiquid = tHatch.drain(aLiquid.amount, true);
-                        return tLiquid != null && tLiquid.amount >= aLiquid.amount;
+                if (tHatch instanceof GT_MetaTileEntity_Hatch_MultiInput) {
+                    if (((GT_MetaTileEntity_Hatch_MultiInput) tHatch).hasFluid(aLiquid)) {
+                        FluidStack tLiquid = tHatch.drain(aLiquid.amount, false);
+                        if (tLiquid != null && tLiquid.amount >= aLiquid.amount) {
+                            tLiquid = tHatch.drain(aLiquid.amount, true);
+                            return tLiquid != null && tLiquid.amount >= aLiquid.amount;
+                        }
+                    }
+                }
+                else {
+                    FluidStack tLiquid = tHatch.getFluid();
+                    if (tLiquid != null && tLiquid.isFluidEqual(aLiquid)) {
+                        tLiquid = tHatch.drain(aLiquid.amount, false);
+                        if (tLiquid != null && tLiquid.amount >= aLiquid.amount) {
+                            tLiquid = tHatch.drain(aLiquid.amount, true);
+                            return tLiquid != null && tLiquid.amount >= aLiquid.amount;
+                        }
                     }
                 }
             }
@@ -849,8 +859,21 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity {
         ArrayList<FluidStack> rList = new ArrayList<>();
         for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
             tHatch.mRecipeMap = getRecipeMap();
-            if (isValidMetaTileEntity(tHatch) && tHatch.getFillableStack() != null) {
-                rList.add(tHatch.getFillableStack());
+            if (tHatch instanceof GT_MetaTileEntity_Hatch_MultiInput) {
+                if (isValidMetaTileEntity(tHatch)) {
+                    for (FluidStack tFluid : ((GT_MetaTileEntity_Hatch_MultiInput) tHatch).getStoredFluid()) {
+                        if (tFluid != null) {
+                            //GT_Log.out.print("mf: " + tFluid + "\n");
+                            rList.add(tFluid);
+                        }
+                    }
+                }
+            }
+            else {
+                if (isValidMetaTileEntity(tHatch) && tHatch.getFillableStack() != null) {
+                    //GT_Log.out.print("sf: " + tHatch.getFillableStack() + "\n");
+                    rList.add(tHatch.getFillableStack());
+                }
             }
         }
         return rList;
-- 
cgit