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

4 files changed, 426 insertions, 0 deletions

diff --git a/src/main/java/tectech/thing/cover/CoverEnderFluidLink.java b/src/main/java/tectech/thing/cover/CoverEnderFluidLink.java
new file mode 100644
index 0000000000..bae4e26b6c
--- /dev/null
+++ b/src/main/java/tectech/thing/cover/CoverEnderFluidLink.java
@@ -0,0 +1,245 @@
+package tectech.thing.cover;
+
+import java.util.UUID;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget;
+
+import eu.usrv.yamcore.auxiliary.PlayerChatHelper;
+import gregtech.api.gui.modularui.CoverUIBuildContext;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.CoverBehavior;
+import gregtech.api.util.GTUtility;
+import gregtech.api.util.ISerializableObject;
+import gregtech.common.gui.modularui.widget.CoverDataControllerWidget;
+import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget;
+import tectech.mechanics.enderStorage.EnderLinkTag;
+import tectech.mechanics.enderStorage.EnderWorldSavedData;
+
+public class CoverEnderFluidLink extends CoverBehavior {
+
+    private static final int L_PER_TICK = 8000;
+    private static final int IMPORT_EXPORT_MASK = 0b0001;
+    private static final int PUBLIC_PRIVATE_MASK = 0b0010;
+
+    public CoverEnderFluidLink() {}
+
+    private void transferFluid(IFluidHandler source, ForgeDirection side, IFluidHandler target, ForgeDirection tSide,
+        int amount) {
+        FluidStack fluidStack = source.drain(side, amount, false);
+
+        if (fluidStack != null) {
+            int fluidTransferred = target.fill(tSide, fluidStack, true);
+            source.drain(side, fluidTransferred, true);
+        }
+    }
+
+    private boolean testBit(int aCoverVariable, int bitMask) {
+        return (aCoverVariable & bitMask) != 0;
+    }
+
+    private int toggleBit(int aCoverVariable, int bitMask) {
+        return (aCoverVariable ^ bitMask);
+    }
+
+    @Override
+    public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable,
+        ICoverable aTileEntity, long aTimer) {
+        if ((aTileEntity instanceof IFluidHandler fluidHandlerSelf)) {
+            IFluidHandler fluidHandlerEnder = EnderWorldSavedData
+                .getEnderFluidContainer(EnderWorldSavedData.getEnderLinkTag((IFluidHandler) aTileEntity));
+
+            if (testBit(aCoverVariable, IMPORT_EXPORT_MASK)) {
+                transferFluid(fluidHandlerEnder, ForgeDirection.UNKNOWN, fluidHandlerSelf, side, L_PER_TICK);
+            } else {
+                transferFluid(fluidHandlerSelf, side, fluidHandlerEnder, ForgeDirection.UNKNOWN, L_PER_TICK);
+            }
+        }
+        return aCoverVariable;
+    }
+
+    @Override
+    public String getDescription(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return "";
+    }
+
+    @Override
+    public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+        EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        int newCoverVariable = toggleBit(aCoverVariable, IMPORT_EXPORT_MASK);
+
+        if (testBit(aCoverVariable, IMPORT_EXPORT_MASK)) {
+            PlayerChatHelper.SendInfo(aPlayer, "Ender Suction Engaged!"); // TODO Translation support
+        } else {
+            PlayerChatHelper.SendInfo(aPlayer, "Ender Filling Engaged!");
+        }
+        return newCoverVariable;
+    }
+
+    @Override
+    public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        // Runs each tick
+        return 1;
+    }
+
+    // region GUI
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public ModularWindow createWindow(CoverUIBuildContext buildContext) {
+        // Only open gui if we're placed on a fluid tank
+        if (buildContext.getTile() instanceof IFluidHandler) {
+            return new EnderFluidLinkUIFactory(buildContext).createWindow();
+        }
+        return null;
+    }
+
+    private class EnderFluidLinkUIFactory extends UIFactory {
+
+        private static final int START_X = 10;
+        private static final int START_Y = 25;
+        private static final int SPACE_X = 18;
+        private static final int SPACE_Y = 18;
+        private static final int PUBLIC_BUTTON_ID = 0;
+        private static final int PRIVATE_BUTTON_ID = 1;
+        private static final int IMPORT_BUTTON_ID = 2;
+        private static final int EXPORT_BUTTON_ID = 3;
+
+        public EnderFluidLinkUIFactory(CoverUIBuildContext buildContext) {
+            super(buildContext);
+        }
+
+        @SuppressWarnings("PointlessArithmeticExpression")
+        @Override
+        protected void addUIWidgets(ModularWindow.Builder builder) {
+            TextFieldWidget frequencyField = new TextFieldWidget();
+            builder.widget(frequencyField.setGetter(() -> {
+                ICoverable te = getUIBuildContext().getTile();
+                if (!frequencyField.isClient() && te instanceof IFluidHandler) {
+                    return EnderWorldSavedData.getEnderLinkTag((IFluidHandler) te)
+                        .getFrequency();
+                }
+                return "";
+            })
+                .setSetter(val -> {
+                    ICoverable te = getUIBuildContext().getTile();
+                    if (!frequencyField.isClient() && te instanceof IFluidHandler) {
+                        UUID uuid;
+                        if (testBit(convert(getCoverData()), PUBLIC_PRIVATE_MASK)) {
+                            uuid = getUUID();
+                            if (!(te instanceof IGregTechTileEntity)) return;
+                            if (!uuid.equals(((IGregTechTileEntity) te).getOwnerUuid())) return;
+                        } else {
+                            uuid = null;
+                        }
+                        EnderWorldSavedData.bindEnderLinkTag((IFluidHandler) te, new EnderLinkTag(val, uuid));
+                    }
+                })
+                .setTextColor(Color.WHITE.dark(1))
+                .setTextAlignment(Alignment.CenterLeft)
+                .setFocusOnGuiOpen(true)
+                .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD.withOffset(-1, -1, 2, 2))
+                .setPos(START_X + SPACE_X * 0, START_Y + SPACE_Y * 0)
+                .setSize(SPACE_X * 5 - 8, 12))
+                .widget(
+                    new CoverDataControllerWidget.CoverDataIndexedControllerWidget_ToggleButtons<>(
+                        this::getCoverData,
+                        this::setCoverData,
+                        CoverEnderFluidLink.this,
+                        (id, coverData) -> !getClickable(id, convert(coverData)),
+                        (id, coverData) -> new ISerializableObject.LegacyCoverData(
+                            getNewCoverVariable(id, convert(coverData))))
+                                .addToggleButton(
+                                    PUBLIC_BUTTON_ID,
+                                    CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                    widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_WHITELIST)
+                                        .addTooltip(GTUtility.trans("326", "Public"))
+                                        .setPos(START_X + SPACE_X * 0, START_Y + SPACE_Y * 2))
+                                .addToggleButton(
+                                    PRIVATE_BUTTON_ID,
+                                    CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                    widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_BLACKLIST)
+                                        .addTooltip(GTUtility.trans("327", "Private"))
+                                        .setPos(START_X + SPACE_X * 1, START_Y + SPACE_Y * 2))
+                                .addToggleButton(
+                                    IMPORT_BUTTON_ID,
+                                    CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                    widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_IMPORT)
+                                        .addTooltip(GTUtility.trans("007", "Import"))
+                                        .setPos(START_X + SPACE_X * 0, START_Y + SPACE_Y * 3))
+                                .addToggleButton(
+                                    EXPORT_BUTTON_ID,
+                                    CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                    widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_EXPORT)
+                                        .addTooltip(GTUtility.trans("006", "Export"))
+                                        .setPos(START_X + SPACE_X * 1, START_Y + SPACE_Y * 3)))
+                .widget(
+                    new TextWidget(GTUtility.trans("328", "Channel")).setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(START_X + SPACE_X * 5, 4 + START_Y + SPACE_Y * 0))
+                .widget(
+                    new TextWidget(GTUtility.trans("329", "Public/Private")).setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(START_X + SPACE_X * 2, 4 + START_Y + SPACE_Y * 2))
+                .widget(
+                    new TextWidget(GTUtility.trans("229", "Import/Export")).setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(START_X + SPACE_X * 2, 4 + START_Y + SPACE_Y * 3));
+        }
+
+        private int getNewCoverVariable(int id, int coverVariable) {
+            switch (id) {
+                case PUBLIC_BUTTON_ID:
+                case PRIVATE_BUTTON_ID:
+                    return toggleBit(coverVariable, PUBLIC_PRIVATE_MASK);
+                case IMPORT_BUTTON_ID:
+                case EXPORT_BUTTON_ID:
+                    return toggleBit(coverVariable, IMPORT_EXPORT_MASK);
+            }
+            return coverVariable;
+        }
+
+        private boolean getClickable(int id, int coverVariable) {
+            switch (id) {
+                case PUBLIC_BUTTON_ID:
+                    return testBit(coverVariable, PUBLIC_PRIVATE_MASK);
+                case PRIVATE_BUTTON_ID:
+                    return !testBit(coverVariable, PUBLIC_PRIVATE_MASK);
+                case IMPORT_BUTTON_ID:
+                    return testBit(coverVariable, IMPORT_EXPORT_MASK);
+                case EXPORT_BUTTON_ID:
+                    return !testBit(coverVariable, IMPORT_EXPORT_MASK);
+            }
+            return false;
+        }
+
+        private UUID getUUID() {
+            return getUIBuildContext().getPlayer()
+                .getUniqueID();
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/cover/CoverPowerPassUpgrade.java b/src/main/java/tectech/thing/cover/CoverPowerPassUpgrade.java
new file mode 100644
index 0000000000..7666ba132e
--- /dev/null
+++ b/src/main/java/tectech/thing/cover/CoverPowerPassUpgrade.java
@@ -0,0 +1,52 @@
+package tectech.thing.cover;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.util.CoverBehavior;
+import tectech.thing.metaTileEntity.multi.base.TTMultiblockBase;
+
+public class CoverPowerPassUpgrade extends CoverBehavior {
+
+    public CoverPowerPassUpgrade() {}
+
+    @Override
+    public boolean isCoverPlaceable(ForgeDirection side, ItemStack aStack, ICoverable aTileEntity) {
+        IMetaTileEntity iGregTechTileEntityOffset = aTileEntity.getIGregTechTileEntityOffset(0, 0, 0)
+            .getMetaTileEntity();
+        if (iGregTechTileEntityOffset instanceof TTMultiblockBase multi) {
+            return !multi.ePowerPassCover;
+        }
+        return false;
+    }
+
+    @Override
+    public void placeCover(ForgeDirection side, ItemStack aCover, ICoverable aTileEntity) {
+        IMetaTileEntity iGregTechTileEntityOffset = aTileEntity.getIGregTechTileEntityOffset(0, 0, 0)
+            .getMetaTileEntity();
+        if (iGregTechTileEntityOffset instanceof TTMultiblockBase multi) {
+            multi.ePowerPassCover = true;
+            multi.ePowerPass = true;
+        }
+        super.placeCover(side, aCover, aTileEntity);
+    }
+
+    @Override
+    public boolean onCoverRemoval(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+        boolean aForced) {
+        IMetaTileEntity iGregTechTileEntityOffset = aTileEntity.getIGregTechTileEntityOffset(0, 0, 0)
+            .getMetaTileEntity();
+        if (iGregTechTileEntityOffset instanceof TTMultiblockBase multi) {
+            multi.ePowerPassCover = false;
+            multi.ePowerPass = false;
+        }
+        return true;
+    }
+
+    @Deprecated
+    public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return 0;
+    }
+}
diff --git a/src/main/java/tectech/thing/cover/CoverTeslaCoil.java b/src/main/java/tectech/thing/cover/CoverTeslaCoil.java
new file mode 100644
index 0000000000..a1dba25e03
--- /dev/null
+++ b/src/main/java/tectech/thing/cover/CoverTeslaCoil.java
@@ -0,0 +1,85 @@
+package tectech.thing.cover;
+
+import static ic2.api.info.Info.DMG_ELECTRIC;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.util.CoverBehavior;
+import gregtech.api.util.GTUtility;
+import tectech.mechanics.tesla.ITeslaConnectable;
+import tectech.mechanics.tesla.TeslaCoverConnection;
+
+public class CoverTeslaCoil extends CoverBehavior {
+
+    public CoverTeslaCoil() {}
+
+    @Override
+    public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable,
+        ICoverable aTileEntity, long aTimer) {
+        // Only do stuff if we're on top and have power
+        if (side == ForgeDirection.UP || aTileEntity.getEUCapacity() > 0) {
+            // Makes sure we're on the list
+            ITeslaConnectable.TeslaUtil.teslaSimpleNodeSetAdd(
+                new TeslaCoverConnection(
+                    aTileEntity.getIGregTechTileEntityOffset(0, 0, 0),
+                    getTeslaReceptionCapability()));
+        }
+        return super.doCoverThings(side, aInputRedstone, aCoverID, aCoverVariable, aTileEntity, aTimer);
+    }
+
+    @Override
+    public void onCoverUnload(ICoverable aTileEntity) {
+        if (!aTileEntity.isClientSide()) {
+            ITeslaConnectable.TeslaUtil.teslaSimpleNodeSetRemove(
+                new TeslaCoverConnection(
+                    aTileEntity.getIGregTechTileEntityOffset(0, 0, 0),
+                    getTeslaReceptionCapability()));
+        }
+    }
+
+    @Override
+    public boolean onCoverRemoval(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+        boolean aForced) {
+        ITeslaConnectable.TeslaUtil.teslaSimpleNodeSetRemove(
+            new TeslaCoverConnection(aTileEntity.getIGregTechTileEntityOffset(0, 0, 0), getTeslaReceptionCapability()));
+        return super.onCoverRemoval(side, aCoverID, aCoverVariable, aTileEntity, aForced);
+    }
+
+    @Override
+    public void onBaseTEDestroyed(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        ITeslaConnectable.TeslaUtil.teslaSimpleNodeSetRemove(
+            new TeslaCoverConnection(aTileEntity.getIGregTechTileEntityOffset(0, 0, 0), getTeslaReceptionCapability()));
+    }
+
+    @Override
+    public String getDescription(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return "Do not attempt to use screwdriver!"; // TODO Translation support
+    }
+
+    @Override
+    public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+        EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        // Shock a non-hazmat player if they dare stuff a screwdriver into one of these
+        if (aTileEntity.getStoredEU() > 0 && !GTUtility.isWearingFullElectroHazmat(aPlayer)) {
+            aPlayer.attackEntityFrom(DMG_ELECTRIC, 20);
+        }
+        return aCoverVariable;
+    }
+
+    @Override
+    public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        // It updates once every 10 ticks, so once every 0.5 second
+        return 10;
+    }
+
+    public byte getTeslaReceptionCapability() {
+        return 2;
+    }
+}
diff --git a/src/main/java/tectech/thing/cover/CoverTeslaCoilUltimate.java b/src/main/java/tectech/thing/cover/CoverTeslaCoilUltimate.java
new file mode 100644
index 0000000000..8f7ab28869
--- /dev/null
+++ b/src/main/java/tectech/thing/cover/CoverTeslaCoilUltimate.java
@@ -0,0 +1,44 @@
+package tectech.thing.cover;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+
+import gregtech.api.interfaces.tileentity.ICoverable;
+
+public class CoverTeslaCoilUltimate extends CoverTeslaCoil {
+
+    public CoverTeslaCoilUltimate() {}
+
+    @Override
+    public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    public byte getTeslaReceptionCapability() {
+        return 1;
+    }
+}