The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

1 files changed, 328 insertions, 0 deletions

diff --git a/src/main/java/gregtech/api/metatileentity/implementations/MTEBasicTank.java b/src/main/java/gregtech/api/metatileentity/implementations/MTEBasicTank.java
new file mode 100644
index 0000000000..003b8c893e
--- /dev/null
+++ b/src/main/java/gregtech/api/metatileentity/implementations/MTEBasicTank.java
@@ -0,0 +1,328 @@
+package gregtech.api.metatileentity.implementations;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import com.gtnewhorizons.modularui.api.NumberFormatMUI;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.fluid.FluidStackTank;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GTUtility;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p>
+ * This is the main construct for my generic Tanks. Filling and emptying behavior have to be implemented manually
+ */
+public abstract class MTEBasicTank extends MTETieredMachineBlock implements IAddUIWidgets {
+
+    public FluidStack mFluid;
+    // Due to class initializing order, getCapacity might not work properly at this time.
+    // So we pass supplier instead of current value here.
+    protected final FluidStackTank fluidTank = new FluidStackTank(
+        () -> mFluid,
+        fluidStack -> mFluid = fluidStack,
+        this::getRealCapacity);
+
+    /**
+     * @param aInvSlotCount should be 3
+     */
+    public MTEBasicTank(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription,
+        ITexture... aTextures) {
+        super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    public MTEBasicTank(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount,
+        String[] aDescription, ITexture... aTextures) {
+        super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    public MTEBasicTank(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    public MTEBasicTank(String aName, int aTier, int aInvSlotCount, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex != getStackDisplaySlot();
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        if (mFluid != null) aNBT.setTag("mFluid", mFluid.writeToNBT(new NBTTagCompound()));
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        mFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluid"));
+    }
+
+    public abstract boolean doesFillContainers();
+
+    public abstract boolean doesEmptyContainers();
+
+    public abstract boolean canTankBeFilled();
+
+    public abstract boolean canTankBeEmptied();
+
+    public abstract boolean displaysItemStack();
+
+    /**
+     * @return If fluid amount is shown on FluidDisplayItem
+     */
+    public abstract boolean displaysStackSize();
+
+    public int getInputSlot() {
+        return 0;
+    }
+
+    public int getOutputSlot() {
+        return 1;
+    }
+
+    public int getStackDisplaySlot() {
+        return 2;
+    }
+
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return true;
+    }
+
+    public boolean isFluidChangingAllowed() {
+        return true;
+    }
+
+    public FluidStack getFillableStack() {
+        return mFluid;
+    }
+
+    public FluidStack setFillableStack(FluidStack aFluid) {
+        mFluid = aFluid;
+        return mFluid;
+    }
+
+    /**
+     * If you override this and change the field returned, be sure to override {@link #isDrainableStackSeparate()} as
+     * well!
+     */
+    public FluidStack getDrainableStack() {
+        return mFluid;
+    }
+
+    public FluidStack setDrainableStack(FluidStack aFluid) {
+        mFluid = aFluid;
+        return mFluid;
+    }
+
+    public boolean isDrainableStackSeparate() {
+        return false;
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (isFluidChangingAllowed() && getFillableStack() != null && getFillableStack().amount <= 0) {
+                setFillableStack(null);
+            }
+
+            final int inputSlot = getInputSlot();
+
+            if (doesEmptyContainers()) {
+                FluidStack tFluid = GTUtility.getFluidForFilledItem(mInventory[inputSlot], true);
+                if (tFluid != null && isFluidInputAllowed(tFluid)) {
+                    if (getFillableStack() == null) {
+                        if (isFluidInputAllowed(tFluid) && tFluid.amount <= getCapacity()) {
+                            if (aBaseMetaTileEntity.addStackToSlot(
+                                getOutputSlot(),
+                                GTUtility.getContainerForFilledItem(mInventory[inputSlot], true),
+                                1)) {
+                                setFillableStack(tFluid.copy());
+                                this.onEmptyingContainerWhenEmpty();
+                                aBaseMetaTileEntity.decrStackSize(inputSlot, 1);
+                            }
+                        }
+                    } else {
+                        if (tFluid.isFluidEqual(getFillableStack())
+                            && ((long) tFluid.amount + getFillableStack().amount) <= (long) getCapacity()) {
+                            if (aBaseMetaTileEntity.addStackToSlot(
+                                getOutputSlot(),
+                                GTUtility.getContainerForFilledItem(mInventory[inputSlot], true),
+                                1)) {
+                                getFillableStack().amount += tFluid.amount;
+                                aBaseMetaTileEntity.decrStackSize(inputSlot, 1);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (doesFillContainers()) {
+                ItemStack tOutput = GTUtility
+                    .fillFluidContainer(getDrainableStack(), mInventory[inputSlot], false, true);
+                if (tOutput != null && aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), tOutput, 1)) {
+                    FluidStack tFluid = GTUtility.getFluidForFilledItem(tOutput, true);
+                    aBaseMetaTileEntity.decrStackSize(inputSlot, 1);
+                    if (tFluid != null) getDrainableStack().amount -= tFluid.amount;
+                    if (getDrainableStack().amount <= 0 && isFluidChangingAllowed()) setDrainableStack(null);
+                }
+            }
+        }
+    }
+
+    @Override
+    public FluidStack getFluid() {
+        return getDrainableStack();
+    }
+
+    @Override
+    public int getFluidAmount() {
+        return getDrainableStack() != null ? getDrainableStack().amount : 0;
+    }
+
+    @Override
+    public int fill(FluidStack aFluid, boolean doFill) {
+        if (aFluid == null || aFluid.getFluid()
+            .getID() <= 0 || aFluid.amount <= 0 || !canTankBeFilled() || !isFluidInputAllowed(aFluid)) return 0;
+
+        if (getFillableStack() == null || getFillableStack().getFluid()
+            .getID() <= 0) {
+            if (aFluid.amount <= getCapacity()) {
+                if (doFill) {
+                    setFillableStack(aFluid.copy());
+                    getBaseMetaTileEntity().markDirty();
+                }
+                return aFluid.amount;
+            }
+            if (doFill) {
+                setFillableStack(aFluid.copy());
+                getFillableStack().amount = getCapacity();
+                getBaseMetaTileEntity().markDirty();
+            }
+            return getCapacity();
+        }
+
+        if (!getFillableStack().isFluidEqual(aFluid)) return 0;
+
+        int space = getCapacity() - getFillableStack().amount;
+        if (aFluid.amount <= space) {
+            if (doFill) {
+                getFillableStack().amount += aFluid.amount;
+                getBaseMetaTileEntity().markDirty();
+            }
+            return aFluid.amount;
+        }
+        if (doFill) getFillableStack().amount = getCapacity();
+        return space;
+    }
+
+    @Override
+    public FluidStack drain(int maxDrain, boolean doDrain) {
+        if (getDrainableStack() == null || !canTankBeEmptied()) return null;
+        if (getDrainableStack().amount <= 0 && isFluidChangingAllowed()) {
+            setDrainableStack(null);
+            getBaseMetaTileEntity().markDirty();
+            return null;
+        }
+
+        int used = maxDrain;
+        if (getDrainableStack().amount < used) used = getDrainableStack().amount;
+
+        if (doDrain) {
+            getDrainableStack().amount -= used;
+            getBaseMetaTileEntity().markDirty();
+        }
+
+        FluidStack drained = getDrainableStack().copy();
+        drained.amount = used;
+
+        if (getDrainableStack().amount <= 0 && isFluidChangingAllowed()) {
+            setDrainableStack(null);
+            getBaseMetaTileEntity().markDirty();
+        }
+
+        return drained;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection side) {
+        if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[] {};
+        if (isDrainableStackSeparate()) {
+            return new FluidTankInfo[] { new FluidTankInfo(getFillableStack(), getCapacity()),
+                new FluidTankInfo(getDrainableStack(), getCapacity()) };
+        } else {
+            return new FluidTankInfo[] { new FluidTankInfo(this) };
+        }
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return aIndex == getOutputSlot();
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return aIndex == getInputSlot();
+    }
+
+    protected void onEmptyingContainerWhenEmpty() {
+        // Do nothing
+    }
+
+    protected static final NumberFormatMUI numberFormat = new NumberFormatMUI();
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(
+            new DrawableWidget().setDrawable(GTUITextures.PICTURE_SCREEN_BLACK)
+                .setPos(7, 16)
+                .setSize(71, 45))
+            .widget(
+                new DrawableWidget().setDrawable(GTUITextures.PICTURE_GAUGE)
+                    .setPos(79, 34)
+                    .setSize(18, 18))
+            .widget(
+                new SlotWidget(inventoryHandler, getInputSlot())
+                    .setBackground(getGUITextureSet().getItemSlot(), GTUITextures.OVERLAY_SLOT_IN)
+                    .setPos(79, 16))
+            .widget(
+                new SlotWidget(inventoryHandler, getOutputSlot()).setAccess(true, false)
+                    .setBackground(getGUITextureSet().getItemSlot(), GTUITextures.OVERLAY_SLOT_OUT)
+                    .setPos(79, 52))
+            .widget(
+                createFluidSlot().setBackground(GTUITextures.TRANSPARENT)
+                    .setPos(58, 41))
+            .widget(
+                new TextWidget("Liquid Amount").setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setPos(10, 20))
+            .widget(
+                new TextWidget().setStringSupplier(() -> numberFormat.format(mFluid != null ? mFluid.amount : 0))
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setPos(10, 30));
+    }
+
+    protected FluidSlotWidget createFluidSlot() {
+        return new FluidSlotWidget(fluidTank);
+    }
+}