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, 138 insertions, 144 deletions

diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeFusionComputer.java
index 5c31d55b16..b14395dc20 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeFusionComputer.java
@@ -2,10 +2,10 @@ package goodgenerator.blocks.tileEntity.base;
 
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static gregtech.api.enums.Textures.BlockIcons.*;
-import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
-import static gregtech.api.util.GT_StructureUtility.filterByMTETier;
-import static gregtech.api.util.GT_StructureUtility.ofFrame;
-import static gregtech.api.util.GT_Utility.filterValidMTEs;
+import static gregtech.api.util.GTStructureUtility.buildHatchAdder;
+import static gregtech.api.util.GTStructureUtility.filterByMTETier;
+import static gregtech.api.util.GTStructureUtility.ofFrame;
+import static gregtech.api.util.GTUtility.filterValidMTEs;
 
 import java.util.List;
 
@@ -24,7 +24,6 @@ import net.minecraftforge.fluids.FluidStack;
 
 import org.jetbrains.annotations.NotNull;
 
-import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
 import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
@@ -38,8 +37,7 @@ import com.gtnewhorizons.modularui.common.widget.TextWidget;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import gregtech.api.enums.GT_HatchElement;
-import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.GTValues;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.SoundResource;
 import gregtech.api.enums.Textures;
@@ -48,12 +46,12 @@ import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.interfaces.tileentity.IOverclockDescriptionProvider;
 import gregtech.api.logic.ProcessingLogic;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
-import gregtech.api.objects.GT_ChunkManager;
-import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.metatileentity.implementations.MTEHatchEnergy;
+import gregtech.api.metatileentity.implementations.MTEHatchInput;
+import gregtech.api.metatileentity.implementations.MTEHatchOutput;
+import gregtech.api.objects.GTChunkManager;
+import gregtech.api.objects.GTItemStack;
 import gregtech.api.objects.overclockdescriber.FusionOverclockDescriber;
 import gregtech.api.objects.overclockdescriber.OverclockDescriber;
 import gregtech.api.recipe.RecipeMap;
@@ -61,28 +59,29 @@ import gregtech.api.recipe.RecipeMaps;
 import gregtech.api.recipe.check.CheckRecipeResult;
 import gregtech.api.recipe.check.CheckRecipeResultRegistry;
 import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_HatchElementBuilder;
-import gregtech.api.util.GT_OverclockCalculator;
-import gregtech.api.util.GT_ParallelHelper;
-import gregtech.api.util.GT_Recipe;
-import gregtech.api.util.GT_Utility;
+import gregtech.api.util.GTRecipe;
+import gregtech.api.util.GTUtility;
+import gregtech.api.util.HatchElementBuilder;
+import gregtech.api.util.OverclockCalculator;
+import gregtech.api.util.ParallelHelper;
 import gregtech.common.tileentities.machines.IDualInputHatch;
-import gregtech.common.tileentities.machines.multi.drone.GT_MetaTileEntity_Hatch_DroneDownLink;
+import gregtech.common.tileentities.machines.multi.drone.MTEHatchDroneDownLink;
+import tectech.thing.metaTileEntity.hatch.MTEHatchEnergyMulti;
 
