Refactors

20 files changed, 756 insertions, 988 deletions

diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java
index 1dc0e34d53..2bc560f8e7 100644
--- a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java
+++ b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java
@@ -116,22 +116,22 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity
     public BaseMetaPipeEntity() {}
 
     @Override
-    public void writeToNBT(NBTTagCompound aNBT) {
+    public void writeToNBT(NBTTagCompound nbt) {
         try {
-            super.writeToNBT(aNBT);
+            super.writeToNBT(nbt);
         } catch (Throwable e) {
             GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity", e);
         }
         try {
-            aNBT.setInteger("mID", mID);
-            writeCoverNBT(aNBT, false);
-            aNBT.setByte("mConnections", mConnections);
-            aNBT.setByte("mColor", mColor);
-            aNBT.setBoolean("mWorks", !mWorks);
+            nbt.setInteger("mID", mID);
+            writeCoverNBT(nbt, false);
+            nbt.setByte("mConnections", mConnections);
+            nbt.setByte("mColor", mColor);
+            nbt.setBoolean("mWorks", !mWorks);
         } catch (Throwable e) {
             GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity", e);
         }
-        saveMetaTileNBT(aNBT);
+        saveMetaTileNBT(nbt);
     }
 
     @Override
diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java
index 386975dd6d..eb26cd7883 100644
--- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java
+++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java
@@ -132,36 +132,36 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity
     public BaseMetaTileEntity() {}
 
     @Override
-    public void writeToNBT(NBTTagCompound aNBT) {
+    public void writeToNBT(NBTTagCompound nbt) {
         try {
-            super.writeToNBT(aNBT);
+            super.writeToNBT(nbt);
         } catch (Throwable e) {
             GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity.", e);
         }
         try {
-            aNBT.setInteger("mID", mID);
-            aNBT.setLong("mStoredSteam", mStoredSteam);
-            aNBT.setLong("mStoredEnergy", mStoredEnergy);
-            writeCoverNBT(aNBT, false);
-            aNBT.setByte("mColor", mColor);
-            aNBT.setByte("mLightValue", mLightValue);
-            aNBT.setByte("mOtherUpgrades", mOtherUpgrades);
-            aNBT.setByte("mWorkData", mWorkData);
-            aNBT.setShort("mFacing", (short) mFacing.ordinal());
-            aNBT.setString("mOwnerName", mOwnerName);
-            aNBT.setString("mOwnerUuid", mOwnerUuid == null ? "" : mOwnerUuid.toString());
-            aNBT.setBoolean("mLockUpgrade", mLockUpgrade);
-            aNBT.setBoolean("mMuffler", mMuffler);
-            aNBT.setBoolean("mSteamConverter", mSteamConverter);
-            aNBT.setBoolean("mActive", mActive);
-            aNBT.setBoolean("mWorks", !mWorks);
-            aNBT.setBoolean("mInputDisabled", mInputDisabled);
-            aNBT.setBoolean("mOutputDisabled", mOutputDisabled);
-            aNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+            nbt.setInteger("mID", mID);
+            nbt.setLong("mStoredSteam", mStoredSteam);
+            nbt.setLong("mStoredEnergy", mStoredEnergy);
+            writeCoverNBT(nbt, false);
+            nbt.setByte("mColor", mColor);
+            nbt.setByte("mLightValue", mLightValue);
+            nbt.setByte("mOtherUpgrades", mOtherUpgrades);
+            nbt.setByte("mWorkData", mWorkData);
+            nbt.setShort("mFacing", (short) mFacing.ordinal());
+            nbt.setString("mOwnerName", mOwnerName);
+            nbt.setString("mOwnerUuid", mOwnerUuid == null ? "" : mOwnerUuid.toString());
+            nbt.setBoolean("mLockUpgrade", mLockUpgrade);
+            nbt.setBoolean("mMuffler", mMuffler);
+            nbt.setBoolean("mSteamConverter", mSteamConverter);
+            nbt.setBoolean("mActive", mActive);
+            nbt.setBoolean("mWorks", !mWorks);
+            nbt.setBoolean("mInputDisabled", mInputDisabled);
+            nbt.setBoolean("mOutputDisabled", mOutputDisabled);
+            nbt.setTag("GT.CraftingComponents", mRecipeStuff);
         } catch (Throwable e) {
             GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity.", e);
         }
-        saveMetaTileNBT(aNBT);
+        saveMetaTileNBT(nbt);
     }
 
     @Override
diff --git a/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java
index d8b0086f0f..ac523eb82c 100644
--- a/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java
+++ b/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java
@@ -106,15 +106,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
 
     private final ChunkCoordinates mReturnedCoordinates = new ChunkCoordinates();
 
-    public static ForgeDirection getSideForPlayerPlacing(Entity aPlayer, ForgeDirection defaultFacing,
+    public static ForgeDirection getSideForPlayerPlacing(Entity player, ForgeDirection defaultFacing,
         boolean[] aAllowedFacings) {
-        if (aPlayer != null) {
-            if (aPlayer.rotationPitch >= 65 && aAllowedFacings[SIDE_UP]) return ForgeDirection.UP;
-            if (aPlayer.rotationPitch <= -65 && aAllowedFacings[SIDE_DOWN]) return ForgeDirection.DOWN;
-            final byte rFacing = COMPASS_DIRECTIONS[MathHelper.floor_double(0.5D + 4.0F * aPlayer.rotationYaw / 360.0F)
-                & 0x3];
-            if (aAllowedFacings[rFacing]) return ForgeDirection.getOrientation(rFacing);
-        }
+
+        final ForgeDirection facingFromPlayer = GT_Utility.getSideFromPlayerFacing(player);
+        if (facingFromPlayer != ForgeDirection.UNKNOWN && aAllowedFacings[facingFromPlayer.ordinal()])
+            return facingFromPlayer;
+
         for (final ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) if (aAllowedFacings[dir.ordinal()]) return dir;
         return defaultFacing;
     }
@@ -160,18 +158,18 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final int getOffsetX(ForgeDirection side, int aMultiplier) {
-        return xCoord + side.offsetX * aMultiplier;
+    public final int getOffsetX(ForgeDirection side, int multiplier) {
+        return xCoord + side.offsetX * multiplier;
     }
 
     @Override
-    public final short getOffsetY(ForgeDirection side, int aMultiplier) {
-        return (short) (yCoord + side.offsetY * aMultiplier);
+    public final short getOffsetY(ForgeDirection side, int multiplier) {
+        return (short) (yCoord + side.offsetY * multiplier);
     }
 
     @Override
-    public final int getOffsetZ(ForgeDirection side, int aMultiplier) {
-        return zCoord + side.offsetZ * aMultiplier;
+    public final int getOffsetZ(ForgeDirection side, int multiplier) {
+        return zCoord + side.offsetZ * multiplier;
     }
 
     @Override
@@ -194,15 +192,15 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
 
     @Override
     @Deprecated
-    public final boolean openGUI(EntityPlayer aPlayer) {
-        return openGUI(aPlayer, 0);
+    public final boolean openGUI(EntityPlayer player) {
+        return openGUI(player, 0);
     }
 
     @Override
     @Deprecated
-    public final boolean openGUI(EntityPlayer aPlayer, int aID) {
-        if (aPlayer == null) return false;
-        aPlayer.openGui(GT, aID, worldObj, xCoord, yCoord, zCoord);
+    public final boolean openGUI(EntityPlayer player, int aID) {
+        if (player == null) return false;
+        player.openGui(GT, aID, worldObj, xCoord, yCoord, zCoord);
         return true;
     }
 
@@ -218,8 +216,8 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final BiomeGenBase getBiome(int aX, int aZ) {
-        return worldObj.getBiomeGenForCoords(aX, aZ);
+    public final BiomeGenBase getBiome(int x, int z) {
+        return worldObj.getBiomeGenForCoords(x, z);
     }
 
     @Override
@@ -228,8 +226,8 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final Block getBlockOffset(int aX, int aY, int aZ) {
-        return getBlock(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final Block getBlockOffset(int x, int y, int z) {
+        return getBlock(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
@@ -238,13 +236,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final Block getBlockAtSideAndDistance(ForgeDirection side, int aDistance) {
-        return getBlock(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final Block getBlockAtSideAndDistance(ForgeDirection side, int distance) {
+        return getBlock(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final byte getMetaIDOffset(int aX, int aY, int aZ) {
-        return getMetaID(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final byte getMetaIDOffset(int x, int y, int z) {
+        return getMetaID(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
@@ -253,13 +251,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final byte getMetaIDAtSideAndDistance(ForgeDirection side, int aDistance) {
-        return getMetaID(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final byte getMetaIDAtSideAndDistance(ForgeDirection side, int distance) {
+        return getMetaID(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final byte getLightLevelOffset(int aX, int aY, int aZ) {
-        return getLightLevel(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final byte getLightLevelOffset(int x, int y, int z) {
+        return getLightLevel(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
@@ -268,13 +266,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final byte getLightLevelAtSideAndDistance(ForgeDirection side, int aDistance) {
-        return getLightLevel(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final byte getLightLevelAtSideAndDistance(ForgeDirection side, int distance) {
+        return getLightLevel(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final boolean getOpacityOffset(int aX, int aY, int aZ) {
-        return getOpacity(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final boolean getOpacityOffset(int x, int y, int z) {
+        return getOpacity(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
@@ -283,13 +281,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final boolean getOpacityAtSideAndDistance(ForgeDirection side, int aDistance) {
-        return getOpacity(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final boolean getOpacityAtSideAndDistance(ForgeDirection side, int distance) {
+        return getOpacity(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final boolean getSkyOffset(int aX, int aY, int aZ) {
-        return getSky(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final boolean getSkyOffset(int x, int y, int z) {
+        return getSky(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
@@ -298,13 +296,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final boolean getSkyAtSideAndDistance(ForgeDirection side, int aDistance) {
-        return getSky(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final boolean getSkyAtSideAndDistance(ForgeDirection side, int distance) {
+        return getSky(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final boolean getAirOffset(int aX, int aY, int aZ) {
-        return getAir(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final boolean getAirOffset(int x, int y, int z) {
+        return getAir(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
@@ -313,31 +311,31 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final boolean getAirAtSideAndDistance(ForgeDirection side, int aDistance) {
-        return getAir(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final boolean getAirAtSideAndDistance(ForgeDirection side, int distance) {
+        return getAir(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final TileEntity getTileEntityOffset(int aX, int aY, int aZ) {
-        return getTileEntity(xCoord + aX, yCoord + aY, zCoord + aZ);
+    public final TileEntity getTileEntityOffset(int x, int y, int z) {
+        return getTileEntity(xCoord + x, yCoord + y, zCoord + z);
     }
 
     @Override
-    public final TileEntity getTileEntityAtSideAndDistance(ForgeDirection side, int aDistance) {
-        if (aDistance == 1) return getTileEntityAtSide(side);
-        return getTileEntity(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance));
+    public final TileEntity getTileEntityAtSideAndDistance(ForgeDirection side, int distance) {
+        if (distance == 1) return getTileEntityAtSide(side);
+        return getTileEntity(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance));
     }
 
     @Override
-    public final IInventory getIInventory(int aX, int aY, int aZ) {
-        final TileEntity tTileEntity = getTileEntity(aX, aY, aZ);
+    public final IInventory getIInventory(int x, int y, int z) {
+        final TileEntity tTileEntity = getTileEntity(x, y, z);
         if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity;
         return null;
     }
 
     @Override
-    public final IInventory getIInventoryOffset(int aX, int aY, int aZ) {
-        final TileEntity tTileEntity = getTileEntityOffset(aX, aY, aZ);
+    public final IInventory getIInventoryOffset(int x, int y, int z) {
+        final TileEntity tTileEntity = getTileEntityOffset(x, y, z);
         if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity;
         return null;
     }
@@ -350,22 +348,22 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int aDistance) {
-        final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance);
+    public final IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int distance) {
+        final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, distance);
         if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity;
         return null;
     }
 
     @Override
-    public final IFluidHandler getITankContainer(int aX, int aY, int aZ) {
-        final TileEntity tTileEntity = getTileEntity(aX, aY, aZ);
+    public final IFluidHandler getITankContainer(int x, int y, int z) {
+        final TileEntity tTileEntity = getTileEntity(x, y, z);
         if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity;
         return null;
     }
 
     @Override
-    public final IFluidHandler getITankContainerOffset(int aX, int aY, int aZ) {
-        final TileEntity tTileEntity = getTileEntityOffset(aX, aY, aZ);
+    public final IFluidHandler getITankContainerOffset(int x, int y, int z) {
+        final TileEntity tTileEntity = getTileEntityOffset(x, y, z);
         if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity;
         return null;
     }
@@ -378,22 +376,22 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int aDistance) {
-        final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance);
+    public final IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int distance) {
+        final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, distance);
         if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity;
         return null;
     }
 
     @Override
-    public final IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ) {
-        final TileEntity tTileEntity = getTileEntity(aX, aY, aZ);
+    public final IGregTechTileEntity getIGregTechTileEntity(int x, int y, int z) {
+        final TileEntity tTileEntity = getTileEntity(x, y, z);
         if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity;
         return null;
     }
 
     @Override
-    public final IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, int aZ) {
-        final TileEntity tTileEntity = getTileEntityOffset(aX, aY, aZ);
+    public final IGregTechTileEntity getIGregTechTileEntityOffset(int x, int y, int z) {
+        final TileEntity tTileEntity = getTileEntityOffset(x, y, z);
         if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity;
         return null;
     }
@@ -406,16 +404,16 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int aDistance) {
-        final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance);
+    public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int distance) {
+        final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, distance);
         if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity;
         return null;
     }
 
     @Override
-    public final Block getBlock(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return Blocks.air;
-        return worldObj.getBlock(aX, aY, aZ);
+    public final Block getBlock(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return Blocks.air;
+        return worldObj.getBlock(x, y, z);
     }
 
     public Block getBlock(ChunkCoordinates aCoords) {
@@ -426,39 +424,39 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public final byte getMetaID(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return 0;
-        return (byte) worldObj.getBlockMetadata(aX, aY, aZ);
+    public final byte getMetaID(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return 0;
+        return (byte) worldObj.getBlockMetadata(x, y, z);
     }
 
     @Override
-    public final byte getLightLevel(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return 0;
-        return (byte) (worldObj.getLightBrightness(aX, aY, aZ) * 15);
+    public final byte getLightLevel(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return 0;
+        return (byte) (worldObj.getLightBrightness(x, y, z) * 15);
     }
 
     @Override
-    public final boolean getSky(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return true;
-        return worldObj.canBlockSeeTheSky(aX, aY, aZ);
+    public final boolean getSky(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return true;
+        return worldObj.canBlockSeeTheSky(x, y, z);
     }
 
     @Override
-    public final boolean getOpacity(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return false;
-        return GT_Utility.isOpaqueBlock(worldObj, aX, aY, aZ);
+    public final boolean getOpacity(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return false;
+        return GT_Utility.isOpaqueBlock(worldObj, x, y, z);
     }
 
     @Override
-    public final boolean getAir(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return true;
-        return GT_Utility.isBlockAir(worldObj, aX, aY, aZ);
+    public final boolean getAir(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return true;
+        return GT_Utility.isBlockAir(worldObj, x, y, z);
     }
 
     @Override
-    public TileEntity getTileEntity(int aX, int aY, int aZ) {
-        if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return null;
-        return worldObj.getTileEntity(aX, aY, aZ);
+    public TileEntity getTileEntity(int x, int y, int z) {
+        if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return null;
+        return worldObj.getTileEntity(x, y, z);
     }
 
     @Override
@@ -492,8 +490,8 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
     }
 
     @Override
-    public void writeToNBT(NBTTagCompound aNBT) {
-        super.writeToNBT(aNBT);
+    public void writeToNBT(NBTTagCompound nbt) {
+        super.writeToNBT(nbt);
     }
 
     @Override
@@ -567,12 +565,12 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje
             zCoord);
     }
 
-    protected boolean crossedChunkBorder(int aX, int aZ) {
-        return aX >> 4 != xCoord >> 4 || aZ >> 4 != zCoord >> 4;
+    protected boolean crossedChunkBorder(int x, int z) {
+        return x >> 4 != xCoord >> 4 || z >> 4 != zCoord >> 4;
     }
 
-    public final boolean crossedChunkBorder(ChunkCoordinates aCoords) {
-        return aCoords.posX >> 4 != xCoord >> 4 || aCoords.posZ >> 4 != zCoord >> 4;
+    public final boolean crossedChunkBorder(ChunkCoordinates coords) {
+        return coords.posX >> 4 != xCoord >> 4 || coords.posZ >> 4 != zCoord >> 4;
     }
 
     public final void setOnFire() {
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java
index 6ee760553e..800e9af20a 100644
--- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java
@@ -8,9 +8,7 @@ import static gregtech.api.util.GT_Util.getTileEntity;
 import static gregtech.api.util.GT_Util.setTileEntity;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -54,15 +52,6 @@ import gregtech.api.interfaces.tileentity.IDebugableTileEntity;
 import gregtech.api.metatileentity.BaseTileEntity;
 import gregtech.api.metatileentity.CoverableTileEntity;
 import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_BreakBlock;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetBlockHardness;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetComparatorInputOverride;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetWeakChanges;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IsProvidingStrongPower;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IsProvidingWeakPower;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnNeighborBlockChange;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_ShouldCheckWeakPower;
 import gregtech.api.objects.XSTR;
 import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_Util;
@@ -75,142 +64,95 @@ import gregtech.common.render.GT_MultiTile_Renderer;
 @Optional.Interface(iface = "com.cricketcraft.chisel.api.IFacade", modid = "ChiselAPI")
 public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITileEntityProvider, IFacade {
 
-    protected static final Map<String, MultiTileEntityBlock> MULTI_BLOCK_MAP = new HashMap<>();
     private static boolean LOCK = false;
 
-    protected final String mNameInternal, mTool;
-    protected final int mHarvestLevelOffset, mHarvestLevelMinimum, mHarvestLevelMaximum;
-    protected final boolean mOpaque, mNormalCube;
-
-    public static String getName(String aMaterialName, SoundType aSoundType, String aTool, int aHarvestLevelOffset,
-        int aHarvestLevelMinimum, int aHarvestLevelMaximum, boolean aOpaque, boolean aNormalCube) {
-        return "gt.block.multiblock." + aMaterialName
-            + "."
-            + aSoundType.soundName
-            + "."
-            + aTool
-            + "."
-            + aHarvestLevelOffset
-            + "."
-            + aHarvestLevelMinimum
-            + "."
-            + aHarvestLevelMaximum
-            + "."
-            + aOpaque
-            + "."
-            + aNormalCube;
-    }
-
-    /**
-     * @param aMaterialName        the Name of the vanilla Material Field. In case this is not a vanilla Material,
-     *                             insert the Name you want to give your own Material instead.
-     * @param aMaterial            the Material used to determine the Block.
-     * @param aSoundType           the Sound Type of the Block.
-     * @param aTool                the Tool used to harvest this Block.
-     * @param aHarvestLevelOffset  obvious
-     * @param aHarvestLevelMinimum obvious
-     * @param aHarvestLevelMaximum obvious
-     * @param aOpaque              if this Block is Opaque.
-     * @param aNormalCube          if this Block is a normal Cube (for Redstone Stuff).
-     */
-    public static MultiTileEntityBlock getOrCreate(String aModID, String aMaterialName, Material aMaterial,
-        SoundType aSoundType, String aTool, int aHarvestLevelOffset, int aHarvestLevelMinimum, int aHarvestLevelMaximum,
-        boolean aOpaque, boolean aNormalCube) {
-        final MultiTileEntityBlock rBlock = MULTI_BLOCK_MAP.get(
-            aModID + ":"
-                + getName(
-                    aMaterialName,
-                    aSoundType,
-                    aTool = aTool.toLowerCase(),
-                    aHarvestLevelOffset,
-                    aHarvestLevelMinimum,
-                    aHarvestLevelMaximum,
-                    aOpaque,
-                    aNormalCube));
-        return rBlock == null
-            ? new MultiTileEntityBlock(
-                aModID,
-                aMaterialName,
-                aMaterial,
-                aSoundType,
-                aTool,
-                aHarvestLevelOffset,
-                aHarvestLevelMinimum,
-                aHarvestLevelMaximum,
-                aOpaque,
-                aNormalCube)
-            : rBlock;
-    }
-
-    protected MultiTileEntityBlock(String aModID, String aMaterialName, Material aMaterial, SoundType aSoundType,
-        String aTool, int aHarvestLevelOffset, int aHarvestLevelMinimum, int aHarvestLevelMaximum, boolean aOpaque,
-        boolean aNormalCube) {
-        super(aMaterial);
+    private boolean registered = false, normalCube;
+    protected String internalName, toolName, materialName, modID;
+
+    public String getName() {
+        return String.join(
+            ".",
+            "gt.block.multiblock",
+            materialName,
+            stepSound.soundName,
+            toolName,
+            Boolean.toString(opaque),
+            Boolean.toString(normalCube));
+    }
+
+    public MultiTileEntityBlock(Material material) {
+        super(material);
         if (GregTech_API.sPreloadFinished)
             throw new IllegalStateException("Blocks can only be initialized within preInit!");
+    }
 
-        mNameInternal = getName(
-            aMaterialName,
-            aSoundType,
-            aTool,
-            aHarvestLevelOffset,
-            aHarvestLevelMinimum,
-            aHarvestLevelMaximum,
-            aOpaque,
-            aNormalCube);
-        GameRegistry.registerBlock(this, ItemBlock.class, mNameInternal);
-
-        MULTI_BLOCK_MAP.put(aModID + ":" + mNameInternal, this);
-
-        setStepSound(aSoundType);
-        mOpaque = aOpaque;
-        mNormalCube = aNormalCube;
-
-        mTool = aTool.toLowerCase();
-        mHarvestLevelOffset = aHarvestLevelOffset;
-        mHarvestLevelMinimum = Math.max(0, aHarvestLevelMinimum);
-        mHarvestLevelMaximum = Math.max(aHarvestLevelMinimum, aHarvestLevelMaximum);
-
-        opaque = isOpaqueCube();
-        lightOpacity = isOpaqueCube() ? 255 : 0;
+    public MultiTileEntityBlock tool(String toolName) {
+        this.toolName = toolName.toLowerCase();
+        return this;
     }
 
-    @Override
-    public final void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) {
-        final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true);
-        if (aTileEntity != null) LAST_BROKEN_TILEENTITY.set(aTileEntity);
-        if (aTileEntity == null || !aTileEntity.shouldRefresh(this, aBlock, aMetaData, aMetaData, aWorld, aX, aY, aZ))
-            return;
-        if (aTileEntity instanceof IMTE_BreakBlock && ((IMTE_BreakBlock) aTileEntity).breakBlock()) return;
-        if (aTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData
-            && ((IMTE_HasMultiBlockMachineRelevantData) aTileEntity).hasMultiBlockMachineRelevantData())
-            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+    public MultiTileEntityBlock sound(SoundType soundtype) {
+        setStepSound(soundtype);
+        return this;
+    }
 
-        aWorld.removeTileEntity(aX, aY, aZ);
+    public MultiTileEntityBlock opaque(Boolean opaque) {
+        this.opaque = opaque;
+        return this;
     }
 
-    @Override
-    public ArrayList<String> getDebugInfo(EntityPlayer aPlayer, int aX, int aY, int aZ, int aLogLevel) {
-        final TileEntity aTileEntity = aPlayer.worldObj.getTileEntity(aX, aY, aZ);
-        if (aTileEntity instanceof IDebugableTileEntity mte) {
-            return mte.getDebugInfo(aPlayer, aLogLevel);
-        }
-        return new ArrayList<>();
+    public MultiTileEntityBlock normalCube(Boolean normalCube) {
+        this.normalCube = normalCube;
+        return this;
     }
 
-    @Override
-    public final boolean func_149730_j /* isFullBlock */() {
-        return mOpaque;
+    public MultiTileEntityBlock modID(String modID) {
+        this.modID = modID;
+        return this;
+    }
+
+    public MultiTileEntityBlock materialName(String materialName) {
+        this.materialName = materialName;
+        return this;
+    }
+
+    public MultiTileEntityBlock register() {
+        if (registered) throw new IllegalStateException("Block already registered " + internalName);
+        if (GregTech_API.sPreloadFinished)
+            throw new IllegalStateException("Blocks can only be initialized within preInit!");
+
+        registered = true;
+        internalName = getName();
+        lightOpacity = isOpaqueCube() ? 255 : 0;
+
+        GameRegistry.registerBlock(this, ItemBlock.class, internalName);
+        return this;
     }
 
     @Override
-    public final boolean isNormalCube() {
-        return mNormalCube;
+    public final void breakBlock(World world, int x, int y, int z, Block block, int metadata) {
+        final TileEntity tileEntity = getTileEntity(world, x, y, z, true);
+        if (tileEntity != null) LAST_BROKEN_TILEENTITY.set(tileEntity);
+        if (tileEntity == null || !tileEntity.shouldRefresh(this, block, metadata, metadata, world, x, y, z)) return;
+        if (tileEntity instanceof IMultiTileEntity mute) mute.onBlockBroken();
+        // spotless:off
+        // if (aTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData
+        //     && ((IMTE_HasMultiBlockMachineRelevantData) aTileEntity).hasMultiBlockMachineRelevantData())
+        //     GregTech_API.causeMachineUpdate(world, x, y, z);
+        // spotless:on
+
+        world.removeTileEntity(x, y, z);
+        super.breakBlock(world, x, y, z, block, metadata);
+
     }
 
     @Override
-    public final boolean renderAsNormalBlock() {
-        return mOpaque || mNormalCube;
+    public ArrayList<String> getDebugInfo(EntityPlayer aPlayer, int x, int y, int z, int aLogLevel) {
+        final TileEntity tileEntity = aPlayer.worldObj.getTileEntity(x, y, z);
+        if (tileEntity instanceof IDebugableTileEntity mte) {
+            return mte.getDebugInfo(aPlayer, aLogLevel);
+        }
+        return new ArrayList<>();
     }
 
     @Override
@@ -220,182 +162,181 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil
     }
 
     @Override
-    public final float getBlockHardness(World aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMTE_GetBlockHardness ? ((IMTE_GetBlockHardness) aTileEntity).getBlockHardness()
-            : 1.0F;
+    public final float getBlockHardness(World world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) tileEntity).getBlockHardness() : 1.0F;
     }
 
     @SideOnly(Side.CLIENT)
     @Override
-    public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int ordinalSide) {
+    public IIcon getIcon(IBlockAccess aIBlockAccess, int x, int y, int z, int ordinalSide) {
         return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon();
     }
 
     @SideOnly(Side.CLIENT)
     @Override
-    public IIcon getIcon(int ordinalSide, int aMeta) {
+    public IIcon getIcon(int ordinalSide, int meta) {
         return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon();
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public final void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB aAABB,
+    public final void addCollisionBoxesToList(World world, int x, int y, int z, AxisAlignedBB aAABB,
         List<AxisAlignedBB> aList, Entity aEntity) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if (aTileEntity instanceof IMultiTileEntity)
-            ((IMultiTileEntity) aTileEntity).addCollisionBoxesToList(aAABB, aList, aEntity);
-        else super.addCollisionBoxesToList(aWorld, aX, aY, aZ, aAABB, aList, aEntity);
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        if (tileEntity instanceof IMultiTileEntity)
+            ((IMultiTileEntity) tileEntity).addCollisionBoxesToList(aAABB, aList, aEntity);
+        else super.addCollisionBoxesToList(world, x, y, z, aAABB, aList, aEntity);
     }
 
     @Override
-    public final AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte ? mte.getCollisionBoundingBoxFromPool()
-            : aTileEntity == null ? null : super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+    public final AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mte ? mte.getCollisionBoundingBoxFromPool()
+            : tileEntity == null ? null : super.getCollisionBoundingBoxFromPool(world, x, y, z);
     }
 
     @Override
-    public final AxisAlignedBB getSelectedBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte ? mte.getSelectedBoundingBoxFromPool()
-            : super.getSelectedBoundingBoxFromPool(aWorld, aX, aY, aZ);
+    public final AxisAlignedBB getSelectedBoundingBoxFromPool(World world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mte ? mte.getSelectedBoundingBoxFromPool()
+            : super.getSelectedBoundingBoxFromPool(world, x, y, z);
     }
 
     @Override
-    public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = blockAccess.getTileEntity(aX, aY, aZ);
-        if (aTileEntity instanceof IMultiTileEntity mte) {
+    public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int x, int y, int z) {
+        final TileEntity tileEntity = blockAccess.getTileEntity(x, y, z);
+        if (tileEntity instanceof IMultiTileEntity mte) {
             mte.setBlockBoundsBasedOnState(this);
             return;
         }
-        super.setBlockBoundsBasedOnState(blockAccess, aX, aY, aZ);
+        super.setBlockBoundsBasedOnState(blockAccess, x, y, z);
     }
 
     @Override
     public final boolean isOpaqueCube() {
-        return mOpaque;
+        return opaque;
     }
 
     @Override
-    public final void onNeighborChange(IBlockAccess aWorld, int aX, int aY, int aZ, int aTileX, int aTileY,
-        int aTileZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+    public final void onNeighborChange(IBlockAccess world, int x, int y, int z, int aTileX, int aTileY, int aTileZ) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
         if (!LOCK) {
             LOCK = true;
-            if (aTileEntity instanceof BaseTileEntity)
-                ((BaseTileEntity) aTileEntity).onAdjacentBlockChange(aTileX, aTileY, aTileZ);
+            if (tileEntity instanceof BaseTileEntity)
+                ((BaseTileEntity) tileEntity).onAdjacentBlockChange(aTileX, aTileY, aTileZ);
             LOCK = false;
         }
     }
 
     @Override
-    public void onNeighborBlockChange(World aWorld, int aX, int aY, int aZ, Block aBlock) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+    public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
         if (!LOCK) {
             LOCK = true;
-            if (aTileEntity instanceof BaseTileEntity bte) bte.onAdjacentBlockChange(aX, aY, aZ);
+            if (tileEntity instanceof BaseTileEntity bte) bte.onAdjacentBlockChange(x, y, z);
             LOCK = false;
         }
-        if (aTileEntity instanceof IMTE_OnNeighborBlockChange change) change.onNeighborBlockChange(aWorld, aBlock);
-        if (aTileEntity == null) aWorld.setBlockToAir(aX, aY, aZ);
+        if (tileEntity instanceof IMultiTileEntity change) change.onNeighborBlockChange(world, block);
+
+        if (tileEntity == null) world.setBlockToAir(x, y, z);
     }
 
     @Override
-    public final void onBlockAdded(World aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if (aTileEntity instanceof IMultiTileEntity mte) mte.onBlockAdded();
+    public final void onBlockAdded(World world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        if (tileEntity instanceof IMultiTileEntity mte) mte.onBlockAdded();
     }
 
     @Override
-    public float getPlayerRelativeBlockHardness(EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte && mte.privateAccess()
-            && !((IMultiTileEntity) aTileEntity).playerOwnsThis(aPlayer, true) ? -1.0F
-                : super.getPlayerRelativeBlockHardness(aPlayer, aWorld, aX, aY, aZ);
+    public float getPlayerRelativeBlockHardness(EntityPlayer aPlayer, World world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mte && mte.privateAccess()
+            && !((IMultiTileEntity) tileEntity).playerOwnsThis(aPlayer, true) ? -1.0F
+                : super.getPlayerRelativeBlockHardness(aPlayer, world, x, y, z);
     }
 
     @Override
-    public final void onBlockClicked(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if (aTileEntity instanceof IMultiTileEntity mte) mte.onLeftClick(aPlayer);
-        else super.onBlockClicked(aWorld, aX, aY, aZ, aPlayer);
+    public final void onBlockClicked(World world, int x, int y, int z, EntityPlayer aPlayer) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        if (tileEntity instanceof IMultiTileEntity mte) mte.onLeftClick(aPlayer);
+        else super.onBlockClicked(world, x, y, z, aPlayer);
     }
 
     @Override
-    public boolean onBlockActivated(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer, int ordinalSide,
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer aPlayer, int ordinalSide,
         float aHitX, float aHitY, float aHitZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
         if (aPlayer != null && ItemList.TC_Thaumometer.isStackEqual(aPlayer.getHeldItem(), true, true)) return false;
-        return aTileEntity instanceof IMultiTileEntity mte
+        return tileEntity instanceof IMultiTileEntity mte
             && mte.onBlockActivated(aPlayer, ForgeDirection.getOrientation(ordinalSide), aHitX, aHitY, aHitZ);
     }
 
     @Override
-    public final int isProvidingWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMTE_IsProvidingWeakPower power
+    public final int isProvidingWeakPower(IBlockAccess world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity power
             ? power.isProvidingWeakPower(ForgeDirection.getOrientation(ordinalSide))
-            : super.isProvidingWeakPower(aWorld, aX, aY, aZ, ordinalSide);
+            : super.isProvidingWeakPower(world, x, y, z, ordinalSide);
     }
 
     @Override
-    public final int isProvidingStrongPower(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMTE_IsProvidingStrongPower power
+    public final int isProvidingStrongPower(IBlockAccess world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity power
             ? power.isProvidingStrongPower(ForgeDirection.getOrientation(ordinalSide))
-            : super.isProvidingStrongPower(aWorld, aX, aY, aZ, ordinalSide);
+            : super.isProvidingStrongPower(world, x, y, z, ordinalSide);
     }
 
     @Override
-    public final boolean shouldCheckWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMTE_ShouldCheckWeakPower power
+    public final boolean shouldCheckWeakPower(IBlockAccess world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity power
             ? power.shouldCheckWeakPower(ForgeDirection.getOrientation(ordinalSide))
-            : isNormalCube(aWorld, aX, aY, aZ);
+            : isNormalCube(world, x, y, z);
     }
 
     @Override
-    public final boolean getWeakChanges(IBlockAccess aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMTE_GetWeakChanges changes ? changes.getWeakChanges()
-            : super.getWeakChanges(aWorld, aX, aY, aZ);
+    public final boolean getWeakChanges(IBlockAccess world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity changes ? changes.getWeakChanges()
+            : super.getWeakChanges(world, x, y, z);
     }
 
     @Override
-    public final void harvestBlock(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, int aMeta) {
+    public final void harvestBlock(World world, EntityPlayer aPlayer, int x, int y, int z, int meta) {
         if (aPlayer == null) aPlayer = harvesters.get();
         aPlayer.addStat(StatList.mineBlockStatArray[getIdFromBlock(this)], 1);
         aPlayer.addExhaustion(0.025F);
         final boolean aSilkTouch = EnchantmentHelper.getSilkTouchModifier(aPlayer);
         final int aFortune = EnchantmentHelper.getFortuneModifier(aPlayer);
         float aChance = 1.0F;
-        final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true);
+        final TileEntity tileEntity = getTileEntity(world, x, y, z, true);
 
-        if (!(aTileEntity instanceof IMultiTileEntity mte)) {
+        if (!(tileEntity instanceof IMultiTileEntity mte)) {
             return;
         }
 
         final ArrayList<ItemStack> tList = mte.getDrops(aFortune, aSilkTouch);
         aChance = ForgeEventFactory
-            .fireBlockHarvesting(tList, aWorld, this, aX, aY, aZ, aMeta, aFortune, aChance, aSilkTouch, aPlayer);
+            .fireBlockHarvesting(tList, world, this, x, y, z, meta, aFortune, aChance, aSilkTouch, aPlayer);
         for (final ItemStack tStack : tList)
-            if (XSTR.XSTR_INSTANCE.nextFloat() <= aChance) dropBlockAsItem(aWorld, aX, aY, aZ, tStack);
+            if (XSTR.XSTR_INSTANCE.nextFloat() <= aChance) dropBlockAsItem(world, x, y, z, tStack);
 
     }
 
     @Override
-    public final boolean shouldSideBeRendered(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity aTileEntity = aWorld
-            .getTileEntity(aX - OFFX[ordinalSide], aY - OFFY[ordinalSide], aZ - OFFZ[ordinalSide]);
-        return aTileEntity instanceof IMultiTileEntity mte
+    public final boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tileEntity = world
+            .getTileEntity(x - OFFX[ordinalSide], y - OFFY[ordinalSide], z - OFFZ[ordinalSide]);
+        return tileEntity instanceof IMultiTileEntity mte
             ? mte.shouldSideBeRendered(ForgeDirection.getOrientation(ordinalSide))
-            : super.shouldSideBeRendered(aWorld, aX, aY, aZ, ordinalSide);
+            : super.shouldSideBeRendered(world, x, y, z, ordinalSide);
     }
 
     @Override
-    public Block getFacade(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+    public Block getFacade(IBlockAccess world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tTileEntity = world.getTileEntity(x, y, z);
         if (tTileEntity instanceof CoverableTileEntity tile) {
             final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide);
             if (ordinalSide != -1) {
@@ -418,8 +359,8 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil
     }
 
     @Override
-    public int getFacadeMetadata(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+    public int getFacadeMetadata(IBlockAccess world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tTileEntity = world.getTileEntity(x, y, z);
         if (tTileEntity instanceof CoverableTileEntity tile) {
             final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide);
             if (ordinalSide != -1) {
@@ -447,24 +388,19 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil
     }
 
     @Override
-    public final boolean canProvidePower() {
-        return !mNormalCube;
-    }
-
-    @Override
     public final String getLocalizedName() {
-        return StatCollector.translateToLocal(mNameInternal + ".name");
+        return StatCollector.translateToLocal(internalName + ".name");
     }
 
     @Override
     public final String getUnlocalizedName() {
-        return mNameInternal;
+        return internalName;
     }
 
     @Override
-    public final boolean onBlockEventReceived(World aWorld, int aX, int aY, int aZ, int aID, int aData) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity == null || aTileEntity.receiveClientEvent(aID, aData);
+    public final boolean onBlockEventReceived(World world, int x, int y, int z, int aID, int aData) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity == null || tileEntity.receiveClientEvent(aID, aData);
     }
 
     @Override
@@ -478,172 +414,164 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil
     }
 
     @Override
-    public final int getComparatorInputOverride(World aWorld, int aX, int aY, int aZ, int ordinalSide) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if (aTileEntity instanceof IMTE_GetComparatorInputOverride override) {
-            return override.getComparatorInputOverride(ForgeDirection.getOrientation(ordinalSide));
-        }
-
-        if (aTileEntity instanceof IMTE_IsProvidingWeakPower power) {
-            return power.isProvidingWeakPower(
+    public final int getComparatorInputOverride(World world, int x, int y, int z, int ordinalSide) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        if (tileEntity instanceof IMultiTileEntity mute) {
+            if (mute.hasComparatorInputOverride())
+                return mute.getComparatorInputOverride(ForgeDirection.getOrientation(ordinalSide));
+            else return mute.isProvidingWeakPower(
                 ForgeDirection.getOrientation(ordinalSide)
                     .getOpposite());
         }
 
-        return super.getComparatorInputOverride(aWorld, aX, aY, aZ, ordinalSide);
+        return super.getComparatorInputOverride(world, x, y, z, ordinalSide);
     }
 
     @Override
     public final void registerBlockIcons(IIconRegister aIconRegister) {
-        /**/
-    }
-
-    @Override
-    public final boolean isNormalCube(IBlockAccess aWorld, int aX, int aY, int aZ) {
-        return mNormalCube;
+        /* Do Nothing */
     }
 
     @Override
-    public final boolean isSideSolid(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection side) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte ? mte.isSideSolid(side) : mOpaque;
+    public final boolean isSideSolid(IBlockAccess world, int x, int y, int z, ForgeDirection side) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mute ? mute.isSideSolid(side) : opaque;
     }
 
     @Override
-    public boolean removedByPlayer(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, boolean aWillHarvest) {
-        final TileEntity aTileEntity = GT_Util.getTileEntity(aWorld, aX, aY, aZ, true);
-        if (aTileEntity != null) LAST_BROKEN_TILEENTITY.set(aTileEntity);
-        return super.removedByPlayer(aWorld, aPlayer, aX, aY, aZ, aWillHarvest);
+    public boolean removedByPlayer(World world, EntityPlayer aPlayer, int x, int y, int z, boolean aWillHarvest) {
+        final TileEntity tileEntity = GT_Util.getTileEntity(world, x, y, z, true);
+        if (tileEntity != null) LAST_BROKEN_TILEENTITY.set(tileEntity);
+        return super.removedByPlayer(world, aPlayer, x, y, z, aWillHarvest);
     }
 
     @Override
-    public int getFlammability(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) {
+    public int getFlammability(IBlockAccess world, int x, int y, int z, ForgeDirection face) {
         return 0;
     }
 
     @Override
-    public int getFireSpreadSpeed(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) {
-        return GregTech_API.sMachineFlammable && (aWorld.getBlockMetadata(aX, aY, aZ) == 0) ? 100 : 0;
+    public int getFireSpreadSpeed(IBlockAccess world, int x, int y, int z, ForgeDirection face) {
+        return GregTech_API.sMachineFlammable && (world.getBlockMetadata(x, y, z) == 0) ? 100 : 0;
     }
 
     @Override
-    public boolean hasTileEntity(int aMeta) {
+    public boolean hasTileEntity(int meta) {
         return true;
     }
 
     @Override
-    public final ArrayList<ItemStack> getDrops(World aWorld, int aX, int aY, int aZ, int aUnusableMetaData,
-        int aFortune) {
-        final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true);
-        if (aTileEntity instanceof IMultiTileEntity mte) return mte.getDrops(aFortune, false);
+    public final ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int aUnusableMetaData, int aFortune) {
+        final TileEntity tileEntity = getTileEntity(world, x, y, z, true);
+        if (tileEntity instanceof IMultiTileEntity mute) return mute.getDrops(aFortune, false);
         return new ArrayList<>();
     }
 
     @Override
-    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess aWorld, int aX, int aY, int aZ) {
+    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
         return false;
     }
 
     @Override
-    public final float getExplosionResistance(Entity aExploder, World aWorld, int aX, int aY, int aZ,
-        double aExplosionX, double aExplosionY, double aExplosionZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte
-            ? mte.getExplosionResistance(aExploder, aExplosionX, aExplosionY, aExplosionZ)
+    public final float getExplosionResistance(Entity aExploder, World world, int x, int y, int z, double aExplosionX,
+        double aExplosionY, double aExplosionZ) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mute
+            ? mute.getExplosionResistance(aExploder, aExplosionX, aExplosionY, aExplosionZ)
             : 1.0F;
     }
 
     @Override
-    public final void onBlockExploded(World aWorld, int aX, int aY, int aZ, Explosion aExplosion) {
-        if (aWorld.isRemote) return;
-        final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true);
-        if (aTileEntity != null) LAST_BROKEN_TILEENTITY.set(aTileEntity);
-        if (aTileEntity instanceof IMultiTileEntity mte) {
+    public final void onBlockExploded(World world, int x, int y, int z, Explosion aExplosion) {
+        if (world.isRemote) return;
+        final TileEntity tileEntity = getTileEntity(world, x, y, z, true);
+        if (tileEntity != null) LAST_BROKEN_TILEENTITY.set(tileEntity);
+        if (tileEntity instanceof IMultiTileEntity mute) {
             GT_Log.exp.printf(
                 "Explosion at : %d | %d | %d DIMID: %s due to near explosion!%n",
-                aX,
-                aY,
-                aZ,
-                aWorld.provider.dimensionId);
-            mte.onExploded(aExplosion);
-        } else aWorld.setBlockToAir(aX, aY, aZ);
+                x,
+                y,
+                z,
+                world.provider.dimensionId);
+            mute.onExploded(aExplosion);
+        } else world.setBlockToAir(x, y, z);
     }
 
     @Override
-    public final boolean canConnectRedstone(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) {
+    public final boolean canConnectRedstone(IBlockAccess world, int x, int y, int z, int ordinalSide) {
         return true;
     }
 
     @Override
-    public final boolean recolourBlock(World aWorld, int aX, int aY, int aZ, ForgeDirection side, int aColor) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte && mte.recolourBlock(side, (byte) aColor);
+    public final boolean recolourBlock(World world, int x, int y, int z, ForgeDirection side, int color) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mute && mute.recolourBlock(side, (byte) color);
     }
 
     @Override
-    public final String getHarvestTool(int aMeta) {
-        return mTool;
+    public final String getHarvestTool(int meta) {
+        return toolName;
     }
 
     @Override
-    public final int getHarvestLevel(int aMeta) {
-        return Math.max(mHarvestLevelMinimum, Math.min(mHarvestLevelMaximum, mHarvestLevelOffset + aMeta));
+    public int getHarvestLevel(int meta) {
+        return meta % 4;
     }
 
     @Override
-    public final boolean isToolEffective(String aType, int aMeta) {
-        return getHarvestTool(aMeta).equals(aType);
+    public final boolean isToolEffective(String toolType, int meta) {
+        return getHarvestTool(meta).equals(toolType);
     }
 
     @Override
-    public final ItemStack getPickBlock(MovingObjectPosition aTarget, World aWorld, int aX, int aY, int aZ,
+    public final ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z,
         EntityPlayer aPlayer) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(aTarget) : null;
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(target) : null;
     }
 
     @Override
-    public final ItemStack getPickBlock(MovingObjectPosition aTarget, World aWorld, int aX, int aY, int aZ) {
-        final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        return aTileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(aTarget) : null;
+    public final ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(target) : null;
     }
 
     @Nullable
-    public final IMultiTileEntity receiveMultiTileEntityData(@Nonnull IBlockAccess aWorld, int aX, int aY, int aZ,
+    public final IMultiTileEntity receiveMultiTileEntityData(@Nonnull IBlockAccess world, int x, int y, int z,
         int registryId, int aID) {
-        if (!(aWorld instanceof World)) return null;
-        TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+        if (!(world instanceof World)) return null;
+        TileEntity tileEntity = world.getTileEntity(x, y, z);
 
-        if (!(aTileEntity instanceof IMultiTileEntity mte) || mte.getMultiTileEntityRegistryID() != registryId
-            || mte.getMultiTileEntityID() != aID) {
+        if (!(tileEntity instanceof IMultiTileEntity mute) || mute.getMultiTileEntityRegistryID() != registryId
+            || mute.getMultiTileEntityID() != aID) {
             final MultiTileEntityRegistry tRegistry = MultiTileEntityRegistry.getRegistry(registryId);
             if (tRegistry == null) return null;
 
-            aTileEntity = tRegistry.getNewTileEntity((World) aWorld, aX, aY, aZ, aID);
-            if (!(aTileEntity instanceof IMultiTileEntity)) return null;
+            tileEntity = tRegistry.getNewTileEntity((World) world, x, y, z, aID);
+            if (!(tileEntity instanceof IMultiTileEntity)) return null;
 
-            setTileEntity((World) aWorld, aX, aY, aZ, aTileEntity, false);
+            setTileEntity((World) world, x, y, z, tileEntity, false);
         }
-        return (IMultiTileEntity) aTileEntity;
+        return (IMultiTileEntity) tileEntity;
     }
 
-    public void receiveCoverData(IMultiTileEntity mte, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4,
+    public void receiveCoverData(IMultiTileEntity mute, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4,
         int aCover5) {
         boolean updated;
-        updated = mte.setCoverIDAtSideNoUpdate(ForgeDirection.DOWN, aCover0);
-        updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.UP, aCover1);
-        updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.NORTH, aCover2);
-        updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.SOUTH, aCover3);
-        updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.WEST, aCover4);
-        updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.EAST, aCover5);
+        updated = mute.setCoverIDAtSideNoUpdate(ForgeDirection.DOWN, aCover0);
+        updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.UP, aCover1);
+        updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.NORTH, aCover2);
+        updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.SOUTH, aCover3);
+        updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.WEST, aCover4);
+        updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.EAST, aCover5);
 
         if (updated) {
-            mte.issueBlockUpdate();
+            mute.issueBlockUpdate();
         }
     }
 
     @Override
-    public final TileEntity createTileEntity(World aWorld, int aMeta) {
+    public final TileEntity createTileEntity(World world, int meta) {
         return null;
     }
 
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java
deleted file mode 100644
index 17e217ae7e..0000000000
--- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package gregtech.api.multitileentity;
-
-import static gregtech.GT_Mod.GT_FML_LOGGER;
-import static gregtech.api.util.GT_Util.setTileEntity;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.material.Material;
-import net.minecraft.client.renderer.texture.IIconRegister;
-import net.minecraft.init.Blocks;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.util.StatCollector;
-import net.minecraft.world.World;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import gregtech.api.GregTech_API;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData;
-import gregtech.common.render.GT_MultiTile_Renderer;
-
-public class MultiTileEntityBlockInternal extends Block {
-
-    public MultiTileEntityRegistry mMultiTileEntityRegistry;
-
-    public MultiTileEntityBlockInternal() {
-        super(Material.anvil);
-    }
-
-    @Override
-    public void registerBlockIcons(IIconRegister aIconRegister) {
-        /* Do Nothing */
-    }
-
-    @Override
-    public int getRenderType() {
-        return GT_MultiTile_Renderer.INSTANCE == null ? super.getRenderType()
-            : GT_MultiTile_Renderer.INSTANCE.getRenderId();
-    }
-
-    @Override
-    public final String getUnlocalizedName() {
-        return mMultiTileEntityRegistry.mNameInternal;
-    }
-
-    @Override
-    public final String getLocalizedName() {
-        return StatCollector.translateToLocal(mMultiTileEntityRegistry.mNameInternal + ".name");
-    }
-
-    public boolean placeBlock(World aWorld, int aX, int aY, int aZ, ForgeDirection side, short aMetaData,
-        NBTTagCompound aNBT, boolean aCauseBlockUpdates, boolean aForcePlacement) {
-        final MultiTileEntityContainer aMTEContainer = mMultiTileEntityRegistry
-            .getNewTileEntityContainer(aWorld, aX, aY, aZ, aMetaData, aNBT);
-        if (aMTEContainer == null) return false;
-
-        final Block tReplacedBlock = aWorld.getBlock(aX, aY, aZ);
-
-        // This is some complicated bullshit Greg had to do to make his MTEs work right.
-        // Set Block with reverse MetaData first.
-        aWorld.setBlock(aX, aY, aZ, aMTEContainer.mBlock, 15 - aMTEContainer.mBlockMetaData, 2);
-        // Make sure the Block has been set, yes I know setBlock has a true/false return value, but guess what, it is
-        // not reliable in 0.0001% of cases! -Greg
-        if (aWorld.getBlock(aX, aY, aZ) != aMTEContainer.mBlock) {
-            aWorld.setBlock(aX, aY, aZ, Blocks.air, 0, 0);
-            return false;
-        }
-        // TileEntity should not refresh yet! -Greg
-        ((IMultiTileEntity) aMTEContainer.mTileEntity).setShouldRefresh(false);
-        // Fake-Set the TileEntity first, bypassing a lot of checks. -Greg
-        setTileEntity(aWorld, aX, aY, aZ, aMTEContainer.mTileEntity, false);
-        // Now set the Block with the REAL MetaData. -Greg
-        setTileEntity(aWorld, aX, aY, aZ, aMTEContainer.mBlock, aMTEContainer.mBlockMetaData, 0, false);
-        // When the TileEntity is set now it SHOULD refresh! -Greg
-        ((IMultiTileEntity) aMTEContainer.mTileEntity).setShouldRefresh(true);
-        // But make sure again that the Block we have set was actually set properly, because 0.0001%! -Greg
-        if (aWorld.getBlock(aX, aY, aZ) != aMTEContainer.mBlock) {
-            aWorld.setBlock(aX, aY, aZ, Blocks.air, 0, 0);
-            return false;
-        }
-        // And finally properly set the TileEntity for real! -Greg
-        setTileEntity(aWorld, aX, aY, aZ, aMTEContainer.mTileEntity, aCauseBlockUpdates);
-        // Yep, all this just to set one Block and its TileEntity properly... -Greg
-
-        try {
-            if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData) {
-                if (((IMTE_HasMultiBlockMachineRelevantData) aMTEContainer.mTileEntity)
-                    .hasMultiBlockMachineRelevantData()) GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
-            }
-        } catch (Throwable e) {
-            GT_FML_LOGGER.error("causeMachineUpdate", e);
-        }
-
-        try {
-            if (!aWorld.isRemote && aCauseBlockUpdates) {
-                aWorld.notifyBlockChange(aX, aY, aZ, tReplacedBlock);
-                aWorld.func_147453_f(aX, aY, aZ, aMTEContainer.mBlock);
-            }
-        } catch (Throwable e) {
-            GT_FML_LOGGER.error("aCauseBlockUpdates", e);
-        }
-
-        try {
-            ((IMultiTileEntity) aMTEContainer.mTileEntity).onTileEntityPlaced();
-        } catch (Throwable e) {
-            GT_FML_LOGGER.error("onTileEntityPlaced", e);
-        }
-
-        try {
-            aWorld.func_147451_t /* updateAllLightTypes */(aX, aY, aZ);
-        } catch (Throwable e) {
-            GT_FML_LOGGER.error("updateAllLightTypes", e);
-        }
-        return true;
-    }
-
-    public MultiTileEntityRegistry getRegistry() {
-        return mMultiTileEntityRegistry;
-    }
-}
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java
new file mode 100644
index 0000000000..3d8da5d796
--- /dev/null
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java
@@ -0,0 +1,47 @@
+package gregtech.api.multitileentity;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.util.StatCollector;
+
+import gregtech.common.render.GT_MultiTile_Renderer;
+
+/*
+ * The internal block used in the registry for lookup.
+ * - Not the same as the block spawned with the MuTE to allow for multiple different types of blocks/materials
+ * in each registry.
+ */
+public class MultiTileEntityBlockRegistryInternal extends Block {
+
+    public MultiTileEntityRegistry registry;
+
+    public MultiTileEntityBlockRegistryInternal() {
+        super(Material.anvil);
+    }
+
+    @Override
+    public void registerBlockIcons(IIconRegister aIconRegister) {
+        /* Do Nothing */
+    }
+
+    @Override
+    public int getRenderType() {
+        return GT_MultiTile_Renderer.INSTANCE == null ? super.getRenderType()
+            : GT_MultiTile_Renderer.INSTANCE.getRenderId();
+    }
+
+    @Override
+    public final String getUnlocalizedName() {
+        return registry.getInternalName();
+    }
+
+    @Override
+    public final String getLocalizedName() {
+        return StatCollector.translateToLocal(registry.getInternalName() + ".name");
+    }
+
+    public MultiTileEntityRegistry getRegistry() {
+        return registry;
+    }
+}
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java
index 4ce4c3c886..6eba28bad9 100644
--- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java
@@ -17,77 +17,78 @@ import gregtech.common.tileentities.casings.upgrade.Tank;
 
 public class MultiTileEntityClassContainer {
 
-    private final WeakReference<MultiTileEntityRegistry> mRegistry;
-    private String mLocalized;
-    private String mCategoryName;
+    private final WeakReference<MultiTileEntityRegistry> registry;
+    private String localized;
+    private String categoryName;
 
-    public final short mID;
-    public Class<? extends MultiTileEntity> mClass;
-    public MultiTileEntityBlock mBlock;
-    public MultiTileEntity mCanonicalTileEntity;
-    public NBTTagCompound mParameters;
+    public final short muteID;
+    public Class<? extends MultiTileEntity> muteClass;
+    public MultiTileEntityBlock block;
+    public MultiTileEntity referenceTileEntity;
+    public NBTTagCompound parameters;
 
     // These have defaults
-    public byte mBlockMetaData = 1;
-    public byte mStackSize = 64;
-    public boolean mHidden = false;
+    public byte blockMetaData = 1;
+    public byte maxStackSize = 64;
+    public boolean hidden = false;
 
     public MultiTileEntityClassContainer(MultiTileEntityRegistry aRegistry, int aID,
         Class<? extends MultiTileEntity> aClass) {
         /* Start the Builder */
-        mRegistry = new WeakReference<>(aRegistry);
-        mID = (short) aID;
-        mClass = aClass;
-        mParameters = new NBTTagCompound();
+        registry = new WeakReference<>(aRegistry);
+        muteID = (short) aID;
+        muteClass = aClass;
+        parameters = new NBTTagCompound();
     }
 
     public boolean register() {
         /* End and register the Builder with the registry */
-        final MultiTileEntityRegistry registry = mRegistry.get();
+        final MultiTileEntityRegistry registry = this.registry.get();
 
-        if (mParameters.hasKey(NBT.MATERIAL) && !mParameters.hasKey(NBT.COLOR)) mParameters.setInteger(
+        if (parameters.hasKey(NBT.MATERIAL) && !parameters.hasKey(NBT.COLOR)) parameters.setInteger(
             NBT.COLOR,
             GT_Util.getRGBInt(
-                Materials.get(mParameters.getString(NBT.MATERIAL))
+                Materials.get(parameters.getString(NBT.MATERIAL))
                     .getRGBA()));
 
         try {
-            mCanonicalTileEntity = mClass.newInstance();
+            referenceTileEntity = muteClass.getDeclaredConstructor()
+                .newInstance();
         } catch (Throwable e) {
             throw new IllegalArgumentException(e);
         }
-        mCanonicalTileEntity.initFromNBT(mParameters, mID, (short) -1);
+        referenceTileEntity.initFromNBT(parameters, muteID, (short) -1);
 
-        return registry != null && registry.add(this.mLocalized, this.mCategoryName, this) != null;
+        return registry != null && registry.add(this.localized, this) != null;
     }
 
     public MultiTileEntityClassContainer name(String aName) {
-        mLocalized = aName;
+        localized = aName;
         return this;
     }
 
     public MultiTileEntityClassContainer category(String aCategoryName) {
-        mCategoryName = aCategoryName;
+        categoryName = aCategoryName;
         return this;
     }
 
     public MultiTileEntityClassContainer meta(int aMeta) {
-        mBlockMetaData = (byte) aMeta;
+        blockMetaData = (byte) aMeta;
         return this;
     }
 
     public MultiTileEntityClassContainer stackSize(int aStackSize) {
-        mStackSize = (byte) aStackSize;
+        maxStackSize = (byte) aStackSize;
         return this;
     }
 
     public MultiTileEntityClassContainer hide() {
-        mHidden = true;
+        hidden = true;
         return this;
     }
 
     public MultiTileEntityClassContainer setBlock(MultiTileEntityBlock aBlock) {
-        mBlock = aBlock;
+        block = aBlock;
         return this;
     }
 
@@ -97,68 +98,68 @@ public class MultiTileEntityClassContainer {
 
     public MultiTileEntityClassContainer material(Materials material) {
         // Sets the material, and the color from the material, if not already set
-        mParameters.setString(NBT.MATERIAL, material.toString());
-        if (!mParameters.hasKey(NBT.COLOR)) mParameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(material.getRGBA()));
+        parameters.setString(NBT.MATERIAL, material.toString());
+        if (!parameters.hasKey(NBT.COLOR)) parameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(material.getRGBA()));
         return this;
     }
 
     public MultiTileEntityClassContainer color(int rbg) {
-        mParameters.setInteger(NBT.COLOR, rbg);
+        parameters.setInteger(NBT.COLOR, rbg);
         return this;
     }
 
     public MultiTileEntityClassContainer color(short[] rgba) {
-        mParameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(rgba));
+        parameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(rgba));
         return this;
     }
 
     public MultiTileEntityClassContainer textureFolder(String texture) {
-        mParameters.setString(NBT.TEXTURE_FOLDER, texture);
+        parameters.setString(NBT.TEXTURE_FOLDER, texture);
         return this;
     }
 
     public MultiTileEntityClassContainer inputInventorySize(int aSize) {
-        mParameters.setInteger(NBT.INV_INPUT_SIZE, aSize);
+        parameters.setInteger(NBT.INV_INPUT_SIZE, aSize);
         return this;
     }
 
     public MultiTileEntityClassContainer outputInventorySize(int aSize) {
-        mParameters.setInteger(NBT.INV_OUTPUT_SIZE, aSize);
+        parameters.setInteger(NBT.INV_OUTPUT_SIZE, aSize);
         return this;
     }
 
     public MultiTileEntityClassContainer tankCapacity(Long aCapacity) {
-        mParameters.setLong(NBT.TANK_CAPACITY, aCapacity);
+        parameters.setLong(NBT.TANK_CAPACITY, aCapacity);
         return this;
     }
 
     public MultiTileEntityClassContainer tier(int aTier) {
         verifyDescendentOfMultiple(true, UpgradeCasing.class, FunctionalCasing.class);
-        mParameters.setInteger(NBT.TIER, aTier);
+        parameters.setInteger(NBT.TIER, aTier);
         return this;
     }
 
     public MultiTileEntityClassContainer upgradeInventorySize(int aSize) {
         verifyDescendentOf(Inventory.class);
 
-        mParameters.setInteger(NBT.UPGRADE_INVENTORY_SIZE, aSize);
+        parameters.setInteger(NBT.UPGRADE_INVENTORY_SIZE, aSize);
         return this;
     }
 
     public MultiTileEntityClassContainer upgradeTankCount(int count) {
         verifyDescendentOf(Tank.class);
 
-        mParameters.setInteger(NBT.UPGRADE_TANK_COUNT, count);
+        parameters.setInteger(NBT.UPGRADE_TANK_COUNT, count);
         return this;
     }
 
     public MultiTileEntityClassContainer upgradeTankCapacity(Long aCapacity) {
-        mParameters.setLong(NBT.UPGRADE_TANK_CAPACITY, aCapacity);
+        parameters.setLong(NBT.UPGRADE_TANK_CAPACITY, aCapacity);
         return this;
     }
 
     public MultiTileEntityClassContainer upgradeAmperage(long amperage) {
-        mParameters.setLong(NBT.UPGRADE_AMPERAGE, amperage);
+        parameters.setLong(NBT.UPGRADE_AMPERAGE, amperage);
         return this;
     }
 
@@ -172,34 +173,35 @@ public class MultiTileEntityClassContainer {
          * Merge in arbitrary NBT tuples of (key, value). Useful for anything for which a custom method has not yet been
          * exposed
          */
-        mParameters = GT_Util.fuseNBT(mParameters, GT_Util.makeNBT(aTags));
+        parameters = GT_Util.fuseNBT(parameters, GT_Util.makeNBT(aTags));
         return this;
     }
 
     private void verifyDescendentOf(Class<?> cls) {
         // Check if cls is extended by mClass
-        if (!cls.isAssignableFrom(mClass)) {
+        if (!cls.isAssignableFrom(muteClass)) {
             throw new IllegalArgumentException(
-                "Expected a descendent of " + cls.getName() + " got " + mClass.getName() + " instead.");
+                "Expected a descendent of " + cls.getName() + " got " + muteClass.getName() + " instead.");
         }
     }
 
     private void verifyDescendentOfMultiple(boolean onlyOne, Class<?>... classes) {
         boolean atLeastOne = false;
-        String classNames = "";
+        final StringBuilder classNames = new StringBuilder();
         for (Class<?> cls : classes) {
-            classNames += cls.getName() + " ";
+            classNames.append(cls.getName())
+                .append(" ");
             if (!onlyOne) {
                 verifyDescendentOf(cls);
                 atLeastOne = true;
-            } else if (cls.isAssignableFrom(mClass)) {
+            } else if (cls.isAssignableFrom(muteClass)) {
                 atLeastOne = true;
             }
         }
 
         if (!atLeastOne) {
             throw new IllegalArgumentException(
-                "Expected a descendent of any of these " + classNames + " got " + mClass.getName() + " instead.");
+                "Expected a descendent of any of these " + classNames + " got " + muteClass.getName() + " instead.");
         }
     }
 }
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java
index 3510140c12..3ca0ee46f4 100644
--- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java
@@ -1,30 +1,24 @@
 package gregtech.api.multitileentity;
 
-import static gregtech.api.util.GT_Util.setTileEntity;
-
-import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
 
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
+import gregtech.api.multitileentity.base.MultiTileEntity;
+import gregtech.api.util.GT_Util;
 
 public class MultiTileEntityContainer {
 
-    public final TileEntity mTileEntity;
-    public final MultiTileEntityBlock mBlock;
-    public final byte mBlockMetaData;
+    public final MultiTileEntity tileEntity;
+    public final MultiTileEntityBlock block;
+    public final byte blockMetaData;
 
-    public MultiTileEntityContainer(TileEntity aTileEntity, MultiTileEntityBlock aBlock, byte aBlockMetaData) {
-        mBlockMetaData = aBlockMetaData;
-        mTileEntity = aTileEntity;
-        mBlock = aBlock;
+    public MultiTileEntityContainer(MultiTileEntity tileEntity, MultiTileEntityBlock block, byte blockMetaData) {
+        this.blockMetaData = blockMetaData;
+        this.tileEntity = tileEntity;
+        this.block = block;
     }
 
     public void setMultiTile(World aWorld, int aX, int aY, int aZ) {
-        // This is some complicated Bullshit Greg had to do to make his MTEs work right.
-        ((IMultiTileEntity) mTileEntity).setShouldRefresh(false);
-        setTileEntity(aWorld, aX, aY, aZ, mTileEntity, false);
-        setTileEntity(aWorld, aX, aY, aZ, mBlock, mBlockMetaData, 0, false);
-        ((IMultiTileEntity) mTileEntity).setShouldRefresh(true);
-        setTileEntity(aWorld, aX, aY, aZ, mTileEntity, true);
+        GT_Util.setBlock(aWorld, aX, aY, aZ, block, blockMetaData, 0, false);
+        GT_Util.setTileEntity(aWorld, aX, aY, aZ, tileEntity, true);
     }
 }
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItem.java
index cc10485f84..8dc1d348ff 100644
--- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItem.java
@@ -16,7 +16,6 @@ import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
@@ -25,43 +24,33 @@ import net.minecraftforge.fluids.IFluidContainerItem;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import gregtech.api.GregTech_API;
 import gregtech.api.metatileentity.CoverableTileEntity;
 import gregtech.api.multitileentity.interfaces.IItemUpdatable;
 import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_AddToolTips;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_CanPlace;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetMaxStackSize;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IgnoreEntityCollisionWhenPlacing;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnlyPlaceableWhenSneaking;
 
-public class MultiTileEntityItemInternal extends ItemBlock implements IFluidContainerItem, IItemUpdatable {
+public class MultiTileEntityItem extends ItemBlock implements IFluidContainerItem, IItemUpdatable {
 
-    public final MultiTileEntityBlockInternal mBlock;
+    public final MultiTileEntityBlockRegistryInternal mBlock;
 
-    public MultiTileEntityItemInternal(Block aBlock) {
+    public MultiTileEntityItem(Block aBlock) {
         super(aBlock);
         setMaxDamage(0);
         setHasSubtypes(true);
-        mBlock = (MultiTileEntityBlockInternal) aBlock;
+        mBlock = (MultiTileEntityBlockRegistryInternal) aBlock;
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List<String> aList, boolean aF3_H) {
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
         if (tTileEntityContainer == null) {
             aList.add("INVALID ITEM!");
             return;
         }
-        if (tTileEntityContainer.mTileEntity instanceof IMTE_AddToolTips mte) {
-            try {
-                mte.addToolTips(aList, aStack, aF3_H);
-            } catch (Throwable e) {
-                GT_FML_LOGGER.error("addInformation", e);
-            }
+        try {
+            tTileEntityContainer.tileEntity.addToolTips(aList, aStack, aF3_H);
+        } catch (Throwable e) {
+            GT_FML_LOGGER.error("addInformation", e);
         }
         final NBTTagCompound aNBT = aStack.getTagCompound();
         CoverableTileEntity.addInstalledCoversInformation(aNBT, aList);
@@ -72,10 +61,10 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
     @SideOnly(Side.CLIENT)
     @SuppressWarnings("unchecked")
     public void getSubItems(Item aItem, CreativeTabs aTab, List<ItemStack> aList) {
-        for (MultiTileEntityClassContainer tClass : mBlock.mMultiTileEntityRegistry.mRegistrations) {
-            if (!tClass.mHidden && ((IMultiTileEntity) tClass.mCanonicalTileEntity)
-                .getSubItems(mBlock, aItem, aTab, aList, tClass.mID)) {
-                aList.add(mBlock.mMultiTileEntityRegistry.getItem(tClass.mID));
+        for (MultiTileEntityClassContainer tClass : mBlock.registry.registrations) {
+            if (!tClass.hidden && ((IMultiTileEntity) tClass.referenceTileEntity)
+                .getSubItems(mBlock, aItem, aTab, aList, tClass.muteID)) {
+                aList.add(mBlock.registry.getItem(tClass.muteID));
             }
         }
     }
@@ -113,66 +102,52 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
                 return false;
             }
 
-            final MultiTileEntityContainer aMTEContainer = mBlock.mMultiTileEntityRegistry
+            final MultiTileEntityContainer MuTEContainer = mBlock.registry
                 .getNewTileEntityContainer(aWorld, aX, aY, aZ, aStack);
 
-            if (aMTEContainer == null) return false;
-
-            if (!aPlayer.isSneaking() && aMTEContainer.mTileEntity instanceof IMTE_OnlyPlaceableWhenSneaking mteSNeaking
-                && mteSNeaking.onlyPlaceableWhenSneaking()) {
-                return false;
-            }
-
-            if ((!(aMTEContainer.mTileEntity instanceof IMTE_IgnoreEntityCollisionWhenPlacing mteIgnoreCollision)
-                || !mteIgnoreCollision
-                    .ignoreEntityCollisionWhenPlacing(aStack, aPlayer, aWorld, aX, aY, aZ, side, aHitX, aHitY, aHitZ))
-                && !aWorld.checkNoEntityCollision(AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX + 1, aY + 1, aZ + 1))) {
-                return false;
-            }
-
-            if (aMTEContainer.mTileEntity instanceof IMTE_CanPlace mteCanPlace
-                && !mteCanPlace.canPlace(aStack, aPlayer, aWorld, aX, aY, aZ, side, aHitX, aHitY, aHitZ)) {
-                return false;
-            }
+            if (MuTEContainer == null) return false;
 
-            if (!aWorld.setBlock(aX, aY, aZ, aMTEContainer.mBlock, 15 - aMTEContainer.mBlockMetaData, 2)) {
+            if (!aWorld.setBlock(aX, aY, aZ, MuTEContainer.block, 15 - MuTEContainer.blockMetaData, 2)) {
                 return false;
             }
 
-            aMTEContainer.setMultiTile(aWorld, aX, aY, aZ);
+            MuTEContainer.setMultiTile(aWorld, aX, aY, aZ);
 
             try {
-                if (((IMultiTileEntity) aMTEContainer.mTileEntity)
+                if (((IMultiTileEntity) MuTEContainer.tileEntity)
                     .onPlaced(aStack, aPlayer, aWorld, aX, aY, aZ, side, aHitX, aHitY, aHitZ)) {
                     aWorld.playSoundEffect(
                         aX + 0.5,
                         aY + 0.5,
                         aZ + 0.5,
-                        aMTEContainer.mBlock.stepSound.func_150496_b(),
-                        (aMTEContainer.mBlock.stepSound.getVolume() + 1) / 2,
-                        aMTEContainer.mBlock.stepSound.getPitch() * 0.8F);
+                        MuTEContainer.block.stepSound.func_150496_b(),
+                        (MuTEContainer.block.stepSound.getVolume() + 1) / 2,
+                        MuTEContainer.block.stepSound.getPitch() * 0.8F);
                 }
             } catch (Throwable e) {
                 GT_FML_LOGGER.error("onPlaced", e);
             }
-            try {
-                if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData mteData
-                    && (mteData.hasMultiBlockMachineRelevantData())) {
-                    GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
-                }
-            } catch (Throwable e) {
-                GT_FML_LOGGER.error("causeMachineUpdate", e);
-            }
+            // spotless:off
+            /*
+             * Used to be behind `IMTE_HasMultiBlockMachineRelevantData`
+             *    Add back if needed
+             */
+            // try {
+            //     GregTech_API.causeMachineUpdate(world, x, y, z);
+            // } catch (Throwable e) {
+            //     GT_FML_LOGGER.error("causeMachineUpdate", e);
+            // }
+            // spotless:on
             try {
                 if (!aWorld.isRemote) {
                     aWorld.notifyBlockChange(aX, aY, aZ, tReplacedBlock);
-                    aWorld.func_147453_f /* updateNeighborsAboutBlockChange */(aX, aY, aZ, aMTEContainer.mBlock);
+                    aWorld.func_147453_f /* updateNeighborsAboutBlockChange */(aX, aY, aZ, MuTEContainer.block);
                 }
             } catch (Throwable e) {
                 GT_FML_LOGGER.error("notifyBlockChange", e);
             }
             try {
-                ((IMultiTileEntity) aMTEContainer.mTileEntity).onTileEntityPlaced();
+                ((IMultiTileEntity) MuTEContainer.tileEntity).onTileEntityPlaced();
             } catch (Throwable e) {
                 GT_FML_LOGGER.error("onTileEntityPlaced", e);
             }
@@ -193,37 +168,30 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
 
     @Override
     public void updateItemStack(ItemStack aStack) {
-        final MultiTileEntityClassContainer tContainer = mBlock.mMultiTileEntityRegistry.getClassContainer(aStack);
+        final MultiTileEntityClassContainer tContainer = mBlock.registry.getClassContainer(aStack);
         if (tContainer == null) return;
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
-        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable itemUpdatable) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.tileEntity instanceof IItemUpdatable itemUpdatable) {
             itemUpdatable.updateItemStack(aStack);
         }
     }
 
     @Override
     public void updateItemStack(ItemStack aStack, World aWorld, int aX, int aY, int aZ) {
-        final MultiTileEntityClassContainer tContainer = mBlock.mMultiTileEntityRegistry.getClassContainer(aStack);
+        final MultiTileEntityClassContainer tContainer = mBlock.registry.getClassContainer(aStack);
         if (tContainer == null) return;
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
-        if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable itemUpdatable) {
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
+        if (tTileEntityContainer != null && tTileEntityContainer.tileEntity instanceof IItemUpdatable itemUpdatable) {
             itemUpdatable.updateItemStack(aStack, aWorld, aX, aY, aZ);
         }
     }
 
     @Override
     public int getItemStackLimit(ItemStack aStack) {
-        final MultiTileEntityClassContainer tContainer = mBlock.mMultiTileEntityRegistry.getClassContainer(aStack);
+        final MultiTileEntityClassContainer tContainer = mBlock.registry.getClassContainer(aStack);
         if (tContainer == null) return 1;
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
-        if (tTileEntityContainer != null
-            && tTileEntityContainer.mTileEntity instanceof IMTE_GetMaxStackSize maxStackSize) {
-            return maxStackSize.getMaxStackSize(aStack, tContainer.mStackSize);
-        }
-        return tContainer.mStackSize;
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
+        return tContainer.maxStackSize;
     }
 
     @Override
@@ -233,10 +201,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
 
     @Override
     public FluidStack getFluid(ItemStack aStack) {
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
         if (tTileEntityContainer != null
-            && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) {
+            && tTileEntityContainer.tileEntity instanceof IFluidContainerItem fluidContainerItem) {
             final FluidStack rFluid = fluidContainerItem.getFluid(aStack);
             updateItemStack(aStack);
             return rFluid;
@@ -246,10 +213,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
 
     @Override
     public int getCapacity(ItemStack aStack) {
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
         if (tTileEntityContainer != null
-            && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) {
+            && tTileEntityContainer.tileEntity instanceof IFluidContainerItem fluidContainerItem) {
             final int rCapacity = fluidContainerItem.getCapacity(aStack);
             updateItemStack(aStack);
             return rCapacity;
@@ -259,10 +225,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
 
     @Override
     public int fill(ItemStack aStack, FluidStack aFluid, boolean aDoFill) {
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
         if (tTileEntityContainer != null
-            && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) {
+            && tTileEntityContainer.tileEntity instanceof IFluidContainerItem fluidContainerItem) {
             final int tFilled = fluidContainerItem.fill(aStack, aFluid, aDoFill);
             updateItemStack(aStack);
             return tFilled;
@@ -272,10 +237,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
 
     @Override
     public FluidStack drain(ItemStack aStack, int aMaxDrain, boolean aDoDrain) {
-        final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry
-            .getCachedTileEntityContainer(aStack);
+        final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack);
         if (tTileEntityContainer != null
-            && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) {
+            && tTileEntityContainer.tileEntity instanceof IFluidContainerItem fluidContainerItem) {
             final FluidStack rFluid = fluidContainerItem.drain(aStack, aMaxDrain, aDoDrain);
             updateItemStack(aStack);
             return rFluid;
@@ -291,12 +255,12 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont
 
     @Override
     public final String getUnlocalizedName() {
-        return mBlock.mMultiTileEntityRegistry.mNameInternal;
+        return mBlock.registry.getInternalName();
     }
 
     @Override
     public final String getUnlocalizedName(ItemStack aStack) {
-        return mBlock.mMultiTileEntityRegistry.mNameInternal + "." + getDamage(aStack);
+        return mBlock.registry.getInternalName() + "." + getDamage(aStack);
     }
 
     @Override
diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityRegistry.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityRegistry.java
index 3392d1ab41..7fe83075cd 100644
--- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityRegistry.java
+++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityRegistry.java
@@ -6,7 +6,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 
 import net.minecraft.block.Block;
 import net.minecraft.init.Items;
@@ -30,6 +29,8 @@ import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
 import gregtech.api.util.GT_LanguageManager;
 import gregtech.api.util.GT_Util;
 import gregtech.api.util.GT_Utility;
+import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
+import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
 
 public class MultiTileEntityRegistry {
 
@@ -40,49 +41,49 @@ public class MultiTileEntityRegistry {
     private static final HashSet<Class<?>> sRegisteredTileEntities = new HashSet<>();
     private final HashMap<Integer, MultiTileEntityContainer> cachedTileEntityContainers = new HashMap<>();
 
-    public HashMap<Short, CreativeTab> mCreativeTabs = new HashMap<>();
-    public Map<Short, MultiTileEntityClassContainer> mRegistry = new HashMap<>();
-    public List<MultiTileEntityClassContainer> mRegistrations = new ArrayList<>();
+    public HashMap<Short, CreativeTab> creativeTabs = new HashMap<>();
+    public final Short2ObjectMap<MultiTileEntityClassContainer> registry = new Short2ObjectOpenHashMap<>();
+    public List<MultiTileEntityClassContainer> registrations = new ArrayList<>();
 
-    public final String mNameInternal;
-    public final MultiTileEntityBlockInternal mBlock;
+    private final String internalName;
+    private final MultiTileEntityBlockRegistryInternal block;
 
-    private static MultiTileEntityBlockInternal regblock(String aNameInternal, MultiTileEntityBlockInternal aBlock,
-        Class<? extends ItemBlock> aItemClass) {
-        GameRegistry.registerBlock(aBlock, aItemClass == null ? ItemBlock.class : aItemClass, aNameInternal);
-        return aBlock;
+    private static MultiTileEntityBlockRegistryInternal regblock(String internalName,
+        MultiTileEntityBlockRegistryInternal block, Class<? extends ItemBlock> itemClass) {
+        GameRegistry.registerBlock(block, itemClass == null ? ItemBlock.class : itemClass, internalName);
+        return block;
     }
 
     /**
-     * @param aNameInternal the internal Name of the Item
+     * @param internalName the internal Name of the Item
      */
-    public MultiTileEntityRegistry(String aNameInternal) {
-        this(aNameInternal, new MultiTileEntityBlockInternal(), MultiTileEntityItemInternal.class);
+    public MultiTileEntityRegistry(String internalName) {
+        this(internalName, new MultiTileEntityBlockRegistryInternal(), MultiTileEntityItem.class);
     }
 
     /**
-     * @param aNameInternal the internal Name of the Item
+     * @param internalName the internal Name of the Item
      */
-    public MultiTileEntityRegistry(String aNameInternal, MultiTileEntityBlockInternal aBlock,
-        Class<? extends ItemBlock> aItemClass) {
-        this(aNameInternal, regblock(aNameInternal, aBlock, aItemClass));
+    public MultiTileEntityRegistry(String internalName, MultiTileEntityBlockRegistryInternal block,
+        Class<? extends ItemBlock> itemClass) {
+        this(internalName, regblock(internalName, block, itemClass));
     }
 
     /**
-     * @param aNameInternal the internal Name of the Item
+     * @param internalName the internal Name of the Item
      */
-    public MultiTileEntityRegistry(String aNameInternal, MultiTileEntityBlockInternal aBlock) {
+    public MultiTileEntityRegistry(String internalName, MultiTileEntityBlockRegistryInternal block) {
         if (!Loader.instance()
             .isInState(LoaderState.PREINITIALIZATION)) {
             throw new IllegalStateException(
                 "The MultiTileEntity Registry must be initialized during Preload Phase and not before");
         }
-        mNameInternal = aNameInternal;
-        mBlock = aBlock;
-        GT_FML_LOGGER.info(aNameInternal + " " + Block.getIdFromBlock(aBlock) + "This is the answer");
-        mBlock.mMultiTileEntityRegistry = this;
-        REGISTRIES.put(new ItemStack(Item.getItemById(Block.getIdFromBlock(aBlock)), 1, GT_Values.W), this);
-        NAMED_REGISTRIES.put(mNameInternal, this);
+        this.internalName = internalName;
+        this.block = block;
+        GT_FML_LOGGER.info(internalName + " " + Block.getIdFromBlock(block) + "This is the answer");
+        this.block.registry = this;
+        REGISTRIES.put(new ItemStack(Item.getItemById(Block.getIdFromBlock(block)), 1, GT_Values.W), this);
+        NAMED_REGISTRIES.put(internalName, this);
     }
 
     public static TileEntity getCanonicalTileEntity(int aRegistryID, int aMultiTileEntityID) {
@@ -90,7 +91,7 @@ public class MultiTileEntityRegistry {
         if (tRegistry == null) return null;
         final MultiTileEntityClassContainer tClassContainer = tRegistry.getClassContainer(aMultiTileEntityID);
         if (tClassContainer == null) return null;
-        return tClassContainer.mCanonicalTileEntity;
+        return tClassContainer.referenceTileEntity;
     }
 
     public static MultiTileEntityRegistry getRegistry(int aRegistryID) {
@@ -109,7 +110,7 @@ public class MultiTileEntityRegistry {
      * Adds a new MultiTileEntity. It is highly recommended to do this in either the PreInit or the Init Phase. PostInit
      * might not work well.
      */
-    public ItemStack add(String aLocalised, String aCategoricalName, MultiTileEntityClassContainer aClassContainer) {
+    public ItemStack add(String aLocalised, MultiTileEntityClassContainer aClassContainer) {
         boolean tFailed = false;
         if (GT_Utility.isStringInvalid(aLocalised)) {
             GT_FML_LOGGER.error("MULTI-TILE REGISTRY ERROR: Localisation Missing!");
@@ -119,21 +120,22 @@ public class MultiTileEntityRegistry {
             GT_FML_LOGGER.error("MULTI-TILE REGISTRY ERROR: Class Container is null!");
             tFailed = true;
         } else {
-            if (aClassContainer.mClass == null) {
+            if (aClassContainer.muteClass == null) {
                 GT_FML_LOGGER.error("MULTI-TILE REGISTRY ERROR: Class inside Class Container is null!");
                 tFailed = true;
             }
-            if (aClassContainer.mID == GT_Values.W) {
+            if (aClassContainer.muteID == GT_Values.W) {
                 GT_FML_LOGGER.error("MULTI-TILE REGISTRY ERROR: Class Container uses Wildcard MetaData!");
                 tFailed = true;
             }
-            if (aClassContainer.mID < 0) {
+            if (aClassContainer.muteID < 0) {
                 GT_FML_LOGGER.error("MULTI-TILE REGISTRY ERROR: Class Container uses negative MetaData!");
                 tFailed = true;
             }
-            if (mRegistry.containsKey(aClassContainer.mID)) {
+            if (registry.containsKey(aClassContainer.muteID)) {
                 GT_FML_LOGGER.error(
-                    "MULTI-TILE REGISTRY ERROR: Class Container uses occupied MetaData! (" + aClassContainer.mID + ")");
+                    "MULTI-TILE REGISTRY ERROR: Class Container uses occupied MetaData! (" + aClassContainer.muteID
+                        + ")");
                 tFailed = true;
             }
         }
@@ -147,31 +149,16 @@ public class MultiTileEntityRegistry {
             return null;
         }
 
-        GT_LanguageManager.addStringLocalization(mNameInternal + "." + aClassContainer.mID + ".name", aLocalised);
-        mRegistry.put(aClassContainer.mID, aClassContainer);
-        mLastRegisteredID = aClassContainer.mID;
-        mRegistrations.add(aClassContainer);
+        GT_LanguageManager.addStringLocalization(internalName + "." + aClassContainer.muteID + ".name", aLocalised);
+        registry.put(aClassContainer.muteID, aClassContainer);
+        mLastRegisteredID = aClassContainer.muteID;
+        registrations.add(aClassContainer);
 
-        if (sRegisteredTileEntities.add(aClassContainer.mCanonicalTileEntity.getClass())) {
-            aClassContainer.mCanonicalTileEntity.onRegistrationFirst(this, aClassContainer.mID);
+        if (sRegisteredTileEntities.add(aClassContainer.referenceTileEntity.getClass())) {
+            aClassContainer.referenceTileEntity.onRegistrationFirst(this, aClassContainer.muteID);
         }
-        // // TODO: Recipe
-        // if (aRecipe != null && aRecipe.length > 1) {
-        // if (aRecipe[0] instanceof Object[]) aRecipe = (Object[])aRecipe[0];
-        // if (aRecipe.length > 2) CR.shaped(getItem(aClassContainer.mID), CR.DEF_REV_NCC, aRecipe);
-        // }
-        // // A simple special case to make it easier to add a Machine to Recipe Lists without having to worry
-        // about anything.
-        // String tRecipeMapName = aClassContainer.mParameters.getString(NBT_RECIPEMAP);
-        // if (GT_Utility.isStringValid(tRecipeMapName)) {RecipeMap tMap =
-        // RecipeMap.RECIPE_MAPS.get(tRecipeMapName); if (tMap != null)
-        // tMap.mRecipeMachineList.add(getItem(aClassContainer.mID));}
-        // tRecipeMapName = aClassContainer.mParameters.getString(NBT_FUELMAP);
-        // if (GT_Utility.isStringValid(tRecipeMapName)) {RecipeMap tMap =
-        // RecipeMap.RECIPE_MAPS.get(tRecipeMapName); if (tMap != null)
-        // tMap.mRecipeMachineList.add(getItem(aClassContainer.mID));}
-        //
-        return getItem(aClassContainer.mID);
+
+        return getItem(aClassContainer.muteID);
     }
 
     public short mLastRegisteredID = GT_Values.W;
@@ -184,87 +171,88 @@ public class MultiTileEntityRegistry {
         return getItem(aID, 1, null);
     }
 
-    public ItemStack getItem(int aID, NBTTagCompound aNBT) {
-        return getItem(aID, 1, aNBT);
+    public ItemStack getItem(int aID, NBTTagCompound nbt) {
+        return getItem(aID, 1, nbt);
     }
 
     public ItemStack getItem(int aID, long aAmount) {
         return getItem(aID, aAmount, null);
     }
 
-    public ItemStack getItem(int aID, long aAmount, NBTTagCompound aNBT) {
-        final ItemStack rStack = new ItemStack(mBlock, (int) aAmount, aID);
-        if (aNBT == null || aNBT.hasNoTags()) {
-            aNBT = new NBTTagCompound();
-            final MultiTileEntityContainer tTileEntityContainer = getNewTileEntityContainer(aID, aNBT);
-            if (tTileEntityContainer != null) ((IMultiTileEntity) tTileEntityContainer.mTileEntity).writeItemNBT(aNBT);
+    public ItemStack getItem(int aID, long aAmount, NBTTagCompound nbt) {
+        final ItemStack rStack = new ItemStack(block, (int) aAmount, aID);
+        if (nbt == null || nbt.hasNoTags()) {
+            nbt = new NBTTagCompound();
+            final MultiTileEntityContainer tTileEntityContainer = getNewTileEntityContainer(aID, nbt);
+            if (tTileEntityContainer != null) ((IMultiTileEntity) tTileEntityContainer.tileEntity).writeItemNBT(nbt);
         }
-        rStack.setTagCompound(aNBT);
+        rStack.setTagCompound(nbt);
         return rStack;
     }
 
     public String getLocal(int aID) {
-        return StatCollector.translateToLocal(mNameInternal + "." + aID + ".name");
+        return StatCollector.translateToLocal(internalName + "." + aID + ".name");
     }
 
     public MultiTileEntityClassContainer getClassContainer(int aID) {
-        return mRegistry.get((short) aID);
+        return registry.get((short) aID);
     }
 
-    public MultiTileEntityClassContainer getClassContainer(ItemStack aStack) {
-        return mRegistry.get((short) Items.feather.getDamage(aStack));
+    public MultiTileEntityClassContainer getClassContainer(ItemStack stack) {
+        return registry.get((short) Items.feather.getDamage(stack));
     }
 
     public TileEntity getNewTileEntity(int aID) {
         final MultiTileEntityContainer tContainer = getNewTileEntityContainer(null, 0, 0, 0, aID, null);
-        return tContainer == null ? null : tContainer.mTileEntity;
+        return tContainer == null ? null : tContainer.tileEntity;
     }
 
-    public MultiTileEntityContainer getNewTileEntityContainer(World aWorld, int aX, int aY, int aZ, int aID,
-        NBTTagCompound aNBT) {
-        final MultiTileEntityClassContainer tClass = mRegistry.get((short) aID);
-        if (tClass == null || tClass.mBlock == null) return null;
-        final MultiTileEntityContainer rContainer = new MultiTileEntityContainer(
-            (TileEntity) GT_Utility.callConstructor(tClass.mClass, -1, null, true),
-            tClass.mBlock,
-            tClass.mBlockMetaData);
-        if (rContainer.mTileEntity == null) return null;
-        rContainer.mTileEntity.setWorldObj(aWorld);
-        rContainer.mTileEntity.xCoord = aX;
-        rContainer.mTileEntity.yCoord = aY;
-        rContainer.mTileEntity.zCoord = aZ;
-        ((IMultiTileEntity) rContainer.mTileEntity).initFromNBT(
-            aNBT == null || aNBT.hasNoTags() ? tClass.mParameters : GT_Util.fuseNBT(aNBT, tClass.mParameters),
+    public MultiTileEntityContainer getNewTileEntityContainer(World world, int x, int y, int z, int aID,
+        NBTTagCompound nbt) {
+        final MultiTileEntityClassContainer tClass = registry.get((short) aID);
+        if (tClass == null || tClass.block == null) return null;
+        final MultiTileEntityContainer container = new MultiTileEntityContainer(
+            (MultiTileEntity) GT_Utility.callConstructor(tClass.muteClass, -1, null, true),
+            tClass.block,
+            tClass.blockMetaData);
+        if (container.tileEntity == null) return null;
+        final MultiTileEntity tileEntity = container.tileEntity;
+        tileEntity.setWorldObj(world);
+        tileEntity.xCoord = x;
+        tileEntity.yCoord = y;
+        tileEntity.zCoord = z;
+        tileEntity.initFromNBT(
+            nbt == null || nbt.hasNoTags() ? tClass.parameters : GT_Util.fuseNBT(nbt, tClass.parameters),
             (short) aID,
-            (short) Block.getIdFromBlock(mBlock));
-        return rContainer;
+            (short) Block.getIdFromBlock(block));
+        return container;
     }
 
-    public TileEntity getNewTileEntity(World aWorld, int aX, int aY, int aZ, int aID) {
-        final MultiTileEntityContainer tContainer = getNewTileEntityContainer(aWorld, aX, aY, aZ, aID, null);
-        return tContainer == null ? null : tContainer.mTileEntity;
+    public TileEntity getNewTileEntity(World world, int x, int y, int z, int aID) {
+        final MultiTileEntityContainer tContainer = getNewTileEntityContainer(world, x, y, z, aID, null);
+        return tContainer == null ? null : tContainer.tileEntity;
     }
 
-    public TileEntity getNewTileEntity(ItemStack aStack) {
+    public TileEntity getNewTileEntity(ItemStack stack) {
         final MultiTileEntityContainer tContainer = getNewTileEntityContainer(
             null,
             0,
             0,
             0,
-            Items.feather.getDamage(aStack),
-            aStack.getTagCompound());
-        return tContainer == null ? null : tContainer.mTileEntity;
+            Items.feather.getDamage(stack),
+            stack.getTagCompound());
+        return tContainer == null ? null : tContainer.tileEntity;
     }
 
-    public TileEntity getNewTileEntity(World aWorld, int aX, int aY, int aZ, ItemStack aStack) {
+    public TileEntity getNewTileEntity(World world, int x, int y, int z, ItemStack stack) {
         final MultiTileEntityContainer tContainer = getNewTileEntityContainer(
-            aWorld,
-            aX,
-            aY,
-            aZ,
-            Items.feather.getDamage(aStack),
-            aStack.getTagCompound());
-        return tContainer == null ? null : tContainer.mTileEntity;
+            world,
+            x,
+            y,
+            z,
+            Items.feather.getDamage(stack),
+            stack.getTagCompound());
+        return tContainer == null ? null : tContainer.tileEntity;
     }
 
     public MultiTileEntityContainer getCachedTileEntityContainer(ItemStack stack) {
@@ -276,15 +264,23 @@ public class MultiTileEntityRegistry {
         return container;
     }
 
-    public MultiTileEntityContainer getNewTileEntityContainer(ItemStack aStack) {
-        return getNewTileEntityContainer(null, 0, 0, 0, Items.feather.getDamage(aStack), aStack.getTagCompound());
+    public MultiTileEntityContainer getNewTileEntityContainer(ItemStack stack) {
+        return getNewTileEntityContainer(null, 0, 0, 0, Items.feather.getDamage(stack), stack.getTagCompound());
+    }
+
+    public MultiTileEntityContainer getNewTileEntityContainer(World world, int x, int y, int z, ItemStack stack) {
+        return getNewTileEntityContainer(world, x, y, z, Items.feather.getDamage(stack), stack.getTagCompound());
+    }
+
+    public MultiTileEntityContainer getNewTileEntityContainer(int aID, NBTTagCompound nbt) {
+        return getNewTileEntityContainer(null, 0, 0, 0, aID, nbt);
     }
 
-    public MultiTileEntityContainer getNewTileEntityContainer(World aWorld, int aX, int aY, int aZ, ItemStack aStack) {
-        return getNewTileEntityContainer(aWorld, aX, aY, aZ, Items.feather.getDamage(aStack), aStack.getTagCompound());
+    public String getInternalName() {
+        return internalName;
     }
 
-    public MultiTileEntityContainer getNewTileEntityContainer(int aID, NBTTagCompound aNBT) {
-        return getNewTileEntityContainer(null, 0, 0, 0, aID, aNBT);
+    public MultiTileEntityBlockRegistryInternal getBlock() {
+        return block;
     }
 }
diff --git a/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java
index 7c56d40296..85f9f2497a 100644
--- a/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java
+++ b/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java
@@ -47,7 +47,7 @@ import gregtech.api.gui.modularui.GT_UIInfos;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.metatileentity.CoverableTileEntity;
 import gregtech.api.metatileentity.GregTechTileClientEvents;
-import gregtech.api.multitileentity.MultiTileEntityBlockInternal;
+import gregtech.api.multitileentity.MultiTileEntityBlockRegistryInternal;
 import gregtech.api.multitileentity.MultiTileEntityClassContainer;
 import gregtech.api.multitileentity.MultiTileEntityRegistry;
 import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
@@ -69,7 +69,7 @@ import mcp.mobius.waila.api.IWailaConfigHandler;
 import mcp.mobius.waila.api.IWailaDataAccessor;
 
 public abstract class MultiTileEntity extends CoverableTileEntity
-    implements IMultiTileEntity.IMTE_BreakBlock, MultiTileBasicRender, SyncedMultiTileEntity {
+    implements IMultiTileEntity, MultiTileBasicRender, SyncedMultiTileEntity {
 
     private ITexture baseTexture = null;
     private ITexture topOverlayTexture = null;
@@ -129,13 +129,13 @@ public abstract class MultiTileEntity extends CoverableTileEntity
     }
 
     @Override
-    public void initFromNBT(NBTTagCompound nbt, short mteID, short mteRegistry) {
-        if (this.mteID == mteID && this.mteRegistry == mteRegistry) {
+    public void initFromNBT(NBTTagCompound nbt, short muteID, short muteRegistry) {
+        if (this.mteID == muteID && this.mteRegistry == muteRegistry) {
             return;
         }
         // Set ID and Registry ID.
-        this.mteID = mteID;
-        this.mteRegistry = mteRegistry;
+        this.mteID = muteID;
+        this.mteRegistry = muteRegistry;
         // Read the Default Parameters from NBT.
         if (nbt != null) readFromNBT(nbt);
     }
@@ -225,7 +225,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity
                 if (tClass != null) {
                     // Add the Default Parameters. Useful for things that differ between different tiers/types of the
                     // same machine
-                    nbt = GT_Util.fuseNBT(nbt, tClass.mParameters);
+                    nbt = GT_Util.fuseNBT(nbt, tClass.parameters);
                 }
             }
         }
@@ -279,33 +279,33 @@ public abstract class MultiTileEntity extends CoverableTileEntity
     protected void readTasksNBT(NBTTagCompound nbt) {}
 
     @Override
-    public final void writeToNBT(NBTTagCompound aNBT) {
-        super.writeToNBT(aNBT);
+    public final void writeToNBT(NBTTagCompound nbt) {
+        super.writeToNBT(nbt);
         // write the IDs
-        aNBT.setShort(NBT.MTE_ID, mteID);
-        aNBT.setShort(NBT.MTE_REG, mteRegistry);
+        nbt.setShort(NBT.MTE_ID, mteID);
+        nbt.setShort(NBT.MTE_REG, mteRegistry);
         // write the Custom Name
         if (GT_Utility.isStringValid(customName)) {
             final NBTTagCompound displayNBT;
-            if (aNBT.hasKey(NBT.DISPLAY)) {
-                displayNBT = aNBT.getCompoundTag(NBT.DISPLAY);
+            if (nbt.hasKey(NBT.DISPLAY)) {
+                displayNBT = nbt.getCompoundTag(NBT.DISPLAY);
             } else {
                 displayNBT = new NBTTagCompound();
-                aNBT.setTag(NBT.DISPLAY, displayNBT);
+                nbt.setTag(NBT.DISPLAY, displayNBT);
             }
             displayNBT.setString(NBT.CUSTOM_NAME, customName);
         }
 
         // write the rest
         try {
-            aNBT.setString(NBT.OWNER, ownerName);
-            aNBT.setString(NBT.OWNER_UUID, ownerUUID == null ? "" : ownerUUID.toString());
-            aNBT.setBoolean(NBT.LOCK_UPGRADE, lockUpgrade);
-            aNBT.setInteger(NBT.FACING, facing.ordinal());
-
-            writeCoverNBT(aNBT, false);
-            writeTasksNBT(aNBT);
-            writeMultiTileNBT(aNBT);
+            nbt.setString(NBT.OWNER, ownerName);
+            nbt.setString(NBT.OWNER_UUID, ownerUUID == null ? "" : ownerUUID.toString());
+            nbt.setBoolean(NBT.LOCK_UPGRADE, lockUpgrade);
+            nbt.setInteger(NBT.FACING, facing.ordinal());
+
+            writeCoverNBT(nbt, false);
+            writeTasksNBT(nbt);
+            writeMultiTileNBT(nbt);
         } catch (Throwable e) {
             GT_FML_LOGGER.error("writeToNBT", e);
         }
@@ -373,7 +373,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity
     public void doBlockUpdate() {
         final Block tBlock = getBlock(getCoords());
         worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, tBlock);
-        if (this instanceof IMTE_IsProvidingStrongPower) {
+        if (this.providesStrongPower()) {
             for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
                 if (getBlockAtSide(side)
                     .isNormalCube(worldObj, xCoord + side.offsetX, yCoord + side.offsetY, zCoord + side.offsetZ)) {
@@ -989,15 +989,15 @@ public abstract class MultiTileEntity extends CoverableTileEntity
     }
 
     @Override
-    public boolean breakBlock() {
+    public boolean onBlockBroken() {
         isDead = true;
         onBaseTEDestroyed();
         return false;
     }
 
     @Override
-    public boolean getSubItems(MultiTileEntityBlockInternal aBlock, Item aItem, CreativeTabs aTab,
-        List<ItemStack> aList, short aID) {
+    public boolean getSubItems(MultiTileEntityBlockRegistryInternal block, Item item, CreativeTabs tab,
+        List<ItemStack> list, short aID) {
         return true;
     }
 
diff --git a/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java
index b25504dc6a..987a4c18b3 100644
--- a/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java
+++ b/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java
@@ -15,13 +15,12 @@ import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
 import gregtech.api.enums.GT_Values;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnNeighborBlockChange;
 import gregtech.api.task.TaskHost;
 import gregtech.api.task.TickableTask;
 import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_Util;
 
-public abstract class TickableMultiTileEntity extends MultiTileEntity implements TaskHost, IMTE_OnNeighborBlockChange {
+public abstract class TickableMultiTileEntity extends MultiTileEntity implements TaskHost {
 
     /** Variable for seeing if the Tick Function is called right now. */
     public boolean isRunningTick = false;
diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java
index 59d838fdeb..b239f4c4c0 100644
--- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java
+++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java
@@ -23,4 +23,13 @@ public interface IMultiBlockPart extends IMultiTileEntity, ItemInventoryLogicHos
     boolean tickCoverAtSide(ForgeDirection side, long aTickTimer);
 
     boolean shouldTick(long tickTimer);
+
+    int getMode();
+
+    void setMode(int mode);
+
+    int getAllowedModes();
+
+    void setAllowedModes(int allowedModes);
+
 }
diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java
index 91803690fc..d504e34c25 100644
--- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java
+++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java
@@ -18,13 +18,10 @@ import net.minecraft.world.Explosion;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-import cpw.mods.fml.common.Optional;
-import gregtech.api.enums.Mods;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IDebugableTileEntity;
 import gregtech.api.interfaces.tileentity.ITurnable;
-import gregtech.api.multitileentity.MultiTileEntityBlockInternal;
-import gregtech.api.multitileentity.MultiTileEntityItemInternal;
+import gregtech.api.multitileentity.MultiTileEntityBlockRegistryInternal;
 import gregtech.api.multitileentity.MultiTileEntityRegistry;
 
 /*
@@ -172,7 +169,7 @@ public interface IMultiTileEntity extends ICoverable, ITurnable, IDebugableTileE
     boolean recolourBlock(ForgeDirection side, byte aColor);
 
     /** Adds to the Creative Tab. return false to prevent it from being added. */
-    boolean getSubItems(MultiTileEntityBlockInternal aBlock, Item aItem, CreativeTabs aTab, List<ItemStack> aList,
+    boolean getSubItems(MultiTileEntityBlockRegistryInternal block, Item item, CreativeTabs tab, List<ItemStack> list,
         short aID);
 
     ItemStack getPickBlock(MovingObjectPosition aTarget);
@@ -184,110 +181,58 @@ public interface IMultiTileEntity extends ICoverable, ITurnable, IDebugableTileE
     boolean onPlaced(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, ForgeDirection side,
         float aHitX, float aHitY, float aHitZ);
 
-    // ItemStack getPickBlock(MovingObjectPosition aTarget);
-
-    /*
-     * Various Sub Interfaces from GT6
-     */
-
-    interface IMTE_OnNeighborBlockChange extends IMultiTileEntity {
-
-        void onNeighborBlockChange(World aWorld, Block aBlock);
-    }
-
-    interface IMTE_IsProvidingWeakPower extends IMultiTileEntity {
-
-        /** Remember that it passes the opposite Side due to the way vanilla works! */
-        int isProvidingWeakPower(ForgeDirection oppositeSide);
-    }
-
-    interface IMTE_IsProvidingStrongPower extends IMultiTileEntity {
-
-        /** Remember that it passes the opposite Side due to the way vanilla works! */
-        int isProvidingStrongPower(ForgeDirection oppositeSide);
-    }
-
-    interface IMTE_ShouldCheckWeakPower extends IMultiTileEntity {
-
-        boolean shouldCheckWeakPower(ForgeDirection side);
-    }
-
-    interface IMTE_GetWeakChanges extends IMultiTileEntity {
+    /** return true to prevent the TileEntity from being removed. */
+    boolean onBlockBroken();
 
-        boolean getWeakChanges();
+    default void onNeighborBlockChange(World aWorld, Block aBlock) {
+        /* Do Nothing */
     }
 
-    interface IMTE_GetComparatorInputOverride extends IMultiTileEntity {
-
-        int getComparatorInputOverride(ForgeDirection side);
-    }
-
-    interface IMTE_BreakBlock extends IMultiTileEntity {
+    // ItemStack getPickBlock(MovingObjectPosition aTarget);
 
-        /** return true to prevent the TileEntity from being removed. */
-        boolean breakBlock();
+    /** Remember that it passes the opposite Side due to the way vanilla works! */
+    default int isProvidingWeakPower(ForgeDirection oppositeSide) {
+        return 0;
     }
 
-    interface IMTE_HasMultiBlockMachineRelevantData extends IMultiTileEntity {
-
-        /** Return true to mark this Block as a Machine Block for Multiblocks. (Triggers machine update thread) */
-        boolean hasMultiBlockMachineRelevantData();
+    default boolean providesStrongPower() {
+        return false;
     }
 
-    interface IMTE_GetBlockHardness extends IMultiTileEntity {
-
-        float getBlockHardness();
+    /** Remember that it passes the opposite Side due to the way vanilla works! */
+    default int isProvidingStrongPower(ForgeDirection oppositeSide) {
+        return 0;
     }
 
-    interface IMTE_GetFoodValues extends IMultiTileEntity {
-
-        @Optional.Method(modid = Mods.Names.APPLE_CORE)
-        squeek.applecore.api.food.FoodValues getFoodValues(MultiTileEntityItemInternal aItem, ItemStack aStack);
+    default boolean shouldCheckWeakPower(ForgeDirection side) {
+        return false;
     }
 
-    interface IMTE_OnlyPlaceableWhenSneaking extends IMultiTileEntity {
-
-        /** Return true to prevent placing this Block without Sneaking. */
-        boolean onlyPlaceableWhenSneaking();
+    default boolean getWeakChanges() {
+        return false;
     }
 
-    interface IMTE_IgnoreEntityCollisionWhenPlacing extends IMultiTileEntity {
-
-        /**
-         * Return true to ignore the Player standing in the way of placing this Block; useful for things like
-         * pipes/wires.
-         */
-        boolean ignoreEntityCollisionWhenPlacing(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY,
-            int aZ, ForgeDirection side, float aHitX, float aHitY, float aHitZ);
+    default boolean hasComparatorInputOverride() {
+        return false;
     }
 
-    interface IMTE_CanPlace extends IMultiTileEntity {
-
-        /** Return false if this TileEntity cannot be placed at that Location. */
-        boolean canPlace(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ,
-            ForgeDirection side, float aHitX, float aHitY, float aHitZ);
+    default int getComparatorInputOverride(ForgeDirection side) {
+        return 0;
     }
 
-    interface IMTE_GetMaxStackSize extends IMultiTileEntity {
-
-        /** Gets the Max Stacksize of this Item. */
-        byte getMaxStackSize(ItemStack aStack, byte aDefault);
+    default float getBlockHardness() {
+        return 1.0f;
     }
 
-    interface IMTE_AddToolTips extends IMultiTileEntity {
-
-        /** Adds ToolTips to the Item. */
-        void addToolTips(List<String> aList, ItemStack aStack, boolean aF3_H);
+    /** Adds ToolTips to the Item. */
+    default void addToolTips(List<String> aList, ItemStack aStack, boolean aF3_H) {
+        // Do nothing
     }
 
-    interface IMTE_HasModes extends IMultiTileEntity {
+    // interface IMTE_HasMultiBlockMachineRelevantData extends IMultiTileEntity {
+    //
+    // /** Return true to mark this Block as a Machine Block for Multiblocks. (Triggers machine update thread) */
+    // boolean hasMultiBlockMachineRelevantData();
+    // }
 
-        int getMode();
-
-        void setMode(int mode);
-
-        int getAllowedModes();
-
-        void setAllowedModes(int allowedModes);
-    }
 }
diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java
index 7ffdc4fb60..442d37a47a 100644
--- a/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java
+++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java
@@ -60,7 +60,6 @@ import gregtech.api.logic.PowerLogic;
 import gregtech.api.multitileentity.enums.MultiTileCasingPurpose;
 import gregtech.api.multitileentity.interfaces.IMultiBlockController;
 import gregtech.api.multitileentity.interfaces.IMultiBlockPart;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_AddToolTips;
 import gregtech.api.multitileentity.machine.MultiTileBasicMachine;
 import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing;
 import gregtech.api.multitileentity.multiblock.casing.UpgradeCasing;
@@ -75,9 +74,8 @@ import mcp.mobius.waila.api.IWailaDataAccessor;
 /**
  * Multi Tile Entities - or MuTEs - don't have dedicated hatches, but their casings can become hatches.
  */
-public abstract class Controller<C extends Controller<C, P>, P extends MuTEProcessingLogic<P>>
-    extends MultiTileBasicMachine<P>
-    implements IAlignment, IMultiBlockController, IDescribable, IMTE_AddToolTips, ISurvivalConstructable {
+public abstract class Controller<C extends Controller<C, P>, P extends MuTEProcessingLogic<P>> extends
+    MultiTileBasicMachine<P> implements IAlignment, IMultiBlockController, IDescribable, ISurvivalConstructable {
 
     public static final String ALL_INVENTORIES_NAME = "all";
     protected static final int AUTO_OUTPUT_FREQUENCY_TICK = 20;
diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java
index 5331d1477d..2b030899ed 100644
--- a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java
+++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java
@@ -52,8 +52,6 @@ import gregtech.api.multitileentity.base.NonTickableMultiTileEntity;
 import gregtech.api.multitileentity.enums.MultiTileCasingPurpose;
 import gregtech.api.multitileentity.interfaces.IMultiBlockController;
 import gregtech.api.multitileentity.interfaces.IMultiBlockPart;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity;
-import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasModes;
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_Utility;
 import gregtech.common.covers.CoverInfo;
@@ -62,7 +60,7 @@ import mcp.mobius.waila.api.IWailaConfigHandler;
 import mcp.mobius.waila.api.IWailaDataAccessor;
 
 public abstract class MultiBlockPart extends NonTickableMultiTileEntity
-    implements IMultiBlockPart, IMTE_HasModes, PowerLogicHost, IMultiTileEntity.IMTE_AddToolTips, GUIHost {
+    implements IMultiBlockPart, PowerLogicHost, GUIHost {
 
     public static final int NOTHING = 0, ENERGY_IN = B[0], ENERGY_OUT = B[1], FLUID_IN = B[2], FLUID_OUT = B[3],
         ITEM_IN = B[4], ITEM_OUT = B[5];
@@ -98,7 +96,7 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity
     }
 
     public void setTarget(IMultiBlockController newTarget, int aAllowedModes) {
-        IMultiBlockController currentTarget = getTarget(false);
+        final IMultiBlockController currentTarget = getTarget(false);
         if (currentTarget != null && currentTarget != newTarget) {
             for (MultiTileCasingPurpose purpose : registeredPurposes) {
                 unregisterPurpose(purpose);
@@ -331,25 +329,25 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity
     }
 
     /**
-     * True if `aMode` is one of the allowed modes
+     * True if `mode` is one of the allowed modes
      */
-    public boolean hasMode(int aMode) {
+    public boolean hasMode(int mode) {
         // This is not sent to the client
-        return (allowedModes & aMode) != 0;
+        return (allowedModes & mode) != 0;
     }
 
     /**
      * Returns true if the part has any of the modes provided, and that mode is the currently selected mode
      */
-    public boolean modeSelected(int... aModes) {
-        for (int aMode : aModes) {
-            if (hasMode(aMode) && mode == getModeOrdinal(aMode)) return true;
+    public boolean modeSelected(int... modes) {
+        for (int mode : modes) {
+            if (hasMode(mode) && this.mode == getModeOrdinal(mode)) return true;
         }
         return false;
     }
 
     @Override
-    public boolean breakBlock() {
+    public boolean onBlockBroken() {
         final IMultiBlockController tTarget = getTarget(false);
         if (tTarget != null) {
             unregisterCovers(tTarget);
diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java
index ccde0c49e6..7005e3a60a 100644
--- a/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java
+++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java
@@ -55,7 +55,7 @@ public class WallShareablePart extends MultiBlockPart {
     }
 
     @Override
-    public boolean breakBlock() {
+    public boolean onBlockBroken() {
         for (final ChunkCoordinates coordinates : targetPositions) {
             IMultiBlockController target = getTarget(coordinates, false);
             if (target == null) {
diff --git a/src/main/java/gregtech/api/util/GT_StructureUtilityMuTE.java b/src/main/java/gregtech/api/util/GT_StructureUtilityMuTE.java
index 8e8d027463..4010fae3bc 100644
--- a/src/main/java/gregtech/api/util/GT_StructureUtilityMuTE.java
+++ b/src/main/java/gregtech/api/util/GT_StructureUtilityMuTE.java
@@ -201,12 +201,12 @@ public class GT_StructureUtilityMuTE {
                     GT_FML_LOGGER.error("NULL CONTAINER");
                     return false;
                 }
-                final IMultiTileEntity te = ((IMultiTileEntity) tContainer.mTileEntity);
+                final IMultiTileEntity te = ((IMultiTileEntity) tContainer.tileEntity);
                 if (!(te instanceof MultiBlockPart)) {
                     GT_FML_LOGGER.error("Not a multiblock part");
                     return false;
                 }
-                if (world.setBlock(x, y, z, tContainer.mBlock, 15 - tContainer.mBlockMetaData, 2)) {
+                if (world.setBlock(x, y, z, tContainer.block, 15 - tContainer.blockMetaData, 2)) {
                     tContainer.setMultiTile(world, x, y, z);
                     ((MultiBlockPart) te).setTarget((IMultiBlockController) t, modes);
 
@@ -263,7 +263,7 @@ public class GT_StructureUtilityMuTE {
             // but it should be properly fixed in the future
             if (registryId == GT_Values.W) {
                 MultiTileEntityRegistry registry = MultiTileEntityRegistry.getRegistry(registryName);
-                registryId = Block.getIdFromBlock(registry.mBlock);
+                registryId = Block.getIdFromBlock(registry.getBlock());
             }
             return registryId;
         }
diff --git a/src/main/java/gregtech/api/util/GT_Util.java b/src/main/java/gregtech/api/util/GT_Util.java
index 8a799a9616..62ebcecd79 100644
--- a/src/main/java/gregtech/api/util/GT_Util.java
+++ b/src/main/java/gregtech/api/util/GT_Util.java
@@ -21,123 +21,123 @@ public class GT_Util {
         return new Tuple(key, value);
     }
 
-    public static NBTTagCompound fuseNBT(NBTTagCompound aNBT1, NBTTagCompound aNBT2) {
-        if (aNBT1 == null) return aNBT2 == null ? new NBTTagCompound() : (NBTTagCompound) aNBT2.copy();
-        final NBTTagCompound rNBT = (NBTTagCompound) aNBT1.copy();
-        if (aNBT2 == null) return rNBT;
-        for (Object tKey : aNBT2.func_150296_c /* getKeySet */())
-            if (!rNBT.hasKey(tKey.toString())) rNBT.setTag(tKey.toString(), aNBT2.getTag(tKey.toString()));
+    public static NBTTagCompound fuseNBT(NBTTagCompound nbt1, NBTTagCompound nbt2) {
+        if (nbt1 == null) return nbt2 == null ? new NBTTagCompound() : (NBTTagCompound) nbt2.copy();
+        final NBTTagCompound rNBT = (NBTTagCompound) nbt1.copy();
+        if (nbt2 == null) return rNBT;
+        for (Object tKey : nbt2.func_150296_c /* getKeySet */())
+            if (!rNBT.hasKey(tKey.toString())) rNBT.setTag(tKey.toString(), nbt2.getTag(tKey.toString()));
         return rNBT;
     }
 
     /**
      * Construct a NBTTagCompound from a series of key, value pairs. Inspired from GT6.
      */
-    public static NBTTagCompound makeNBT(Tuple... aTags) {
-        final NBTTagCompound rNBT = new NBTTagCompound();
-        for (Tuple t : aTags) {
+    public static NBTTagCompound makeNBT(Tuple... tags) {
+        final NBTTagCompound nbt = new NBTTagCompound();
+        for (Tuple t : tags) {
             if (t.getSecond() == null) continue;
 
-            if (t.getSecond() instanceof Boolean) rNBT.setBoolean(
+            if (t.getSecond() instanceof Boolean) nbt.setBoolean(
                 t.getFirst()
                     .toString(),
                 (Boolean) t.getSecond());
-            else if (t.getSecond() instanceof Byte) rNBT.setByte(
+            else if (t.getSecond() instanceof Byte) nbt.setByte(
                 t.getFirst()
                     .toString(),
                 (Byte) t.getSecond());
-            else if (t.getSecond() instanceof Short) rNBT.setShort(
+            else if (t.getSecond() instanceof Short) nbt.setShort(
                 t.getFirst()
                     .toString(),
                 (Short) t.getSecond());
-            else if (t.getSecond() instanceof Integer) rNBT.setInteger(
+            else if (t.getSecond() instanceof Integer) nbt.setInteger(
                 t.getFirst()
                     .toString(),
                 (Integer) t.getSecond());
-            else if (t.getSecond() instanceof Long) rNBT.setLong(
+            else if (t.getSecond() instanceof Long) nbt.setLong(
                 t.getFirst()
                     .toString(),
                 (Long) t.getSecond());
-            else if (t.getSecond() instanceof Float) rNBT.setFloat(
+            else if (t.getSecond() instanceof Float) nbt.setFloat(
                 t.getFirst()
                     .toString(),
                 (Float) t.getSecond());
-            else if (t.getSecond() instanceof Double) rNBT.setDouble(
+            else if (t.getSecond() instanceof Double) nbt.setDouble(
                 t.getFirst()
                     .toString(),
                 (Double) t.getSecond());
-            else if (t.getSecond() instanceof String) rNBT.setString(
+            else if (t.getSecond() instanceof String) nbt.setString(
                 t.getFirst()
                     .toString(),
                 (String) t.getSecond());
-            else if (t.getSecond() instanceof NBTBase) rNBT.setTag(
+            else if (t.getSecond() instanceof NBTBase) nbt.setTag(
                 t.getFirst()
                     .toString(),
                 (NBTBase) t.getSecond());
-            else rNBT.setString(
+            else nbt.setString(
                 t.getFirst()
                     .toString(),
                 t.getSecond()
                     .toString());
         }
 
-        return rNBT;
+        return nbt;
     }
 
     /**
      * Get a TileEntity
      */
-    public static TileEntity getTileEntity(World aWorld, int aX, int aY, int aZ, boolean aLoadUnloadedChunks) {
-        if (aLoadUnloadedChunks || aWorld.blockExists(aX, aY, aZ)) {
-            TileEntity rTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-            if (rTileEntity instanceof IMultiTileEntity && ((IMultiTileEntity) rTileEntity).isDead()) return null;
-            if (rTileEntity != null) return rTileEntity;
-            rTileEntity = LAST_BROKEN_TILEENTITY.get();
-            if (rTileEntity != null && rTileEntity.xCoord == aX && rTileEntity.yCoord == aY && rTileEntity.zCoord == aZ)
-                return rTileEntity;
+    public static TileEntity getTileEntity(World world, int x, int y, int z, boolean aLoadUnloadedChunks) {
+        if (aLoadUnloadedChunks || world.blockExists(x, y, z)) {
+            TileEntity tileEntity = world.getTileEntity(x, y, z);
+            if (tileEntity instanceof IMultiTileEntity && ((IMultiTileEntity) tileEntity).isDead()) return null;
+            if (tileEntity != null) return tileEntity;
+            tileEntity = LAST_BROKEN_TILEENTITY.get();
+            if (tileEntity != null && tileEntity.xCoord == x && tileEntity.yCoord == y && tileEntity.zCoord == z)
+                return tileEntity;
         }
         return null;
     }
 
     /** Sets the TileEntity at the passed position, with the option of turning adjacent TileEntity updates off. */
-    public static TileEntity setTileEntity(World aWorld, int aX, int aY, int aZ, TileEntity aTileEntity,
+    public static TileEntity setTileEntity(World world, int x, int y, int z, TileEntity aTileEntity,
         boolean aCauseTileEntityUpdates) {
-        if (aCauseTileEntityUpdates) aWorld.setTileEntity(aX, aY, aZ, aTileEntity);
+        if (aCauseTileEntityUpdates) world.setTileEntity(x, y, z, aTileEntity);
         else {
-            Chunk tChunk = aWorld.getChunkFromChunkCoords(aX >> 4, aZ >> 4);
+            final Chunk tChunk = world.getChunkFromChunkCoords(x >> 4, z >> 4);
             if (tChunk != null) {
-                aWorld.addTileEntity(aTileEntity);
-                tChunk.func_150812_a /* setBlockTileEntityInChunk */(aX & 15, aY, aZ & 15, aTileEntity);
+                world.addTileEntity(aTileEntity);
+                tChunk.func_150812_a /* setBlockTileEntityInChunk */(x & 15, y, z & 15, aTileEntity);
                 tChunk.setChunkModified();
             }
         }
         return aTileEntity;
     }
 
-    public static boolean setTileEntity(World aWorld, int aX, int aY, int aZ, Block aBlock, short aMeta, long aFlags,
+    public static boolean setBlock(World world, int x, int y, int z, Block block, short aMeta, long aFlags,
         boolean aRemoveGrassBelow) {
         if (aRemoveGrassBelow) {
-            final Block tBlock = aWorld.getBlock(aX, aY - 1, aZ);
-            if (tBlock == Blocks.grass || tBlock == Blocks.mycelium)
-                aWorld.setBlock(aX, aY - 1, aZ, Blocks.dirt, 0, (byte) aFlags);
+            final Block blockBelow = world.getBlock(x, y - 1, z);
+            if (blockBelow == Blocks.grass || blockBelow == Blocks.mycelium)
+                world.setBlock(x, y - 1, z, Blocks.dirt, 0, (byte) aFlags);
         }
-        return aWorld.setBlock(aX, aY, aZ, aBlock, aMeta, (byte) aFlags);
+        return world.setBlock(x, y, z, block, aMeta, (byte) aFlags);
     }
 
-    public static TileEntity getTileEntity(World aWorld, ChunkCoordinates aCoords, boolean aLoadUnloadedChunks) {
-        return getTileEntity(aWorld, aCoords.posX, aCoords.posY, aCoords.posZ, aLoadUnloadedChunks);
+    public static TileEntity getTileEntity(World world, ChunkCoordinates coords, boolean loadUnloadedChunks) {
+        return getTileEntity(world, coords.posX, coords.posY, coords.posZ, loadUnloadedChunks);
     }
 
     /** Marks a Chunk dirty so it is saved */
-    public static boolean markChunkDirty(World aWorld, int aX, int aZ) {
-        if (aWorld == null || aWorld.isRemote) return false;
-        Chunk aChunk = aWorld.getChunkFromBlockCoords(aX, aZ);
+    public static boolean markChunkDirty(World world, int x, int z) {
+        if (world == null || world.isRemote) return false;
+        Chunk aChunk = world.getChunkFromBlockCoords(x, z);
         if (aChunk == null) {
-            aWorld.getBlockMetadata(aX, 0, aZ);
-            aChunk = aWorld.getChunkFromBlockCoords(aX, aZ);
+            world.getBlockMetadata(x, 0, z);
+            aChunk = world.getChunkFromBlockCoords(x, z);
             if (aChunk == null) {
                 GT_Log.err.println(
-                    "Some important Chunk does not exist for some reason at Coordinates X: " + aX + " and Z: " + aZ);
+                    "Some important Chunk does not exist for some reason at Coordinates X: " + x + " and Z: " + z);
                 return false;
             }
         }
@@ -146,11 +146,9 @@ public class GT_Util {
     }
 
     /** Marks a Chunk dirty so it is saved */
-    public static boolean markChunkDirty(Object aTileEntity) {
-        return aTileEntity instanceof TileEntity && markChunkDirty(
-            ((TileEntity) aTileEntity).getWorldObj(),
-            ((TileEntity) aTileEntity).xCoord,
-            ((TileEntity) aTileEntity).zCoord);
+    public static boolean markChunkDirty(Object maybeTile) {
+        return maybeTile instanceof TileEntity tileEntity
+            && markChunkDirty(tileEntity.getWorldObj(), tileEntity.xCoord, tileEntity.zCoord);
     }
 
     public static int mixRGBInt(int aRGB1, int aRGB2) {
diff --git a/src/main/java/gregtech/api/util/GT_Utility.java b/src/main/java/gregtech/api/util/GT_Utility.java
index 72b74c3f97..ca2a3f9a5f 100644
--- a/src/main/java/gregtech/api/util/GT_Utility.java
+++ b/src/main/java/gregtech/api/util/GT_Utility.java
@@ -1,6 +1,7 @@
 package gregtech.api.util;
 
 import static gregtech.GT_Mod.GT_FML_LOGGER;
+import static gregtech.api.enums.GT_Values.COMPASS_DIRECTIONS;
 import static gregtech.api.enums.GT_Values.D1;
 import static gregtech.api.enums.GT_Values.E;
 import static gregtech.api.enums.GT_Values.GT;
@@ -4105,6 +4106,15 @@ public class GT_Utility {
         return metaTileEntities;
     }
 
+    public static ForgeDirection getSideFromPlayerFacing(Entity player) {
+        if (player == null) return ForgeDirection.UNKNOWN;
+        if (player.rotationPitch >= 65) return ForgeDirection.UP;
+        if (player.rotationPitch <= -65) return ForgeDirection.DOWN;
+        final byte facing = COMPASS_DIRECTIONS[MathHelper.floor_double(0.5D + 4.0F * player.rotationYaw / 360.0F)
+            & 0x3];
+        return ForgeDirection.getOrientation(facing);
+    }
+
     public static class ItemNBT {
 
         public static void setNBT(ItemStack aStack, NBTTagCompound aNBT) {