-public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+public abstract class MTELargeFusionComputer extends MTETooltipMultiBlockBaseEM
     implements IConstructable, ISurvivalConstructable, IOverclockDescriptionProvider {
 
     public static final String MAIN_NAME = "largeFusion";
     public static final int M = 1_000_000;
     private boolean isLoadedChunk;
-    public GT_Recipe mLastRecipe;
+    public GTRecipe mLastRecipe;
     public int para;
     protected OverclockDescriber overclockDescriber;
-    private static final ClassValue<IStructureDefinition<LargeFusionComputer>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<LargeFusionComputer>>() {
+    private static final ClassValue<IStructureDefinition<MTELargeFusionComputer>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<MTELargeFusionComputer>>() {
 
         @Override
-        protected IStructureDefinition<LargeFusionComputer> computeValue(Class<?> type) {
-            return StructureDefinition.<LargeFusionComputer>builder()
+        protected IStructureDefinition<MTELargeFusionComputer> computeValue(Class<?> type) {
+            return StructureDefinition.<MTELargeFusionComputer>builder()
                 .addShape(MAIN_NAME, transpose(new String[][] { L0, L1, L2, L3, L2, L1, L0 }))
                 .addElement('H', lazy(x -> ofBlock(x.getCoilBlock(), x.getCoilMeta())))
                 .addElement('C', lazy(x -> ofBlock(x.getCasingBlock(), x.getCasingMeta())))
@@ -90,11 +89,11 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
                 .addElement(
                     'I',
                     lazy(
-                        x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
+                        x -> HatchElementBuilder.<MTELargeFusionComputer>builder()
                             .atLeast(
-                                GT_HatchElement.InputHatch.or(GT_HatchElement.InputBus),
-                                GT_HatchElement.OutputHatch)
-                            .adder(LargeFusionComputer::addFluidIO)
+                                gregtech.api.enums.HatchElement.InputHatch.or(gregtech.api.enums.HatchElement.InputBus),
+                                gregtech.api.enums.HatchElement.OutputHatch)
+                            .adder(MTELargeFusionComputer::addFluidIO)
                             .casingIndex(x.textureIndex())
                             .dot(1)
                             .hatchItemFilterAnd(x2 -> filterByMTETier(x2.hatchTier(), Integer.MAX_VALUE))
@@ -102,9 +101,11 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
                 .addElement(
                     'E',
                     lazy(
-                        x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
-                            .anyOf(HatchElement.EnergyMulti.or(GT_HatchElement.Energy))
-                            .adder(LargeFusionComputer::addEnergyInjector)
+                        x -> HatchElementBuilder.<MTELargeFusionComputer>builder()
+                            .anyOf(
+                                tectech.thing.metaTileEntity.multi.base.TTMultiblockBase.HatchElement.EnergyMulti
+                                    .or(gregtech.api.enums.HatchElement.Energy))
+                            .adder(MTELargeFusionComputer::addEnergyInjector)
                             .casingIndex(x.textureIndex())
                             .hatchItemFilterAnd(x2 -> filterByMTETier(x2.hatchTier(), Integer.MAX_VALUE))
                             .dot(2)
@@ -113,7 +114,7 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
                 .addElement(
                     'D',
                     lazy(
-                        x -> buildHatchAdder(LargeFusionComputer.class).adder(LargeFusionComputer::addDroneHatch)
+                        x -> buildHatchAdder(MTELargeFusionComputer.class).adder(MTELargeFusionComputer::addDroneHatch)
                             .hatchId(9401)
                             .casingIndex(x.textureIndex())
                             .dot(3)
@@ -137,13 +138,13 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
                     .build()));
     }
 
-    public LargeFusionComputer(String name) {
+    public MTELargeFusionComputer(String name) {
         super(name);
         useLongPower = true;
         this.overclockDescriber = createOverclockDescriber();
     }
 
-    public LargeFusionComputer(int id, String name, String nameRegional) {
+    public MTELargeFusionComputer(int id, String name, String nameRegional) {
         super(id, name, nameRegional);
         useLongPower = true;
         this.overclockDescriber = createOverclockDescriber();
@@ -199,7 +200,7 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
     public abstract ITexture getTextureOverlay();
 
     @Override
-    public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aStack) {
+    public boolean allowCoverOnSide(ForgeDirection side, GTItemStack aStack) {
         return side != getBaseMetaTileEntity().getFrontFacing();
     }
 
@@ -236,38 +237,38 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
     public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
         if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) {
             // if machine has stopped, stop chunkloading
-            GT_ChunkManager.releaseTicket((TileEntity) aBaseMetaTileEntity);
+            GTChunkManager.releaseTicket((TileEntity) aBaseMetaTileEntity);
             this.isLoadedChunk = false;
         } else if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && !this.isLoadedChunk) {
             // load a 3x3 area when machine is running
-            GT_ChunkManager.releaseTicket((TileEntity) aBaseMetaTileEntity);
+            GTChunkManager.releaseTicket((TileEntity) aBaseMetaTileEntity);
             int offX = aBaseMetaTileEntity.getFrontFacing().offsetX;
             int offZ = aBaseMetaTileEntity.getFrontFacing().offsetZ;
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + 1 + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() - 1 + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + 1 + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() - 1 + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + 1 + offZ));
-            GT_ChunkManager.requestChunkLoad(
+            GTChunkManager.requestChunkLoad(
                 (TileEntity) aBaseMetaTileEntity,
                 new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() - 1 + offZ));
             this.isLoadedChunk = true;
@@ -298,8 +299,8 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
                     }
 
                     long energyLimit = getSingleHatchPower();
-                    List<GT_MetaTileEntity_Hatch> hatches = getExoticAndNormalEnergyHatchList();
-                    for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(hatches)) {
+                    List<MTEHatch> hatches = getExoticAndNormalEnergyHatchList();
+                    for (MTEHatch hatch : filterValidMTEs(hatches)) {
                         long consumableEnergy = Math.min(hatch.getEUVar(), energyLimit);
                         long receivedEnergy = Math
                             .min(consumableEnergy, maxEUStore() - aBaseMetaTileEntity.getStoredEU());
@@ -365,27 +366,27 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
      * @return The power one hatch can deliver to the reactor
      */
     protected long getSingleHatchPower() {
-        return GT_Values.V[tier()] * getMaxPara() * extraPara(100) / 32;
+        return GTValues.V[tier()] * getMaxPara() * extraPara(100) / 32;
     }
 
     public boolean turnCasingActive(boolean status) {
         if (this.mEnergyHatches != null) {
-            for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) {
+            for (MTEHatchEnergy hatch : this.mEnergyHatches) {
                 hatch.updateTexture(status ? 52 : 53);
             }
         }
         if (this.eEnergyMulti != null) {
-            for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) {
+            for (MTEHatchEnergyMulti hatch : this.eEnergyMulti) {
                 hatch.updateTexture(status ? 52 : 53);
             }
         }
         if (this.mOutputHatches != null) {
-            for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) {
+            for (MTEHatchOutput hatch : this.mOutputHatches) {
                 hatch.updateTexture(status ? 52 : 53);
             }
         }
         if (this.mInputHatches != null) {
-            for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) {
+            for (MTEHatchInput hatch : this.mInputHatches) {
                 hatch.updateTexture(status ? 52 : 53);
             }
         }
@@ -437,25 +438,25 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
 
             @NotNull
             @Override
-            protected GT_ParallelHelper createParallelHelper(@NotNull GT_Recipe recipe) {
+            protected ParallelHelper createParallelHelper(@NotNull GTRecipe recipe) {
                 // When the fusion first loads and is still processing, it does the recipe check without consuming.
                 return super.createParallelHelper(recipe).setConsumption(!mRunningOnLoad);
             }
 
             @NotNull
             @Override
-            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+            protected OverclockCalculator createOverclockCalculator(@NotNull GTRecipe recipe) {
                 return overclockDescriber.createCalculator(super.createOverclockCalculator(recipe), recipe);
             }
 
             @NotNull
             @Override
-            protected CheckRecipeResult validateRecipe(@NotNull GT_Recipe recipe) {
+            protected CheckRecipeResult validateRecipe(@NotNull GTRecipe recipe) {
                 if (!mRunningOnLoad) {
                     if (recipe.mSpecialValue > maxEUStore()) {
                         return CheckRecipeResultRegistry.insufficientStartupPower(recipe.mSpecialValue);
                     }
-                    if (recipe.mEUt > GT_Values.V[tier()]) {
+                    if (recipe.mEUt > GTValues.V[tier()]) {
                         return CheckRecipeResultRegistry.insufficientPower(recipe.mEUt);
                     }
                 }
@@ -482,13 +483,13 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
 
     @Override
     protected void setProcessingLogicPower(ProcessingLogic logic) {
-        logic.setAvailableVoltage(GT_Values.V[tier()]);
-        logic.setAvailableAmperage(getSingleHatchPower() * 32 / GT_Values.V[tier()]);
+        logic.setAvailableVoltage(GTValues.V[tier()]);
+        logic.setAvailableAmperage(getSingleHatchPower() * 32 / GTValues.V[tier()]);
     }
 
     @Override
     public void onRemoval() {
-        if (this.isLoadedChunk) GT_ChunkManager.releaseTicket((TileEntity) getBaseMetaTileEntity());
+        if (this.isLoadedChunk) GTChunkManager.releaseTicket((TileEntity) getBaseMetaTileEntity());
         super.onRemoval();
     }
 
@@ -503,11 +504,11 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
     private boolean addEnergyInjector(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) {
         IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity();
         if (aMetaTileEntity == null) return false;
-        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy tHatch) {
+        if (aMetaTileEntity instanceof MTEHatchEnergy tHatch) {
             if (tHatch.getTierForStructure() < hatchTier()) return false;
             tHatch.updateTexture(aBaseCasingIndex);
             return mEnergyHatches.add(tHatch);
-        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti tHatch) {
+        } else if (aMetaTileEntity instanceof MTEHatchEnergyMulti tHatch) {
             if (tHatch.getTierForStructure() < hatchTier()) return false;
             tHatch.updateTexture(aBaseCasingIndex);
             return eEnergyMulti.add(tHatch);
@@ -518,16 +519,16 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
     private boolean addFluidIO(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) {
         IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity();
         if (aMetaTileEntity == null) return false;
-        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch hatch) {
+        if (aMetaTileEntity instanceof MTEHatch hatch) {
             hatch.updateTexture(aBaseCasingIndex);
             hatch.updateCraftingIcon(this.getMachineCraftingIcon());
         }
-        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input tInput) {
+        if (aMetaTileEntity instanceof MTEHatchInput tInput) {
             if (tInput.getTierForStructure() < hatchTier()) return false;
             tInput.mRecipeMap = getRecipeMap();
             return mInputHatches.add(tInput);
         }
-        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output tOutput) {
+        if (aMetaTileEntity instanceof MTEHatchOutput tOutput) {
             if (tOutput.getTierForStructure() < hatchTier()) return false;
             return mOutputHatches.add(tOutput);
         }
@@ -542,13 +543,13 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
         if (aBaseMetaTileEntity == null) return false;
         IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity();
         if (aMetaTileEntity == null) return false;
-        if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DroneDownLink tHatch)) return false;
+        if (!(aMetaTileEntity instanceof MTEHatchDroneDownLink tHatch)) return false;
         tHatch.updateTexture(aBaseCasingIndex);
         return addToMachineList(aBaseMetaTileEntity, aBaseCasingIndex);
     }
 
     @Override
-    public IStructureDefinition<LargeFusionComputer> getStructure_EM() {
+    public IStructureDefinition<MTELargeFusionComputer> getStructure_EM() {
         return STRUCTURE_DEFINITION.get(getClass());
     }
 
@@ -589,25 +590,25 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
         return new String[] { EnumChatFormatting.BLUE + "Fusion Reactor MK " + EnumChatFormatting.RESET + tier,
             StatCollector.translateToLocal("scanner.info.UX.0") + ": "
                 + EnumChatFormatting.LIGHT_PURPLE
-                + GT_Utility.formatNumbers(this.para)
+                + GTUtility.formatNumbers(this.para)
                 + EnumChatFormatting.RESET,
             StatCollector.translateToLocal("GT5U.fusion.req") + ": "
                 + EnumChatFormatting.RED
-                + GT_Utility.formatNumbers(-lEUt)
+                + GTUtility.formatNumbers(-lEUt)
                 + EnumChatFormatting.RESET
                 + "EU/t",
             StatCollector.translateToLocal("GT5U.multiblock.energy") + ": "
                 + EnumChatFormatting.GREEN
-                + GT_Utility.formatNumbers(baseMetaTileEntity != null ? baseMetaTileEntity.getStoredEU() : 0)
+                + GTUtility.formatNumbers(baseMetaTileEntity != null ? baseMetaTileEntity.getStoredEU() : 0)
                 + EnumChatFormatting.RESET
                 + " EU / "
                 + EnumChatFormatting.YELLOW
-                + GT_Utility.formatNumbers(maxEUStore())
+                + GTUtility.formatNumbers(maxEUStore())
                 + EnumChatFormatting.RESET
                 + " EU",
             StatCollector.translateToLocal("GT5U.fusion.plasma") + ": "
                 + EnumChatFormatting.YELLOW
-                + GT_Utility.formatNumbers(plasmaOut)
+                + GTUtility.formatNumbers(plasmaOut)
                 + EnumChatFormatting.RESET
                 + "L/t" };
     }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeFusionComputerPP.java
index 7d87e6fdd1..7089616911 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeFusionComputerPP.java
@@ -2,30 +2,29 @@ package goodgenerator.blocks.tileEntity.base;
 
 import static net.minecraft.util.StatCollector.translateToLocal;
 
-import com.github.technus.tectech.thing.metaTileEntity.multi.base.INameFunction;
-import com.github.technus.tectech.thing.metaTileEntity.multi.base.IStatusFunction;
-import com.github.technus.tectech.thing.metaTileEntity.multi.base.LedStatus;
-import com.github.technus.tectech.thing.metaTileEntity.multi.base.Parameters;
-
 import gregtech.api.objects.overclockdescriber.OverclockDescriber;
 import gregtech.api.util.AdvancedFusionOverclockDescriber;
+import tectech.thing.metaTileEntity.multi.base.INameFunction;
+import tectech.thing.metaTileEntity.multi.base.IStatusFunction;
+import tectech.thing.metaTileEntity.multi.base.LedStatus;
+import tectech.thing.metaTileEntity.multi.base.Parameters;
 
-public abstract class LargeFusionComputerPP extends LargeFusionComputer {
+public abstract class MTELargeFusionComputerPP extends MTELargeFusionComputer {
 
     protected Parameters.Group.ParameterIn batchSetting;
 
     /** Name of the batch setting */
-    private static final INameFunction<LargeFusionComputerPP> BATCH_SETTING_NAME = (base,
+    private static final INameFunction<MTELargeFusionComputerPP> BATCH_SETTING_NAME = (base,
         p) -> translateToLocal("gt.blockmachines.LargeFusionComputerPP.cfgi.0"); // Batch size
     /** Status of the batch setting */
-    private static final IStatusFunction<LargeFusionComputerPP> BATCH_STATUS = (base, p) -> LedStatus
+    private static final IStatusFunction<MTELargeFusionComputerPP> BATCH_STATUS = (base, p) -> LedStatus
         .fromLimitsInclusiveOuterBoundary(p.get(), 1, 0, 32, 128);
 
-    public LargeFusionComputerPP(String name) {
+    public MTELargeFusionComputerPP(String name) {
         super(name);
     }
 
-    public LargeFusionComputerPP(int id, String name, String nameRegional) {
+    public MTELargeFusionComputerPP(int id, String name, String nameRegional) {
         super(id, name, nameRegional);
     }
 
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeTurbineBase.java
index 3df71aa25a..1c298d2b9a 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeTurbineBase.java
@@ -5,9 +5,9 @@ package goodgenerator.blocks.tileEntity.base;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
-import static gregtech.api.enums.GT_HatchElement.*;
-import static gregtech.api.util.GT_StructureUtility.*;
-import static gregtech.api.util.GT_Utility.filterValidMTEs;
+import static gregtech.api.enums.HatchElement.*;
+import static gregtech.api.util.GTStructureUtility.*;
+import static gregtech.api.util.GTUtility.filterValidMTEs;
 
 import java.util.ArrayList;
 
@@ -28,24 +28,24 @@ import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.items.GT_MetaGenerated_Tool;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.items.MetaGeneratedTool;
+import gregtech.api.metatileentity.implementations.MTEEnhancedMultiBlockBase;
+import gregtech.api.metatileentity.implementations.MTEHatchDynamo;
+import gregtech.api.metatileentity.implementations.MTEHatchMuffler;
 import gregtech.api.recipe.check.CheckRecipeResult;
 import gregtech.api.recipe.check.CheckRecipeResultRegistry;
-import gregtech.api.util.GT_Utility;
-import gregtech.common.items.GT_MetaGenerated_Tool_01;
+import gregtech.api.util.GTUtility;
+import gregtech.common.items.MetaGeneratedTool01;
 
-public abstract class GT_MetaTileEntity_LargeTurbineBase extends
-    GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_LargeTurbineBase> implements ISurvivalConstructable {
+public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTELargeTurbineBase>
+    implements ISurvivalConstructable {
 
     private static final String STRUCTURE_PIECE_MAIN = "main";
-    private static final ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>>() {
+    private static final ClassValue<IStructureDefinition<MTELargeTurbineBase>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<MTELargeTurbineBase>>() {
 
         @Override
-        protected IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> computeValue(Class<?> type) {
-            return StructureDefinition.<GT_MetaTileEntity_LargeTurbineBase>builder()
+        protected IStructureDefinition<MTELargeTurbineBase> computeValue(Class<?> type) {
+            return StructureDefinition.<MTELargeTurbineBase>builder()
                 .addShape(
                     STRUCTURE_PIECE_MAIN,
                     transpose(
@@ -59,18 +59,16 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
                 .addElement(
                     'h',
                     lazy(
-                        t -> buildHatchAdder(GT_MetaTileEntity_LargeTurbineBase.class)
+                        t -> buildHatchAdder(MTELargeTurbineBase.class)
                             .atLeast(Maintenance, InputHatch, OutputHatch, OutputBus, InputBus, Muffler)
                             .casingIndex(t.getCasingTextureIndex())
                             .dot(2)
                             .buildAndChain(t.getCasingBlock(), t.getCasingMeta())))
-                .addElement(
-                    'x',
-                    (IStructureElementCheckOnly<GT_MetaTileEntity_LargeTurbineBase>) (aContext, aWorld, aX, aY, aZ) -> {
-                        TileEntity tTile = aWorld.getTileEntity(aX, aY, aZ);
-                        return !(tTile instanceof IGregTechTileEntity) || !(((IGregTechTileEntity) tTile)
-                            .getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase);
-                    })
+                .addElement('x', (IStructureElementCheckOnly<MTELargeTurbineBase>) (aContext, aWorld, aX, aY, aZ) -> {
+                    TileEntity tTile = aWorld.getTileEntity(aX, aY, aZ);
+                    return !(tTile instanceof IGregTechTileEntity)
+                        || !(((IGregTechTileEntity) tTile).getMetaTileEntity() instanceof MTELargeTurbineBase);
+                })
                 .build();
         }
     };
@@ -83,11 +81,11 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
     protected boolean looseFit = false;
     protected long maxPower = 0;
 
-    public GT_MetaTileEntity_LargeTurbineBase(int aID, String aName, String aNameRegional) {
+    public MTELargeTurbineBase(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
     }
 
-    public GT_MetaTileEntity_LargeTurbineBase(String aName) {
+    public MTELargeTurbineBase(String aName) {
         super(aName);
     }
 
@@ -97,7 +95,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
     }
 
     @Override
-    public IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> getStructureDefinition() {
+    public IStructureDefinition<MTELargeTurbineBase> getStructureDefinition() {
         return STRUCTURE_DEFINITION.get(getClass());
     }
 
@@ -139,10 +137,9 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
     @Override
     public @NotNull CheckRecipeResult checkProcessing() {
         ItemStack controllerSlot = getControllerSlot();
-        if ((counter & 7) == 0
-            && (controllerSlot == null || !(controllerSlot.getItem() instanceof GT_MetaGenerated_Tool)
-                || controllerSlot.getItemDamage() < 170
-                || controllerSlot.getItemDamage() > 179)) {
+        if ((counter & 7) == 0 && (controllerSlot == null || !(controllerSlot.getItem() instanceof MetaGeneratedTool)
+            || controllerSlot.getItemDamage() < 170
+            || controllerSlot.getItemDamage() > 179)) {
             stopMachine();
             return CheckRecipeResultRegistry.NO_TURBINE_FOUND;
         }
@@ -155,15 +152,14 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
                 || this.getBaseMetaTileEntity()
                     .hasInventoryBeenModified()) {
                 counter = 0;
-                baseEff = GT_Utility.safeInt(
-                    (long) ((5F
-                        + ((GT_MetaGenerated_Tool) controllerSlot.getItem()).getToolCombatDamage(controllerSlot))
+                baseEff = GTUtility.safeInt(
+                    (long) ((5F + ((MetaGeneratedTool) controllerSlot.getItem()).getToolCombatDamage(controllerSlot))
                         * 1000F));
-                optFlow = GT_Utility.safeInt(
+                optFlow = GTUtility.safeInt(
                     (long) Math.max(
                         Float.MIN_NORMAL,
-                        ((GT_MetaGenerated_Tool) controllerSlot.getItem()).getToolStats(controllerSlot)
-                            .getSpeedMultiplier() * GT_MetaGenerated_Tool.getPrimaryMaterial(controllerSlot).mToolSpeed
+                        ((MetaGeneratedTool) controllerSlot.getItem()).getToolStats(controllerSlot)
+                            .getSpeedMultiplier() * MetaGeneratedTool.getPrimaryMaterial(controllerSlot).mToolSpeed
                             * 50));
                 if (optFlow <= 0 || baseEff <= 0) {
                     stopMachine(); // in case the turbine got removed
@@ -181,7 +177,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
         // Magic numbers: can always change by at least 10 eu/t, but otherwise by at most 1 percent of the difference in
         // power level (per tick)
         // This is how much the turbine can actually change during this tick
-        int maxChangeAllowed = Math.max(10, GT_Utility.safeInt((long) Math.abs(difference) / 100));
+        int maxChangeAllowed = Math.max(10, GTUtility.safeInt((long) Math.abs(difference) / 100));
 
         if (Math.abs(difference) > maxChangeAllowed) { // If this difference is too big, use the maximum allowed change
             int change = maxChangeAllowed * (difference > 0 ? 1 : -1); // Make the change positive or negative.
@@ -210,10 +206,10 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
 
     @Override
     public int getMaxEfficiency(ItemStack aStack) {
-        if (GT_Utility.isStackInvalid(aStack)) {
+        if (GTUtility.isStackInvalid(aStack)) {
             return 0;
         }
-        if (aStack.getItem() instanceof GT_MetaGenerated_Tool_01) {
+        if (aStack.getItem() instanceof MetaGeneratedTool01) {
             return 10000;
         }
         return 0;
@@ -226,7 +222,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
 
     public long getMaximumOutput() {
         long aTotal = 0;
-        for (GT_MetaTileEntity_Hatch_Dynamo aDynamo : filterValidMTEs(mDynamoHatches)) {
+        for (MTEHatchDynamo aDynamo : filterValidMTEs(mDynamoHatches)) {
             long aVoltage = aDynamo.maxEUOutput();
             aTotal = aDynamo.maxAmperesOut() * aVoltage;
             break;
@@ -237,7 +233,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
     @Override
     public String[] getInfoData() {
         int mPollutionReduction = 0;
-        for (GT_MetaTileEntity_Hatch_Muffler tHatch : filterValidMTEs(mMufflerHatches)) {
+        for (MTEHatchMuffler tHatch : filterValidMTEs(mMufflerHatches)) {
             mPollutionReduction = Math.max(tHatch.calculatePollutionReduction(100), mPollutionReduction);
         }
 
@@ -253,15 +249,15 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
                 + EnumChatFormatting.RESET;
         int tDura = 0;
 
-        if (mInventory[1] != null && mInventory[1].getItem() instanceof GT_MetaGenerated_Tool_01) {
-            tDura = GT_Utility.safeInt(
-                (long) (100.0f / GT_MetaGenerated_Tool.getToolMaxDamage(mInventory[1])
-                    * (GT_MetaGenerated_Tool.getToolDamage(mInventory[1])) + 1));
+        if (mInventory[1] != null && mInventory[1].getItem() instanceof MetaGeneratedTool01) {
+            tDura = GTUtility.safeInt(
+                (long) (100.0f / MetaGeneratedTool.getToolMaxDamage(mInventory[1])
+                    * (MetaGeneratedTool.getToolDamage(mInventory[1])) + 1));
         }
 
         long storedEnergy = 0;
         long maxEnergy = 0;
-        for (GT_MetaTileEntity_Hatch_Dynamo tHatch : filterValidMTEs(mDynamoHatches)) {
+        for (MTEHatchDynamo tHatch : filterValidMTEs(mDynamoHatches)) {
             storedEnergy += tHatch.getBaseMetaTileEntity()
                 .getStoredEU();
             maxEnergy += tHatch.getBaseMetaTileEntity()
@@ -271,7 +267,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
             // 8 Lines available for information panels
             tRunning + ": "
                 + EnumChatFormatting.RED
-                + GT_Utility.formatNumbers(mEUt)
+                + GTUtility.formatNumbers(mEUt)
                 + EnumChatFormatting.RESET
                 + " EU/t", /* 1 */
             tMaintainance, /* 2 */
@@ -282,16 +278,16 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
                 + "%", /* 2 */
             StatCollector.translateToLocal("GT5U.multiblock.energy") + ": "
                 + EnumChatFormatting.GREEN
-                + GT_Utility.formatNumbers(storedEnergy)
+                + GTUtility.formatNumbers(storedEnergy)
                 + EnumChatFormatting.RESET
                 + " EU / "
                 + /* 3 */ EnumChatFormatting.YELLOW
-                + GT_Utility.formatNumbers(maxEnergy)
+                + GTUtility.formatNumbers(maxEnergy)
                 + EnumChatFormatting.RESET
                 + " EU",
             StatCollector.translateToLocal("GT5U.turbine.flow") + ": "
                 + EnumChatFormatting.YELLOW
-                + GT_Utility.formatNumbers(GT_Utility.safeInt((long) realOptFlow))
+                + GTUtility.formatNumbers(GTUtility.safeInt((long) realOptFlow))
                 + EnumChatFormatting.RESET
                 + " L/t"
                 + /* 4 */ EnumChatFormatting.YELLOW
@@ -301,7 +297,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
                 + ")", /* 5 */
             StatCollector.translateToLocal("GT5U.turbine.fuel") + ": "
                 + EnumChatFormatting.GOLD
-                + GT_Utility.formatNumbers(storedFluid)
+                + GTUtility.formatNumbers(storedFluid)
                 + EnumChatFormatting.RESET
                 + "L", /* 6 */
             StatCollector.translateToLocal(
@@ -317,7 +313,7 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase extends
             .contains("Steam"))
             ret[4] = StatCollector.translateToLocal("GT5U.turbine.flow") + ": "
                 + EnumChatFormatting.YELLOW
-                + GT_Utility.safeInt((long) realOptFlow)
+                + GTUtility.safeInt((long) realOptFlow)
                 + EnumChatFormatting.RESET
                 + " L/t";
         return ret;
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_TooltipMultiBlockBase_EM.java b/src/main/java/goodgenerator/blocks/tileEntity/base/MTETooltipMultiBlockBaseEM.java
index 010dc1db88..90d0cc5395 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_TooltipMultiBlockBase_EM.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/MTETooltipMultiBlockBaseEM.java
@@ -7,27 +7,25 @@ import net.minecraft.item.ItemStack;
 
 import org.lwjgl.input.Keyboard;
 
-import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
-
 import gregtech.api.interfaces.ISecondaryDescribable;
-import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.MultiblockTooltipBuilder;
+import tectech.thing.metaTileEntity.multi.base.TTMultiblockBase;
 
-public abstract class GT_MetaTileEntity_TooltipMultiBlockBase_EM extends GT_MetaTileEntity_MultiblockBase_EM
-    implements ISecondaryDescribable {
+public abstract class MTETooltipMultiBlockBaseEM extends TTMultiblockBase implements ISecondaryDescribable {
 
-    private static final Map<Integer, GT_Multiblock_Tooltip_Builder> tooltips = new ConcurrentHashMap<>();
+    private static final Map<Integer, MultiblockTooltipBuilder> tooltips = new ConcurrentHashMap<>();
 
-    protected GT_MetaTileEntity_TooltipMultiBlockBase_EM(int aID, String aName, String aNameRegional) {
+    protected MTETooltipMultiBlockBaseEM(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
     }
 
-    protected GT_MetaTileEntity_TooltipMultiBlockBase_EM(String aName) {
+    protected MTETooltipMultiBlockBaseEM(String aName) {
         super(aName);
     }
 
-    protected GT_Multiblock_Tooltip_Builder getTooltip() {
+    protected MultiblockTooltipBuilder getTooltip() {
         int tId = getBaseMetaTileEntity().getMetaTileID();
-        GT_Multiblock_Tooltip_Builder tooltip = tooltips.get(tId);
+        MultiblockTooltipBuilder tooltip = tooltips.get(tId);
         if (tooltip == null) {
             tooltip = createTooltip();
             tooltips.put(tId, tooltip);
@@ -35,7 +33,7 @@ public abstract class GT_MetaTileEntity_TooltipMultiBlockBase_EM extends GT_Meta
         return tooltip;
     }
 
-    protected abstract GT_Multiblock_Tooltip_Builder createTooltip();
+    protected abstract MultiblockTooltipBuilder createTooltip();
 
     @Override
     public String[] getDescription() {